probatio 0.1.3 → 0.3.0

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;
@@ -753,7 +814,7 @@ function loadRun(options, commit) {
     writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`);
     return { id };
 }
-async function createWorktrees(repo, packageDir, runId, commit, workers, outDir) {
+export async function createWorktrees(repo, packageDir, runId, commit, workers, outDir) {
     removeWorktrees(repo, recordedWorktrees(outDir), outDir);
     const dirs = [];
     for (let index = 0; index < workers; index++) {
@@ -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))
@@ -819,7 +884,7 @@ export function probatioWorktreeDir(dir) {
         return false;
     return /^probatio-[0-9a-f]+-\d+$/.test(path.basename(resolved));
 }
-function removeWorktrees(repo, dirs, outDir) {
+export function removeWorktrees(repo, dirs, outDir) {
     for (const dir of dirs) {
         if (!probatioWorktreeDir(dir))
             continue;
@@ -909,7 +974,7 @@ function findNodeModules(root) {
     visit(root);
     return out;
 }
-function packageIn(worktree, repo, packageDir) {
+export function packageIn(worktree, repo, packageDir) {
     const rel = path.relative(repo, packageDir);
     return rel && !rel.startsWith("..") ? path.join(worktree, rel) : worktree;
 }
@@ -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);
@@ -1215,7 +1294,9 @@ function pytestNodeId(name) {
     return name.slice(0, mark).endsWith(".py");
 }
 function testArg(pkg, file, testsDir) {
-    const rel = path.relative(pkg, file);
+    // Compare real paths. A report can name /private/var while the package is /var on macOS, and the
+    // basename fallback below would then rerun tests/<name> instead of tests/unit/<name>.
+    const rel = path.relative(realOrSame(pkg), realOrSame(path.resolve(pkg, file)));
     if (rel && !rel.startsWith(".."))
         return rel.split(path.sep).join("/");
     return path.join(testsDir, path.basename(file));

package/dist/mutate/sealed.js

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 /** The label stays in its own file. The run report must not repeat these three values. */
@@ -62,3 +63,56 @@ function field(text, key) {
     const match = text.match(new RegExp(`^${key}=(.*)$`, "m"));
     return match?.[1]?.trim() ?? "";
 }
+/**
+ * A sealed run hides the revealing test, but a fix commit often edits an older test too.
+ * A kill by that edited test is the fix's own test, not an older test that caught the bug.
+ * Returns the edited test files that killed, and whether any kill came from a test the fix left alone.
+ */
+export function fixEditedKillers(repo, packageDir, commit, hide, kills) {
+    if (kills.length === 0)
+        return { files: [], olderTestCatch: false };
+    const diff = spawnSync("git", ["-C", repo, "diff", "--name-only", `${commit}^`, commit], { encoding: "utf8" });
+    // No parent, or git failed: nothing is known to be edited, so every kill stays an older-test catch.
+    if (diff.status !== 0)
+        return { files: [], olderTestCatch: true };
+    const hidden = new Set(hide.map((rel) => rel.split(path.sep).join("/")));
+    const edited = diff.stdout
+        .split("\n")
+        .filter((rel) => rel.length > 0)
+        .map((rel) => ({ repoRel: rel, pkgRel: path.relative(packageDir, path.join(repo, rel)).split(path.sep).join("/") }))
+        .filter((item) => !item.pkgRel.startsWith("..") && !hidden.has(item.pkgRel));
+    const text = new Map();
+    const contents = (repoRel) => {
+        if (!text.has(repoRel)) {
+            const shown = spawnSync("git", ["-C", repo, "show", `${commit}:${repoRel}`], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+            text.set(repoRel, shown.status === 0 ? shown.stdout : "");
+        }
+        return text.get(repoRel) ?? "";
+    };
+    const fileFor = (id) => edited.find((item) => killerInFile(id, item.pkgRel, () => contents(item.repoRel)));
+    const files = new Set();
+    let olderTestCatch = false;
+    for (const kill of kills) {
+        const owners = kill.killedBy.map(fileFor);
+        for (const owner of owners)
+            if (owner)
+                files.add(owner.pkgRel);
+        if (owners.some((owner) => !owner))
+            olderTestCatch = true;
+    }
+    return { files: [...files].sort(), olderTestCatch };
+}
+/** True when a kill id names this file, its class, or a test written in it. */
+function killerInFile(id, rel, read) {
+    if (id.includes(rel) || id.startsWith(`${path.posix.basename(rel)}::`))
+        return true;
+    const stem = path.posix.basename(rel).replace(/\.[^.]+$/, "");
+    // JUnit `pkg.ClassTest.method` or `ClassTest#method`, Go and Rust paths.
+    if (stem.length > 0 && id.split(/[.#:/]+/).includes(stem))
+        return true;
+    const leaf = id.split(/::|#/).pop()?.split(/\.(?=[^.]+$)/).pop()?.replace(/\[.*\]$/, "").trim() ?? "";
+    if (leaf.length < 4)
+        return false;
+    const body = read();
+    return [`"${leaf}"`, `'${leaf}'`, `\`${leaf}\``, `${leaf}(`, `def ${leaf}`, `func ${leaf}`, `fn ${leaf}`].some((needle) => body.includes(needle));
+}