Fixes

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 6a1863fa-92ca-4fd6-9e0c-12ae4ac61826

Author: Martin Taillefer (from Dev Box)

crates/cargo-gamma-engine/src/parse/nesting.rs

@@ -332,7 +332,7 @@ fn identifier_end(text: &str, at: usize) -> Option<usize> {
 
 #[cfg(test)]
 mod tests {
-    use std::fs;
+    use std::{env, fs};
 
     use camino::Utf8Path;
     use walkdir::WalkDir;
@@ -531,8 +531,13 @@ mod tests {
     /// The counts added here are proxies, and a proxy that refuses ordinary Rust is worse than the
     /// crash it prevents. This is the check that keeps them calibrated against real code.
     #[test]
-
     fn this_workspace_is_within_the_limit() {
+        // Gamma's scratch tree contains instrumented source whose guard expressions are
+        // intentionally deeper than the source this calibration test is meant to measure.
+        let _ = env::var_os("CARGO_GAMMA").is_none().then(assert_workspace_is_within_limit);
+    }
+
+    fn assert_workspace_is_within_limit() {
         let root = Utf8Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
 
         for entry in WalkDir::new(root.as_std_path()).into_iter().filter_map(Result::ok) {

crates/cargo-gamma-lib/docs/DESIGN.md

@@ -69,7 +69,7 @@ Each Cargo output stream is retained up to 256 MiB for artifact and diagnostic
 processing, and each logical line is bounded at 1 MiB. The buffers grow with
 observed output rather than reserving those ceilings for every invocation.
 
-Each failed baseline observation retains a bounded 64 KiB, 200-line tail from
+Each failed baseline observation retains a bounded 64 KiB, 2,000-line tail from
 stdout and stderr, along with the process exit code or signal when available.
 The baseline error identifies the package, target, runner, executable, working
 directory, elapsed time, resource failure, and failing or last-observed test.
@@ -81,10 +81,20 @@ safely encoded output tails, to `baseline-failure.json` and writes the ordinary
 controls are eligible for diagnostic records, never the inherited process
 environment.
 
+Completed runs publish the five ordinary `gamma-report.json`, HTML, SARIF,
+performance-advice, and diagnostics artifacts. An early baseline failure
+instead publishes `baseline-failure.json` and `gamma-diagnostics.json` before
+the scratch workspace is removed. The baseline record uses `schemaVersion: 1`
+and records the failure kind and reason; package, target, runner, executable,
+and working directory; cargo-gamma's explicit environment overrides; failing
+and last-observed tests; termination, elapsed time, budget, peak, and memory
+limit; and control-character-encoded stdout and stderr tails with a truncation
+flag.
+
 When Cargo's resolved package selection covers the whole workspace, every stage
-checks mutation viability with that constant Cargo root set. Packages with no
-mutable files may be omitted from preflight, but do not narrow the staged
-checks. This keeps dependency feature unification identical across stages
+checks mutation viability with that constant Cargo root set, and preflight
+validates the same roots even when some packages contain no mutable files. This
+keeps dependency feature unification identical across validation and stages
 instead of compiling a new dependency variant for each downstream package
 selection. Only the current stage's mutants are instrumented; mutants belonging
 to other stages are restored before each ordinary, probe, or isolation build.

crates/cargo-gamma-lib/src/commands/run.rs

@@ -806,7 +806,8 @@ fn measured<H: Host>(host: &mut H, args: &RunArgs, progress_when: When, styler:
     if let Some(lock_identity) = cache_lock_identity {
         pause_after_cache_adoption(&survey.root, lock_identity);
     }
-    let mut outcome = exec::run_with_locks(&survey, &selection, &config, &mut events, cache_locks);
+    let mut failed_work = None;
+    let mut outcome = exec::run_with_locks(&survey, &selection, &config, &mut events, cache_locks, &mut failed_work);
 
     // A phase that failed never got to say what it found, so the line it opened is still waiting
     // for an ending. Close it before the error is printed, or the error arrives as the rest of
@@ -821,6 +822,13 @@ fn measured<H: Host>(host: &mut H, args: &RunArgs, progress_when: When, styler:
         emit_failure_artifacts(&mut events, args, &survey.skeleton(), failure, &artifact_dir, started, styler);
     }
 
+    if let Some(mut work) = failed_work
+        && let Err(cleanup) = work.teardown()
+        && let Err(failure) = &mut outcome
+    {
+        failure.append_message(&format!("\nCleanup:       {cleanup}"));
+    }
+
     let exec::Measured {
         plan,
         built,

crates/cargo-gamma-lib/src/exec/baseline.rs

@@ -296,8 +296,8 @@ fn baseline_failure_error(
         "packageId": binary.package_id,
         "target": binary.target,
         "runner": runner,
-        "executable": binary.path,
-        "workingDirectory": directory,
+        "executable": binary.path.as_str(),
+        "workingDirectory": directory.as_str(),
         "environmentOverrides": baseline_environment(work),
         "test": test,
         "lastObservedTest": last_test,
@@ -483,6 +483,8 @@ mod tests {
 
         assert_eq!(artifact.file_name, "baseline-failure.json");
         assert_eq!(artifact.value["package"], "subject");
+        assert_eq!(artifact.value["executable"], binaries[0].path.as_str());
+        assert_eq!(artifact.value["workingDirectory"], working_directory(&work, &binaries[0]).as_str());
         assert_eq!(artifact.value["test"], "a::b");
         assert_eq!(artifact.value["termination"]["kind"], "exitCode");
         assert_eq!(artifact.value["termination"]["value"], 101);

crates/cargo-gamma-lib/src/exec/build.rs

@@ -203,10 +203,10 @@ pub(super) struct Abandoned {
 
 /// Drives the build, withdrawing mutants that cannot compile until what is asked for compiles.
 ///
-/// A run converges the workspace one stage at a time and then once as a whole, and every one of
-/// those builds shares the same withdrawal set and budget reference. Sharing the withdrawal set is
-/// what lets a stage inherit what earlier stages already ruled out: a mutant already known to be
-/// unbuildable stays withdrawn for the rest of the run.
+/// A run converges the workspace one stage at a time and then once as a whole. The withdrawal set is
+/// shared, which lets a stage inherit what earlier stages already ruled out: a mutant already known
+/// to be unbuildable stays withdrawn for the rest of the run. Timeout calibration is reset for each
+/// build so only comparable Cargo commands and root sets share a reference.
 ///
 /// The round counter is not shared. `--rollback-rounds` caps the rounds one build may spend
 /// converging, so it is reset for each build; a cumulative counter would let early stages spend the
@@ -249,11 +249,11 @@ pub(super) struct Converger {
     /// wants to know is where the run's build time went, not where one stage's did.
     history: Vec<Round>,
 
-    /// How long the first build of the run took, which every later budget is scaled from.
+    /// How long the first ordinary round of the current build took.
     ///
-    /// Set once and never reset. A narrowed stage can build a fraction of the workspace, so letting
-    /// one set this reference would leave every later stage — and the whole-workspace build that
-    /// follows them — with a budget derived from a build that was never comparable.
+    /// Reset before each convergence. Subsequent rollback and isolation rounds repeat that build's
+    /// Cargo command and roots, so they are comparable; a later stage or final test-target build is
+    /// not.
     first_round: Option<Duration>,
 
     /// What the tree already holds, so a round rewrites only the files it changed.
@@ -403,6 +403,13 @@ impl Converger {
         withdrawn
     }
 
+    /// Resets state that describes one Cargo command and root set.
+    fn begin_convergence(&mut self) {
+        self.rounds = 0;
+        self.per_round.clear();
+        self.first_round = None;
+    }
+
     /// Instruments the tree and builds it until it compiles, withdrawing whatever stands in the way.
     ///
     /// The scope's roots name the packages Cargo compiles, while its mutants limit what convergence
@@ -427,8 +434,7 @@ impl Converger {
         // to answer for, and the withdrawal series the limit error reads has to describe the build
         // that failed. The withdrawal set is deliberately left alone — a mutant already known not
         // to compile stays withdrawn for the rest of the run.
-        self.rounds = 0;
-        self.per_round.clear();
+        self.begin_convergence();
 
         // Before the first ordinary round, and only ever before it. Whatever the probe withdraws is
         // withdrawn by the compiler's own accusation in a real build, so the loop below starts from
@@ -779,11 +785,8 @@ impl Converger {
             return Ok(());
         };
 
-        // Deliberately not allowed to set `first_round`, which every later build timeout is scaled
-        // from. A probe compiles a fraction of the mutants and usually stops on the first errors,
-        // so its elapsed time is not what a full round of this build costs — adopting it as the
-        // reference would set every later budget from a build that was never comparable, and the
-        // run would start timing out builds that are merely honest about their size.
+        // A probe compiles a fraction of the mutants and usually stops on the first errors, so it
+        // cannot calibrate the ordinary rounds that follow.
 
         if outcome.succeeded {
             // Every hint was wrong: nothing here is unviable now. Nothing is withdrawn and nothing
@@ -1200,7 +1203,7 @@ impl Converger {
                 roots: select,
                 mutants: select,
             },
-            &["build", "--tests", "--examples", "--keep-going"],
+            &["build", "--tests", "--keep-going"],
             limits,
             events,
         )

crates/cargo-gamma-lib/src/exec/build/tests.rs

@@ -177,6 +177,32 @@ fn a_build_past_its_output_limit_fails_without_retaining_the_excess() {
     );
 }
 
+/// The public defaults, rather than test-only reduced limits, exceed the historical stream and line
+/// caps.
+#[test]
+fn default_output_limits_accept_large_streams_and_lines() {
+    const OLD_STREAM_LIMIT: usize = 4 * 1024 * 1024;
+    const LINE_LENGTH: usize = 128 * 1024;
+
+    let mut output = Vec::with_capacity(OLD_STREAM_LIMIT + LINE_LENGTH);
+    while output.len() <= OLD_STREAM_LIMIT {
+        output.extend(std::iter::repeat_n(b'x', LINE_LENGTH - 1));
+        output.push(b'\n');
+    }
+
+    let (sender, lines) = mpsc::sync_channel(64);
+    let pipe = read_pipe(io::Cursor::new(output.clone()), Stream::Prose, &sender)
+        .expect("spawn reader")
+        .join()
+        .expect("reader");
+    drop(sender);
+    drop(lines);
+
+    assert_eq!(pipe.text, output);
+    assert!(pipe.complete);
+    assert!(pipe.within_limits, "the production defaults regressed to their old bounds");
+}
+
 /// A small retained cap records truncation while continuing to drain the pipe.
 #[test]
 fn an_over_limit_pipe_keeps_only_its_configured_prefix() {
@@ -367,17 +393,23 @@ fn a_narrowed_build_that_fails_is_retried_across_the_whole_workspace() {
     assert!(build.widened, "the build should have reported that it widened");
 }
 
-/// Examples remain part of the compilation oracle even though they are never test binaries.
+/// Targets that cargo-gamma will not run do not belong to its compilation oracle.
 #[test]
-fn the_final_build_still_compiles_examples() {
-    let (_dir, work) = trivial_workspace("build-example-");
+fn the_final_build_does_not_compile_examples_or_benches() {
+    let (_dir, work) = trivial_workspace("build-non-test-targets-");
 
     fs::create_dir_all(work.root.join("examples").as_std_path()).expect("examples");
     fs::write(
         work.root.join("examples/broken.rs").as_std_path(),
         "fn main() { let _: i32 = \"not an integer\"; }\n",
     )
     .expect("example");
+    fs::create_dir_all(work.root.join("benches").as_std_path()).expect("benches");
+    fs::write(
+        work.root.join("benches/broken.rs").as_std_path(),
+        "fn main() { let _: i32 = \"not an integer\"; }\n",
+    )
+    .expect("bench");
 
     let mut plan = empty_plan(&work);
     let build = Converger::default()
@@ -388,13 +420,13 @@ fn the_final_build_still_compiles_examples() {
             BuildLimits::default(),
             &mut crate::testing::Recorder::default(),
         )
-        .expect("the build reports the example failure");
+        .expect("non-test targets are not part of the build");
 
+    assert!(build.stuck.is_none(), "examples and benches must not affect the test oracle");
     assert!(
-        build.stuck.is_some(),
-        "a broken example must not disappear from the compilation oracle"
+        !build.binaries.is_empty(),
+        "the test oracle still contains its runnable test binary"
     );
-    assert!(build.binaries.is_empty(), "a failed compilation produces no runnable oracle");
 }
 
 /// A workspace of two members, one of which does not compile and is not being mutated.
@@ -1034,6 +1066,23 @@ fn each_build_gets_the_whole_round_budget_rather_than_what_earlier_builds_left()
     assert_eq!(converger.withdrawn(), 2, "withdrawals carry across builds");
 }
 
+/// A check-stage duration cannot budget a later code-generating test-target build.
+#[test]
+fn each_build_calibrates_its_own_timeout_reference() {
+    let mut converger = Converger {
+        rounds: 7,
+        per_round: vec![3, 1],
+        first_round: Some(Duration::from_millis(1)),
+        ..Converger::default()
+    };
+
+    converger.begin_convergence();
+
+    assert_eq!(converger.rounds, 0);
+    assert!(converger.per_round.is_empty());
+    assert_eq!(converger.first_round, None);
+}
+
 /// The limit error reads a series of withdrawal counts and gives falling-or-flat advice from
 /// it, so the series has to describe the build that just failed. Counts left over from earlier
 /// builds would have it describe work the reader is not being told about.