fix(cargo-gamma): stabilize builds and baseline diagnostics

- Keep whole-workspace Cargo roots stable across staged convergence while physically withdrawing deferred-stage mutants. This preserves dependency feature unification and prevents unrelated mutants from affecting each stage.

- Bound Cargo output safely without reserving the full ceiling, and normalize leading ANSI erase sequences so redirected progress remains readable.

- Remove the noisy cgroup-containment warning while retaining best-effort process-group cleanup on hosts without delegated cgroups.

- Make baseline failures self-diagnosing. Record termination, timing, memory, package, target, runner, working directory, and bounded control-encoded stdout/stderr tails in baseline-failure.json.

- Write baseline-failure.json and gamma-diagnostics.json before early cleanup, and point the console diagnostic at both files instead of replaying captured test output. Artifact failures remain secondary and inherited environment values stay private.

- Restrict failure-output retention and complete harness draining to baseline measurement, leaving successful observations and mutation/confirmation hot paths unchanged.

- Preserve an existing `cargo-gamma-rt` dependency's `features`/`default-features` when redirecting it to the vendored runtime, for both direct and workspace-inherited dependencies.

- Write vendored runtime dependency paths with portable (`/`) separators so the rewritten manifest parses as valid TOML on Windows.

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

Author: Martin Taillefer

Cargo.lock

@@ -34,12 +34,12 @@ bytes = { version = "1.12.1", default-features = false }
 camino = { version = "1.2.5", default-features = false }
 # local dependencies
 cargo-aprz-lib = { path = "crates/cargo-aprz-lib", default-features = false, version = "1.1.2" }
-cargo-gamma-attrs-impl = { path = "crates/cargo-gamma-attrs-impl", default-features = false, version = "0.2.0" }
-cargo-gamma-engine = { path = "crates/cargo-gamma-engine", default-features = false, version = "0.2.0" }
-cargo-gamma-lib = { path = "crates/cargo-gamma-lib", default-features = false, version = "0.2.0" }
-cargo-gamma-process = { path = "crates/cargo-gamma-process", default-features = false, version = "0.2.0" }
-cargo-gamma-rt = { path = "crates/cargo-gamma-rt", default-features = false, version = "0.2.0" }
-cargo-gamma-unsafe = { path = "crates/cargo-gamma-unsafe", default-features = false, version = "0.2.0" }
+cargo-gamma-attrs-impl = { path = "crates/cargo-gamma-attrs-impl", default-features = false, version = "0.2.1" }
+cargo-gamma-engine = { path = "crates/cargo-gamma-engine", default-features = false, version = "0.2.1" }
+cargo-gamma-lib = { path = "crates/cargo-gamma-lib", default-features = false, version = "0.2.1" }
+cargo-gamma-process = { path = "crates/cargo-gamma-process", default-features = false, version = "0.2.1" }
+cargo-gamma-rt = { path = "crates/cargo-gamma-rt", default-features = false, version = "0.2.1" }
+cargo-gamma-unsafe = { path = "crates/cargo-gamma-unsafe", default-features = false, version = "0.2.1" }
 cargo-heather = { path = "crates/cargo-heather", default-features = false, version = "0.2.1" }
 # external dependencies
 cargo-platform = { version = "0.3.3", default-features = false }

Cargo.toml

@@ -4,7 +4,7 @@
 [package]
 name = "cargo-gamma-attrs-impl"
 description = "Implementation of the inert attribute macros exposed by cargo-gamma-attrs"
-version = "0.2.0"
+version = "0.2.1"
 readme = "README.md"
 keywords = ["cargo", "mutation-testing", "testing"]
 categories = ["development-tools::testing"]

crates/cargo-gamma-attrs-impl/Cargo.toml

@@ -4,7 +4,7 @@
 [package]
 name = "cargo-gamma-attrs"
 description = "Inert attribute macros for suppressing cargo-gamma mutations"
-version = "0.2.0"
+version = "0.2.1"
 readme = "README.md"
 keywords = ["cargo", "mutation-testing", "testing"]
 categories = ["development-tools::testing"]

crates/cargo-gamma-attrs/Cargo.toml

@@ -4,7 +4,7 @@
 [package]
 name = "cargo-gamma-engine"
 description = "Internal Rust source mutation engine for cargo-gamma"
-version = "0.2.0"
+version = "0.2.1"
 readme = "README.md"
 keywords = ["cargo", "mutation-testing", "testing"]
 categories = ["development-tools::testing"]

crates/cargo-gamma-engine/Cargo.toml

@@ -4,7 +4,7 @@
 [package]
 name = "cargo-gamma-lib"
 description = "Internal library for cargo-gamma"
-version = "0.2.0"
+version = "0.2.1"
 readme = "README.md"
 keywords = ["cargo", "mutation-testing", "testing"]
 categories = ["development-tools::testing"]

crates/cargo-gamma-lib/Cargo.toml

@@ -61,6 +61,38 @@ includes both failure to acquire the startup environment and a guard reached
 before the runtime constructor installed its selection; either fixed marker
 disqualifies the process as mutation-score evidence.
 
