@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/dotnet_cmd.rs

@@ -1,1771 +0,0 @@
-use crate::binlog;
-use crate::dotnet_format_report;
-use crate::dotnet_trx;
-use crate::tracking;
-use crate::utils::truncate;
-use anyhow::{Context, Result};
-use std::ffi::OsString;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-const DOTNET_CLI_UI_LANGUAGE: &str = "DOTNET_CLI_UI_LANGUAGE";
-const DOTNET_CLI_UI_LANGUAGE_VALUE: &str = "en-US";
-static TEMP_PATH_COUNTER: AtomicU64 = AtomicU64::new(0);
-
-pub fn run_build(args: &[String], verbose: u8) -> Result<()> {
-    run_dotnet_with_binlog("build", args, verbose)
-}
-
-pub fn run_test(args: &[String], verbose: u8) -> Result<()> {
-    run_dotnet_with_binlog("test", args, verbose)
-}
-
-pub fn run_restore(args: &[String], verbose: u8) -> Result<()> {
-    run_dotnet_with_binlog("restore", args, verbose)
-}
-
-pub fn run_format(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-    let (report_path, cleanup_report_path) = resolve_format_report_path(args);
-    let mut cmd = Command::new("dotnet");
-    cmd.env(DOTNET_CLI_UI_LANGUAGE, DOTNET_CLI_UI_LANGUAGE_VALUE);
-    cmd.arg("format");
-
-    for arg in build_effective_dotnet_format_args(args, report_path.as_deref()) {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: dotnet format {}", args.join(" "));
-    }
-
-    let command_started_at = SystemTime::now();
-    let output = cmd.output().context("Failed to run dotnet format")?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let check_mode = !has_write_mode_override(args);
-    let filtered =
-        format_report_summary_or_raw(report_path.as_deref(), check_mode, &raw, command_started_at);
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("dotnet format {}", args.join(" ")),
-        &format!("rtk dotnet format {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    if cleanup_report_path {
-        if let Some(path) = report_path.as_deref() {
-            cleanup_temp_file(path);
-        }
-    }
-
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
-}
-
-pub fn run_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
-    if args.is_empty() {
-        anyhow::bail!("dotnet: no subcommand specified");
-    }
-
-    let timer = tracking::TimedExecution::start();
-    let subcommand = args[0].to_string_lossy().to_string();
-
-    let mut cmd = Command::new("dotnet");
-    cmd.env(DOTNET_CLI_UI_LANGUAGE, DOTNET_CLI_UI_LANGUAGE_VALUE);
-    cmd.arg(&subcommand);
-    for arg in &args[1..] {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: dotnet {} ...", subcommand);
-    }
-
-    let output = cmd
-        .output()
-        .with_context(|| format!("Failed to run dotnet {}", subcommand))?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    print!("{}", stdout);
-    eprint!("{}", stderr);
-
-    timer.track(
-        &format!("dotnet {}", subcommand),
-        &format!("rtk dotnet {}", subcommand),
-        &raw,
-        &raw,
-    );
-
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
-}
-
-fn run_dotnet_with_binlog(subcommand: &str, args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-    let binlog_path = build_binlog_path(subcommand);
-    let should_expect_binlog = subcommand != "test" || has_binlog_arg(args);
-
-    // For test commands, prefer user-provided results directory; otherwise create isolated one.
-    let (trx_results_dir, cleanup_trx_results_dir) = resolve_trx_results_dir(subcommand, args);
-
-    let mut cmd = Command::new("dotnet");
-    cmd.env(DOTNET_CLI_UI_LANGUAGE, DOTNET_CLI_UI_LANGUAGE_VALUE);
-    cmd.arg(subcommand);
-
-    for arg in
-        build_effective_dotnet_args(subcommand, args, &binlog_path, trx_results_dir.as_deref())
-    {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: dotnet {} {}", subcommand, args.join(" "));
-    }
-
-    let command_started_at = SystemTime::now();
-    let output = cmd
-        .output()
-        .with_context(|| format!("Failed to run dotnet {}", subcommand))?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let filtered = match subcommand {
-        "build" => {
-            let binlog_summary = if should_expect_binlog && binlog_path.exists() {
-                normalize_build_summary(
-                    binlog::parse_build(&binlog_path).unwrap_or_default(),
-                    output.status.success(),
-                )
-            } else {
-                binlog::BuildSummary::default()
-            };
-            let raw_summary = normalize_build_summary(
-                binlog::parse_build_from_text(&raw),
-                output.status.success(),
-            );
-            let summary = merge_build_summaries(binlog_summary, raw_summary);
-            format_build_output(&summary, &binlog_path)
-        }
-        "test" => {
-            // First try to parse from binlog/console output
-            let parsed_summary = if should_expect_binlog && binlog_path.exists() {
-                binlog::parse_test(&binlog_path).unwrap_or_default()
-            } else {
-                binlog::TestSummary::default()
-            };
-            let raw_summary = binlog::parse_test_from_text(&raw);
-            let merged_summary = merge_test_summaries(parsed_summary, raw_summary);
-            let summary = merge_test_summary_from_trx(
-                merged_summary,
-                trx_results_dir.as_deref(),
-                dotnet_trx::find_recent_trx_in_testresults(),
-                command_started_at,
-            );
-
-            let summary = normalize_test_summary(summary, output.status.success());
-            let binlog_diagnostics = if should_expect_binlog && binlog_path.exists() {
-                normalize_build_summary(
-                    binlog::parse_build(&binlog_path).unwrap_or_default(),
-                    output.status.success(),
-                )
-            } else {
-                binlog::BuildSummary::default()
-            };
-            let raw_diagnostics = normalize_build_summary(
-                binlog::parse_build_from_text(&raw),
-                output.status.success(),
-            );
-            let test_build_summary = merge_build_summaries(binlog_diagnostics, raw_diagnostics);
-            format_test_output(
-                &summary,
-                &test_build_summary.errors,
-                &test_build_summary.warnings,
-                &binlog_path,
-            )
-        }
-        "restore" => {
-            let binlog_summary = if should_expect_binlog && binlog_path.exists() {
-                normalize_restore_summary(
-                    binlog::parse_restore(&binlog_path).unwrap_or_default(),
-                    output.status.success(),
-                )
-            } else {
-                binlog::RestoreSummary::default()
-            };
-            let raw_summary = normalize_restore_summary(
-                binlog::parse_restore_from_text(&raw),
-                output.status.success(),
-            );
-            let summary = merge_restore_summaries(binlog_summary, raw_summary);
-
-            let (raw_errors, raw_warnings) = binlog::parse_restore_issues_from_text(&raw);
-
-            format_restore_output(&summary, &raw_errors, &raw_warnings, &binlog_path)
-        }
-        _ => raw.clone(),
-    };
-
-    let output_to_print = if !output.status.success() {
-        let stdout_trimmed = stdout.trim();
-        let stderr_trimmed = stderr.trim();
-        if !stdout_trimmed.is_empty() {
-            format!("{}\n\n{}", stdout_trimmed, filtered)
-        } else if !stderr_trimmed.is_empty() {
-            format!("{}\n\n{}", stderr_trimmed, filtered)
-        } else {
-            filtered
-        }
-    } else {
-        filtered
-    };
-
-    println!("{}", output_to_print);
-
-    timer.track(
-        &format!("dotnet {} {}", subcommand, args.join(" ")),
-        &format!("rtk dotnet {} {}", subcommand, args.join(" ")),
-        &raw,
-        &output_to_print,
-    );
-
-    cleanup_temp_file(&binlog_path);
-    if cleanup_trx_results_dir {
-        if let Some(dir) = trx_results_dir.as_deref() {
-            cleanup_temp_dir(dir);
-        }
-    }
-
-    if verbose > 0 {
-        eprintln!("Binlog cleaned up: {}", binlog_path.display());
-    }
-
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
-}
-
-fn build_binlog_path(subcommand: &str) -> PathBuf {
-    std::env::temp_dir().join(format!(
-        "rtk_dotnet_{}_{}.binlog",
-        subcommand,
-        unique_temp_suffix()
-    ))
-}
-
-fn build_trx_results_dir() -> PathBuf {
-    std::env::temp_dir().join(format!("rtk_dotnet_testresults_{}", unique_temp_suffix()))
-}
-
-fn unique_temp_suffix() -> String {
-    let ts = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_millis())
-        .unwrap_or(0);
-    let pid = std::process::id();
-    let seq = TEMP_PATH_COUNTER.fetch_add(1, Ordering::Relaxed);
-
-    // Keep suffix compact to avoid long temp paths while preserving practical uniqueness.
-    format!("{:x}{:x}{:x}", ts, pid, seq)
-}
-
-fn resolve_trx_results_dir(subcommand: &str, args: &[String]) -> (Option<PathBuf>, bool) {
-    if subcommand != "test" {
-        return (None, false);
-    }
-
-    if let Some(user_dir) = extract_results_directory_arg(args) {
-        return (Some(user_dir), false);
-    }
-
-    (Some(build_trx_results_dir()), true)
-}
-
-fn build_format_report_path() -> PathBuf {
-    std::env::temp_dir().join(format!("rtk_dotnet_format_{}.json", unique_temp_suffix()))
-}
-
-fn resolve_format_report_path(args: &[String]) -> (Option<PathBuf>, bool) {
-    if let Some(user_report_path) = extract_report_arg(args) {
-        return (Some(user_report_path), false);
-    }
-
-    (Some(build_format_report_path()), true)
-}
-
-fn build_effective_dotnet_format_args(args: &[String], report_path: Option<&Path>) -> Vec<String> {
-    let mut effective: Vec<String> = args
-        .iter()
-        .filter(|arg| !arg.eq_ignore_ascii_case("--write"))
-        .cloned()
-        .collect();
-    let force_write_mode = has_write_mode_override(args);
-
-    if !force_write_mode && !has_verify_no_changes_arg(args) {
-        effective.push("--verify-no-changes".to_string());
-    }
-
-    if !has_report_arg(args) {
-        if let Some(path) = report_path {
-            effective.push("--report".to_string());
-            effective.push(path.display().to_string());
-        }
-    }
-
-    effective
-}
-
-fn format_report_summary_or_raw(
-    report_path: Option<&Path>,
-    check_mode: bool,
-    raw: &str,
-    command_started_at: SystemTime,
-) -> String {
-    let Some(report_path) = report_path else {
-        return raw.to_string();
-    };
-
-    if !is_fresh_report(report_path, command_started_at) {
-        return raw.to_string();
-    }
-
-    match dotnet_format_report::parse_format_report(report_path) {
-        Ok(summary) => format_dotnet_format_output(&summary, check_mode),
-        Err(_) => raw.to_string(),
-    }
-}
-
-fn is_fresh_report(path: &Path, command_started_at: SystemTime) -> bool {
-    let Ok(metadata) = std::fs::metadata(path) else {
-        return false;
-    };
-
-    let Ok(modified_at) = metadata.modified() else {
-        return false;
-    };
-
-    modified_at.duration_since(command_started_at).is_ok()
-}
-
-fn format_dotnet_format_output(
-    summary: &dotnet_format_report::FormatSummary,
-    check_mode: bool,
-) -> String {
-    let changed_count = summary.files_with_changes.len();
-
-    if changed_count == 0 {
-        return format!(
-            "ok dotnet format: {} files formatted correctly",
-            summary.total_files
-        );
-    }
-
-    if !check_mode {
-        return format!(
-            "ok dotnet format: formatted {} files ({} already formatted)",
-            changed_count, summary.files_unchanged
-        );
-    }
-
-    let mut output = format!("Format: {} files need formatting", changed_count);
-    output.push_str("\n---------------------------------------");
-
-    for (index, file) in summary.files_with_changes.iter().take(20).enumerate() {
-        let first_change = &file.changes[0];
-        let rule = if first_change.diagnostic_id.is_empty() {
-            first_change.format_description.as_str()
-        } else {
-            first_change.diagnostic_id.as_str()
-        };
-        output.push_str(&format!(
-            "\n{}. {} (line {}, col {}, {})",
-            index + 1,
-            file.path,
-            first_change.line_number,
-            first_change.char_number,
-            rule
-        ));
-    }
-
-    if changed_count > 20 {
-        output.push_str(&format!("\n... +{} more files", changed_count - 20));
-    }
-
-    output.push_str(&format!(
-        "\n\nok {} files already formatted\nRun `dotnet format` to apply fixes",
-        summary.files_unchanged
-    ));
-    output
-}
-
-fn cleanup_temp_file(path: &Path) {
-    if path.exists() {
-        std::fs::remove_file(path).ok();
-    }
-}
-
-fn cleanup_temp_dir(path: &Path) {
-    if path.exists() {
-        std::fs::remove_dir_all(path).ok();
-    }
-}
-
-fn merge_test_summary_from_trx(
-    mut summary: binlog::TestSummary,
-    trx_results_dir: Option<&Path>,
-    fallback_trx_path: Option<PathBuf>,
-    command_started_at: SystemTime,
-) -> binlog::TestSummary {
-    let mut trx_summary = None;
-
-    if let Some(dir) = trx_results_dir.filter(|path| path.exists()) {
-        trx_summary = dotnet_trx::parse_trx_files_in_dir_since(dir, Some(command_started_at));
-
-        if trx_summary.is_none() {
-            trx_summary = dotnet_trx::parse_trx_files_in_dir(dir);
-        }
-    }
-
-    if trx_summary.is_none() {
-        if let Some(trx) = fallback_trx_path {
-            trx_summary = dotnet_trx::parse_trx_file_since(&trx, command_started_at);
-        }
-    }
-
-    let Some(trx_summary) = trx_summary else {
-        return summary;
-    };
-
-    if trx_summary.total > 0 && (summary.total == 0 || trx_summary.total >= summary.total) {
-        summary.passed = trx_summary.passed;
-        summary.failed = trx_summary.failed;
-        summary.skipped = trx_summary.skipped;
-        summary.total = trx_summary.total;
-    }
-
-    if summary.failed_tests.is_empty() && !trx_summary.failed_tests.is_empty() {
-        summary.failed_tests = trx_summary.failed_tests;
-    }
-
-    if let Some(duration) = trx_summary.duration_text {
-        summary.duration_text = Some(duration);
-    }
-
-    if trx_summary.project_count > summary.project_count {
-        summary.project_count = trx_summary.project_count;
-    }
-
-    summary
-}
-
-fn build_effective_dotnet_args(
-    subcommand: &str,
-    args: &[String],
-    binlog_path: &Path,
-    trx_results_dir: Option<&Path>,
-) -> Vec<String> {
-    let mut effective = Vec::new();
-
-    if subcommand != "test" && !has_binlog_arg(args) {
-        effective.push(format!("-bl:{}", binlog_path.display()));
-    }
-
-    if subcommand != "test" && !has_verbosity_arg(args) {
-        effective.push("-v:minimal".to_string());
-    }
-
-    if !has_nologo_arg(args) {
-        effective.push("-nologo".to_string());
-    }
-
-    if subcommand == "test" {
-        if !has_trx_logger_arg(args) {
-            effective.push("--logger".to_string());
-            effective.push("trx".to_string());
-        }
-
-        if !has_results_directory_arg(args) {
-            if let Some(results_dir) = trx_results_dir {
-                effective.push("--results-directory".to_string());
-                effective.push(results_dir.display().to_string());
-            }
-        }
-    }
-
-    effective.extend(args.iter().cloned());
-    effective
-}
-
-fn has_binlog_arg(args: &[String]) -> bool {
-    args.iter().any(|arg| {
-        let lower = arg.to_ascii_lowercase();
-        lower.starts_with("-bl") || lower.starts_with("/bl")
-    })
-}
-
-fn has_verbosity_arg(args: &[String]) -> bool {
-    args.iter().any(|arg| {
-        let lower = arg.to_ascii_lowercase();
-        lower.starts_with("-v:")
-            || lower.starts_with("/v:")
-            || lower == "-v"
-            || lower == "/v"
-            || lower == "--verbosity"
-            || lower.starts_with("--verbosity=")
-    })
-}
-
-fn has_nologo_arg(args: &[String]) -> bool {
-    args.iter()
-        .any(|arg| matches!(arg.to_ascii_lowercase().as_str(), "-nologo" | "/nologo"))
-}
-
-fn has_trx_logger_arg(args: &[String]) -> bool {
-    let mut iter = args.iter().peekable();
-    while let Some(arg) = iter.next() {
-        let lower = arg.to_ascii_lowercase();
-        if lower == "--logger" {
-            if let Some(next) = iter.peek() {
-                let next_lower = next.to_ascii_lowercase();
-                if next_lower == "trx" || next_lower.starts_with("trx;") {
-                    return true;
-                }
-            }
-            continue;
-        }
-
-        for prefix in ["--logger:", "--logger="] {
-            if let Some(value) = lower.strip_prefix(prefix) {
-                if value == "trx" || value.starts_with("trx;") {
-                    return true;
-                }
-            }
-        }
-    }
-
-    false
-}
-
-fn has_results_directory_arg(args: &[String]) -> bool {
-    args.iter().any(|arg| {
-        let lower = arg.to_ascii_lowercase();
-        lower == "--results-directory" || lower.starts_with("--results-directory=")
-    })
-}
-
-fn has_report_arg(args: &[String]) -> bool {
-    args.iter().any(|arg| {
-        let lower = arg.to_ascii_lowercase();
-        lower == "--report" || lower.starts_with("--report=")
-    })
-}
-
-fn extract_report_arg(args: &[String]) -> Option<PathBuf> {
-    let mut iter = args.iter().peekable();
-    while let Some(arg) = iter.next() {
-        if arg.eq_ignore_ascii_case("--report") {
-            if let Some(next) = iter.peek() {
-                return Some(PathBuf::from(next.as_str()));
-            }
-            continue;
-        }
-
-        if let Some((_, value)) = arg.split_once('=') {
-            if arg
-                .split('=')
-                .next()
-                .is_some_and(|key| key.eq_ignore_ascii_case("--report"))
-            {
-                return Some(PathBuf::from(value));
-            }
-        }
-    }
-
-    None
-}
-
-fn has_verify_no_changes_arg(args: &[String]) -> bool {
-    args.iter().any(|arg| {
-        let lower = arg.to_ascii_lowercase();
-        lower == "--verify-no-changes" || lower.starts_with("--verify-no-changes=")
-    })
-}
-
-fn has_write_mode_override(args: &[String]) -> bool {
-    args.iter().any(|arg| arg.eq_ignore_ascii_case("--write"))
-}
-
-fn extract_results_directory_arg(args: &[String]) -> Option<PathBuf> {
-    let mut iter = args.iter().peekable();
-    while let Some(arg) = iter.next() {
-        if arg.eq_ignore_ascii_case("--results-directory") {
-            if let Some(next) = iter.peek() {
-                return Some(PathBuf::from(next.as_str()));
-            }
-            continue;
-        }
-
-        if let Some((_, value)) = arg.split_once('=') {
-            if arg
-                .split('=')
-                .next()
-                .is_some_and(|key| key.eq_ignore_ascii_case("--results-directory"))
-            {
-                return Some(PathBuf::from(value));
-            }
-        }
-    }
-
-    None
-}
-
-fn normalize_build_summary(
-    mut summary: binlog::BuildSummary,
-    command_success: bool,
-) -> binlog::BuildSummary {
-    if command_success {
-        summary.succeeded = true;
-        if summary.project_count == 0 {
-            summary.project_count = 1;
-        }
-    }
-
-    summary
-}
-
-fn merge_build_summaries(
-    mut binlog_summary: binlog::BuildSummary,
-    raw_summary: binlog::BuildSummary,
-) -> binlog::BuildSummary {
-    if binlog_summary.errors.is_empty() {
-        binlog_summary.errors = raw_summary.errors;
-    }
-    if binlog_summary.warnings.is_empty() {
-        binlog_summary.warnings = raw_summary.warnings;
-    }
-
-    if binlog_summary.project_count == 0 {
-        binlog_summary.project_count = raw_summary.project_count;
-    }
-    if binlog_summary.duration_text.is_none() {
-        binlog_summary.duration_text = raw_summary.duration_text;
-    }
-
-    binlog_summary
-}
-
-fn normalize_test_summary(
-    mut summary: binlog::TestSummary,
-    command_success: bool,
-) -> binlog::TestSummary {
-    if !command_success && summary.failed == 0 && summary.failed_tests.is_empty() {
-        summary.failed = 1;
-        if summary.total == 0 {
-            summary.total = 1;
-        }
-    }
-
-    if command_success && summary.total == 0 && summary.passed == 0 {
-        summary.project_count = summary.project_count.max(1);
-    }
-
-    summary
-}
-
-fn merge_test_summaries(
-    mut binlog_summary: binlog::TestSummary,
-    raw_summary: binlog::TestSummary,
-) -> binlog::TestSummary {
-    if binlog_summary.total == 0 && raw_summary.total > 0 {
-        binlog_summary.passed = raw_summary.passed;
-        binlog_summary.failed = raw_summary.failed;
-        binlog_summary.skipped = raw_summary.skipped;
-        binlog_summary.total = raw_summary.total;
-    }
-
-    if !raw_summary.failed_tests.is_empty() {
-        binlog_summary.failed_tests = raw_summary.failed_tests;
-    }
-
-    if binlog_summary.project_count == 0 {
-        binlog_summary.project_count = raw_summary.project_count;
-    }
-
-    if binlog_summary.duration_text.is_none() {
-        binlog_summary.duration_text = raw_summary.duration_text;
-    }
-
-    binlog_summary
-}
-
-fn normalize_restore_summary(
-    mut summary: binlog::RestoreSummary,
-    command_success: bool,
-) -> binlog::RestoreSummary {
-    if !command_success && summary.errors == 0 {
-        summary.errors = 1;
-    }
-
-    summary
-}
-
-fn merge_restore_summaries(
-    mut binlog_summary: binlog::RestoreSummary,
-    raw_summary: binlog::RestoreSummary,
-) -> binlog::RestoreSummary {
-    if binlog_summary.restored_projects == 0 {
-        binlog_summary.restored_projects = raw_summary.restored_projects;
-    }
-    if binlog_summary.errors == 0 {
-        binlog_summary.errors = raw_summary.errors;
-    }
-    if binlog_summary.warnings == 0 {
-        binlog_summary.warnings = raw_summary.warnings;
-    }
-    if binlog_summary.duration_text.is_none() {
-        binlog_summary.duration_text = raw_summary.duration_text;
-    }
-
-    binlog_summary
-}
-
-fn format_issue(issue: &binlog::BinlogIssue, kind: &str) -> String {
-    if issue.file.is_empty() {
-        return format!("  {} {}", kind, truncate(&issue.message, 180));
-    }
-    if issue.code.is_empty() {
-        return format!(
-            "  {}({},{}) {}: {}",
-            issue.file,
-            issue.line,
-            issue.column,
-            kind,
-            truncate(&issue.message, 180)
-        );
-    }
-    format!(
-        "  {}({},{}) {} {}: {}",
-        issue.file,
-        issue.line,
-        issue.column,
-        kind,
-        issue.code,
-        truncate(&issue.message, 180)
-    )
-}
-
-fn format_build_output(summary: &binlog::BuildSummary, _binlog_path: &Path) -> String {
-    let status_icon = if summary.succeeded { "ok" } else { "fail" };
-    let duration = summary.duration_text.as_deref().unwrap_or("unknown");
-
-    let mut out = format!(
-        "{} dotnet build: {} projects, {} errors, {} warnings ({})",
-        status_icon,
-        summary.project_count,
-        summary.errors.len(),
-        summary.warnings.len(),
-        duration
-    );
-
-    if !summary.errors.is_empty() {
-        out.push_str("\n---------------------------------------\n\nErrors:\n");
-        for issue in summary.errors.iter().take(20) {
-            out.push_str(&format!("{}\n", format_issue(issue, "error")));
-        }
-        if summary.errors.len() > 20 {
-            out.push_str(&format!(
-                "  ... +{} more errors\n",
-                summary.errors.len() - 20
-            ));
-        }
-    }
-
-    if !summary.warnings.is_empty() {
-        out.push_str("\nWarnings:\n");
-        for issue in summary.warnings.iter().take(10) {
-            out.push_str(&format!("{}\n", format_issue(issue, "warning")));
-        }
-        if summary.warnings.len() > 10 {
-            out.push_str(&format!(
-                "  ... +{} more warnings\n",
-                summary.warnings.len() - 10
-            ));
-        }
-    }
-
-    // Binlog path omitted from output (temp file, already cleaned up)
-    out
-}
-
-fn format_test_output(
-    summary: &binlog::TestSummary,
-    errors: &[binlog::BinlogIssue],
-    warnings: &[binlog::BinlogIssue],
-    _binlog_path: &Path,
-) -> String {
-    let has_failures = summary.failed > 0 || !summary.failed_tests.is_empty();
-    let status_icon = if has_failures { "fail" } else { "ok" };
-    let duration = summary.duration_text.as_deref().unwrap_or("unknown");
-    let warning_count = warnings.len();
-    let counts_unavailable = summary.passed == 0
-        && summary.failed == 0
-        && summary.skipped == 0
-        && summary.total == 0
-        && summary.failed_tests.is_empty();
-
-    let mut out = if counts_unavailable {
-        format!(
-            "{} dotnet test: completed (binlog-only mode, counts unavailable, {} warnings) ({})",
-            status_icon, warning_count, duration
-        )
-    } else if has_failures {
-        format!(
-            "{} dotnet test: {} passed, {} failed, {} skipped, {} warnings in {} projects ({})",
-            status_icon,
-            summary.passed,
-            summary.failed,
-            summary.skipped,
-            warning_count,
-            summary.project_count,
-            duration
-        )
-    } else {
-        format!(
-            "{} dotnet test: {} tests passed, {} warnings in {} projects ({})",
-            status_icon, summary.passed, warning_count, summary.project_count, duration
-        )
-    };
-
-    if has_failures && !summary.failed_tests.is_empty() {
-        out.push_str("\n---------------------------------------\n\nFailed Tests:\n");
-        for failed in summary.failed_tests.iter().take(15) {
-            out.push_str(&format!("  {}\n", failed.name));
-            for detail in &failed.details {
-                out.push_str(&format!("    {}\n", truncate(detail, 320)));
-            }
-            out.push('\n');
-        }
-        if summary.failed_tests.len() > 15 {
-            out.push_str(&format!(
-                "... +{} more failed tests\n",
-                summary.failed_tests.len() - 15
-            ));
-        }
-    }
-
-    if !errors.is_empty() {
-        out.push_str("\nErrors:\n");
-        for issue in errors.iter().take(10) {
-            out.push_str(&format!("{}\n", format_issue(issue, "error")));
-        }
-        if errors.len() > 10 {
-            out.push_str(&format!("  ... +{} more errors\n", errors.len() - 10));
-        }
-    }
-
-    if !warnings.is_empty() {
-        out.push_str("\nWarnings:\n");
-        for issue in warnings.iter().take(10) {
-            out.push_str(&format!("{}\n", format_issue(issue, "warning")));
-        }
-        if warnings.len() > 10 {
-            out.push_str(&format!("  ... +{} more warnings\n", warnings.len() - 10));
-        }
-    }
-
-    // Binlog path omitted from output (temp file, already cleaned up)
-    out
-}
-
-fn format_restore_output(
-    summary: &binlog::RestoreSummary,
-    errors: &[binlog::BinlogIssue],
-    warnings: &[binlog::BinlogIssue],
-    _binlog_path: &Path,
-) -> String {
-    let has_errors = summary.errors > 0;
-    let status_icon = if has_errors { "fail" } else { "ok" };
-    let duration = summary.duration_text.as_deref().unwrap_or("unknown");
-
-    let mut out = format!(
-        "{} dotnet restore: {} projects, {} errors, {} warnings ({})",
-        status_icon, summary.restored_projects, summary.errors, summary.warnings, duration
-    );
-
-    if !errors.is_empty() {
-        out.push_str("\n---------------------------------------\n\nErrors:\n");
-        for issue in errors.iter().take(20) {
-            out.push_str(&format!("{}\n", format_issue(issue, "error")));
-        }
-        if errors.len() > 20 {
-            out.push_str(&format!("  ... +{} more errors\n", errors.len() - 20));
-        }
-    }
-
-    if !warnings.is_empty() {
-        out.push_str("\nWarnings:\n");
-        for issue in warnings.iter().take(10) {
-            out.push_str(&format!("{}\n", format_issue(issue, "warning")));
-        }
-        if warnings.len() > 10 {
-            out.push_str(&format!("  ... +{} more warnings\n", warnings.len() - 10));
-        }
-    }
-
-    // Binlog path omitted from output (temp file, already cleaned up)
-    out
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::dotnet_format_report;
-    use std::fs;
-    use std::time::Duration;
-
-    fn build_dotnet_args_for_test(
-        subcommand: &str,
-        args: &[String],
-        with_trx: bool,
-    ) -> Vec<String> {
-        let binlog_path = Path::new("/tmp/test.binlog");
-        let trx_results_dir = if with_trx {
-            Some(Path::new("/tmp/test results"))
-        } else {
-            None
-        };
-
-        build_effective_dotnet_args(subcommand, args, binlog_path, trx_results_dir)
-    }
-
-    fn trx_with_counts(total: usize, passed: usize, failed: usize) -> String {
-        format!(
-            r#"<?xml version="1.0" encoding="utf-8"?>
-<TestRun xmlns="http://microsoft.com/schemas/VisualStudio/TeamTest/2010">
-  <ResultSummary outcome="Completed">
-    <Counters total="{}" executed="{}" passed="{}" failed="{}" error="0" />
-  </ResultSummary>
-</TestRun>"#,
-            total, total, passed, failed
-        )
-    }
-
-    fn format_fixture(name: &str) -> PathBuf {
-        PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .join("tests")
-            .join("fixtures")
-            .join("dotnet")
-            .join(name)
-    }
-
-    #[test]
-    fn test_has_binlog_arg_detects_variants() {
-        let args = vec!["-bl:my.binlog".to_string()];
-        assert!(has_binlog_arg(&args));
-
-        let args = vec!["/bl".to_string()];
-        assert!(has_binlog_arg(&args));
-
-        let args = vec!["--configuration".to_string(), "Release".to_string()];
-        assert!(!has_binlog_arg(&args));
-    }
-
-    #[test]
-    fn test_format_build_output_includes_errors_and_warnings() {
-        let summary = binlog::BuildSummary {
-            succeeded: false,
-            project_count: 2,
-            errors: vec![binlog::BinlogIssue {
-                code: "CS0103".to_string(),
-                file: "src/Program.cs".to_string(),
-                line: 42,
-                column: 15,
-                message: "The name 'foo' does not exist".to_string(),
-            }],
-            warnings: vec![binlog::BinlogIssue {
-                code: "CS0219".to_string(),
-                file: "src/Program.cs".to_string(),
-                line: 25,
-                column: 10,
-                message: "Variable 'x' is assigned but never used".to_string(),
-            }],
-            duration_text: Some("00:00:04.20".to_string()),
-        };
-
-        let output = format_build_output(&summary, Path::new("/tmp/build.binlog"));
-        assert!(output.contains("dotnet build: 2 projects, 1 errors, 1 warnings"));
-        assert!(output.contains("error CS0103"));
-        assert!(output.contains("warning CS0219"));
-    }
-
-    #[test]
-    fn test_format_test_output_shows_failures() {
-        let summary = binlog::TestSummary {
-            passed: 10,
-            failed: 1,
-            skipped: 0,
-            total: 11,
-            project_count: 1,
-            failed_tests: vec![binlog::FailedTest {
-                name: "MyTests.ShouldFail".to_string(),
-                details: vec!["Assert.Equal failure".to_string()],
-            }],
-            duration_text: Some("1 s".to_string()),
-        };
-
-        let output = format_test_output(&summary, &[], &[], Path::new("/tmp/test.binlog"));
-        assert!(output.contains("10 passed, 1 failed"));
-        assert!(output.contains("MyTests.ShouldFail"));
-    }
-
-    #[test]
-    fn test_format_test_output_surfaces_warnings() {
-        let summary = binlog::TestSummary {
-            passed: 940,
-            failed: 0,
-            skipped: 7,
-            total: 947,
-            project_count: 1,
-            failed_tests: Vec::new(),
-            duration_text: Some("1 s".to_string()),
-        };
-
-        let warnings = vec![binlog::BinlogIssue {
-            code: String::new(),
-            file: "/sdk/Microsoft.TestPlatform.targets".to_string(),
-            line: 48,
-            column: 5,
-            message: "Violators:".to_string(),
-        }];
-
-        let output = format_test_output(&summary, &[], &warnings, Path::new("/tmp/test.binlog"));
-        assert!(output.contains("940 tests passed, 1 warnings"));
-        assert!(output.contains("Warnings:"));
-        assert!(output.contains("Microsoft.TestPlatform.targets"));
-    }
-
-    #[test]
-    fn test_format_test_output_surfaces_errors() {
-        let summary = binlog::TestSummary {
-            passed: 939,
-            failed: 1,
-            skipped: 7,
-            total: 947,
-            project_count: 1,
-            failed_tests: Vec::new(),
-            duration_text: Some("1 s".to_string()),
-        };
-
-        let errors = vec![binlog::BinlogIssue {
-            code: "TESTERROR".to_string(),
-            file: "/repo/MessageMapperTests.cs".to_string(),
-            line: 135,
-            column: 0,
-            message: "CreateInstance_should_initialize_interface_message_type_on_demand"
-                .to_string(),
-        }];
-
-        let output = format_test_output(&summary, &errors, &[], Path::new("/tmp/test.binlog"));
-        assert!(output.contains("Errors:"));
-        assert!(output.contains("error TESTERROR"));
-        assert!(
-            output.contains("CreateInstance_should_initialize_interface_message_type_on_demand")
-        );
-    }
-
-    #[test]
-    fn test_format_restore_output_success() {
-        let summary = binlog::RestoreSummary {
-            restored_projects: 3,
-            warnings: 1,
-            errors: 0,
-            duration_text: Some("00:00:01.10".to_string()),
-        };
-
-        let output = format_restore_output(&summary, &[], &[], Path::new("/tmp/restore.binlog"));
-        assert!(output.starts_with("ok dotnet restore"));
-        assert!(output.contains("3 projects"));
-        assert!(output.contains("1 warnings"));
-    }
-
-    #[test]
-    fn test_format_restore_output_failure() {
-        let summary = binlog::RestoreSummary {
-            restored_projects: 2,
-            warnings: 0,
-            errors: 1,
-            duration_text: Some("00:00:01.00".to_string()),
-        };
-
-        let output = format_restore_output(&summary, &[], &[], Path::new("/tmp/restore.binlog"));
-        assert!(output.starts_with("fail dotnet restore"));
-        assert!(output.contains("1 errors"));
-    }
-
-    #[test]
-    fn test_format_restore_output_includes_error_details() {
-        let summary = binlog::RestoreSummary {
-            restored_projects: 2,
-            warnings: 0,
-            errors: 1,
-            duration_text: Some("00:00:01.00".to_string()),
-        };
-
-        let issues = vec![binlog::BinlogIssue {
-            code: "NU1101".to_string(),
-            file: "/repo/src/App/App.csproj".to_string(),
-            line: 0,
-            column: 0,
-            message: "Unable to find package Foo.Bar".to_string(),
-        }];
-
-        let output =
-            format_restore_output(&summary, &issues, &[], Path::new("/tmp/restore.binlog"));
-        assert!(output.contains("Errors:"));
-        assert!(output.contains("error NU1101"));
-        assert!(output.contains("Unable to find package Foo.Bar"));
-    }
-
-    #[test]
-    fn test_format_test_output_handles_binlog_only_without_counts() {
-        let summary = binlog::TestSummary {
-            passed: 0,
-            failed: 0,
-            skipped: 0,
-            total: 0,
-            project_count: 0,
-            failed_tests: Vec::new(),
-            duration_text: Some("unknown".to_string()),
-        };
-
-        let output = format_test_output(&summary, &[], &[], Path::new("/tmp/test.binlog"));
-        assert!(output.contains("counts unavailable"));
-    }
-
-    #[test]
-    fn test_normalize_build_summary_sets_success_floor() {
-        let summary = binlog::BuildSummary {
-            succeeded: false,
-            project_count: 0,
-            errors: Vec::new(),
-            warnings: Vec::new(),
-            duration_text: None,
-        };
-
-        let normalized = normalize_build_summary(summary, true);
-        assert!(normalized.succeeded);
-        assert_eq!(normalized.project_count, 1);
-    }
-
-    #[test]
-    fn test_merge_build_summaries_keeps_structured_issues_when_present() {
-        let binlog_summary = binlog::BuildSummary {
-            succeeded: false,
-            project_count: 11,
-            errors: vec![binlog::BinlogIssue {
-                code: String::new(),
-                file: "IDE0055".to_string(),
-                line: 0,
-                column: 0,
-                message: "Fix formatting".to_string(),
-            }],
-            warnings: Vec::new(),
-            duration_text: Some("00:00:03.54".to_string()),
-        };
-
-        let raw_summary = binlog::BuildSummary {
-            succeeded: false,
-            project_count: 2,
-            errors: vec![
-                binlog::BinlogIssue {
-                    code: "IDE0055".to_string(),
-                    file: "/repo/src/Behavior.cs".to_string(),
-                    line: 13,
-                    column: 32,
-                    message: "Fix formatting".to_string(),
-                },
-                binlog::BinlogIssue {
-                    code: "IDE0055".to_string(),
-                    file: "/repo/src/Behavior.cs".to_string(),
-                    line: 13,
-                    column: 41,
-                    message: "Fix formatting".to_string(),
-                },
-            ],
-            warnings: Vec::new(),
-            duration_text: Some("00:00:03.54".to_string()),
-        };
-
-        let merged = merge_build_summaries(binlog_summary, raw_summary);
-        assert_eq!(merged.project_count, 11);
-        assert_eq!(merged.errors.len(), 1);
-        assert_eq!(merged.errors[0].file, "IDE0055");
-        assert_eq!(merged.errors[0].line, 0);
-        assert_eq!(merged.errors[0].column, 0);
-    }
-
-    #[test]
-    fn test_merge_build_summaries_keeps_binlog_when_context_is_good() {
-        let binlog_summary = binlog::BuildSummary {
-            succeeded: false,
-            project_count: 2,
-            errors: vec![binlog::BinlogIssue {
-                code: "CS0103".to_string(),
-                file: "src/Program.cs".to_string(),
-                line: 42,
-                column: 15,
-                message: "The name 'foo' does not exist".to_string(),
-            }],
-            warnings: Vec::new(),
-            duration_text: Some("00:00:01.00".to_string()),
-        };
-
-        let raw_summary = binlog::BuildSummary {
-            succeeded: false,
-            project_count: 2,
-            errors: vec![binlog::BinlogIssue {
-                code: "CS0103".to_string(),
-                file: String::new(),
-                line: 0,
-                column: 0,
-                message: "Build error #1 (details omitted)".to_string(),
-            }],
-            warnings: Vec::new(),
-            duration_text: None,
-        };
-
-        let merged = merge_build_summaries(binlog_summary.clone(), raw_summary);
-        assert_eq!(merged.errors, binlog_summary.errors);
-    }
-
-    #[test]
-    fn test_normalize_test_summary_sets_failure_floor() {
-        let summary = binlog::TestSummary {
-            passed: 0,
-            failed: 0,
-            skipped: 0,
-            total: 0,
-            project_count: 0,
-            failed_tests: Vec::new(),
-            duration_text: None,
-        };
-
-        let normalized = normalize_test_summary(summary, false);
-        assert_eq!(normalized.failed, 1);
-        assert_eq!(normalized.total, 1);
-    }
-
-    #[test]
-    fn test_merge_test_summaries_keeps_structured_counts_and_fills_failed_tests() {
-        let binlog_summary = binlog::TestSummary {
-            passed: 939,
-            failed: 1,
-            skipped: 8,
-            total: 948,
-            project_count: 1,
-            failed_tests: Vec::new(),
-            duration_text: Some("unknown".to_string()),
-        };
-
-        let raw_summary = binlog::TestSummary {
-            passed: 939,
-            failed: 1,
-            skipped: 7,
-            total: 947,
-            project_count: 0,
-            failed_tests: vec![binlog::FailedTest {
-                name: "MessageMapperTests.CreateInstance_should_initialize_interface_message_type_on_demand"
-                    .to_string(),
-                details: vec!["Assert.That(messageInstance, Is.Null)".to_string()],
-            }],
-            duration_text: Some("1 s".to_string()),
-        };
-
-        let merged = merge_test_summaries(binlog_summary, raw_summary);
-        assert_eq!(merged.skipped, 8);
-        assert_eq!(merged.total, 948);
-        assert_eq!(merged.failed_tests.len(), 1);
-        assert!(merged.failed_tests[0]
-            .name
-            .contains("CreateInstance_should_initialize"));
-    }
-
-    #[test]
-    fn test_normalize_restore_summary_sets_error_floor_on_failed_command() {
-        let summary = binlog::RestoreSummary {
-            restored_projects: 2,
-            warnings: 0,
-            errors: 0,
-            duration_text: None,
-        };
-
-        let normalized = normalize_restore_summary(summary, false);
-        assert_eq!(normalized.errors, 1);
-    }
-
-    #[test]
-    fn test_merge_restore_summaries_prefers_raw_error_count() {
-        let binlog_summary = binlog::RestoreSummary {
-            restored_projects: 2,
-            warnings: 0,
-            errors: 0,
-            duration_text: Some("unknown".to_string()),
-        };
-
-        let raw_summary = binlog::RestoreSummary {
-            restored_projects: 0,
-            warnings: 0,
-            errors: 1,
-            duration_text: Some("unknown".to_string()),
-        };
-
-        let merged = merge_restore_summaries(binlog_summary, raw_summary);
-        assert_eq!(merged.errors, 1);
-        assert_eq!(merged.restored_projects, 2);
-    }
-
-    #[test]
-    fn test_forwarding_args_with_spaces() {
-        let args = vec![
-            "--filter".to_string(),
-            "FullyQualifiedName~MyTests.Calculator*".to_string(),
-            "-c".to_string(),
-            "Release".to_string(),
-        ];
-
-        let injected = build_dotnet_args_for_test("test", &args, true);
-        assert!(injected.contains(&"--filter".to_string()));
-        assert!(injected.contains(&"FullyQualifiedName~MyTests.Calculator*".to_string()));
-        assert!(injected.contains(&"-c".to_string()));
-        assert!(injected.contains(&"Release".to_string()));
-    }
-
-    #[test]
-    fn test_forwarding_config_and_framework() {
-        let args = vec![
-            "--configuration".to_string(),
-            "Release".to_string(),
-            "--framework".to_string(),
-            "net8.0".to_string(),
-        ];
-
-        let injected = build_dotnet_args_for_test("test", &args, true);
-        assert!(injected.contains(&"--configuration".to_string()));
-        assert!(injected.contains(&"Release".to_string()));
-        assert!(injected.contains(&"--framework".to_string()));
-        assert!(injected.contains(&"net8.0".to_string()));
-    }
-
-    #[test]
-    fn test_forwarding_project_file() {
-        let args = vec![
-            "--project".to_string(),
-            "src/My App.Tests/My App.Tests.csproj".to_string(),
-        ];
-
-        let injected = build_dotnet_args_for_test("test", &args, true);
-        assert!(injected.contains(&"--project".to_string()));
-        assert!(injected.contains(&"src/My App.Tests/My App.Tests.csproj".to_string()));
-    }
-
-    #[test]
-    fn test_forwarding_no_build_and_no_restore() {
-        let args = vec!["--no-build".to_string(), "--no-restore".to_string()];
-
-        let injected = build_dotnet_args_for_test("test", &args, true);
-        assert!(injected.contains(&"--no-build".to_string()));
-        assert!(injected.contains(&"--no-restore".to_string()));
-    }
-
-    #[test]
-    fn test_user_verbose_override() {
-        let args = vec!["-v:detailed".to_string()];
-
-        let injected = build_dotnet_args_for_test("test", &args, true);
-        let verbose_count = injected.iter().filter(|a| a.starts_with("-v:")).count();
-        assert_eq!(verbose_count, 1);
-        assert!(injected.contains(&"-v:detailed".to_string()));
-        assert!(!injected.contains(&"-v:minimal".to_string()));
-    }
-
-    #[test]
-    fn test_user_long_verbosity_override() {
-        let args = vec!["--verbosity".to_string(), "detailed".to_string()];
-
-        let injected = build_dotnet_args_for_test("build", &args, false);
-        assert!(injected.contains(&"--verbosity".to_string()));
-        assert!(injected.contains(&"detailed".to_string()));
-        assert!(!injected.contains(&"-v:minimal".to_string()));
-    }
-
-    #[test]
-    fn test_test_subcommand_does_not_inject_minimal_verbosity_by_default() {
-        let args = Vec::<String>::new();
-
-        let injected = build_dotnet_args_for_test("test", &args, true);
-        assert!(!injected.contains(&"-v:minimal".to_string()));
-    }
-
-    #[test]
-    fn test_user_logger_override() {
-        let args = vec![
-            "--logger".to_string(),
-            "console;verbosity=detailed".to_string(),
-        ];
-
-        let injected = build_dotnet_args_for_test("test", &args, true);
-        assert!(injected.contains(&"--logger".to_string()));
-        assert!(injected.contains(&"console;verbosity=detailed".to_string()));
-        assert!(injected.iter().any(|a| a == "trx"));
-        assert!(injected.iter().any(|a| a == "--results-directory"));
-    }
-
-    #[test]
-    fn test_trx_logger_and_results_directory_injected() {
-        let args = Vec::<String>::new();
-
-        let injected = build_dotnet_args_for_test("test", &args, true);
-        assert!(injected.contains(&"--logger".to_string()));
-        assert!(injected.contains(&"trx".to_string()));
-        assert!(injected.contains(&"--results-directory".to_string()));
-        assert!(injected.contains(&"/tmp/test results".to_string()));
-    }
-
-    #[test]
-    fn test_user_trx_logger_does_not_duplicate() {
-        let args = vec!["--logger".to_string(), "trx".to_string()];
-
-        let injected = build_dotnet_args_for_test("test", &args, true);
-        let trx_logger_count = injected.iter().filter(|a| *a == "trx").count();
-        assert_eq!(trx_logger_count, 1);
-    }
-
-    #[test]
-    fn test_user_results_directory_prevents_extra_injection() {
-        let args = vec![
-            "--results-directory".to_string(),
-            "/custom/results".to_string(),
-        ];
-
-        let injected = build_dotnet_args_for_test("test", &args, true);
-        assert!(!injected
-            .windows(2)
-            .any(|w| w[0] == "--results-directory" && w[1] == "/tmp/test results"));
-        assert!(injected
-            .windows(2)
-            .any(|w| w[0] == "--results-directory" && w[1] == "/custom/results"));
-    }
-
-    #[test]
-    fn test_merge_test_summary_from_trx_uses_primary_and_cleans_file() {
-        let temp_dir = tempfile::tempdir().expect("create temp dir");
-        let primary = temp_dir.path().join("primary.trx");
-        fs::write(&primary, trx_with_counts(3, 3, 0)).expect("write primary trx");
-
-        let filled = merge_test_summary_from_trx(
-            binlog::TestSummary::default(),
-            Some(temp_dir.path()),
-            None,
-            SystemTime::now(),
-        );
-
-        assert_eq!(filled.total, 3);
-        assert_eq!(filled.passed, 3);
-        assert!(primary.exists());
-    }
-
-    #[test]
-    fn test_merge_test_summary_from_trx_falls_back_to_testresults() {
-        let temp_dir = tempfile::tempdir().expect("create temp dir");
-        let fallback = temp_dir.path().join("fallback.trx");
-        fs::write(&fallback, trx_with_counts(2, 1, 1)).expect("write fallback trx");
-        let missing_primary = temp_dir.path().join("missing.trx");
-
-        let filled = merge_test_summary_from_trx(
-            binlog::TestSummary::default(),
-            Some(&missing_primary),
-            Some(fallback.clone()),
-            UNIX_EPOCH,
-        );
-
-        assert_eq!(filled.total, 2);
-        assert_eq!(filled.failed, 1);
-        assert!(fallback.exists());
-    }
-
-    #[test]
-    fn test_merge_test_summary_from_trx_returns_default_when_no_trx() {
-        let temp_dir = tempfile::tempdir().expect("create temp dir");
-        let missing = temp_dir.path().join("missing.trx");
-
-        let filled = merge_test_summary_from_trx(
-            binlog::TestSummary::default(),
-            Some(&missing),
-            None,
-            SystemTime::now(),
-        );
-        assert_eq!(filled.total, 0);
-    }
-
-    #[test]
-    fn test_merge_test_summary_from_trx_ignores_stale_fallback_file() {
-        let temp_dir = tempfile::tempdir().expect("create temp dir");
-        let fallback = temp_dir.path().join("fallback.trx");
-        fs::write(&fallback, trx_with_counts(2, 1, 1)).expect("write fallback trx");
-        std::thread::sleep(std::time::Duration::from_millis(5));
-        let command_started_at = SystemTime::now();
-        let missing_primary = temp_dir.path().join("missing.trx");
-
-        let filled = merge_test_summary_from_trx(
-            binlog::TestSummary::default(),
-            Some(&missing_primary),
-            Some(fallback.clone()),
-            command_started_at,
-        );
-
-        assert_eq!(filled.total, 0);
-        assert!(fallback.exists());
-    }
-
-    #[test]
-    fn test_merge_test_summary_from_trx_keeps_larger_existing_counts() {
-        let temp_dir = tempfile::tempdir().expect("create temp dir");
-        let primary = temp_dir.path().join("primary.trx");
-        fs::write(&primary, trx_with_counts(5, 4, 1)).expect("write primary trx");
-
-        let existing = binlog::TestSummary {
-            passed: 10,
-            failed: 2,
-            skipped: 0,
-            total: 12,
-            project_count: 1,
-            failed_tests: Vec::new(),
-            duration_text: Some("1 s".to_string()),
-        };
-
-        let merged =
-            merge_test_summary_from_trx(existing, Some(temp_dir.path()), None, SystemTime::now());
-        assert_eq!(merged.total, 12);
-        assert_eq!(merged.passed, 10);
-        assert_eq!(merged.failed, 2);
-    }
-
-    #[test]
-    fn test_merge_test_summary_from_trx_overrides_smaller_existing_counts() {
-        let temp_dir = tempfile::tempdir().expect("create temp dir");
-        let primary = temp_dir.path().join("primary.trx");
-        fs::write(&primary, trx_with_counts(12, 10, 2)).expect("write primary trx");
-
-        let existing = binlog::TestSummary {
-            passed: 4,
-            failed: 1,
-            skipped: 0,
-            total: 5,
-            project_count: 1,
-            failed_tests: Vec::new(),
-            duration_text: Some("1 s".to_string()),
-        };
-
-        let merged =
-            merge_test_summary_from_trx(existing, Some(temp_dir.path()), None, SystemTime::now());
-        assert_eq!(merged.total, 12);
-        assert_eq!(merged.passed, 10);
-        assert_eq!(merged.failed, 2);
-    }
-
-    #[test]
-    fn test_merge_test_summary_from_trx_uses_larger_project_count() {
-        let temp_dir = tempfile::tempdir().expect("create temp dir");
-        let trx_a = temp_dir.path().join("a.trx");
-        let trx_b = temp_dir.path().join("b.trx");
-        fs::write(&trx_a, trx_with_counts(2, 2, 0)).expect("write first trx");
-        fs::write(&trx_b, trx_with_counts(3, 3, 0)).expect("write second trx");
-
-        let existing = binlog::TestSummary {
-            passed: 5,
-            failed: 0,
-            skipped: 0,
-            total: 5,
-            project_count: 1,
-            failed_tests: Vec::new(),
-            duration_text: Some("1 s".to_string()),
-        };
-
-        let merged =
-            merge_test_summary_from_trx(existing, Some(temp_dir.path()), None, SystemTime::now());
-        assert_eq!(merged.project_count, 2);
-    }
-
-    #[test]
-    fn test_has_results_directory_arg_detects_variants() {
-        let args = vec!["--results-directory".to_string(), "/tmp/trx".to_string()];
-        assert!(has_results_directory_arg(&args));
-
-        let args = vec!["--results-directory=/tmp/trx".to_string()];
-        assert!(has_results_directory_arg(&args));
-
-        let args = vec!["--logger".to_string(), "trx".to_string()];
-        assert!(!has_results_directory_arg(&args));
-    }
-
-    #[test]
-    fn test_extract_results_directory_arg_detects_variants() {
-        let args = vec!["--results-directory".to_string(), "/tmp/r1".to_string()];
-        assert_eq!(
-            extract_results_directory_arg(&args),
-            Some(PathBuf::from("/tmp/r1"))
-        );
-
-        let args = vec!["--results-directory=/tmp/r2".to_string()];
-        assert_eq!(
-            extract_results_directory_arg(&args),
-            Some(PathBuf::from("/tmp/r2"))
-        );
-    }
-
-    #[test]
-    fn test_resolve_trx_results_dir_user_directory_is_not_marked_for_cleanup() {
-        let args = vec![
-            "--results-directory".to_string(),
-            "/custom/results".to_string(),
-        ];
-
-        let (dir, cleanup) = resolve_trx_results_dir("test", &args);
-        assert_eq!(dir, Some(PathBuf::from("/custom/results")));
-        assert!(!cleanup);
-    }
-
-    #[test]
-    fn test_resolve_trx_results_dir_generated_directory_is_marked_for_cleanup() {
-        let args = Vec::<String>::new();
-
-        let (dir, cleanup) = resolve_trx_results_dir("test", &args);
-        assert!(dir.is_some());
-        assert!(cleanup);
-    }
-
-    #[test]
-    fn test_format_all_formatted() {
-        let summary =
-            dotnet_format_report::parse_format_report(&format_fixture("format_success.json"))
-                .expect("parse format report");
-
-        let output = format_dotnet_format_output(&summary, true);
-        assert!(output.contains("ok dotnet format: 2 files formatted correctly"));
-    }
-
-    #[test]
-    fn test_format_needs_formatting() {
-        let summary =
-            dotnet_format_report::parse_format_report(&format_fixture("format_changes.json"))
-                .expect("parse format report");
-
-        let output = format_dotnet_format_output(&summary, true);
-        assert!(output.contains("Format: 2 files need formatting"));
-        assert!(output.contains("src/Program.cs (line 42, col 17, WHITESPACE)"));
-        assert!(output.contains("Run `dotnet format` to apply fixes"));
-    }
-
-    #[test]
-    fn test_format_temp_file_cleanup() {
-        let args = Vec::<String>::new();
-        let (report_path, cleanup) = resolve_format_report_path(&args);
-        let report_path = report_path.expect("report path");
-
-        assert!(cleanup);
-        fs::write(&report_path, "[]").expect("write temp report");
-        cleanup_temp_file(&report_path);
-        assert!(!report_path.exists());
-    }
-
-    #[test]
-    fn test_format_user_report_arg_no_cleanup() {
-        let args = vec![
-            "--report".to_string(),
-            "/tmp/user-format-report.json".to_string(),
-        ];
-
-        let (report_path, cleanup) = resolve_format_report_path(&args);
-        assert_eq!(
-            report_path,
-            Some(PathBuf::from("/tmp/user-format-report.json"))
-        );
-        assert!(!cleanup);
-    }
-
-    #[test]
-    fn test_format_preserves_positional_project_argument_order() {
-        let args = vec!["src/App/App.csproj".to_string()];
-
-        let effective =
-            build_effective_dotnet_format_args(&args, Some(Path::new("/tmp/report.json")));
-        assert_eq!(
-            effective.first().map(String::as_str),
-            Some("src/App/App.csproj")
-        );
-    }
-
-    #[test]
-    fn test_format_report_summary_ignores_stale_report_file() {
-        let temp_dir = tempfile::tempdir().expect("create temp dir");
-        let report = temp_dir.path().join("report.json");
-        fs::write(&report, "[]").expect("write report");
-
-        let command_started_at = SystemTime::now()
-            .checked_add(Duration::from_secs(2))
-            .expect("future timestamp");
-        let raw = "RAW OUTPUT";
-
-        let output = format_report_summary_or_raw(Some(&report), true, raw, command_started_at);
-        assert_eq!(output, raw);
-    }
-
-    #[test]
-    fn test_format_report_summary_uses_fresh_report_file() {
-        let report = format_fixture("format_success.json");
-        let raw = "RAW OUTPUT";
-
-        let output = format_report_summary_or_raw(Some(&report), true, raw, UNIX_EPOCH);
-        assert!(output.contains("ok dotnet format: 2 files formatted correctly"));
-    }
-
-    #[test]
-    fn test_cleanup_temp_file_removes_existing_file() {
-        let temp_dir = tempfile::tempdir().expect("create temp dir");
-        let temp_file = temp_dir.path().join("temp.binlog");
-        fs::write(&temp_file, "content").expect("write temp file");
-
-        cleanup_temp_file(&temp_file);
-
-        assert!(!temp_file.exists());
-    }
-
-    #[test]
-    fn test_cleanup_temp_file_ignores_missing_file() {
-        let temp_dir = tempfile::tempdir().expect("create temp dir");
-        let missing_file = temp_dir.path().join("missing.binlog");
-
-        cleanup_temp_file(&missing_file);
-
-        assert!(!missing_file.exists());
-    }
-}