probatio 0.1.2 → 0.1.3

package/README.md

@@ -1,21 +1,38 @@
 # Probatio
 
-Probatio (Latin: a testing, a proof) is a free testing toolkit under the MIT license, built for AI agents
-(Claude, Grok, ChatGPT, others), working alone or as swarms. Every claim it makes is checkable.
-It remembers what was fixed so agents with small context do not redo or undo work, and it shows
-which tests already touch a change.
+[![npm version](https://img.shields.io/npm/v/probatio)](https://www.npmjs.com/package/probatio)
 
-Status (2026-10-06): `mutate run` discovers the project suite and scores it. Node, pytest, C (when the binary was built with LLVM coverage), Go, Maven/Java, Rust, C#, and Mocha collect a line map on the baseline. Mocha's map comes from its own root hooks. Loading the node:test collector under Mocha does not name Mocha tests. A line no test executes is `no coverage`, and the suite is not started. A plain Node script can write the lines it ran, and the parent test that reads that dump stores them under its own name. A child the parent does not read stays `no coverage`, and the suite is not started. A suite with no line map, a baseline of 5 seconds or more, and more than 30 mutants stops before the first mutant. `verify-change` names the tests the line map ran. It scores `src/`, a `lib/` file when the package tests import `lib/`, and a Go file beside `go.mod`. Tests, docs, `dist/`, and `node_modules` stay unseen. `ran` stays the direct-importer list. Covered mutants of one Node file run one after another inside the suite process that is already running. `--workers` stays 1. A Node test that sets its own `timeout` keeps that time when `--test-timeout-ms` is shorter. A mutant that crashes or leaves that process dirty ends it, and the next mutant starts clean. An uncovered line still does not start the suite. `mutate tally` does not delete a test. A kill is an assertion the suite already had. A sealed miss means the suite did not see the bug. The kill count is not a merge gate. On Commons CSV (Apache-2.0, commit `2c83a308`), two sealed runs agreed: with the new test file hidden, `CSVFormatTest.testFormatThrowsNullPointerException` failed on the reverted printer. `deletedTests` stayed 0. That older JUnit platform did not write a line map, so the first pass was the whole suite and confirm reran the older test. Auspex, markupsafe, and a hand-planted fixture are not that result. The package version in this repository is 0.1.2. npm latest is 0.1.0. The BugsInPy search row is still open, and the rows that apply only when a sealed run misses do not apply, because this catch held. The MCP server speaks one JSON object per line and returns the same JSON as the CLI.
+Probatio scores a test suite by the bugs it already catches. A kill is an assertion the suite had. The kill count is not a merge gate.
 
-Read in this order:
+Node 22.6 or newer:
 
-1. `HANDOFF.md` — why, the evidence from Auspex, the design, and the lessons that cost time.
-2. `FOR-GROK.md` — the builder brief: build order with acceptance tests, the agent contract,
-   memory for agents, anti-gaming, swarm protocol, traps.
-3. `seed/` — code copied from the Auspex experiment to start from (Auspex paths inside).
+```bash
+npm install probatio
+```
+
+```bash
+npx probatio mutate generate --package . --out .probatio/generate
+npx probatio mutate run --package . --patches .probatio/generate/mutants --out .probatio/runs
+npx probatio mutate tally --out .probatio/runs
+```
 
-Roles: Grok builds most of it; Claude refines and finishes. Grok keeps `NOTES-FOR-CLAUDE.md` here
-(decisions, guesses, shortcuts with file:line, acceptance output actually run).
+Each command prints one JSON object and exits 0 only when `ok` is true.
+
+```json
+{
+  "schemaVersion": 1,
+  "ok": true,
+  "summary": "0 no coverage, 0 survived, 1 killed, 0 flaky, 0 timed out, 0 errored, of 1 finished.",
+  "next": "No survivor in this batch.",
+  "nextCall": { "argv": ["mutate", "tally", "--out", ".probatio/runs"] }
+}
+```
+
+Agents changing this repo should read [AGENTS.md](AGENTS.md). The MCP server is `probatio mcp`. Snippets are in the MCP section below. People building Probatio should read [docs/builders.md](docs/builders.md). Small suites live in [examples/](examples/).
+
+## Status
+
+Status (2026-10-06): `mutate run` discovers the project suite and scores it. Node, pytest, C (when the binary was built with LLVM coverage), Go, Maven/Java, Rust, C#, and Mocha collect a line map on the baseline. Mocha's map comes from its own root hooks. Loading the node:test collector under Mocha does not name Mocha tests. A line no test executes is `no coverage`, and the suite is not started. A plain Node script can write the lines it ran, and the parent test that reads that dump stores them under its own name. A child the parent does not read stays `no coverage`, and the suite is not started. A suite with no line map, a baseline of 5 seconds or more, and more than 30 mutants stops before the first mutant. `verify-change` names the tests the line map ran. It scores `src/`, a `lib/` file when the package tests import `lib/`, and a Go file beside `go.mod`. Tests, docs, `dist/`, and `node_modules` stay unseen. `ran` stays the direct-importer list. Covered mutants of one Node file run one after another inside the suite process that is already running. `--workers` stays 1. A Node test that sets its own `timeout` keeps that time when `--test-timeout-ms` is shorter. A mutant that crashes or leaves that process dirty ends it, and the next mutant starts clean. An uncovered line still does not start the suite. `mutate tally` does not delete a test. A kill is an assertion the suite already had. A sealed miss means the suite did not see the bug. The kill count is not a merge gate. On Commons CSV (Apache-2.0, commit `2c83a308`), two sealed runs agreed: with the new test file hidden, `CSVFormatTest.testFormatThrowsNullPointerException` failed on the reverted printer. `deletedTests` stayed 0. That older JUnit platform did not write a line map, so the first pass was the whole suite and confirm reran the older test. Auspex, markupsafe, and a hand-planted fixture are not that result. The package version in this repository is 0.1.3. npm latest is 0.1.2 (`29301bc`). The BugsInPy search row is still open, and the rows that apply only when a sealed run misses do not apply, because this catch held. The MCP server speaks one JSON object per line and returns the same JSON as the CLI.
 
 ## mutate
 
@@ -81,4 +98,23 @@ Lists the tests that can see the diff, runs mutants on the changed lines, and re
 
 An item is `.probatio/queue/<id>.json`. `queue claim` renames it to `claimed/<agent>-<id>.json` with a lease. `queue reap` moves an expired lease back. `check-kill <id>` runs the tests that directly import the mutated file and confirms the killing test again. It is done only when that mutant dies and that suite is still green. `verify-change` is the edit-sized run: it uses the line map and does not confirm a second time.
 
-The MCP server speaks stdio JSON-RPC. Its one tool runs the CLI and returns that command's JSON.
+## MCP
+
+`probatio mcp` and the `probatio-mcp` bin speak stdio JSON-RPC, one JSON object per line. The tool name is `probatio`. `argv` is the CLI words. `ping` returns `{}`. An unknown method returns JSON-RPC `-32601` with the same id.
+
+```json
+{
+  "mcpServers": {
+    "probatio": {
+      "command": "probatio",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+That block is the Claude, Cursor, and Grok shape. The tool runs the CLI and returns that command's JSON. `nextCall.argv` keeps absolute paths so a later spawn does not have to expand `~`.
+
+`mutate generate` reads the commit (`HEAD` unless you pass `--commit`). `--working-tree` reads the checkout on disk and says so. `mutate run` scores the commit either way.
+
+`verify-change` does not score uncommitted edits when `--base` and `--commit` are the same. A clean empty diff says `No diff-scoped mutant.`

package/dist/cli.js

@@ -10,65 +10,82 @@ import { appendFinding, chooseSealed, fixGap, guardAllows, lineHash, loadState,
 import { git } from "./mutate/patch.js";
 import { generateMutants } from "./mutate/generate.js";
 import { runMutants } from "./mutate/run.js";
-import { LABEL_LEAK_SUMMARY, labelLeaked, readSealedLabel } from "./mutate/sealed.js";
+import { LABEL_LEAK_SUMMARY, labelLeaked, readSealedLabel, sealedTreeLeaked } from "./mutate/sealed.js";
 import { generateNext } from "./mutate/suite-decision.js";
 import { discoverSuite } from "./mutate/suites.js";
 import { tallyRun } from "./mutate/tally.js";
 import { checkKill } from "./swarm/check-kill.js";
 import { claimItem, reapClaims, seedQueue } from "./swarm/queue.js";
 import { verifyChange } from "./verify/change.js";
-const parsed = parseArgs(process.argv.slice(2));
-const [group, action] = parsed.command;
-try {
-    if (group === "mutate" && action === "generate")
-        finish(await generateCommand(parsed.flags), parsed.human);
-    if (group === "mutate" && action === "run")
-        finish(await runCommand(parsed.flags), parsed.human);
-    if (group === "mutate" && action === "sealed")
-        finish(await sealedCommand(parsed.flags), parsed.human);
-    if (group === "mutate" && action === "tally")
-        finish(tallyCommand(parsed.flags), parsed.human);
-    if (group === "ledger" && action === "build")
-        finish(await ledgerCommand(parsed.flags), parsed.human);
-    if (group === "matrix" && action === "report")
-        finish(matrixCommand(parsed.flags), parsed.human);
-    if (group === "golden" && action === "check")
-        finish(goldenCommand(parsed.flags), parsed.human);
-    if (group === "gap" && action === "fix")
-        finish(gapFixCommand(parsed.flags), parsed.human);
-    if (group === "gap" && action === "revert")
-        finish(gapRevertCommand(parsed.flags), parsed.human);
-    if (group === "guard" && action === "check")
-        finish(guardCommand(parsed.flags), parsed.human);
-    if (group === "findings" && action === "add")
-        finish(findingsCommand(parsed.flags), parsed.human);
-    if (group === "status")
-        finish(statusCommand(parsed.flags), parsed.human);
-    if (group === "seal")
-        finish(sealCommand(parsed.flags), parsed.human);
-    if (group === "queue" && action === "seed")
-        finish(queueSeedCommand(parsed.flags), parsed.human);
-    if (group === "queue" && action === "claim")
-        finish(queueClaimCommand(parsed.flags), parsed.human);
-    if (group === "queue" && action === "reap")
-        finish(queueReapCommand(parsed.flags), parsed.human);
-    if (group === "check-kill")
-        finish(await checkKillCommand(parsed.flags, action), parsed.human);
-    if (group === "verify-change")
-        finish(await verifyCommand(parsed.flags), parsed.human);
-    finish(usage(false, "Use mutate, ledger, matrix, golden, gap, guard, findings, status, queue, check-kill, or verify-change."), parsed.human);
-}
-catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    finish({
+import { nodeTooOld } from "./node-version.js";
+const tooOld = nodeTooOld(process.versions.node);
+if (tooOld) {
+    process.stdout.write(`${JSON.stringify({
         schemaVersion: SCHEMA_VERSION,
         ok: false,
-        command: `${group ?? "mutate"}.${action ?? "help"}`,
-        summary: message,
-        next: "Fix the command and run it again.",
+        command: "mutate.help",
+        summary: tooOld,
+        next: "Install Node 22.6 or newer and run the command again.",
         nextCall: null,
-    }, parsed.human);
+    })}\n`);
+    process.exit(1);
 }
+const parsed = parseArgs(process.argv.slice(2));
+const [group, action] = parsed.command;
+if (group === "mcp" && !action) {
+    await import("./mcp.js");
+}
+else
+    try {
+        if (group === "mutate" && action === "generate")
+            finish(await generateCommand(parsed.flags), parsed.human);
+        if (group === "mutate" && action === "run")
+            finish(await runCommand(parsed.flags), parsed.human);
+        if (group === "mutate" && action === "sealed")
+            finish(await sealedCommand(parsed.flags), parsed.human);
+        if (group === "mutate" && action === "tally")
+            finish(tallyCommand(parsed.flags), parsed.human);
+        if (group === "ledger" && action === "build")
+            finish(await ledgerCommand(parsed.flags), parsed.human);
+        if (group === "matrix" && action === "report")
+            finish(matrixCommand(parsed.flags), parsed.human);
+        if (group === "golden" && action === "check")
+            finish(goldenCommand(parsed.flags), parsed.human);
+        if (group === "gap" && action === "fix")
+            finish(gapFixCommand(parsed.flags), parsed.human);
+        if (group === "gap" && action === "revert")
+            finish(gapRevertCommand(parsed.flags), parsed.human);
+        if (group === "guard" && action === "check")
+            finish(guardCommand(parsed.flags), parsed.human);
+        if (group === "findings" && action === "add")
+            finish(findingsCommand(parsed.flags), parsed.human);
+        if (group === "status")
+            finish(statusCommand(parsed.flags), parsed.human);
+        if (group === "seal")
+            finish(sealCommand(parsed.flags), parsed.human);
+        if (group === "queue" && action === "seed")
+            finish(queueSeedCommand(parsed.flags), parsed.human);
+        if (group === "queue" && action === "claim")
+            finish(queueClaimCommand(parsed.flags), parsed.human);
+        if (group === "queue" && action === "reap")
+            finish(queueReapCommand(parsed.flags), parsed.human);
+        if (group === "check-kill")
+            finish(await checkKillCommand(parsed.flags, action), parsed.human);
+        if (group === "verify-change")
+            finish(await verifyCommand(parsed.flags), parsed.human);
+        finish(usage(false, "Use mutate, ledger, matrix, golden, gap, guard, findings, status, queue, check-kill, or verify-change."), parsed.human);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        finish({
+            schemaVersion: SCHEMA_VERSION,
+            ok: false,
+            command: `${group ?? "mutate"}.${action ?? "help"}`,
+            summary: message,
+            next: "Fix the command and run it again.",
+            nextCall: null,
+        }, parsed.human);
+    }
 function usage(ok, summary) {
     return {
         schemaVersion: SCHEMA_VERSION,
@@ -93,7 +110,19 @@ async function generateCommand(flags) {
         maxMutants: int(flags, "max-mutants") ?? null,
         maxMinutes: int(flags, "max-minutes") ?? null,
         skipFiles: texts(flags, "skip-file"),
+        commit: text(flags, "commit") ?? "HEAD",
+        workingTree: bool(flags, "working-tree", false),
     });
+    if (result.error) {
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            ok: false,
+            command: "mutate.generate",
+            summary: result.error,
+            next: "Commit the file, or pass --working-tree to mutate the checkout on disk. mutate run scores the commit.",
+            nextCall: null,
+        };
+    }
     if (result.violations.length > 0) {
         const first = result.violations[0];
         return {
@@ -117,9 +146,14 @@ async function generateCommand(flags) {
         summary: stopped
             ? `Stopped by the time budget after ${result.filesVisited} files. ${result.mutants.length} mutants written.`
             : `${result.mutants.length} mutants in ${result.filesVisited} files. No string-literal mutant.`,
-        next: stopped
-            ? "Narrow --src or raise --max-minutes, then run the same command."
-            : generateNext(result.mutants.length, suite ? { kind: suite.kind, command: suite.command } : null),
+        next: [
+            stopped
+                ? "Narrow --src or raise --max-minutes, then run the same command."
+                : generateNext(result.mutants.length, suite ? { kind: suite.kind, command: suite.command } : null),
+            result.source === "working-tree"
+                ? "These patches match the working tree. mutate run scores the commit, so commit the files before mutate run."
+                : "",
+        ].filter((line) => line.length > 0).join(" "),
         nextCall: result.mutants.length === 0
             ? null
             : { argv: ["mutate", "run", "--package", packageDir, "--patches", patches, "--out", path.join(outDir, "runs")] },
@@ -133,6 +167,19 @@ async function generateCommand(flags) {
     };
 }
 async function runCommand(flags, hide = null) {
+    const hidden = hide ?? texts(flags, "hide");
+    const escaped = hidden.find((rel) => rel.split(/[\\/]/).includes(".."));
+    if (escaped) {
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            ok: false,
+            command: "mutate.run",
+            summary: `--hide stays inside the package. Refused ${escaped}.`,
+            next: "Pass a relative path with no .. segment.",
+            nextCall: null,
+            killed: 0,
+        };
+    }
     const onlyNames = texts(flags, "only-test");
     if (onlyNames.some((id) => id === "::command" || id.endsWith("::command"))) {
         return {
@@ -234,9 +281,10 @@ function tallyCommand(flags) {
 async function sealedCommand(flags) {
     const label = readSealedLabel(path.resolve(requireText(flags, "label")));
     const hide = texts(flags, "hide");
+    const outDir = path.resolve(requireText(flags, "out"));
     const report = await runCommand(flags, hide);
     const body = JSON.stringify(report);
-    if (!labelLeaked(body, label))
+    if (!labelLeaked(body, label) && !sealedTreeLeaked(outDir, label))
         return report;
     return {
         schemaVersion: SCHEMA_VERSION,

package/dist/contract.js

@@ -1,18 +1,20 @@
 import { homedir } from "node:os";
 export const SCHEMA_VERSION = 1;
 /** Replace the home directory so a result never carries a user's name or home path. */
-export function scrub(value, home = homedir()) {
+export function scrub(value, home = homedir(), keepPaths = false) {
     if (typeof value === "string") {
-        if (!home || !value.includes(home))
+        if (keepPaths || !home || !value.includes(home))
             return value;
         return value.split(home).join("~");
     }
     if (Array.isArray(value))
-        return value.map((item) => scrub(item, home));
+        return value.map((item) => scrub(item, home, keepPaths));
     if (value && typeof value === "object") {
         const out = {};
-        for (const [key, item] of Object.entries(value))
-            out[key] = scrub(item, home);
+        for (const [key, item] of Object.entries(value)) {
+            // nextCall.argv is executed. A tilde is not expanded by spawn or by MCP.
+            out[key] = scrub(item, home, keepPaths || key === "nextCall");
+        }
         return out;
     }
     return value;

package/dist/mcp.js

@@ -3,6 +3,19 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { nodeTooOld } from "./node-version.js";
+const tooOld = nodeTooOld(process.versions.node);
+if (tooOld) {
+    process.stdout.write(`${JSON.stringify({
+        schemaVersion: 1,
+        ok: false,
+        command: "mcp",
+        summary: tooOld,
+        next: "Install Node 22.6 or newer and run the command again.",
+        nextCall: null,
+    })}\n`);
+    process.exit(1);
+}
 const here = path.dirname(fileURLToPath(import.meta.url));
 const version = readVersion();
 const tool = {
@@ -63,6 +76,10 @@ function handle(message) {
         send({ jsonrpc: "2.0", id: message.id, result: { tools: [tool] } });
         return;
     }
+    if (message.method === "ping") {
+        send({ jsonrpc: "2.0", id: message.id, result: {} });
+        return;
+    }
     if (message.method === "tools/call") {
         const argv = message.params?.arguments?.argv;
         if (!Array.isArray(argv) || argv.some((item) => typeof item !== "string")) {
@@ -92,7 +109,13 @@ function handle(message) {
                 isError: envelope.ok !== true,
             },
         });
+        return;
     }
+    send({
+        jsonrpc: "2.0",
+        id: message.id,
+        error: { code: -32601, message: `method not found: ${message.method}` },
+    });
 }
 function cliCommand() {
     const compiled = path.join(here, "cli.js");

package/dist/mutate/coverage-map.js

@@ -104,17 +104,10 @@ export function writeLlvmCoverage(pkg, profileDir, binary, dest) {
         return { ok: false, detail: "no profraw" };
     if (!binary)
         return { ok: false, detail: "no instrumented binary" };
-    const llvmCov = findTool("llvm-cov");
-    const llvmProf = findTool("llvm-profdata");
-    if (!llvmCov || !llvmProf)
-        return { ok: false, detail: `llvm tool missing (${llvmCov ? "llvm-profdata" : "llvm-cov"})` };
     const merged = path.join(profileDir, "baseline.profdata");
-    const merge = spawnSync(llvmProf, ["merge", "-sparse", "-o", merged, ...raws], { encoding: "utf8" });
-    if (merge.status !== 0)
-        return { ok: false, detail: (merge.stderr || merge.stdout || "llvm-profdata failed").trim() };
-    const exported = spawnSync(llvmCov, ["export", binary, `-instr-profile=${merged}`], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
-    if (exported.status !== 0)
-        return { ok: false, detail: (exported.stderr || exported.stdout || "llvm-cov failed").trim() };
+    const exported = exportLlvmProfile(binary, raws, merged);
+    if (!exported.ok)
+        return exported;
     const map = llvmExportToMap(exported.stdout, pkg);
     if (!map)
         return { ok: false, detail: "llvm-cov export was not a coverage map" };
@@ -159,14 +152,78 @@ function llvmExportToMap(stdout, pkg) {
         return null;
     return { files };
 }
-function findTool(name) {
+/**
+ * clang and rustc write different profraw versions. Each pair is one LLVM install.
+ * The first pair that can merge the profile wins.
+ */
+export function llvmToolsPresent() {
+    return llvmToolPairs().length > 0;
+}
+export function exportLlvmProfile(binary, raws, merged) {
+    const pairs = llvmToolPairs();
+    if (pairs.length === 0)
+        return { ok: false, detail: "llvm tool missing (llvm-cov)" };
+    let detail = "llvm-profdata failed";
+    for (const { cov, prof } of pairs) {
+        const merge = spawnSync(prof, ["merge", "-sparse", "-o", merged, ...raws], { encoding: "utf8" });
+        if (merge.status !== 0) {
+            detail = (merge.stderr || merge.stdout || "llvm-profdata failed").trim();
+            continue;
+        }
+        const exported = spawnSync(cov, ["export", binary, `-instr-profile=${merged}`], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+        if (exported.status !== 0) {
+            detail = (exported.stderr || exported.stdout || "llvm-cov failed").trim();
+            continue;
+        }
+        return { ok: true, stdout: exported.stdout };
+    }
+    return { ok: false, detail };
+}
+function llvmToolPairs() {
+    const covs = toolCandidates("llvm-cov");
+    const profs = toolCandidates("llvm-profdata");
+    const pairs = [];
+    const seen = new Set();
+    for (const cov of covs) {
+        const prof = profs.find((item) => path.dirname(item) === path.dirname(cov));
+        if (!prof)
+            continue;
+        const key = `${cov}\0${prof}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        pairs.push({ cov, prof });
+    }
+    return pairs;
+}
+function toolCandidates(name) {
+    const out = [];
+    const add = (file) => {
+        if (!file || out.includes(file) || !existsSync(file))
+            return;
+        out.push(file);
+    };
     const fromXcrun = spawnSync("xcrun", ["--find", name], { encoding: "utf8" });
-    const xcrunPath = fromXcrun.stdout?.trim() ?? "";
-    if (fromXcrun.status === 0 && xcrunPath && existsSync(xcrunPath))
-        return xcrunPath;
+    if (fromXcrun.status === 0)
+        add((fromXcrun.stdout ?? "").trim());
     const which = spawnSync("sh", ["-c", `command -v ${name}`], { encoding: "utf8" });
-    const found = which.stdout?.trim() ?? "";
-    if (which.status === 0 && found)
-        return found;
-    return null;
+    if (which.status === 0)
+        add((which.stdout ?? "").trim());
+    const rustc = spawnSync("rustc", ["--print", "sysroot"], { encoding: "utf8" });
+    if (rustc.status === 0) {
+        const root = path.join(rustc.stdout.trim(), "lib", "rustlib");
+        if (existsSync(root)) {
+            for (const host of readdirSync(root))
+                add(path.join(root, host, "bin", name));
+        }
+    }
+    const usr = "/usr/lib";
+    if (existsSync(usr)) {
+        for (const dir of readdirSync(usr)) {
+            if (dir.startsWith("llvm-"))
+                add(path.join(usr, dir, "bin", name));
+        }
+    }
+    add(path.join("/usr/bin", name));
+    return out;
 }

