covguard_orchestrator/

lib.rs

//! Application orchestration for covguard.
//!
//! This crate provides the high-level `check` function that orchestrates
//! the entire diff coverage analysis pipeline:
//!
//! 1. Parse the diff to extract changed line ranges
//! 2. Parse LCOV coverage data
//! 3. Detect ignore directives in source files
//! 4. Evaluate coverage against the policy
//! 5. Build and return a report with markdown and annotations
//!
//! # Example
//!
//! ```rust,ignore
//! use covguard_orchestrator::{check, CheckRequest};
//! use covguard_types::Scope;
//!
//! let request = CheckRequest {
//!     diff_text: "...".to_string(),
//!     diff_file_path: Some("test.patch".to_string()),
//!     lcov_texts: vec!["...".to_string()],
//!     lcov_paths: vec!["coverage.info".to_string()],
//!     threshold_pct: 80.0,
//!     scope: Scope::Added,
//!     ..Default::default()
//! };
//!
//! let result = check(request)?;
//! println!("Exit code: {}", result.exit_code);
//! ```

use covguard_adapters_coverage::LcovError;
use covguard_adapters_diff::DiffError;
use covguard_config::should_include_path;
pub use covguard_directives::detect_ignored_lines;
pub use covguard_domain::MissingBehavior;
use covguard_domain::{EvalInput, EvalOutput, Policy, evaluate};
pub use covguard_output::{
    DEFAULT_ANNOTATION_LIMIT as DEFAULT_MAX_ANNOTATIONS,
    DEFAULT_MARKDOWN_LINES as DEFAULT_MAX_LINES,
    DEFAULT_SARIF_RESULTS as DEFAULT_MAX_SARIF_RESULTS, render_annotations,
    render_annotations_with_limit, render_markdown, render_markdown_with_limit, render_sarif,
    render_sarif_with_limit,
};
use covguard_output_features::OutputFeatureFlags;
pub use covguard_policy::FailOn;
pub use covguard_ports::{Clock, CoverageMap, CoverageProvider, DiffProvider, RepoReader};
#[cfg(test)]
use covguard_reporting::build_reasons as reporting_build_reasons;
use covguard_reporting::{
    ReportContext, build_debug as reporting_build_debug,
    build_error_report_pair as reporting_build_error_report_pair,
    build_report as reporting_build_report, build_report_pair as reporting_build_report_pair,
    build_skip_report_pair as reporting_build_skip_report_pair,
    is_invalid_diff as reporting_is_invalid_diff,
};
#[cfg(test)]
use covguard_types::{
    CODE_COVERAGE_BELOW_THRESHOLD, CODE_RUNTIME_ERROR, Finding, InputStatus,
    REASON_BELOW_THRESHOLD, REASON_DIFF_COVERED, REASON_NO_CHANGED_LINES, REASON_SKIPPED,
    REASON_TRUNCATED, REASON_UNCOVERED_LINES, SCHEMA_ID, SENSOR_SCHEMA_ID,
};
use covguard_types::{
    CODE_INVALID_DIFF, CODE_INVALID_LCOV, REASON_MISSING_LCOV, Report, Scope, VerdictStatus,
};
use std::collections::{BTreeMap, BTreeSet};
use thiserror::Error;

// ============================================================================
// Clock Trait
// ============================================================================

/// System clock implementation that returns the actual current time.
pub struct SystemClock;

impl Clock for SystemClock {
    fn now(&self) -> chrono::DateTime<chrono::Utc> {
        chrono::Utc::now()
    }
}

// ============================================================================
// Request and Result Types
// ============================================================================

/// A no-op reader that returns None for all lines.
/// Used when ignore directives are disabled.
struct NullReader;

impl RepoReader for NullReader {
    fn read_line(&self, _path: &str, _line_no: u32) -> Option<String> {
        None
    }
}

/// Request for a coverage check operation.
#[derive(Debug, Clone)]
pub struct CheckRequest {
    /// Patch file content (unified diff format).
    pub diff_text: String,
    /// Path to the diff file, for report metadata.
    pub diff_file_path: Option<String>,
    /// Base git ref, for report metadata (alternative to diff_file_path).
    pub base_ref: Option<String>,
    /// Head git ref, for report metadata (alternative to diff_file_path).
    pub head_ref: Option<String>,
    /// LCOV coverage file contents (one per input).
    pub lcov_texts: Vec<String>,
    /// Paths to LCOV files, for report metadata.
    pub lcov_paths: Vec<String>,
    /// Maximum allowed uncovered lines (optional tolerance buffer).
    pub max_uncovered_lines: Option<u32>,
    /// How to handle missing coverage lines within files.
    pub missing_coverage: MissingBehavior,
    /// How to handle files with no coverage data.
    pub missing_file: MissingBehavior,
    /// Glob patterns to include (allowlist).
    pub include_patterns: Vec<String>,
    /// Glob patterns to exclude.
    pub exclude_patterns: Vec<String>,
    /// Prefixes to strip from LCOV SF paths.
    pub path_strip: Vec<String>,
    /// Minimum diff coverage percentage threshold.
    pub threshold_pct: f64,
    /// Scope of lines to evaluate.
    pub scope: Scope,
    /// Determines when the evaluation should fail.
    pub fail_on: FailOn,
    /// Whether to honor `covguard: ignore` directives.
    pub ignore_directives: bool,
    /// Pre-computed ignored lines (path -> set of line numbers).
    /// If provided, these are used directly instead of reading from source.
    pub ignored_lines: Option<BTreeMap<String, BTreeSet<u32>>>,
    /// Emit sensor.report.v1 schema with capabilities block.
    pub sensor_schema: bool,
    /// Renderer budgets used for markdown/annotations/SARIF output.
    pub output: OutputFeatureFlags,
    /// Maximum number of findings to include in the report (truncation).
    pub max_findings: Option<usize>,
}

impl Default for CheckRequest {
    fn default() -> Self {
        Self {
            diff_text: String::new(),
            diff_file_path: None,
            base_ref: None,
            head_ref: None,
            lcov_texts: Vec::new(),
            lcov_paths: Vec::new(),
            max_uncovered_lines: None,
            missing_coverage: MissingBehavior::Warn,
            missing_file: MissingBehavior::Warn,
            include_patterns: Vec::new(),
            exclude_patterns: Vec::new(),
            path_strip: Vec::new(),
            threshold_pct: 80.0,
            scope: Scope::Added,
            fail_on: FailOn::Error,
            ignore_directives: true,
            ignored_lines: None,
            sensor_schema: false,
            output: OutputFeatureFlags::default(),
            max_findings: None,
        }
    }
}

/// Result of a coverage check operation.
#[derive(Debug, Clone)]
pub struct CheckResult {
    /// The domain report (covguard.report.v1, ALL findings, no capabilities).
    pub report: Report,
    /// Renderer budgets that were used to build outputs for this result.
    pub output: OutputFeatureFlags,
    /// The cockpit receipt (sensor.report.v1, truncated findings, capabilities).
    /// Only populated when `sensor_schema: true` (cockpit mode).
    pub cockpit_receipt: Option<Report>,
    /// Markdown rendering of the report.
    pub markdown: String,
    /// GitHub annotations rendering of the report.
    pub annotations: String,
    /// SARIF rendering of the report.
    pub sarif: String,
    /// Exit code for the CLI.
    /// - 0: pass or warn
    /// - 2: policy fail (blocking findings)
    /// - 1: tool/runtime error (not returned here, only via AppError)
    pub exit_code: i32,
}