+Interactive build progress reuses Cargo's progress text while cargo-gamma owns
+the terminal redraw. Cargo's leading erase control is consumed rather than
+rendered visibly, and its color styling remains intact.
+
+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
+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.
+It points to the generated diagnostics instead of printing captured test output
+to the console. Successful observations retain none of this output. Before
+early failure cleanup, the command writes the structured record, including
+safely encoded output tails, to `baseline-failure.json` and writes the ordinary
+`gamma-diagnostics.json` bundle; only environment values cargo-gamma explicitly
+controls are eligible for diagnostic records, never the inherited process
+environment.
+
+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
+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.
+Diagnostic blame, isolation, and withdrawal therefore remain limited to the
+current stage even though Cargo checks the wider graph. The final test-target
+build retains its reachability-based package selection; runs whose original
+Cargo selection is a package subset retain their narrowed graph throughout.
+
 Diff paths are resolved to the workspace-relative Rust files discovered by the
 survey. Absolute or rooted paths inside the workspace are normalized to those
 candidates; one from another checkout is normalized only when its suffix

…es/cargo-gamma-lib/docs/design/README.md crates/cargo-gamma-lib/docs/DESIGN.mdcrates/cargo-gamma-lib/docs/design/README.md renamed to crates/cargo-gamma-lib/docs/DESIGN.md crates/cargo-gamma-lib/docs/design/README.md renamed to crates/cargo-gamma-lib/docs/DESIGN.md

@@ -19,7 +19,7 @@ use crate::discover::Plan;
 use crate::error::{Error, error};
 use crate::exec;
 use crate::model::{Mutant, Outcome};
-use crate::report::{Listings, Progress, Styler, quantity};
+use crate::report::{Listings, Progress, Styler, encode_controls, quantity};
 #[cfg(any(test, feature = "internals"))]
 use crate::testing::pause_after_cache_adoption;
 
@@ -110,7 +110,7 @@ fn run_info(args: &RunArgs, tests: Option<usize>, dropped: &[String]) -> crate::
 
 /// Where a run's documents go, once the defaults and any overrides have been settled.
 ///
-/// Every run writes all five — HTML, JSON and SARIF reports, Markdown advice and a diagnostics bundle.
+/// Every completed run writes all five — HTML, JSON and SARIF reports, Markdown advice and a diagnostics bundle.
 /// The reason they are produced by default rather than on request is
 /// that the flags were a trap: a run that takes an hour and answers a question about your test
 /// suite is exactly the run you do not want to repeat because you forgot to ask for the artifact
@@ -806,7 +806,7 @@ 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 outcome = exec::run_with_locks(&survey, &selection, &config, &mut events, cache_locks);
+    let mut outcome = exec::run_with_locks(&survey, &selection, &config, &mut events, cache_locks);
 
     // 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