package/dist/mutate/generate.js

@@ -8,8 +8,9 @@ export function generateMutants(options) {
     const started = Date.now();
     const limit = options.maxMinutes;
     const over = () => limit != null && Date.now() - started >= limit * 60_000;
+    const sourceDefault = options.workingTree ? "working-tree" : "commit";
     if (over())
-        return { mutants: [], violations: [], filesVisited: 0, budgetHit: true };
+        return { mutants: [], violations: [], filesVisited: 0, budgetHit: true, source: sourceDefault };
     const srcRoot = path.resolve(options.packageDir, options.srcDir);
     const walked = walkSources(srcRoot, over);
     const files = walked.files.filter((file) => !options.skipFiles.includes(path.basename(file)));
@@ -18,13 +19,18 @@ export function generateMutants(options) {
     const chosen = [];
     let filesVisited = 0;
     let budgetHit = walked.stopped;
+    let source = sourceDefault;
     for (const file of files) {
         if (over()) {
             budgetHit = true;
             break;
         }
         filesVisited += 1;
-        const text = readFileSync(file, "utf8");
+        const loaded = fileText(options.packageDir, file, options);
+        if ("error" in loaded)
+            return { mutants: [], violations: [], filesVisited, budgetHit, source: "commit", error: loaded.error };
+        source = loaded.source;
+        const text = loaded.text;
         const rel = posix(path.relative(options.packageDir, file));
         const found = findInSource(rel, text);
         violations.push(...found.violations);
@@ -34,7 +40,7 @@ export function generateMutants(options) {
             chosen.push({ rel, text, point });
     }
     if (violations.length > 0)
-        return { mutants: [], violations, filesVisited, budgetHit };
+        return { mutants: [], violations, filesVisited, budgetHit, source };
     const capped = options.maxMutants === null ? chosen : chosen.slice(0, options.maxMutants);
     const packageReal = real(options.packageDir);
     const patchRoot = gitRoot(packageReal);
@@ -55,7 +61,22 @@ export function generateMutants(options) {
         mutants.push({ id, file: item.rel, line: item.point.line, op: item.point.op, patch });
     }
     writeFileSync(path.join(mutantsDir, "mutants.json"), `${JSON.stringify({ schemaVersion: 1, seed: options.seed, mutants }, null, 2)}\n`);
-    return { mutants, violations, filesVisited, budgetHit };
+    return { mutants, violations, filesVisited, budgetHit, source };
+}
+function fileText(packageDir, absFile, options) {
+    if (options.workingTree)
+        return { text: readFileSync(absFile, "utf8"), source: "working-tree" };
+    const root = gitRoot(packageDir);
+    if (!root)
+        return { text: readFileSync(absFile, "utf8"), source: "working-tree" };
+    const rel = posix(path.relative(root, real(absFile)));
+    const commit = options.commit && options.commit.length > 0 ? options.commit : "HEAD";
+    const shown = spawnSync("git", ["-C", root, "show", `${commit}:${rel}`], { encoding: "utf8" });
+    if (shown.status !== 0) {
+        const shownRel = posix(path.relative(packageDir, absFile));
+        return { error: `${shownRel} is not in ${commit}. Pass --working-tree to read the checkout.` };
+    }
+    return { text: shown.stdout, source: "commit" };
 }
 function walkSources(dir, over) {
     if (!statExists(dir))

package/dist/mutate/run.js

@@ -41,7 +41,7 @@ export async function runMutants(options) {
         return failReport(options.outDir, "", options.commit, "that commit does not resolve");
     const commit = sha.stdout.trim();
     mkdirSync(options.outDir, { recursive: true });
-    const run = loadRun(options.outDir, commit, options.agent);
+    const run = loadRun(options, commit);
     if ("error" in run)
         return failReport(options.outDir, run.id, commit, run.error);
     const listed = listPatches(options.patchDirs);
@@ -211,7 +211,7 @@ async function prepare(pkg, options, progress) {
         if (baseline.compileToken)
             return { ok: false, error: `baseline build failed (${baseline.compileToken})` };
         if (!baseline.report)
-            return { ok: false, error: baselineReportError(baseline.detail) };
+            return { ok: false, error: baselineReportError(baseline.detail, baseline.command || spec.command) };
         baselineFailed = baseline.report.failed.map((item) => item.name);
         if (collect && !existsSync(mapPath)) {
             const binary = binaryFromCommand(baseline.command || spec.command, pkg);
@@ -224,6 +224,10 @@ async function prepare(pkg, options, progress) {
         progress(`suite report tests=${baseline.report.tests}`);
         progress(baselineFailed.length > 0 ? `baseline failing ${baselineFailed.length}` : "baseline pass");
         if (baselineFailed.length > 0) {
+            const tool = missingToolFrom(baseline.detail, baseline.command || spec.command);
+            const unnamed = baselineFailed.every((name) => name === "command" || name === "::command");
+            if (tool && unnamed)
+                return { ok: false, error: `missing tool: ${tool}. baseline suite did not return a test report` };
             return { ok: false, error: "baseline already failing", baselineFailed, suiteCommand: spec.command };
         }
         if (collect && !existsSync(mapPath) && languageMapKind(spec.kind)) {
@@ -250,12 +254,13 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep, la
     const raw = readFileSync(patchPath, "utf8");
     const files = filesInDiff(raw);
     const edited = changedLines(raw);
+    const located = edited.length > 0 ? edited : files;
     const mutantHash = sha256(raw);
     const base = () => ({
         id,
         outcome: "error",
         direction: null,
-        files,
+        files: located,
         killedBy: [],
         cause: null,
         next: "",
@@ -319,8 +324,16 @@ 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, []);
-        if (!main.report)
-            return { ...base(), direction, error: "test reporter returned nothing", command: commands.join(" | ") };
+        if (!main.report) {
+            const detail = main.detail ? clip(main.detail) : "";
+            const tool = missingToolFrom(detail, main.command);
+            const error = tool
+                ? `missing tool: ${tool}`
+                : detail
+                    ? `test reporter returned nothing (${detail})`
+                    : "test reporter returned nothing";
+            return { ...base(), direction, error, command: commands.join(" | ") };
+        }
         const whole = main.wholeSuite || forceWhole;
         const chosen = main.selectedTests;
         if (main.report.failed.length === 0)
@@ -397,19 +410,22 @@ async function rerunGroup(pkg, options, file, failures, counts, pattern, prep, t
         if (rerun.command)
             commands.push(rerun.command);
         if (pattern === null && rerun.timedOut) {
-            for (const failure of failures)
-                bump(counts, failureId(pkg, failure));
+            for (const id of new Set(failures.map((item) => failureId(pkg, item))))
+                bump(counts, id);
             continue;
         }
         if (!rerun.report)
             continue;
+        const seen = new Set();
         for (const hit of rerun.report.failed) {
             if (pattern === null && !hit.fileTimeout)
                 continue;
             const id = failureId(pkg, hit);
             if (failures.some((item) => failureId(pkg, item) === id))
-                bump(counts, id);
+                seen.add(id);
         }
+        for (const id of seen)
+            bump(counts, id);
     }
     return wholeSuite;
 }
@@ -708,8 +724,8 @@ function loadMeta(dirs) {
     }
     return meta;
 }
-function loadRun(outDir, commit, agent) {
-    const file = path.join(outDir, "run.json");
+function loadRun(options, commit) {
+    const file = path.join(options.outDir, "run.json");
     if (existsSync(file)) {
         const stored = JSON.parse(readFileSync(file, "utf8"));
         if (stored.commit !== commit)
@@ -717,7 +733,24 @@ function loadRun(outDir, commit, agent) {
         return { id: stored.id };
     }
     const id = randomBytes(4).toString("hex");
-    writeFileSync(file, `${JSON.stringify({ id, commit, agent, started: new Date().toISOString() }, null, 2)}\n`);
+    const record = {
+        id,
+        commit,
+        agent: options.agent,
+        started: new Date().toISOString(),
+        package: options.packageDir,
+        patches: options.patchDirs,
+        out: options.outDir,
+        repo: options.repoDir,
+        workers: options.workers,
+        confirm: options.confirm,
+        testsDir: options.testsDir,
+        suiteTimeoutMs: options.suiteTimeoutMs,
+        testTimeoutMs: options.testTimeoutMs,
+        direction: options.direction,
+        suiteCommand: options.suiteCommand ?? null,
+    };
+    writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`);
     return { id };
 }
 async function createWorktrees(repo, packageDir, runId, commit, workers, outDir) {
@@ -725,6 +758,10 @@ async function createWorktrees(repo, packageDir, runId, commit, workers, outDir)
     const dirs = [];
     for (let index = 0; index < workers; index++) {
         const dir = path.join(tmpdir(), `probatio-${runId}-${index}`);
+        if (!probatioWorktreeDir(dir)) {
+            removeWorktrees(repo, dirs, outDir);
+            return { error: "worktree path is outside the probatio temp prefix" };
+        }
         rmSync(dir, { recursive: true, force: true });
         const added = git(repo, ["worktree", "add", "--detach", dir, commit]);
         if (added.status !== 0) {
@@ -750,15 +787,42 @@ async function createWorktrees(repo, packageDir, runId, commit, workers, outDir)
 function hidePaths(dirs, repo, packageDir, hide) {
     for (const dir of dirs) {
         const pkg = packageIn(dir, repo, packageDir);
+        const root = path.resolve(pkg);
         for (const rel of hide) {
-            if (!rel || path.isAbsolute(rel))
+            if (!rel || path.isAbsolute(rel) || rel.split(/[\\/]/).includes(".."))
+                continue;
+            const target = path.resolve(root, rel);
+            if (target !== root && !target.startsWith(root + path.sep))
                 continue;
-            rmSync(path.join(pkg, rel), { force: true });
+            rmSync(target, { force: true });
         }
     }
 }
+/** A worktree Probatio created: one directory under the OS temp dir, named probatio- plus hex and an index. */
+export function probatioWorktreeDir(dir) {
+    let resolved = path.resolve(dir);
+    try {
+        resolved = realpathSync(dir);
+    }
+    catch {
+        // The directory is created on the next line. The unresolved path is still checked.
+    }
+    const roots = new Set([path.resolve(tmpdir())]);
+    try {
+        roots.add(realpathSync(tmpdir()));
+    }
+    catch {
+        // tmpdir() itself is enough when realpath is unavailable.
+    }
+    const inside = [...roots].some((root) => resolved === root || resolved.startsWith(root + path.sep));
+    if (!inside)
+        return false;
+    return /^probatio-[0-9a-f]+-\d+$/.test(path.basename(resolved));
+}
 function removeWorktrees(repo, dirs, outDir) {
     for (const dir of dirs) {
+        if (!probatioWorktreeDir(dir))
+            continue;
         git(repo, ["worktree", "remove", "--force", dir]);
         rmSync(dir, { recursive: true, force: true });
     }
@@ -899,6 +963,9 @@ function reportOf(results, context) {
         notes.push(resumeNext(context.notStarted));
     if (results.some((result) => result.wholeSuite))
         notes.push(WHOLE_SUITE_NEXT);
+    const broken = results.find((result) => (result.outcome === "error" || result.outcome === "build-failed") && result.error);
+    if (broken?.error)
+        notes.push(`${broken.id}: ${broken.error}`);
     if (notes.length === 0)
         notes.push("No survivor in this batch.");
     return {
@@ -1156,13 +1223,27 @@ function testArg(pkg, file, testsDir) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function baselineReportError(detail) {
+function missingToolFrom(detail, command) {
+    const spawnMiss = /spawn ([^\s]+) ENOENT/.exec(detail);
+    if (spawnMiss)
+        return path.basename(spawnMiss[1]);
+    const shellMiss = /(?:^|\s)([A-Za-z0-9_./+-]+): (?:command not found|not found)\b/.exec(detail);
+    if (shellMiss)
+        return path.basename(shellMiss[1]);
+    if (/No such file or directory|ENOENT/.test(detail)) {
+        const bin = command.trim().split(/\s+/)[0];
+        if (bin)
+            return path.basename(bin);
+    }
+    return null;
+}
+function baselineReportError(detail, command = "") {
+    const tool = missingToolFrom(detail, command);
     const line = detail.trim();
     // The first line of a Python or Node crash is a stack fragment. The summary
     // states the limit and does not carry that fragment.
-    if (!line || isStackFragment(line))
-        return "baseline suite did not return a test report";
-    return `baseline suite did not return a test report (${line})`;
+    const base = !line || isStackFragment(line) ? "baseline suite did not return a test report" : `baseline suite did not return a test report (${line})`;
+    return tool ? `missing tool: ${tool}. ${base}` : base;
 }
 function isStackFragment(line) {
     return line.startsWith("Traceback") || /^\s+at \S/.test(line) || /File ".+", line \d+/.test(line);

package/dist/mutate/rust-coverage.js

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, realpathSync, writeFileSync } from "node:fs";
 import path from "node:path";
+import { exportLlvmProfile, llvmToolsPresent } from "./coverage-map.js";
 /**
  * One instrumented test binary, then one profile per test name.
  * A single cargo test profile does not say which test hit the line.
@@ -9,9 +10,7 @@ export function writeRustCoverage(pkg, testNames, dest) {
     const names = [...new Set(testNames.map((name) => name.trim()).filter((name) => name.length > 0 && !/\s/.test(name)))];
     if (names.length === 0)
         return { ok: false, detail: "rust coverage: no test names" };
-    const llvmCov = findTool("llvm-cov");
-    const llvmProf = findTool("llvm-profdata");
-    if (!llvmCov || !llvmProf)
+    if (!llvmToolsPresent())
         return { ok: false, detail: "rust coverage: llvm tool missing" };
     const env = { ...process.env, RUSTFLAGS: "-C instrument-coverage", CARGO_INCREMENTAL: "0" };
     const built = spawnSync("cargo", ["test", "--no-run", "--message-format=json"], {
@@ -43,11 +42,8 @@ export function writeRustCoverage(pkg, testNames, dest) {
             if (!new RegExp(`^test ${escapeRegExp(name)} \\.\\.\\. ok`, "m").test(`${ran.stdout}\n${ran.stderr}`))
                 continue;
             const merged = path.join(work, `${safe(name)}-${safe(path.basename(exe))}.profdata`);
-            const merge = spawnSync(llvmProf, ["merge", "-sparse", "-o", merged, raw], { encoding: "utf8" });
-            if (merge.status !== 0)
-                continue;
-            const exported = spawnSync(llvmCov, ["export", exe, `-instr-profile=${merged}`], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
-            if (exported.status !== 0)
+            const exported = exportLlvmProfile(exe, [raw], merged);
+            if (!exported.ok)
                 continue;
             for (const hit of llvmHits(exported.stdout, pkg))
                 addHit(files, hit.file, hit.line, name);
@@ -136,17 +132,6 @@ function addHit(files, file, line, test) {
     lines[key] = names;
     files[file] = lines;
 }
-function findTool(name) {
-    const fromXcrun = spawnSync("xcrun", ["--find", name], { encoding: "utf8" });
-    const xcrunPath = fromXcrun.stdout?.trim() ?? "";
-    if (fromXcrun.status === 0 && xcrunPath && existsSync(xcrunPath))
-        return xcrunPath;
-    const which = spawnSync("sh", ["-c", `command -v ${name}`], { encoding: "utf8" });
-    const found = which.stdout?.trim() ?? "";
-    if (which.status === 0 && found)
-        return found;
-    return null;
-}
 function safe(value) {
     return value.replace(/[^A-Za-z0-9._-]+/g, "_");
 }

package/dist/mutate/sealed.js

@@ -1,4 +1,5 @@
-import { readFileSync } from "node:fs";
+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. */
 export function readSealedLabel(file) {
     let text = "";
@@ -18,6 +19,44 @@ export function readSealedLabel(file) {
 export function labelLeaked(body, label) {
     return body.includes(label.bugId) || body.includes(label.issueId) || body.includes(label.expectedFail);
 }
+/** The envelope can be clean while a result file on disk still repeats the label. */
+export function sealedTreeLeaked(dir, label) {
+    const visit = (current) => {
+        let names;
+        try {
+            names = readdirSync(current);
+        }
+        catch {
+            return false;
+        }
+        for (const name of names) {
+            const full = path.join(current, name);
+            let info;
+            try {
+                info = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (info.isDirectory()) {
+                if (visit(full))
+                    return true;
+                continue;
+            }
+            if (!info.isFile() || info.size > 2_000_000)
+                continue;
+            try {
+                if (labelLeaked(readFileSync(full, "utf8"), label))
+                    return true;
+            }
+            catch {
+                // A binary artifact is not a report.
+            }
+        }
+        return false;
+    };
+    return visit(dir);
+}
 export const LABEL_LEAK_SUMMARY = "The label was copied into the report.";
 function field(text, key) {
     const match = text.match(new RegExp(`^${key}=(.*)$`, "m"));

package/dist/mutate/suites.js

@@ -386,8 +386,8 @@ async function launch(pkg, spec, files, pattern, names, timeoutMs, env, hooks) {
     if (spec.kind === "swift")
         return tag(runSwift(pkg, timeoutMs, env), spec.command, wantsNames, selection);
     if (spec.kind === "maven") {
-        const tests = selection.map(surefireTest).filter((name) => name.length > 0);
-        const args = ["-B", "test", ...(tests.length > 0 ? [`-Dtest=${tests.join(",")}`] : [])];
+        const tests = surefireArg(uniqueSurefire(selection));
+        const args = ["-B", "test", ...(tests.length > 0 ? [`-Dtest=${tests}`] : [])];
         const whole = wantsNames && tests.length === 0;
         // Surefire leaves the previous run's XML in place. A confirm that did not
         // re-execute a class would otherwise read that class as failed again.
@@ -468,12 +468,47 @@ function goRunFilter(names, pattern) {
         return null;
     return `^(${names.map(escapeRegExp).join("|")})$`;
 }
+function uniqueSurefire(names) {
+    const out = [];
+    const seen = new Set();
+    for (const name of names) {
+        const selector = surefireTest(name);
+        if (!selector || seen.has(selector))
+            continue;
+        seen.add(selector);
+        out.push(selector);
+    }
+    return out;
+}
+/** Surefire 2.12 splits `-Dtest` on commas and then reads `#method+method`. `Class#a,Class#b` runs only `a`. */
+export function surefireArg(tests) {
+    const groups = new Map();
+    for (const test of tests) {
+        const hash = test.indexOf("#");
+        const klass = hash === -1 ? test : test.slice(0, hash);
+        const method = hash === -1 ? "" : test.slice(hash + 1);
+        const methods = groups.get(klass);
+        if (methods) {
+            if (method)
+                methods.push(method);
+        }
+        else {
+            groups.set(klass, method ? [method] : []);
+        }
+    }
+    return [...groups.entries()]
+        .map(([klass, methods]) => (methods.length > 0 ? `${klass}#${methods.join("+")}` : klass))
+        .join(",");
+}
 function surefireTest(name) {
     const leaf = name.split("::").pop() ?? name;
     const dot = leaf.lastIndexOf(".");
     const body = dot <= 0 ? leaf : `${leaf.slice(0, dot)}#${leaf.slice(dot + 1)}`;
-    // testShut[0] collects nothing. method(Parser)[1] keeps the parameter types.
-    return body.replace(/\[[^\]]*\]$/, "");
+    // testShut[0] matches nothing. A bare testShut matches on Surefire 3.6 and runs
+    // zero tests on 3.5. testShut* matches every invocation on both. method(Parser)[1] keeps the types.
+    const invocation = /\[[^\]]*\]$/.test(body);
+    const method = body.replace(/\[[^\]]*\]$/, "");
+    return invocation ? `${method}*` : method;
 }
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -764,7 +799,8 @@ function scriptInvocation(pkg) {
     if (!suiteNeedsTty(pkg))
         return { bin: "bash", args: ["run_tests.sh"], command: "bash run_tests.sh" };
     if (gnuScript()) {
-        const args = ["-q", "-c", "bash run_tests.sh", "/dev/null"];
+        // -e returns the child status. Without it, util-linux script exits 0 and a failing suite looks green.
+        const args = ["-q", "-e", "-c", "bash run_tests.sh", "/dev/null"];
         return { bin: "script", args, command: shown("script", args) };
     }
     const args = ["-q", "/dev/null", "bash", "run_tests.sh"];
@@ -1403,6 +1439,11 @@ function mavenReport(pkg, text, code) {
     }
     return parseSurefire(pkg) ?? parseMavenText(text);
 }
+/** An attribute on the opening tag. `classname` must not be read as `name`. */
+export function surefireAttr(fragment, key) {
+    const open = fragment.slice(0, fragment.indexOf(">") === -1 ? fragment.length : fragment.indexOf(">"));
+    return new RegExp(`(?:^|\\s)${key}="([^"]*)"`).exec(open)?.[1] ?? "";
+}
 function parseSurefire(pkg) {
     const dir = path.join(pkg, "target", "surefire-reports");
     if (!existsSync(dir))
@@ -1414,11 +1455,11 @@ function parseSurefire(pkg) {
             continue;
         const xml = readFileSync(path.join(dir, name), "utf8");
         for (const part of xml.split("<testcase ").slice(1)) {
-            const test = /name="([^"]+)"/.exec(part)?.[1];
-            const klass = /classname="([^"]+)"/.exec(part)?.[1] ?? "";
+            const test = surefireAttr(part, "name");
+            const klass = surefireAttr(part, "classname");
             if (!test)
                 continue;
-            const id = `${klass}.${test}`;
+            const id = klass ? `${klass}.${test}` : test;
             names.push(id);
             if (part.includes("<failure") || part.includes("<error"))
                 failed.push({ name: id, file: klass, line: 0 });

package/dist/mutate/tally.js

@@ -105,7 +105,7 @@ export function tallyRun(outDir) {
         command: "mutate.tally",
         summary,
         next,
-        nextCall: keep.length > 0 ? { argv: ["mutate", "run", ...keep.flatMap((id) => ["--only-test", id])] } : null,
+        nextCall: resumeArgv(outDir, keep),
         keep,
         drop,
         gaps,
@@ -117,6 +117,43 @@ export function tallyRun(outDir) {
     writeFileSync(fullPath, `${JSON.stringify(complete, null, 2)}\n`);
     return { ...complete, gaps: shown, rest: gaps.length - shown.length };
 }
+function resumeArgv(outDir, keep) {
+    if (keep.length === 0)
+        return null;
+    let stored = {};
+    try {
+        stored = JSON.parse(readFileSync(path.join(outDir, "run.json"), "utf8"));
+    }
+    catch {
+        stored = {};
+    }
+    const argv = ["mutate", "run"];
+    if (stored.package)
+        argv.push("--package", stored.package);
+    for (const dir of stored.patches ?? [])
+        argv.push("--patches", dir);
+    argv.push("--out", stored.out || outDir);
+    if (stored.repo)
+        argv.push("--repo", stored.repo);
+    if (stored.commit)
+        argv.push("--commit", stored.commit);
+    if (typeof stored.workers === "number")
+        argv.push("--workers", String(stored.workers));
+    if (stored.confirm === false)
+        argv.push("--no-confirm");
+    if (stored.testsDir && stored.testsDir !== "tests")
+        argv.push("--tests-dir", stored.testsDir);
+    if (typeof stored.suiteTimeoutMs === "number")
+        argv.push("--suite-timeout-ms", String(stored.suiteTimeoutMs));
+    if (typeof stored.testTimeoutMs === "number")
+        argv.push("--test-timeout-ms", String(stored.testTimeoutMs));
+    if (stored.direction && stored.direction !== "auto")
+        argv.push("--direction", stored.direction);
+    if (stored.suiteCommand)
+        argv.push("--suite-command", stored.suiteCommand);
+    argv.push(...keep.flatMap((id) => ["--only-test", id]));
+    return { argv };
+}
 function readResults(dir) {
     const out = [];
     for (const name of readdirSync(dir)) {

package/dist/node-version.js

@@ -0,0 +1,13 @@
+/** `--experimental-strip-types` needs this. Older Node is refused before a command runs. */
+export const MIN_NODE = "22.6";
+export function nodeTooOld(version) {
+    const match = /^(\d+)\.(\d+)/.exec(version);
+    const required = `Node ${version} is too old. Probatio needs Node ${MIN_NODE} or newer.`;
+    if (!match)
+        return required;
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    if (major > 22 || (major === 22 && minor >= 6))
+        return null;
+    return required;
+}

package/dist/swarm/queue.js

@@ -1,13 +1,19 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { loadSealed } from "../memory/state.js";
+/** One path segment. Rejects slashes and `..` so a claim cannot leave the queue directory. */
+export function safeFilePart(value) {
+    if (!/^[A-Za-z0-9._-]+$/.test(value) || value === "." || value === "..")
+        return null;
+    return value;
+}
 export function seedQueue(root, ids) {
     const sealed = new Set(loadSealed(root));
     const queue = path.join(root, "queue");
     mkdirSync(queue, { recursive: true });
     const written = [];
     for (const id of [...ids].sort()) {
-        if (sealed.has(id))
+        if (sealed.has(id) || !safeFilePart(id))
             continue;
         const dest = path.join(queue, `${id}.json`);
         if (existsSync(dest))
@@ -19,23 +25,23 @@ export function seedQueue(root, ids) {
 }
 /** Claim by atomic rename. A second claim fails because the queue file is already gone. */
 export function claimItem(root, id, agent, now, leaseMs) {
+    if (!safeFilePart(id) || !safeFilePart(agent))
+        return { ok: false, summary: "agent and id must be a single file name.", file: null };
     const source = path.join(root, "queue", `${id}.json`);
     const claimed = path.join(root, "claimed");
     const dest = path.join(claimed, `${agent}-${id}.json`);
     if (!existsSync(source))
         return { ok: false, summary: `${id} is not in the queue.`, file: null };
     mkdirSync(claimed, { recursive: true });
-    const body = JSON.parse(readFileSync(source, "utf8"));
-    body.id = id;
-    body.agent = agent;
-    body.leasedUntil = now + leaseMs;
-    writeFileSync(source, `${JSON.stringify(body)}\n`);
+    // Rename first. Writing the body before the rename lets the other claim overwrite the winner.
     try {
         renameSync(source, dest);
     }
     catch {
         return { ok: false, summary: `${id} was claimed by someone else.`, file: null };
     }
+    const body = { id, agent, leasedUntil: now + leaseMs };
+    writeFileSync(dest, `${JSON.stringify(body)}\n`);
     return { ok: true, summary: `${agent} claimed ${id} until ${body.leasedUntil}.`, file: dest };
 }
 /** Move claims whose lease has expired back to the queue. */
@@ -53,7 +59,7 @@ export function reapClaims(root, now) {
         const body = JSON.parse(readFileSync(file, "utf8"));
         if (typeof body.leasedUntil !== "number" || body.leasedUntil > now)
             continue;
-        if (!body.id)
+        if (!body.id || !safeFilePart(body.id))
             continue;
         renameSync(file, path.join(queue, `${body.id}.json`));
         returned.push(body.id);

package/dist/verify/change.js

@@ -23,6 +23,11 @@ export async function verifyChange(options) {
     const ranges = parseUnified(diff.stdout);
     const names = git(repo, ["diff", "--name-only", "--no-renames", options.base, options.commit, ...scope]);
     const changed = names.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const status = git(repo, ["status", "--porcelain", ...scope]);
+    const dirty = status.stdout.trim().length > 0;
+    if (dirty && (options.base === options.commit || changed.length === 0)) {
+        return fail(options.outDir, "The working tree has uncommitted changes. verify-change did not score them. Commit the edit, or pass --base and --commit that name different commits with a diff.");
+    }
     const goldenContract = goldenDiffs(repo, options.base, options.commit, changed);
     const packageFiles = [];
     const chosen = [];

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "probatio",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Mutation runner for AI agents. Scores a test suite by the bugs it catches.",
   "type": "module",
   "bin": {
-    "probatio": "dist/cli.js"
+    "probatio": "dist/cli.js",
+    "probatio-mcp": "dist/mcp.js"
   },
   "files": [
     "dist"
@@ -20,11 +21,12 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && mkdir -p dist/mutate && cp src/mutate/fail-reporter.mjs src/mutate/node-coverage.mjs src/mutate/precise-lines.mjs src/mutate/child-lines.mjs src/mutate/mocha-coverage.cjs src/mutate/node-batch.mjs src/mutate/node-batch-loader.mjs src/mutate/py-reporter.py src/mutate/py-pytest-reporter.py src/mutate/probatio-jacoco-run.java dist/mutate/",
+    "prepack": "npm run build",
     "test": "tsx --test tests/*.test.ts",
     "probatio": "tsx src/cli.ts"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=22.6"
   },
   "dependencies": {
     "typescript": "^5.7.2"