probatio 0.1.3 → 0.2.0

package/dist/mutate/node-coverage.mjs

@@ -1,13 +1,14 @@
 // Baseline-only per-test line map for node --test. Loaded with --import in each
 // test-file process. Writes one shard; the runner merges shards after the suite.
 // takePreciseCoverage resets counters, so each sample is only what ran since the last take.
-// A plain-script child does not run these hooks. It may leave a nameless hit list in
-// ${map}.children. afterEach stores that list under the parent test before the shard is written.
+// A node child of a test does not run these hooks. exposeChildLines puts child-lines.mjs in
+// its NODE_OPTIONS, so it leaves a nameless hit list in ${map}.children when it exits.
+// afterEach stores that list under the parent test before the shard is written.
 import { randomBytes } from "node:crypto"
-import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs"
+import { mkdirSync, writeFileSync } from "node:fs"
 import { after, afterEach, before } from "node:test"
 import path from "node:path"
-import { openLineSampler } from "./precise-lines.mjs"
+import { exposeChildLines, openLineSampler, takeChildHits } from "./precise-lines.mjs"
 
 const mapPath = process.env.PROBATIO_COVERAGE_MAP
 if (mapPath) {
@@ -19,6 +20,7 @@ if (mapPath) {
   }
 
   if (sampler) {
+    exposeChildLines()
     /** @type {Map<string, Map<number, Set<string>>>} */
     const byFile = new Map()
     /** @type {Array<{ file: string, line: number }>} */
@@ -41,33 +43,6 @@ if (mapPath) {
       }
     }
 
-    function takeChildHits() {
-      const dir = `${mapPath}.children`
-      if (!existsSync(dir)) return []
-      /** @type {Array<{ file: string, line: number }>} */
-      const hits = []
-      for (const name of readdirSync(dir)) {
-        if (!name.endsWith(".json")) continue
-        const full = path.join(dir, name)
-        try {
-          const parsed = JSON.parse(readFileSync(full, "utf8"))
-          const list = parsed && Array.isArray(parsed.hits) ? parsed.hits : []
-          for (const hit of list) {
-            if (!hit || typeof hit.file !== "string" || !Number.isInteger(hit.line)) continue
-            hits.push({ file: hit.file, line: hit.line })
-          }
-        } catch {
-          // A torn dump is ignored. The parent does not invent a line.
-        }
-        try {
-          unlinkSync(full)
-        } catch {
-          // The next test must not inherit this dump.
-        }
-      }
-      return hits
-    }
-
     before(async () => {
       try {
         prelude = await sampler.positiveLines()
@@ -80,7 +55,7 @@ if (mapPath) {
       try {
         add(prelude, t.name)
         add(await sampler.positiveLines(), t.name)
-        add(takeChildHits(), t.name)
+        add(takeChildHits(mapPath), t.name)
       } catch (err) {
         writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
       }

package/dist/mutate/patch.js

@@ -131,5 +131,6 @@ export function applyPatch(repo, raw, direction) {
 /** Put a throwaway worktree back. A diff label is not trusted for the path list. */
 export function restoreTree(repo) {
     git(repo, ["checkout", "--", "."]);
-    git(repo, ["clean", "-fd", "-e", "node_modules"]);
+    // .probatio.json may be the user's uncommitted copy, put there when the worktree was made.
+    git(repo, ["clean", "-fd", "-e", "node_modules", "-e", ".probatio.json"]);
 }

package/dist/mutate/precise-lines.mjs

@@ -1,5 +1,7 @@
 // Inspector line samples shared by the node:test collector, the Mocha collector,
 // and a plain-script child. This file has no test hooks and writes no shard.
+import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs"
+import { Session as SyncSession } from "node:inspector"
 import { Session } from "node:inspector/promises"
 import { findSourceMap } from "node:module"
 import path from "node:path"
@@ -31,32 +33,14 @@ function decodeSegments(row) {
 }
 
 /**
+ * Offsets to source lines, shared by the async sampler (test processes) and the sync one (children).
+ * Paths are relative to `root`. node_modules and paths outside root are left out.
  * @param {(rel: string) => boolean} [skipRel]
- * @returns {Promise<{ positiveLines: () => Promise<Array<{ file: string, line: number }>>, reset: () => Promise<void> }>}
+ * @param {string} [root]
  */
-export async function openLineSampler(skipRel) {
-  const session = new Session()
-  session.connect()
-  await session.post("Profiler.enable")
-  await session.post("Debugger.enable")
-  await session.post("Profiler.startPreciseCoverage", { callCount: true, detailed: true })
-
-  const textCache = new Map()
+function lineConverter(skipRel, root = process.cwd()) {
   const indexCache = new Map()
 
-  async function scriptText(script) {
-    if (textCache.has(script.scriptId)) return textCache.get(script.scriptId)
-    let text = ""
-    try {
-      const got = await session.post("Debugger.getScriptSource", { scriptId: script.scriptId })
-      text = got.scriptSource || ""
-    } catch {
-      text = ""
-    }
-    textCache.set(script.scriptId, text)
-    return text
-  }
-
   function relPath(url) {
     if (!url || url.startsWith("node:")) return null
     let abs
@@ -65,7 +49,7 @@ export async function openLineSampler(skipRel) {
     } catch {
       return null
     }
-    const rel = path.relative(process.cwd(), abs).split(path.sep).join("/")
+    const rel = path.relative(root, abs).split(path.sep).join("/")
     if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return null
     if (rel.split("/").includes("node_modules")) return null
     if (skipRel && skipRel(rel)) return null
@@ -163,18 +147,55 @@ export async function openLineSampler(skipRel) {
     return counts
   }
 
+  /** Lines with a positive count in one script, or null when the script is not ours. */
+  function scriptLines(script, text) {
+    const file = relPath(script.url)
+    if (!file || !text) return null
+    const counts = applyRanges(text, script, indexFor(script.scriptId, text, findSourceMap(script.url)))
+    const found = []
+    for (const [line, count] of counts) {
+      if (count > 0) found.push({ file, line })
+    }
+    return found
+  }
+
+  return { relPath, scriptLines }
+}
+
+/**
+ * @param {(rel: string) => boolean} [skipRel]
+ * @returns {Promise<{ positiveLines: () => Promise<Array<{ file: string, line: number }>>, reset: () => Promise<void> }>}
+ */
+export async function openLineSampler(skipRel) {
+  const session = new Session()
+  session.connect()
+  await session.post("Profiler.enable")
+  await session.post("Debugger.enable")
+  await session.post("Profiler.startPreciseCoverage", { callCount: true, detailed: true })
+
+  const textCache = new Map()
+  const convert = lineConverter(skipRel)
+
+  async function scriptText(script) {
+    if (textCache.has(script.scriptId)) return textCache.get(script.scriptId)
+    let text = ""
+    try {
+      const got = await session.post("Debugger.getScriptSource", { scriptId: script.scriptId })
+      text = got.scriptSource || ""
+    } catch {
+      text = ""
+    }
+    textCache.set(script.scriptId, text)
+    return text
+  }
+
   async function positiveLines() {
     const cov = await session.post("Profiler.takePreciseCoverage")
     const found = []
     for (const script of cov.result || []) {
-      const file = relPath(script.url)
-      if (!file) continue
-      const text = await scriptText(script)
-      if (!text) continue
-      const counts = applyRanges(text, script, indexFor(script.scriptId, text, findSourceMap(script.url)))
-      for (const [line, count] of counts) {
-        if (count > 0) found.push({ file, line })
-      }
+      if (!convert.relPath(script.url)) continue
+      const lines = convert.scriptLines(script, await scriptText(script))
+      if (lines) found.push(...lines)
     }
     return found
   }
@@ -186,3 +207,98 @@ export async function openLineSampler(skipRel) {
     },
   }
 }
+
+/**
+ * The same sampler with synchronous calls, so an `exit` handler can read it.
+ * `exit` runs after process.exit(), where a promise never settles.
+ * @param {(rel: string) => boolean} [skipRel]
+ * @param {string} [root]
+ */
+export function openSyncLineSampler(skipRel, root) {
+  const session = new SyncSession()
+  session.connect()
+  const post = (method, params) => {
+    let result
+    let failure = null
+    let done = false
+    session.post(method, params, (err, value) => {
+      failure = err
+      result = value
+      done = true
+    })
+    if (!done) throw new Error(`inspector ${method} did not answer synchronously`)
+    if (failure) throw failure
+    return result
+  }
+  post("Profiler.enable")
+  post("Debugger.enable")
+  post("Profiler.startPreciseCoverage", { callCount: true, detailed: true })
+  const convert = lineConverter(skipRel, root)
+  return {
+    positiveLines() {
+      const cov = post("Profiler.takePreciseCoverage")
+      const found = []
+      for (const script of cov.result || []) {
+        if (!convert.relPath(script.url)) continue
+        let text = ""
+        try {
+          text = post("Debugger.getScriptSource", { scriptId: script.scriptId }).scriptSource || ""
+        } catch {
+          text = ""
+        }
+        const lines = convert.scriptLines(script, text)
+        if (lines) found.push(...lines)
+      }
+      return found
+    },
+  }
+}
+
+/**
+ * Called inside a test process that collects a line map. Every node child it starts
+ * loads child-lines.mjs through NODE_OPTIONS, with no import in the child's own code.
+ * The marker tells child-lines that this process already has test hooks.
+ */
+export function exposeChildLines() {
+  globalThis.__probatioTestHooks = true
+  // One dump dir per test process. Test files can run in parallel, and a child's lines
+  // belong to the test in the process that started it, not to a test in another file.
+  const mapPath = process.env.PROBATIO_COVERAGE_MAP
+  if (mapPath) process.env.PROBATIO_CHILD_DIR = childDir(mapPath)
+  const childLines = new URL("./child-lines.mjs", import.meta.url).href
+  const flag = `--import=${childLines}`
+  const current = process.env.NODE_OPTIONS || ""
+  if (!current.includes(flag)) process.env.NODE_OPTIONS = current ? `${current} ${flag}` : flag
+  if (!process.env.PROBATIO_PACKAGE_ROOT) process.env.PROBATIO_PACKAGE_ROOT = process.cwd()
+}
+
+export function childDir(mapPath) {
+  return path.join(`${mapPath}.children`, String(process.pid))
+}
+
+/** Line dumps the children of the current test left. Each one is read once. */
+export function takeChildHits(mapPath) {
+  const dir = childDir(mapPath)
+  if (!existsSync(dir)) return []
+  const hits = []
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith(".json")) continue
+    const full = path.join(dir, name)
+    try {
+      const parsed = JSON.parse(readFileSync(full, "utf8"))
+      const list = parsed && Array.isArray(parsed.hits) ? parsed.hits : []
+      for (const hit of list) {
+        if (!hit || typeof hit.file !== "string" || !Number.isInteger(hit.line)) continue
+        hits.push({ file: hit.file, line: hit.line })
+      }
+    } catch {
+      // A torn dump is ignored. The parent does not invent a line.
+    }
+    try {
+      unlinkSync(full)
+    } catch {
+      // The next test must not inherit this dump.
+    }
+  }
+  return hits
+}

package/dist/mutate/probatio-jacoco-run.java

@@ -85,8 +85,8 @@ public class ProbatioJacocoRun {
       System.err.println("java coverage: tests ran but JaCoCo recorded no classes");
       System.exit(1);
     }
-    // jsoup's integration tests leave Netty loops running. A normal return would
-    // wait on those threads until the parent clock kills the dump.
+    // Integration tests can leave non-daemon threads running (jsoup leaves Netty loops).
+    // A normal return would wait on those threads until the parent clock kills the dump.
     System.exit(0);
   }
 

package/dist/mutate/project-config.js

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+/**
+ * `.probatio.json` at the package root. How to run this project's suite, written by the
+ * project and visible in review. Probatio does not patch a project's files or environment
+ * to make one repository pass. A project that needs that says so here.
+ */
+export const CONFIG_FILE = ".probatio.json";
+const EMPTY = { env: {}, testLine: null, passLine: null };
+export function readProjectConfig(pkg) {
+    const file = path.join(pkg, CONFIG_FILE);
+    if (!existsSync(file))
+        return EMPTY;
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        return { error: `${CONFIG_FILE} is not JSON (${error instanceof Error ? error.message : String(error)})` };
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return { error: `${CONFIG_FILE} must be one JSON object` };
+    const body = raw;
+    const env = {};
+    if (body.env !== undefined) {
+        if (!body.env || typeof body.env !== "object" || Array.isArray(body.env))
+            return { error: `${CONFIG_FILE} env must be an object of strings` };
+        for (const [key, value] of Object.entries(body.env)) {
+            if (typeof value !== "string")
+                return { error: `${CONFIG_FILE} env.${key} must be a string` };
+            env[key] = value;
+        }
+    }
+    const testLine = pattern(body.testLine, "testLine");
+    if (typeof testLine === "string")
+        return { error: testLine };
+    const passLine = pattern(body.passLine, "passLine");
+    if (typeof passLine === "string")
+        return { error: passLine };
+    return { env, testLine, passLine };
+}
+/** The config, or the empty one when the file is unreadable. The runner refuses that case earlier. */
+export function projectConfig(pkg) {
+    const read = readProjectConfig(pkg);
+    return "error" in read ? EMPTY : read;
+}
+function pattern(value, name) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== "string" || value.length === 0)
+        return `${CONFIG_FILE} ${name} must be a non-empty string`;
+    try {
+        return new RegExp(value);
+    }
+    catch (error) {
+        return `${CONFIG_FILE} ${name} is not a regular expression (${error instanceof Error ? error.message : String(error)})`;
+    }
+}

package/dist/mutate/run.js

@@ -12,7 +12,8 @@ import { writeJavaCoverage } from "./java-coverage.js";
 import { writeRustCoverage } from "./rust-coverage.js";
 import { applyPatch, changedLines, chooseDirection, filesInDiff, git, restoreTree } from "./patch.js";
 import { killLabel } from "./kill-label.js";
-import { TIMEOUT_FLOOR_MS, TIMEOUT_MULTIPLE, TIMEOUT_NEXT, WHOLE_PROGRAM_TEST, WHOLE_SUITE_NEXT, campaignSummary, decideSuite, hasLineMap, noCoverageNext, resumeNext, scaleStop, timeoutLimitMs, } from "./suite-decision.js";
+import { CONFIG_FILE, readProjectConfig } from "./project-config.js";
+import { UNVIABLE_NEXT, TIMEOUT_FLOOR_MS, TIMEOUT_MULTIPLE, TIMEOUT_NEXT, WHOLE_PROGRAM_TEST, WHOLE_SUITE_NEXT, campaignSummary, decideSuite, hasLineMap, noCoverageNext, resumeNext, scaleStop, timeoutLimitMs, } from "./suite-decision.js";
 import { commandSuite, discoverSuite, nodeTestTimeoutMs, runDiscoveredSuite, sourceCandidates } from "./suites.js";
 import { duplicateTitles } from "./titles.js";
 export const reporterPath = fileURLToPath(new URL("./fail-reporter.mjs", import.meta.url));
@@ -52,6 +53,9 @@ export async function runMutants(options) {
         : listed.files;
     if (patchFiles.length === 0)
         return failReport(options.outDir, run.id, commit, "no patches");
+    const config = readProjectConfig(packageDir);
+    if ("error" in config)
+        return failReport(options.outDir, run.id, commit, config.error, undefined, `Fix ${CONFIG_FILE} and run the same command again.`);
     const gate = resolveSuite(packageDir, options);
     if (gate.action === "stop")
         return failReport(options.outDir, run.id, commit, gate.summary, undefined, gate.next, gate.suiteCommand);
@@ -67,6 +71,13 @@ export async function runMutants(options) {
     if ("error" in worktrees)
         return failReport(options.outDir, run.id, commit, worktrees.error);
     hidePaths(worktrees.dirs, repo, packageDir, options.hide ?? []);
+    // A cancelled run (MCP cancel, Ctrl-C) still removes its worktrees from the user's repo.
+    const onSignal = (signal) => {
+        removeWorktrees(repo, worktrees.dirs, options.outDir);
+        process.exit(signal === "SIGINT" ? 130 : 143);
+    };
+    process.once("SIGTERM", onSignal);
+    process.once("SIGINT", onSignal);
     const budgetMs = options.budgetMs ?? (options.maxMinutes == null ? null : options.maxMinutes * 60_000);
     let budgetStarted = 0;
     const overBudget = () => budgetMs !== null && budgetStarted !== 0 && Date.now() - budgetStarted > budgetMs;
@@ -113,7 +124,7 @@ export async function runMutants(options) {
                     const prior = history.get(id);
                     if (prior && reusable(prior, raw, treePkg)) {
                         startedMutants += 1;
-                        const reused = reusedResult(prior, commit, run.id, options.agent);
+                        const reused = normalizeResult(reusedResult(prior, commit, run.id, options.agent));
                         writeResult(options.outDir, reused);
                         progress(`reused ${id}`);
                         continue;
@@ -165,6 +176,8 @@ export async function runMutants(options) {
         });
     }
     finally {
+        process.removeListener("SIGTERM", onSignal);
+        process.removeListener("SIGINT", onSignal);
         removeWorktrees(repo, worktrees.dirs, options.outDir);
     }
 }
@@ -292,10 +305,12 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep, la
                 return { ...base(), direction, outcome: "timeout", error: "build timed out", next: TIMEOUT_NEXT };
             // The baseline build already succeeded. A mutant that no longer builds cannot pass the suite.
             if (built.code !== 0)
-                return finishMutant(killed(base, direction, ["build"]), pkg, "", false, []);
+                return finishMutant(unviable(base, direction, "build"), pkg, "", false, []);
         }
         const picked = selectionFor(prep.coverage, edited.length > 0 ? edited : files);
-        const forced = options.onlyNames && options.onlyNames.length > 0 ? options.onlyNames : null;
+        const forced = options.onlyNames && options.onlyNames.length > 0
+            ? prep.spec.kind === "node" ? options.onlyNames.map(nodeTitle) : options.onlyNames
+            : null;
         if (!forced && picked.state === "uncovered") {
             return {
                 ...base(),
@@ -323,7 +338,7 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep, la
         }
         // A compile error can leave the previous run's report on disk. That report is not this mutant.
         if (main.compileToken)
-            return finishMutant(killed(base, direction, [main.compileToken]), pkg, commands.join(" | "), false, []);
+            return finishMutant(unviable(base, direction, main.compileToken), pkg, commands.join(" | "), false, []);
         if (!main.report) {
             const detail = main.detail ? clip(main.detail) : "";
             const tool = missingToolFrom(detail, main.command);
@@ -334,13 +349,23 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep, la
                     : "test reporter returned nothing";
             return { ...base(), direction, error, command: commands.join(" | ") };
         }
+        // A node name pattern that matches nothing passes the file. That is not a survivor.
+        // A requested describe block reports its leaf tests, so any test that ran counts.
+        if (forced && prep.spec.kind === "node" && main.report.names.every((name) => isNodeTestFile(name))) {
+            return { ...base(), direction, error: `no requested test ran (${forced.join(", ")})`, command: commands.join(" | ") };
+        }
         const whole = main.wholeSuite || forceWhole;
         const chosen = main.selectedTests;
         if (main.report.failed.length === 0)
             return finishMutant({ ...base(), direction, outcome: "survived" }, pkg, commands.join(" | "), whole, chosen);
+        // A test file that no longer links ran no test. It is the build failing, the same as javac rejecting it.
+        // Only a failure where code ran can kill. When none did, the mutant did not build.
+        const ran = main.report.failed.filter((item) => !item.staticLoad);
+        if (ran.length === 0)
+            return finishMutant(unviable(base, direction, "compiler"), pkg, commands.join(" | "), false, []);
         if (!options.confirm)
-            return finishMutant(killed(base, direction, main.report.failed.map((item) => failureId(pkg, item))), pkg, commands.join(" | "), whole, chosen);
-        const confirmed = await confirmFailures(pkg, options, main.report.failed, prep, limit, commands);
+            return finishMutant(killed(base, direction, ran.map((item) => failureId(pkg, item))), pkg, commands.join(" | "), whole, chosen);
+        const confirmed = await confirmFailures(pkg, options, ran, prep, limit, commands);
         const killedBy = confirmed.killed.map((item) => failureId(pkg, item));
         const flaky = confirmed.flaky.map((item) => failureId(pkg, item));
         const outcome = killedBy.length > 0 ? "killed" : "flaky";
@@ -368,16 +393,31 @@ function killed(base, direction, killedBy) {
     const label = killLabel(killedBy);
     return { ...base(), direction, outcome: "killed", killedBy, cause: label?.cause ?? "test", next: label?.next ?? "" };
 }
+/** The compiler rejected the mutant. `killedBy` names the compiler so the record says which one. */
+function unviable(base, direction, compiler) {
+    return { ...base(), direction, outcome: "unviable", killedBy: [compiler], cause: "build", next: UNVIABLE_NEXT };
+}
+/**
+ * Results written before `unviable` existed stored a compile failure as killed with cause build.
+ * Read them the new way so an old out dir does not count a compiler as a test.
+ */
+export function normalizeResult(result) {
+    if (result.outcome === "killed" && result.cause === "build")
+        return { ...result, outcome: "unviable", next: UNVIABLE_NEXT };
+    return result;
+}
 async function confirmFailures(pkg, options, failed, prep, timeoutMs, commands) {
     const counts = new Map();
     let wholeSuite = false;
     const named = new Map();
     const hungFiles = new Map();
+    const unloaded = new Map();
     for (const failure of failed) {
         const key = failure.file || "*";
         // A name filter skips the tests that left the handle open, so the file
         // timeout never comes back. Rerun that file with no name pattern.
-        const bucket = failure.fileTimeout ? hungFiles : named;
+        // A file that did not load has no test name to filter by either.
+        const bucket = failure.fileTimeout ? hungFiles : failure.fileLoad ? unloaded : named;
         const list = bucket.get(key) ?? [];
         list.push(failure);
         bucket.set(key, list);
@@ -391,13 +431,17 @@ async function confirmFailures(pkg, options, failed, prep, timeoutMs, commands)
         if (await rerunGroup(pkg, options, file, failures, counts, null, prep, timeoutMs, commands))
             wholeSuite = true;
     }
+    for (const [file, failures] of unloaded) {
+        if (await rerunGroup(pkg, options, file, failures, counts, null, prep, timeoutMs, commands, "load"))
+            wholeSuite = true;
+    }
     const killed = [];
     const flaky = [];
     for (const failure of failed)
         (counts.get(failureId(pkg, failure)) === 2 ? killed : flaky).push(failure);
     return { killed, flaky, wholeSuite };
 }
-async function rerunGroup(pkg, options, file, failures, counts, pattern, prep, timeoutMs, commands) {
+async function rerunGroup(pkg, options, file, failures, counts, pattern, prep, timeoutMs, commands, fileFailure = "timeout") {
     const files = file === "*" ? listTestFiles(pkg, options.testsDir, prep.spec) : [testArg(pkg, file, options.testsDir)];
     const isolated = { ...options, concurrency: 1 };
     let wholeSuite = false;
@@ -409,7 +453,7 @@ async function rerunGroup(pkg, options, file, failures, counts, pattern, prep, t
             wholeSuite = true;
         if (rerun.command)
             commands.push(rerun.command);
-        if (pattern === null && rerun.timedOut) {
+        if (pattern === null && fileFailure === "timeout" && rerun.timedOut) {
             for (const id of new Set(failures.map((item) => failureId(pkg, item))))
                 bump(counts, id);
             continue;
@@ -418,7 +462,7 @@ async function rerunGroup(pkg, options, file, failures, counts, pattern, prep, t
             continue;
         const seen = new Set();
         for (const hit of rerun.report.failed) {
-            if (pattern === null && !hit.fileTimeout)
+            if (pattern === null && !(fileFailure === "timeout" ? hit.fileTimeout : hit.fileLoad))
                 continue;
             const id = failureId(pkg, hit);
             if (failures.some((item) => failureId(pkg, item) === id))
@@ -552,7 +596,7 @@ class NodeBatch {
             return {
                 report: null,
                 timedOut: false,
-                detail: waited.error || "test reporter returned nothing",
+                detail: waited.error || (selected.length > 0 ? `no requested test ran (${selected.join(", ")})` : "test reporter returned nothing"),
                 compileToken: null,
                 command: waited.command || "",
                 wholeSuite: false,
@@ -615,6 +659,11 @@ function isNodeTestFile(file) {
     const base = path.posix.basename(file);
     return /\.(test|spec)\.(ts|tsx|mts|js|mjs|cjs)$/.test(base) || /_test\.(ts|tsx|js|mjs)$/.test(base);
 }
+/** A node keep id may carry its file (`tests/gate.test.ts::zero stays shut`). node:test matches the title. */
+export function nodeTitle(id) {
+    const match = /^[^\s:][^:]*\.(?:[cm]?[jt]s|[jt]sx)::(.+)$/.exec(id);
+    return match ? match[1] : id;
+}
 function narrowNodeFiles(pkg, files, names, kind) {
     if (kind !== "node" || !names || names.length === 0)
         return files;
@@ -652,6 +701,18 @@ function childEnv(unset) {
         if (key === "NODE_TEST_CONTEXT" || key.startsWith("NODE_TEST_"))
             delete env[key];
     }
+    // This run may itself be a child of a suite that another Probatio run is mapping.
+    // That outer map is not this run's. Only the baseline sets a map, through runDiscoveredSuite.
+    delete env.PROBATIO_COVERAGE_MAP;
+    delete env.PROBATIO_PACKAGE_ROOT;
+    delete env.PROBATIO_CHILD_DIR;
+    if (env.NODE_OPTIONS) {
+        const kept = env.NODE_OPTIONS.split(/\s+/).filter((part) => part.length > 0 && !/child-lines\.mjs$/.test(part)).join(" ");
+        if (kept)
+            env.NODE_OPTIONS = kept;
+        else
+            delete env.NODE_OPTIONS;
+    }
     for (const key of unset)
         delete env[key];
     return env;
@@ -772,8 +833,12 @@ async function createWorktrees(repo, packageDir, runId, commit, workers, outDir)
     }
     writeFileSync(path.join(outDir, "worktrees.json"), `${JSON.stringify(dirs)}\n`);
     const sources = nodeModuleSources(repo, packageDir);
+    const config = path.join(packageDir, CONFIG_FILE);
     for (const dir of dirs) {
         const pkgRoot = packageIn(dir, repo, packageDir);
+        // How to run the suite is not the code under test. An uncommitted .probatio.json still applies.
+        if (existsSync(config) && !existsSync(path.join(pkgRoot, CONFIG_FILE)))
+            copyFileSync(config, path.join(pkgRoot, CONFIG_FILE));
         for (const source of sources) {
             const dest = path.join(pkgRoot, source.rel);
             if (existsSync(dest))
@@ -932,11 +997,12 @@ function readResult(outDir, id) {
     const file = resultPath(outDir, id);
     if (!existsSync(file))
         return null;
-    return JSON.parse(readFileSync(file, "utf8"));
+    return normalizeResult(JSON.parse(readFileSync(file, "utf8")));
 }
 function reportOf(results, context) {
     const count = (outcome) => results.filter((result) => result.outcome === outcome).length;
     const killed = count("killed");
+    const unviableCount = count("unviable");
     const survived = count("survived");
     const flaky = count("flaky");
     const timeouts = count("timeout");
@@ -950,7 +1016,7 @@ function reportOf(results, context) {
         return { id: result.id, file, line, ...(known?.op ? { op: known.op } : {}) };
     });
     const budgetHit = context.budgetHit || context.pendingLeft > 0;
-    const summary = campaignSummary({ noCoverage, survived, killed, flaky, timeouts, errors, finished: results.length });
+    const summary = campaignSummary({ noCoverage, survived, killed, unviable: unviableCount, flaky, timeouts, errors, finished: results.length });
     const notes = [];
     const uncovered = results.find((result) => result.outcome === "no coverage");
     if (uncovered?.next)
@@ -976,6 +1042,8 @@ function reportOf(results, context) {
         commit: context.commit,
         runId: context.runId,
         killed,
+        unviable: unviableCount,
+        unviableIds: results.filter((result) => result.outcome === "unviable").slice(0, 10).map((result) => result.id),
         survived,
         flaky,
         timeouts,
@@ -1035,6 +1103,8 @@ function failReport(outDir, runId, commit, error, baselineFailed, next, suiteCom
         commit,
         runId,
         killed: 0,
+        unviable: 0,
+        unviableIds: [],
         survived: 0,
         flaky: 0,
         timeouts: 0,
@@ -1199,10 +1269,19 @@ function failureId(pkg, failure) {
         return BARE_SUITE.has(failure.name) ? `::${failure.name}` : failure.name;
     if (!testFileOnDisk(pkg, failure.file))
         return failure.name;
-    const rel = path.relative(pkg, failure.file);
+    // macOS temp dirs are /var and /private/var. A report can name either, so compare real paths.
+    const rel = path.relative(realOrSame(pkg), realOrSame(path.resolve(pkg, failure.file)));
     const file = !rel || rel.startsWith("..") ? path.basename(failure.file) : rel.split(path.sep).join("/");
     return `${file}::${failure.name}`;
 }
+function realOrSame(file) {
+    try {
+        return realpathSync(file);
+    }
+    catch {
+        return file;
+    }
+}
 function testFileOnDisk(pkg, file) {
     if (path.isAbsolute(file))
         return existsSync(file);