@@ -817,6 +817,10 @@ fn measured<H: Host>(host: &mut H, args: &RunArgs, progress_when: When, styler:
 
     let log_result = events.finish_verdict_log();
 
+    if let Err(failure) = &mut outcome {
+        emit_failure_artifacts(&mut events, args, &survey.skeleton(), failure, &artifact_dir, started, styler);
+    }
+
     let exec::Measured {
         plan,
         built,
@@ -928,6 +932,66 @@ fn measured<H: Host>(host: &mut H, args: &RunArgs, progress_when: When, styler:
     Ok(Executed { plan: Some(plan), stuck })
 }
 
+fn emit_failure_artifacts<H: Host>(
+    events: &mut ConsoleEvents<'_, H>,
+    args: &RunArgs,
+    plan: &Plan,
+    failure: &mut Error,
+    artifact_dir: &Utf8Path,
+    started: Instant,
+    styler: Styler,
+) {
+    let Some(artifact) = failure.artifact() else {
+        return;
+    };
+
+    let path = artifact_dir.join(artifact.file_name);
+    let diagnostics = Documents::resolve(args, &plan.root).diag;
+    let written = serde_json::to_string_pretty(&artifact.value)
+        .map_err(|cause| error!("could not encode `{path}`").caused_by(cause))
+        .and_then(|contents| crate::elements::write(&path, &contents));
+
+    let baseline_written = match written {
+        Ok(()) => {
+            let _announced = writeln!(events.host.error(), "{} {path}", styler.verb("Wrote"));
+            true
+        }
+        Err(artifact_failure) => {
+            crate::exec::Events::warn(
+                events,
+                &format!("could not preserve the baseline failure record: {artifact_failure}"),
+            );
+            false
+        }
+    };
+
+    let diagnostics_written = match emit_diag(events.host, args, plan, None, started, styler) {
+        Ok(()) => true,
+        Err(diag_failure) => {
+            crate::exec::Events::warn(
+                events,
+                &format!("could not preserve the diagnostics bundle after the baseline failure: {diag_failure}"),
+            );
+            false
+        }
+    };
+
+    match (baseline_written, diagnostics_written) {
+        (true, true) => failure.append_message(&format!(
+            "\nDiagnostics:   {}\n               {}",
+            encode_controls(path.as_str()),
+            encode_controls(diagnostics.as_str()),
+        )),
+        (true, false) => {
+            failure.append_message(&format!("\nDiagnostics:   {}", encode_controls(path.as_str())));
+        }
+        (false, true) => {
+            failure.append_message(&format!("\nDiagnostics:   {}", encode_controls(diagnostics.as_str())));
+        }
+        (false, false) => {}
+    }
+}
+
 fn warn_auxiliary<H: Host>(host: &mut H, failure: Option<&Error>, styler: Styler) {
     if let Some(failure) = failure {
         let _ = writeln!(host.error(), "{} {failure}", styler.warning());
@@ -1739,6 +1803,45 @@ mod tests {
         assert!(String::from_utf8(host.err).expect("utf-8").contains(path.as_str()));
     }
 
+    #[test]
+    fn a_baseline_error_writes_its_record_and_the_diagnostics_bundle() {
+        let dir = workdir("run-baseline-failure-artifacts-");
+        let root = Utf8PathBuf::from_path_buf(dir.path().to_path_buf()).expect("utf8");
+        let args = RunArgs {
+            artifact_dir: Some(root.clone()),
+            ..Default::default()
+        };
+        let plan = plan();
+        let mut failure = Error::new("baseline failed").with_artifact(
+            "baseline-failure.json",
+            serde_json::json!({
+                "schemaVersion": 1,
+                "kind": "testFailure",
+                "stderrTail": "assertion failed",
+            }),
+        );
+        let mut host = Sink::default();
+        let mut events = ConsoleEvents {
+            host: &mut host,
+            progress: Progress::new(false, Styler::new(false), Some(80)),
+            styler: Styler::new(false),
+            estimate: false,
+            show_build: false,
+            verdict_log: VerdictLog::default(),
+        };
+
+        emit_failure_artifacts(&mut events, &args, &plan, &mut failure, &root, Instant::now(), Styler::new(false));
+
+        let baseline = fs::read_to_string(root.join("baseline-failure.json")).expect("baseline record");
+        let diagnostics = fs::read_to_string(root.join("gamma-diagnostics.json")).expect("diagnostics bundle");
+
+        assert!(baseline.contains("assertion failed"), "{baseline}");
+        assert!(diagnostics.contains("\"schemaVersion\": \"3\""), "{diagnostics}");
+        assert!(failure.to_string().contains("Diagnostics:"), "{failure}");
+        assert!(failure.to_string().contains("baseline-failure.json"), "{failure}");
+        assert!(failure.to_string().contains("gamma-diagnostics.json"), "{failure}");
+    }
+
     /// A run that censused says so in its bundle: the phase carries its own elapsed time, the tests
     /// it walked, and the binaries it examined, so the census's cost is legible on its own rather
     /// than folded inside the build's total.

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

@@ -9,6 +9,14 @@ use std::backtrace::Backtrace;
 use std::io;
 
 use cargo_gamma_engine::{Error as EngineError, Parts as EngineParts};
+use serde_json::Value;
+
+/// A machine-readable diagnostic that should be persisted before an error unwinds its run state.
+#[derive(Debug)]
+pub(crate) struct Artifact {
+    pub(crate) file_name: &'static str,
+    pub(crate) value: Value,
+}
 
 /// An error carrying a human-readable message and an optional cause.
 ///
@@ -20,6 +28,7 @@ pub struct Error {
     cause: Option<Box<dyn StdError + Send + Sync>>,
     usage: bool,
     skippable: bool,
+    artifact: Option<Box<Artifact>>,
 
     /// Captured at construction, unconditionally.
     ///
@@ -39,6 +48,7 @@ impl Error {
             cause: None,
             usage: false,
             skippable: false,
+            artifact: None,
             backtrace: Backtrace::capture(),
         }
     }
@@ -81,6 +91,23 @@ impl Error {
         self.skippable
     }
 
+    /// Attaches a machine-readable diagnostic for the command layer to persist.
+    #[must_use]
+    pub(crate) fn with_artifact(mut self, file_name: &'static str, value: Value) -> Self {
+        self.artifact = Some(Box::new(Artifact { file_name, value }));
+        self
+    }
+
+    /// Returns the diagnostic attached to this failure, when it has one.
+    pub(crate) fn artifact(&self) -> Option<&Artifact> {
+        self.artifact.as_deref()
+    }
+
+    /// Appends command-layer context that was not available where the error originated.
+    pub(crate) fn append_message(&mut self, suffix: &str) {
+        self.message.push_str(suffix);
+    }
+
     /// Attaches an underlying cause.
     #[must_use]
     pub fn caused_by(mut self, cause: impl StdError + Send + Sync + 'static) -> Self {
@@ -148,6 +175,7 @@ impl From<EngineError> for Error {
             cause,
             usage,
             skippable,
+            artifact: None,
             backtrace,
         }
     }