// ============================================================================
// Errors
// ============================================================================

/// Errors that can occur during the check operation.
#[derive(Debug, Error)]
pub enum AppError {
    /// Failed to parse the diff.
    #[error("Failed to parse diff: {0}")]
    DiffParse(String),

    /// Failed to parse the LCOV coverage file.
    #[error("Failed to parse LCOV: {0}")]
    LcovParse(String),

    /// I/O error.
    #[error("I/O error: {0}")]
    Io(String),
}

impl From<DiffError> for AppError {
    fn from(e: DiffError) -> Self {
        AppError::DiffParse(e.to_string())
    }
}

impl From<LcovError> for AppError {
    fn from(e: LcovError) -> Self {
        AppError::LcovParse(e.to_string())
    }
}

// ============================================================================
// Main Check Function
// ============================================================================

/// Run a diff coverage check.
///
/// This is the main entry point for the covguard analysis. It:
/// 1. Parses the diff to extract changed line ranges
/// 2. Parses LCOV coverage data
/// 3. Evaluates coverage against the policy
/// 4. Builds and returns a result with report, markdown, annotations, and exit code
///
/// # Arguments
///
/// * `request` - The check request containing diff, coverage, and options
///
/// # Returns
///
/// A `CheckResult` containing the report, rendered outputs, and exit code.
///
/// # Errors
///
/// Returns `AppError` if parsing fails.
pub fn check(request: CheckRequest) -> Result<CheckResult, AppError> {
    check_with_clock(request, &SystemClock)
}

/// Run a diff coverage check with a custom clock.
///
/// This allows for deterministic testing with fixed timestamps.
pub fn check_with_clock<C: Clock>(
    request: CheckRequest,
    clock: &C,
) -> Result<CheckResult, AppError> {
    check_with_clock_and_reader(request, clock, &NullReader)
}

/// Run a diff coverage check with a custom clock and repo reader.
///
/// The repo reader is used to detect `covguard: ignore` directives in source files.
pub fn check_with_clock_and_reader<C: Clock, R: RepoReader>(
    request: CheckRequest,
    clock: &C,
    reader: &R,
) -> Result<CheckResult, AppError> {
    let diff_provider = covguard_adapters_diff::GitDiffProvider;
    let coverage_provider = covguard_adapters_coverage::LcovCoverageProvider;
    check_with_providers_and_reader(request, clock, reader, &diff_provider, &coverage_provider)
}

/// Run a diff coverage check with pluggable diff and coverage providers.
///
/// This enables fully port-driven orchestration while preserving the default
/// API surface for callers that use built-in adapters.
pub fn check_with_providers_and_reader<
    C: Clock,
    R: RepoReader,
    D: DiffProvider,
    P: CoverageProvider,
>(
    request: CheckRequest,
    clock: &C,
    reader: &R,
    diff_provider: &D,
    coverage_provider: &P,
) -> Result<CheckResult, AppError> {
    let started_at = clock.now();

    // Determine diff availability
    let diff_available = !request.diff_text.is_empty()
        || request.diff_file_path.is_some()
        || (request.base_ref.is_some() && request.head_ref.is_some());

    // Determine coverage availability
    let coverage_available =
        !request.lcov_texts.is_empty() && request.lcov_texts.iter().any(|t| !t.trim().is_empty());

    // In sensor schema mode, return skip result if coverage is unavailable
    if request.sensor_schema && !coverage_available {
        return Ok(build_skip_result(
            &request,
            started_at,
            diff_available,
            false, // coverage unavailable
            REASON_MISSING_LCOV,
            clock,
        ));
    }

    // Validate diff input (non-empty must include diff markers)
    if is_invalid_diff(&request.diff_text) {
        return Ok(build_error_result(
            &request,
            started_at,
            CODE_INVALID_DIFF,
            "Diff input did not contain any recognized diff markers.",
            true, // diff was provided (non-empty)
            coverage_available,
            clock,
        ));
    }

    // Parse the diff
    let parse_result = match diff_provider.parse_patch(&request.diff_text) {
        Ok(ranges) => ranges,
        Err(e) => {
            return Ok(build_error_result(
                &request,
                started_at,
                CODE_INVALID_DIFF,
                &format!("Failed to parse diff: {e}"),
                true, // diff was provided
                coverage_available,
                clock,
            ));
        }
    };
    let changed_ranges = parse_result.changed_ranges;
    let binary_files = parse_result.binary_files;

    // Parse LCOV coverage (merge multiple inputs)
    let mut coverage_maps: Vec<CoverageMap> = Vec::new();
    for lcov_text in &request.lcov_texts {
        if lcov_text.trim().is_empty() {
            continue;
        }
        if !lcov_text.contains("SF:") {
            return Ok(build_error_result(
                &request,
                started_at,
                CODE_INVALID_LCOV,
                "LCOV input contained no SF records.",
                true, // diff parsed OK
                true, // coverage was provided (but invalid)
                clock,
            ));
        }
        match coverage_provider.parse_lcov(lcov_text, &request.path_strip) {
            Ok(map) => coverage_maps.push(map),
            Err(e) => {
                return Ok(build_error_result(
                    &request,
                    started_at,
                    CODE_INVALID_LCOV,
                    &format!("Failed to parse LCOV: {e}"),
                    true, // diff parsed OK
                    true, // coverage was provided (but invalid)
                    clock,
                ));
            }
        }
    }
    let coverage: CoverageMap = coverage_provider.merge_coverage(coverage_maps);

    // Detect ignored lines
    let mut filtered_ranges = changed_ranges;
    let mut excluded_files_count = 0u32;
    filtered_ranges.retain(|path, _| {
        if should_include_path(path, &request.include_patterns, &request.exclude_patterns) {
            true
        } else {
            excluded_files_count += 1;
            false
        }
    });

    let ignored_lines = if request.ignore_directives {
        request
            .ignored_lines
            .clone()
            .unwrap_or_else(|| detect_ignored_lines(&filtered_ranges, reader))
    } else {
        BTreeMap::new()
    };

    let domain_scope = request.scope;

    let policy = Policy {
        scope: domain_scope,
        threshold_pct: request.threshold_pct,
        max_uncovered_lines: request.max_uncovered_lines,
        missing_coverage: request.missing_coverage,
        missing_file: request.missing_file,
        fail_on: request.fail_on,
        ignore_directives_enabled: request.ignore_directives,
    };

    // Build evaluation input
    let eval_input = EvalInput {
        changed_ranges: filtered_ranges,
        coverage,
        policy,
        ignored_lines,
    };

    // Run evaluation
    let eval_output = evaluate(eval_input);

    // Build the report pair (domain report + optional cockpit receipt)
    let debug = build_debug(&binary_files);
    let ended_at = clock.now();
    let output = request.output;
    let (domain_report, cockpit_receipt) = build_report_pair(
        eval_output.clone(),
        &request,
        started_at,
        ended_at,
        excluded_files_count,
        debug,
    );

    // Render outputs from the domain report (full findings)
    let markdown = render_markdown_with_limit(&domain_report, output.max_markdown_lines);
    let annotations = render_annotations_with_limit(&domain_report, output.max_annotations);
    let sarif = render_sarif_with_limit(&domain_report, output.max_sarif_results);

    // Determine exit code from domain report verdict
    let exit_code = match domain_report.verdict.status {
        VerdictStatus::Pass | VerdictStatus::Warn | VerdictStatus::Skip => 0,
        VerdictStatus::Fail => 2,
    };

    Ok(CheckResult {
        report: domain_report,
        output,
        cockpit_receipt,
        markdown,
        annotations,
        sarif,
        exit_code,
    })
}

// ============================================================================
// Report Builder
// ============================================================================

// truncate_findings moved to `covguard_output` for shared API semantics.

fn build_report_context(request: &CheckRequest) -> ReportContext {
    ReportContext {
        threshold_pct: request.threshold_pct,
        scope: request.scope,
        sensor_schema: request.sensor_schema,
        max_findings: request.max_findings,
        diff_file_path: request.diff_file_path.clone(),
        base_ref: request.base_ref.clone(),
        head_ref: request.head_ref.clone(),
        lcov_paths: request.lcov_paths.clone(),
    }
}

/// Build a pair of reports from evaluation output: a domain report and an optional cockpit receipt.
///
/// - **Domain report**: Always `covguard.report.v1`, no capabilities, full findings
///   (standard-mode truncation preserved when `!sensor_schema && max_findings.is_some()`).
/// - **Cockpit receipt** (only when `sensor_schema: true`): `sensor.report.v1`,
///   capabilities block, findings truncated to `max_findings`, counts from full set.
fn build_report_pair(
    eval: EvalOutput,
    request: &CheckRequest,
    started_at: chrono::DateTime<chrono::Utc>,
    ended_at: chrono::DateTime<chrono::Utc>,
    excluded_files_count: u32,
    debug: Option<serde_json::Value>,
) -> (Report, Option<Report>) {
    reporting_build_report_pair(
        eval,
        &build_report_context(request),
        started_at,
        ended_at,
        excluded_files_count,
        debug,
    )
}

/// Build a Report from evaluation output.
///
/// # Arguments
///
/// * `eval` - The evaluation output from the domain layer
/// * `request` - The original check request
/// * `started_at` - When the check started
///
/// # Returns
///
/// A fully populated Report struct.
pub fn build_report(
    eval: EvalOutput,
    request: &CheckRequest,
    started_at: chrono::DateTime<chrono::Utc>,
    ended_at: chrono::DateTime<chrono::Utc>,
    excluded_files_count: u32,
    debug: Option<serde_json::Value>,
) -> Report {
    reporting_build_report(
        eval,
        &build_report_context(request),
        started_at,
        ended_at,
        excluded_files_count,
        debug,
    )
}

fn build_debug(binary_files: &[String]) -> Option<serde_json::Value> {
    reporting_build_debug(binary_files)
}

fn build_error_result<C: Clock>(
    request: &CheckRequest,
    started_at: chrono::DateTime<chrono::Utc>,
    code: &str,
    message: &str,
    diff_available: bool,
    coverage_available: bool,
    clock: &C,
) -> CheckResult {
    let ended_at = clock.now();
    let (domain_report, cockpit_receipt) = build_error_report_pair(
        request,
        started_at,
        ended_at,
        code,
        message,
        diff_available,
        coverage_available,
    );
    let markdown = render_markdown_with_limit(&domain_report, request.output.max_markdown_lines);
    let annotations = render_annotations_with_limit(&domain_report, request.output.max_annotations);
    let sarif = render_sarif_with_limit(&domain_report, request.output.max_sarif_results);

    CheckResult {
        report: domain_report,
        output: request.output,
        cockpit_receipt,
        markdown,
        annotations,
        sarif,
        exit_code: 1,
    }
}

/// Build both domain report and optional cockpit receipt for error cases.
fn build_error_report_pair(
    request: &CheckRequest,
    started_at: chrono::DateTime<chrono::Utc>,
    ended_at: chrono::DateTime<chrono::Utc>,
    code: &str,
    message: &str,
    diff_available: bool,
    coverage_available: bool,
) -> (Report, Option<Report>) {
    reporting_build_error_report_pair(
        &build_report_context(request),
        started_at,
        ended_at,
        code,
        message,
        diff_available,
        coverage_available,
    )
}

/// Build a skip result when inputs are unavailable (sensor.report.v1 compliance).
fn build_skip_result<C: Clock>(
    request: &CheckRequest,
    started_at: chrono::DateTime<chrono::Utc>,
    diff_available: bool,
    coverage_available: bool,
    reason: &str,
    clock: &C,
) -> CheckResult {
    let ended_at = clock.now();
    let (domain_report, cockpit_receipt) = build_skip_report_pair(
        request,
        started_at,
        ended_at,
        diff_available,
        coverage_available,
        reason,
    );
    let markdown = render_markdown_with_limit(&domain_report, request.output.max_markdown_lines);
    let annotations = render_annotations_with_limit(&domain_report, request.output.max_annotations);
    let sarif = render_sarif_with_limit(&domain_report, request.output.max_sarif_results);

    CheckResult {
        report: domain_report,
        output: request.output,
        cockpit_receipt,
        markdown,
        annotations,
        sarif,
        exit_code: 0, // Skip is not a failure
    }
}

/// Build both domain report and cockpit receipt for skip cases.
fn build_skip_report_pair(
    request: &CheckRequest,
    started_at: chrono::DateTime<chrono::Utc>,
    ended_at: chrono::DateTime<chrono::Utc>,
    diff_available: bool,
    coverage_available: bool,
    reason: &str,
) -> (Report, Option<Report>) {
    reporting_build_skip_report_pair(
        &build_report_context(request),
        started_at,
        ended_at,
        diff_available,
        coverage_available,
        reason,
    )
}

fn is_invalid_diff(diff_text: &str) -> bool {
    reporting_is_invalid_diff(diff_text)
}

/// Build verdict reasons based on evaluation output.
#[cfg(test)]
fn build_reasons(output: &EvalOutput) -> Vec<String> {
    reporting_build_reasons(output)
}

// ============================================================================
// Convenience Functions
// ============================================================================

// Rendering convenience functions are re-exported from `covguard_output`
// to keep output formatting responsibilities centralized.

// ============================================================================
// Ignore Directive Detection
// ============================================================================
//
// Detection is delegated to `covguard_directives::detect_ignored_lines` and
// re-exported from this module for backward-compatible API access.

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;
    use covguard_domain::Metrics;
    use std::collections::{BTreeMap, BTreeSet};
    use std::path::Path;

    /// A test clock that returns a fixed time.
    struct FixedClock {
        time: chrono::DateTime<chrono::Utc>,
    }

    impl FixedClock {
        fn new(timestamp: &str) -> Self {
            Self {
                time: chrono::DateTime::parse_from_rfc3339(timestamp)
                    .unwrap()
                    .with_timezone(&chrono::Utc),
            }
        }
    }

    impl Clock for FixedClock {
        fn now(&self) -> chrono::DateTime<chrono::Utc> {
            self.time
        }
    }

    struct MapReader {
        lines: BTreeMap<(String, u32), String>,
    }

    impl MapReader {
        fn new(entries: Vec<(&str, u32, &str)>) -> Self {
            let mut lines = BTreeMap::new();
            for (path, line_no, content) in entries {
                lines.insert((path.to_string(), line_no), content.to_string());
            }
            Self { lines }
        }
    }

    impl RepoReader for MapReader {
        fn read_line(&self, path: &str, line_no: u32) -> Option<String> {
            self.lines.get(&(path.to_string(), line_no)).cloned()
        }
    }

    struct FakeDiffProvider {
        parsed: covguard_ports::DiffParseResult,
    }

    impl DiffProvider for FakeDiffProvider {
        fn parse_patch(&self, _text: &str) -> Result<covguard_ports::DiffParseResult, String> {
            Ok(self.parsed.clone())
        }

        fn load_diff_from_git(
            &self,
            _base: &str,
            _head: &str,
            _repo_root: &Path,
        ) -> Result<String, String> {
            Ok(String::new())
        }
    }

    struct FakeCoverageProvider {
        map: CoverageMap,
    }

    impl CoverageProvider for FakeCoverageProvider {
        fn parse_lcov(
            &self,
            _text: &str,
            _strip_prefixes: &[String],
        ) -> Result<CoverageMap, String> {
            Ok(self.map.clone())
        }

        fn merge_coverage(&self, maps: Vec<CoverageMap>) -> CoverageMap {
            let mut merged = BTreeMap::new();
            for map in maps {
                for (path, lines) in map {
                    merged.insert(path, lines);
                }
            }
            merged
        }
    }

    // ========================================================================
    // End-to-end tests with fixtures
    // ========================================================================

    #[test]
    fn test_e2e_uncovered() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..1111111
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,3 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
"#;

        let lcov = r#"TN:
SF:src/lib.rs
DA:1,0
DA:2,0
DA:3,0
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("fixtures/diff/simple_added.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["fixtures/lcov/uncovered.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        // Verify report
        assert_eq!(result.report.schema, SCHEMA_ID);
        assert_eq!(result.report.verdict.status, VerdictStatus::Fail);
        assert_eq!(result.report.data.changed_lines_total, 3);
        assert_eq!(result.report.data.covered_lines, 0);
        assert_eq!(result.report.data.uncovered_lines, 3);
        assert_eq!(result.report.data.diff_coverage_pct, 0.0);

        // Should have 3 uncovered line findings + 1 threshold finding
        assert_eq!(result.report.findings.len(), 4);

        // Verify exit code
        assert_eq!(result.exit_code, 2);

        // Verify markdown contains expected content
        assert!(result.markdown.contains("covguard"));
        assert!(result.markdown.contains("fail"));

        // Verify annotations are present
        assert!(!result.annotations.is_empty());
        assert!(result.annotations.contains("::error"));
    }

    #[test]
    fn test_check_with_providers_uses_injected_ports() {
        let request = CheckRequest {
            // This would fail with the built-in parser due to malformed hunk header.
            diff_text: "diff --git a/src/lib.rs b/src/lib.rs\n@@ -1,1 @@\n+line\n".to_string(),
            lcov_texts: vec!["SF:src/lib.rs\nDA:1,1\nend_of_record\n".to_string()],
            scope: Scope::Added,
            ..Default::default()
        };

        let mut changed_ranges = BTreeMap::new();
        changed_ranges.insert("src/lib.rs".to_string(), vec![1..=1]);
        let diff_provider = FakeDiffProvider {
            parsed: covguard_ports::DiffParseResult {
                changed_ranges,
                binary_files: Vec::new(),
            },
        };

        let mut coverage_lines = BTreeMap::new();
        coverage_lines.insert(1, 1);
        let mut coverage_map = BTreeMap::new();
        coverage_map.insert("src/lib.rs".to_string(), coverage_lines);
        let coverage_provider = FakeCoverageProvider { map: coverage_map };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_providers_and_reader(
            request,
            &clock,
            &NullReader,
            &diff_provider,
            &coverage_provider,
        )
        .unwrap();

        assert_eq!(result.report.verdict.status, VerdictStatus::Pass);
        assert_eq!(result.report.data.changed_lines_total, 1);
        assert_eq!(result.report.data.covered_lines, 1);
        assert_eq!(result.report.findings.len(), 0);
    }

    #[test]
    fn test_e2e_covered() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..1111111
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,3 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
"#;

        let lcov = r#"TN:
SF:src/lib.rs
DA:1,1
DA:2,1
DA:3,1
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("fixtures/diff/simple_added.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["fixtures/lcov/covered.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        // Verify report
        assert_eq!(result.report.verdict.status, VerdictStatus::Pass);
        assert_eq!(result.report.data.changed_lines_total, 3);
        assert_eq!(result.report.data.covered_lines, 3);
        assert_eq!(result.report.data.uncovered_lines, 0);
        assert_eq!(result.report.data.diff_coverage_pct, 100.0);

        // No findings for covered code
        assert!(result.report.findings.is_empty());

        // Verify exit code
        assert_eq!(result.exit_code, 0);

        // Verify markdown contains expected content
        assert!(result.markdown.contains("pass"));
    }

    // ========================================================================
    // Error handling tests
    // ========================================================================

    #[test]
    fn test_error_bad_diff() {
        let diff = "not a valid diff at all\nrandom garbage";
        let lcov = "TN:\nSF:src/lib.rs\nDA:1,1\nend_of_record\n";

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: None,
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec![],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let result = check(request).expect("invalid diff should return error report");
        assert_eq!(result.exit_code, 1);
        assert_eq!(result.report.verdict.status, VerdictStatus::Fail);
        assert!(
            result
                .report
                .findings
                .iter()
                .any(|f| f.code == CODE_INVALID_DIFF)
        );
        assert!(
            result
                .report
                .findings
                .iter()
                .any(|f| f.code == CODE_RUNTIME_ERROR)
        );
    }

    #[test]
    fn test_error_bad_lcov() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,1 @@
+fn main() {}
"#;

        // Invalid LCOV: DA without SF
        let lcov = "DA:1,1\nend_of_record\n";

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: None,
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec![],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let result = check(request).expect("invalid lcov should return error report");
        assert_eq!(result.exit_code, 1);
        assert_eq!(result.report.verdict.status, VerdictStatus::Fail);
        assert!(
            result
                .report
                .findings
                .iter()
                .any(|f| f.code == CODE_INVALID_LCOV)
        );
        assert!(
            result
                .report
                .findings
                .iter()
                .any(|f| f.code == CODE_RUNTIME_ERROR)
        );
    }

    // ========================================================================
    // Unit tests
    // ========================================================================

    #[test]
    fn test_check_request_default() {
        let request = CheckRequest::default();
        assert_eq!(request.threshold_pct, 80.0);
        assert_eq!(request.scope, Scope::Added);
        assert!(request.diff_text.is_empty());
        assert!(request.lcov_texts.is_empty());
    }

    #[test]
    fn test_clock_trait() {
        let clock = SystemClock;
        let now = clock.now();
        // Just verify it returns a valid time
        assert!(now.timestamp() > 0);
    }

    #[test]
    fn test_fixed_clock() {
        let clock = FixedClock::new("2026-02-02T12:30:45Z");
        let time = clock.now();
        assert_eq!(
            time.format("%Y-%m-%dT%H:%M:%SZ").to_string(),
            "2026-02-02T12:30:45Z"
        );
    }

    #[test]
    fn test_empty_diff() {
        let request = CheckRequest {
            diff_text: String::new(),
            diff_file_path: None,
            base_ref: None,
            head_ref: None,
            lcov_texts: vec!["TN:\nSF:src/lib.rs\nDA:1,1\nend_of_record\n".to_string()],
            lcov_paths: vec![],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let result = check(request).unwrap();
        assert_eq!(result.report.verdict.status, VerdictStatus::Pass);
        assert_eq!(result.report.data.changed_lines_total, 0);
        assert_eq!(result.exit_code, 0);
    }

    #[test]
    fn test_exit_codes() {
        // Pass case
        let request = CheckRequest {
            diff_text: String::new(),
            diff_file_path: None,
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![String::new()],
            lcov_paths: vec![],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };
        let result = check(request).unwrap();
        assert_eq!(result.exit_code, 0);

        // Fail case
        let diff =
            "diff --git a/x.rs b/x.rs\n--- /dev/null\n+++ b/x.rs\n@@ -0,0 +1,1 @@\n+fn x() {}\n";
        let lcov = "TN:\nSF:x.rs\nDA:1,0\nend_of_record\n";
        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: None,
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec![],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };
        let result = check(request).unwrap();
        assert_eq!(result.exit_code, 2);
    }

    #[test]
    fn test_build_report_timestamp() {
        use chrono::TimeZone;

        let eval = EvalOutput {
            findings: vec![],
            verdict: VerdictStatus::Pass,
            metrics: covguard_domain::Metrics::default(),
        };

        let request = CheckRequest::default();
        let started_at = chrono::Utc.with_ymd_and_hms(2026, 2, 2, 10, 30, 0).unwrap();
        let ended_at = chrono::Utc.with_ymd_and_hms(2026, 2, 2, 10, 30, 1).unwrap();

        let report = build_report(eval, &request, started_at, ended_at, 0, None);

        assert_eq!(report.run.started_at, "2026-02-02T10:30:00Z");
        assert_eq!(
            report.run.ended_at,
            Some("2026-02-02T10:30:01Z".to_string())
        );
        assert_eq!(report.run.duration_ms, Some(1000));
    }

    #[test]
    fn test_build_report_tool_info() {
        let eval = EvalOutput {
            findings: vec![],
            verdict: VerdictStatus::Pass,
            metrics: covguard_domain::Metrics::default(),
        };

        let request = CheckRequest::default();
        let started_at = chrono::Utc::now();
        let ended_at = started_at;

        let report = build_report(eval, &request, started_at, ended_at, 0, None);

        assert_eq!(report.tool.name, "covguard");
        assert_eq!(report.tool.version, "0.1.0");
    }

    #[test]
    fn test_render_markdown() {
        let report = Report::default();
        let md = render_markdown(&report);
        assert!(md.contains("covguard"));
    }

    #[test]
    fn test_render_annotations_empty() {
        let report = Report::default();
        let ann = render_annotations(&report);
        assert!(ann.is_empty());
    }

    #[test]
    fn test_scope_touched() {
        let diff =
            "diff --git a/x.rs b/x.rs\n--- /dev/null\n+++ b/x.rs\n@@ -0,0 +1,1 @@\n+fn x() {}\n";
        let lcov = "TN:\nSF:x.rs\nDA:1,1\nend_of_record\n";

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: None,
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec![],
            threshold_pct: 80.0,
            scope: Scope::Touched,
            ..Default::default()
        };

        let result = check(request).unwrap();
        assert_eq!(result.report.data.scope, "touched");
    }

    #[test]
    fn test_git_refs_metadata() {
        let diff =
            "diff --git a/x.rs b/x.rs\n--- /dev/null\n+++ b/x.rs\n@@ -0,0 +1,1 @@\n+fn x() {}\n";
        let lcov = "TN:\nSF:x.rs\nDA:1,1\nend_of_record\n";

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: None,
            base_ref: Some("main".to_string()),
            head_ref: Some("feature".to_string()),
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["coverage.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let result = check(request).unwrap();
        assert_eq!(result.report.data.inputs.diff_source, "git-refs");
        assert_eq!(result.report.data.inputs.base, Some("main".to_string()));
        assert_eq!(result.report.data.inputs.head, Some("feature".to_string()));
        assert!(result.report.data.inputs.diff_file.is_none());
    }

    #[test]
    fn test_diff_file_metadata() {
        let diff =
            "diff --git a/x.rs b/x.rs\n--- /dev/null\n+++ b/x.rs\n@@ -0,0 +1,1 @@\n+fn x() {}\n";
        let lcov = "TN:\nSF:x.rs\nDA:1,1\nend_of_record\n";

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("my.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["coverage.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let result = check(request).unwrap();
        assert_eq!(result.report.data.inputs.diff_source, "diff-file");
        assert_eq!(
            result.report.data.inputs.diff_file,
            Some("my.patch".to_string())
        );
        assert!(result.report.data.inputs.base.is_none());
        assert!(result.report.data.inputs.head.is_none());
    }

    // ========================================================================
    // Insta Snapshot Tests
    // ========================================================================

    #[test]
    fn test_snapshot_report_uncovered() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..1111111
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,3 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
"#;

        let lcov = r#"TN:
SF:src/lib.rs
DA:1,0
DA:2,0
DA:3,0
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("fixtures/diff/simple_added.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["fixtures/lcov/uncovered.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        let report_json: serde_json::Value = serde_json::to_value(&result.report).unwrap();
        insta::assert_json_snapshot!("report_uncovered", report_json);
    }

    #[test]
    fn test_snapshot_report_covered() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..1111111
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,3 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
"#;

        let lcov = r#"TN:
SF:src/lib.rs
DA:1,1
DA:2,1
DA:3,1
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("fixtures/diff/simple_added.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["fixtures/lcov/covered.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        let report_json: serde_json::Value = serde_json::to_value(&result.report).unwrap();
        insta::assert_json_snapshot!("report_covered", report_json);
    }

    #[test]
    fn test_snapshot_report_partial() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..1111111
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,5 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
+pub fn sub(a: i32, b: i32) -> i32 {
+    a - b
"#;

        let lcov = r#"TN:
SF:src/lib.rs
DA:1,1
DA:2,1
DA:3,1
DA:4,0
DA:5,0
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("fixtures/diff/partial.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["fixtures/lcov/partial.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        let report_json: serde_json::Value = serde_json::to_value(&result.report).unwrap();
        insta::assert_json_snapshot!("report_partial", report_json);
    }

    #[test]
    fn test_snapshot_report_empty_diff() {
        let diff = "";
        let lcov = r#"TN:
SF:src/lib.rs
DA:1,1
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: None,
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["fixtures/lcov/covered.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        let report_json: serde_json::Value = serde_json::to_value(&result.report).unwrap();
        insta::assert_json_snapshot!("report_empty_diff", report_json);
    }

    #[test]
    fn test_snapshot_markdown_uncovered() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..1111111
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,3 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
"#;

        let lcov = r#"TN:
SF:src/lib.rs
DA:1,0
DA:2,0
DA:3,0
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("fixtures/diff/simple_added.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["fixtures/lcov/uncovered.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        insta::assert_snapshot!("full_markdown_uncovered", result.markdown);
    }

    #[test]
    fn test_snapshot_sarif_uncovered() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..1111111
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,3 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
"#;

        let lcov = r#"TN:
SF:src/lib.rs
DA:1,0
DA:2,0
DA:3,0
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("fixtures/diff/simple_added.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["fixtures/lcov/uncovered.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        let sarif_json: serde_json::Value = serde_json::from_str(&result.sarif).unwrap();
        insta::assert_json_snapshot!("full_sarif_uncovered", sarif_json);
    }

    // ========================================================================
    // Sensor Schema / Cockpit Mode Tests
    // ========================================================================

    #[test]
    fn test_sensor_schema_skip_on_missing_coverage() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,1 @@
+fn main() {}
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("test.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![], // No coverage provided
            lcov_paths: vec![],
            threshold_pct: 80.0,
            scope: Scope::Added,
            sensor_schema: true, // Enable sensor schema mode
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        // Domain report should always use standard schema, no capabilities
        assert_eq!(result.report.schema, SCHEMA_ID);
        assert!(result.report.run.capabilities.is_none());
        assert_eq!(result.report.verdict.status, VerdictStatus::Skip);
        assert_eq!(result.exit_code, 0);

        // Cockpit receipt should have sensor schema and capabilities
        let receipt = result.cockpit_receipt.as_ref().unwrap();
        assert_eq!(receipt.schema, SENSOR_SCHEMA_ID);
        let capabilities = receipt.run.capabilities.as_ref().unwrap();
        assert_eq!(capabilities.inputs.diff.status, InputStatus::Available);
        assert_eq!(
            capabilities.inputs.coverage.status,
            InputStatus::Unavailable
        );
        assert_eq!(
            capabilities.inputs.coverage.reason,
            Some("missing_lcov".to_string())
        );

        // Should have missing_lcov reason
        assert!(
            receipt
                .verdict
                .reasons
                .contains(&"missing_lcov".to_string())
        );

        // No findings for skip
        assert!(receipt.findings.is_empty());
    }

    #[test]
    fn test_sensor_schema_includes_capabilities_on_success() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,1 @@
+fn main() {}
"#;

        let lcov = "TN:\nSF:src/lib.rs\nDA:1,1\nend_of_record\n";

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("test.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["coverage.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            sensor_schema: true, // Enable sensor schema mode
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        // Domain report should always use standard schema, no capabilities
        assert_eq!(result.report.schema, SCHEMA_ID);
        assert!(result.report.run.capabilities.is_none());
        assert_eq!(result.report.verdict.status, VerdictStatus::Pass);

        // Cockpit receipt should have sensor schema and capabilities
        let receipt = result.cockpit_receipt.as_ref().unwrap();
        assert_eq!(receipt.schema, SENSOR_SCHEMA_ID);
        let capabilities = receipt.run.capabilities.as_ref().unwrap();
        assert_eq!(capabilities.inputs.diff.status, InputStatus::Available);
        assert_eq!(capabilities.inputs.coverage.status, InputStatus::Available);
    }

    #[test]
    fn test_standard_schema_no_capabilities() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,1 @@
+fn main() {}
"#;

        let lcov = "TN:\nSF:src/lib.rs\nDA:1,1\nend_of_record\n";

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("test.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["coverage.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            sensor_schema: false, // Standard mode
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        // Should use standard schema
        assert_eq!(result.report.schema, SCHEMA_ID);

        // Should NOT have capabilities block
        assert!(result.report.run.capabilities.is_none());

        // No cockpit receipt in standard mode
        assert!(result.cockpit_receipt.is_none());
    }

    #[test]
    fn test_snapshot_report_skip_no_coverage() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,1 @@
+fn main() {}
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("fixtures/diff/simple.patch".to_string()),
            base_ref: None,
            head_ref: None,
            lcov_texts: vec![],
            lcov_paths: vec![],
            threshold_pct: 80.0,
            scope: Scope::Added,
            sensor_schema: true,
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        // Snapshot the domain report (now covguard.report.v1)
        let report_json: serde_json::Value = serde_json::to_value(&result.report).unwrap();
        insta::assert_json_snapshot!("report_skip_no_coverage", report_json);
    }

    // ========================================================================
    // Truncation Edge-Case Tests
    // ========================================================================

    #[test]
    fn test_max_findings_zero_produces_truncation_metadata() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..1111111
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,3 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
"#;

        let lcov = r#"TN:
SF:src/lib.rs
DA:1,0
DA:2,0
DA:3,0
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("test.patch".to_string()),
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["coverage.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            max_findings: Some(0),
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        // Findings array should be empty
        assert!(result.report.findings.is_empty());

        // Truncation metadata should be present
        let truncation = result
            .report
            .data
            .truncation
            .as_ref()
            .expect("truncation metadata should be present");
        assert!(truncation.findings_truncated);
        assert_eq!(truncation.shown, 0);
        assert!(
            truncation.total > 0,
            "total should reflect pre-truncation count"
        );

        // Reasons should include "truncated"
        let has_trunc_reason = result
            .report
            .verdict
            .reasons
            .contains(&REASON_TRUNCATED.to_string());
        assert!(has_trunc_reason, "reasons should include 'truncated'");
    }

    // ========================================================================
    // Core Split Tests
    // ========================================================================

    #[test]
    fn test_cockpit_receipt_has_truncated_findings() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..1111111
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,3 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
"#;

        let lcov = r#"TN:
SF:src/lib.rs
DA:1,0
DA:2,0
DA:3,0
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("test.patch".to_string()),
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["coverage.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            sensor_schema: true,
            max_findings: Some(2),
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        // Domain report should have ALL findings (no truncation in cockpit mode)
        assert_eq!(result.report.findings.len(), 4); // 3 uncovered + 1 threshold
        assert!(result.report.data.truncation.is_none());
        assert_eq!(result.report.schema, SCHEMA_ID);
        assert!(result.report.run.capabilities.is_none());

        // Cockpit receipt should have truncated findings
        let receipt = result.cockpit_receipt.as_ref().unwrap();
        assert_eq!(receipt.findings.len(), 2);
        assert_eq!(receipt.schema, SENSOR_SCHEMA_ID);
        let truncation = receipt.data.truncation.as_ref().unwrap();
        assert!(truncation.findings_truncated);
        assert_eq!(truncation.shown, 2);
        assert_eq!(truncation.total, 4);
    }

    #[test]
    fn test_cockpit_receipt_counts_reflect_full_set() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..1111111
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,3 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
"#;

        let lcov = r#"TN:
SF:src/lib.rs
DA:1,0
DA:2,0
DA:3,0
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("test.patch".to_string()),
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["coverage.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            sensor_schema: true,
            max_findings: Some(1),
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        // Cockpit receipt counts should reflect ALL findings, not just truncated
        let receipt = result.cockpit_receipt.as_ref().unwrap();
        assert_eq!(receipt.findings.len(), 1); // Truncated to 1
        assert_eq!(receipt.verdict.counts.error, 4); // But counts reflect full 4
    }

    #[test]
    fn test_domain_report_never_has_capabilities() {
        // Standard mode
        let diff =
            "diff --git a/x.rs b/x.rs\n--- /dev/null\n+++ b/x.rs\n@@ -0,0 +1,1 @@\n+fn x() {}\n";
        let lcov = "TN:\nSF:x.rs\nDA:1,1\nend_of_record\n";

        let request = CheckRequest {
            diff_text: diff.to_string(),
            lcov_texts: vec![lcov.to_string()],
            sensor_schema: false,
            ..Default::default()
        };
        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();
        assert!(result.report.run.capabilities.is_none());

        // Cockpit mode
        let request = CheckRequest {
            diff_text: diff.to_string(),
            lcov_texts: vec![lcov.to_string()],
            sensor_schema: true,
            ..Default::default()
        };
        let result = check_with_clock(request, &clock).unwrap();
        assert!(result.report.run.capabilities.is_none());
        assert_eq!(result.report.schema, SCHEMA_ID);

        // Cockpit receipt HAS capabilities
        let receipt = result.cockpit_receipt.as_ref().unwrap();
        assert!(receipt.run.capabilities.is_some());
    }

    #[test]
    fn test_renderers_use_full_findings() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..1111111
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,3 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
"#;

        let lcov = r#"TN:
SF:src/lib.rs
DA:1,0
DA:2,0
DA:3,0
end_of_record
"#;

        let request = CheckRequest {
            diff_text: diff.to_string(),
            diff_file_path: Some("test.patch".to_string()),
            lcov_texts: vec![lcov.to_string()],
            lcov_paths: vec!["coverage.info".to_string()],
            threshold_pct: 80.0,
            scope: Scope::Added,
            sensor_schema: true,
            max_findings: Some(1), // Truncate cockpit receipt heavily
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        // Cockpit receipt only has 1 finding
        let receipt = result.cockpit_receipt.as_ref().unwrap();
        assert_eq!(receipt.findings.len(), 1);

        // But markdown (rendered from domain report) should contain all uncovered lines
        // The domain report has 4 findings (3 uncovered + 1 threshold)
        assert_eq!(result.report.findings.len(), 4);
        // Markdown should mention all 3 uncovered lines
        assert!(result.markdown.contains("src/lib.rs"));
    }

    // ========================================================================
    // Helper/Utility Tests
    // ========================================================================

    #[test]
    fn test_build_debug_empty_returns_none() {
        assert!(build_debug(&[]).is_none());
    }

    #[test]
    fn test_build_debug_populated() {
        let debug = build_debug(&["assets/logo.png".to_string()]).expect("debug");
        assert_eq!(debug["binary_files_count"], 1);
        assert_eq!(debug["binary_files"][0], "assets/logo.png");
    }

    #[test]
    fn test_is_invalid_diff_detection() {
        assert!(!is_invalid_diff(""));
        assert!(!is_invalid_diff("   \n\t"));
        assert!(!is_invalid_diff("diff --git a/a.rs b/a.rs"));
        assert!(!is_invalid_diff("@@ -1 +1 @@"));
        assert!(!is_invalid_diff("+++ b/a.rs"));
        assert!(!is_invalid_diff("--- a/a.rs"));
        assert!(!is_invalid_diff("rename to a.rs"));
        assert!(is_invalid_diff("just some random text"));
    }

    #[test]
    fn test_build_reasons_pass_no_changes() {
        let output = EvalOutput {
            findings: vec![],
            verdict: VerdictStatus::Pass,
            metrics: Metrics {
                changed_lines_total: 0,
                ..Metrics::default()
            },
        };

        let reasons = build_reasons(&output);
        assert_eq!(reasons, vec![REASON_NO_CHANGED_LINES.to_string()]);
    }

    #[test]
    fn test_build_reasons_pass_with_changes() {
        let output = EvalOutput {
            findings: vec![],
            verdict: VerdictStatus::Pass,
            metrics: Metrics {
                changed_lines_total: 3,
                ..Metrics::default()
            },
        };

        let reasons = build_reasons(&output);
        assert_eq!(reasons, vec![REASON_DIFF_COVERED.to_string()]);
    }

    #[test]
    fn test_build_reasons_warn_with_uncovered_and_threshold() {
        let finding = Finding {
            severity: covguard_types::Severity::Error,
            check_id: "diff.coverage_below_threshold".to_string(),
            code: CODE_COVERAGE_BELOW_THRESHOLD.to_string(),
            message: "below threshold".to_string(),
            location: None,
            data: None,
            fingerprint: None,
        };

        let output = EvalOutput {
            findings: vec![finding],
            verdict: VerdictStatus::Warn,
            metrics: Metrics {
                changed_lines_total: 5,
                uncovered_lines: 2,
                ..Metrics::default()
            },
        };

        let reasons = build_reasons(&output);
        assert!(reasons.contains(&REASON_UNCOVERED_LINES.to_string()));
        assert!(reasons.contains(&REASON_BELOW_THRESHOLD.to_string()));
    }

    #[test]
    fn test_build_reasons_skip() {
        let output = EvalOutput {
            findings: vec![],
            verdict: VerdictStatus::Skip,
            metrics: Metrics::default(),
        };

        let reasons = build_reasons(&output);
        assert_eq!(reasons, vec![REASON_SKIPPED.to_string()]);
    }

    #[test]
    fn test_detect_ignored_lines_with_reader() {
        let mut changed_ranges = BTreeMap::new();
        changed_ranges.insert("src/lib.rs".to_string(), vec![1..=3]);
        changed_ranges.insert("src/main.rs".to_string(), vec![10..=11]);

        let reader = MapReader::new(vec![
            ("src/lib.rs", 2, "let x = 1; // covguard: ignore"),
            ("src/main.rs", 11, "# covguard: ignore"),
        ]);

        let ignored = detect_ignored_lines(&changed_ranges, &reader);
        assert_eq!(
            ignored.get("src/lib.rs").cloned(),
            Some(BTreeSet::from([2]))
        );
        assert_eq!(
            ignored.get("src/main.rs").cloned(),
            Some(BTreeSet::from([11]))
        );
    }

    #[test]
    fn test_detect_ignored_lines_empty_when_no_directives() {
        let mut changed_ranges = BTreeMap::new();
        changed_ranges.insert("src/lib.rs".to_string(), vec![1..=2]);

        let reader = MapReader::new(vec![("src/lib.rs", 1, "let x = 1;")]);
        let ignored = detect_ignored_lines(&changed_ranges, &reader);
        assert!(ignored.is_empty());
    }

    #[test]
    fn test_app_error_from_diff_error() {
        use covguard_adapters_diff::DiffError;

        let err = DiffError::InvalidFormat("bad diff".to_string());
        let app: AppError = err.into();
        assert!(matches!(
            app,
            AppError::DiffParse(ref msg) if msg.contains("bad diff")
        ));
    }

    #[test]
    fn test_app_error_from_lcov_error() {
        use covguard_adapters_coverage::LcovError;

        let err = LcovError::InvalidFormat("bad lcov".to_string());
        let app: AppError = err.into();
        assert!(matches!(
            app,
            AppError::LcovParse(ref msg) if msg.contains("bad lcov")
        ));
    }

    #[test]
    fn test_error_bad_diff_parse_branch() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
index 1111111..2222222 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,1 @@
+line
"#;

        let lcov = "TN:\nSF:src/lib.rs\nDA:1,1\nend_of_record\n";
        let request = CheckRequest {
            diff_text: diff.to_string(),
            lcov_texts: vec![lcov.to_string()],
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        assert!(
            result
                .report
                .findings
                .iter()
                .any(|f| f.code == CODE_INVALID_DIFF)
        );
    }

    #[test]
    fn test_error_lcov_missing_sf_records() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,1 @@
+fn main() {}
"#;

        let lcov = "TN:\nDA:1,1\nend_of_record\n";
        let request = CheckRequest {
            diff_text: diff.to_string(),
            lcov_texts: vec![lcov.to_string()],
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();
        assert!(
            result
                .report
                .findings
                .iter()
                .any(|f| f.code == CODE_INVALID_LCOV)
        );
    }

    #[test]
    fn test_error_lcov_parse_failure_branch() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,1 @@
+fn main() {}
"#;

        let lcov = "TN:\nSF:src/lib.rs\nDA:abc,1\nend_of_record\n";
        let request = CheckRequest {
            diff_text: diff.to_string(),
            lcov_texts: vec![lcov.to_string()],
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();
        assert!(
            result
                .report
                .findings
                .iter()
                .any(|f| f.code == CODE_INVALID_LCOV)
        );
    }

    #[test]
    fn test_excluded_files_count_incremented() {
        let diff = r#"diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,1 @@
+fn main() {}
"#;
        let lcov = "TN:\nSF:src/lib.rs\nDA:1,1\nend_of_record\n";
        let request = CheckRequest {
            diff_text: diff.to_string(),
            lcov_texts: vec![lcov.to_string()],
            exclude_patterns: vec!["src/**".to_string()],
            ..Default::default()
        };

        let clock = FixedClock::new("2026-02-02T00:00:00Z");
        let result = check_with_clock(request, &clock).unwrap();

        assert_eq!(result.report.data.excluded_files_count, 1);
    }

    #[test]
    fn test_truncate_findings_no_truncation_when_under_limit() {
        let findings = vec![Finding::uncovered_line("src/lib.rs", 1, 0)];
        let (truncated, trunc) = covguard_output::truncate_findings(findings.clone(), Some(5));
        assert_eq!(truncated.len(), findings.len());
        assert!(trunc.is_none());
    }

    #[test]
    fn test_build_error_report_pair_with_capabilities() {
        let request = CheckRequest {
            base_ref: Some("main".to_string()),
            head_ref: Some("feature".to_string()),
            sensor_schema: true,
            scope: Scope::Touched,
            ..Default::default()
        };
        let now = chrono::Utc::now();
        let (domain, receipt) = build_error_report_pair(
            &request,
            now,
            now,
            CODE_INVALID_DIFF,
            "bad diff",
            true,
            false,
        );

        assert_eq!(domain.data.inputs.diff_source, "git-refs");
        let receipt = receipt.expect("receipt should exist");
        let capabilities = receipt.run.capabilities.expect("capabilities");
        assert_eq!(capabilities.inputs.diff.status, InputStatus::Available);
        assert_eq!(
            capabilities.inputs.coverage.status,
            InputStatus::Unavailable
        );
    }

    #[test]
    fn test_build_error_report_pair_diff_missing() {
        let request = CheckRequest {
            sensor_schema: true,
            scope: Scope::Added,
            ..Default::default()
        };
        let now = chrono::Utc::now();
        let (_domain, receipt) = build_error_report_pair(
            &request,
            now,
            now,
            CODE_INVALID_DIFF,
            "bad diff",
            false,
            true,
        );

        let receipt = receipt.expect("receipt should exist");
        let capabilities = receipt.run.capabilities.expect("capabilities");
        assert_eq!(capabilities.inputs.diff.status, InputStatus::Unavailable);
        assert_eq!(capabilities.inputs.coverage.status, InputStatus::Available);
    }

    #[test]
    fn test_build_error_report_pair_without_capabilities() {
        let request = CheckRequest {
            sensor_schema: false,
            ..Default::default()
        };
        let now = chrono::Utc::now();
        let (_domain, receipt) = build_error_report_pair(
            &request,
            now,
            now,
            CODE_INVALID_DIFF,
            "bad diff",
            true,
            true,
        );
        assert!(receipt.is_none());
    }

    #[test]
    fn test_build_skip_report_pair_sensor_schema_false_stdin() {
        let request = CheckRequest {
            sensor_schema: false,
            scope: Scope::Touched,
            ..Default::default()
        };
        let now = chrono::Utc::now();
        let (domain, receipt) =
            build_skip_report_pair(&request, now, now, false, true, REASON_MISSING_LCOV);
        assert_eq!(domain.data.inputs.diff_source, "stdin");
        assert_eq!(domain.data.scope, "touched");
        assert!(receipt.is_none());
    }

    #[test]
    fn test_build_skip_report_pair_diff_present_cov_missing() {
        let request = CheckRequest {
            base_ref: Some("main".to_string()),
            head_ref: Some("feature".to_string()),
            sensor_schema: true,
            ..Default::default()
        };
        let now = chrono::Utc::now();
        let (_domain, receipt) =
            build_skip_report_pair(&request, now, now, true, false, REASON_MISSING_LCOV);
        let receipt = receipt.expect("receipt should exist");
        let capabilities = receipt.run.capabilities.expect("capabilities");
        assert_eq!(capabilities.inputs.diff.status, InputStatus::Available);
        assert_eq!(
            capabilities.inputs.coverage.status,
            InputStatus::Unavailable
        );
    }

    #[test]
    fn test_build_skip_report_pair_diff_missing_cov_present() {
        let request = CheckRequest {
            sensor_schema: true,
            ..Default::default()
        };
        let now = chrono::Utc::now();
        let (_domain, receipt) =
            build_skip_report_pair(&request, now, now, false, true, REASON_MISSING_LCOV);
        let receipt = receipt.expect("receipt should exist");
        let capabilities = receipt.run.capabilities.expect("capabilities");
        assert_eq!(capabilities.inputs.diff.status, InputStatus::Unavailable);
        assert_eq!(capabilities.inputs.coverage.status, InputStatus::Available);
    }

    #[test]
    fn test_render_wrappers_with_limits() {
        let report = Report::default();
        let md = render_markdown_with_limit(&report, 1);
        let annotations = render_annotations_with_limit(&report, 1);
        let sarif = render_sarif_with_limit(&report, 1);

        assert!(!md.is_empty());
        assert!(annotations.is_empty());
        assert!(sarif.contains("\"version\""));
    }
}