probatio 0.0.1 → 0.0.2

package/README.md

@@ -5,7 +5,7 @@ Probatio (Latin: a testing, a proof) is a free, open-source testing toolkit buil
 it remembers what was fixed so agents with small context do not redo or undo work; and it finds
 the bugs a test suite would miss instead of asking anyone to read more tests.
 
-Status (2026-10-05): `mutate run` discovers the project suite and scores it. Python, JavaScript, and TypeScript narrow each mutant with a line map collected on the baseline. C does the same when the binary was built with LLVM coverage. 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` mutates the changed lines and uses that same map. `mutate tally` reads a finished run, names tests that killed nothing, and does not delete a test. The MCP server returns the same JSON as the CLI.
+Status (2026-10-05): `mutate run` discovers the project suite and scores it. Python, JavaScript, and TypeScript narrow each mutant with a line map collected on the baseline. C does the same when the binary was built with LLVM coverage. 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` mutates the changed lines and uses that same map. `mutate tally` reads a finished run, names tests that killed nothing, and does not delete a test. The MCP server speaks one JSON object per line and returns the same JSON as the CLI.
 
 Read in this order:
 
@@ -23,19 +23,19 @@ One JSON object on stdout. `schemaVersion`, `ok`, `summary`, `next`, `nextCall`.
 
 ```bash
 npx probatio mutate generate --package . --out .probatio/generate
-npx probatio mutate run --package . --patches .probatio/generate/mutants --out .probatio/runs --no-build
+npx probatio mutate run --package . --patches .probatio/generate/mutants --out .probatio/runs
 npx probatio mutate tally --out .probatio/runs
 ```
 
 `generate` writes operator mutants (conditions, `&&`/`||`, `===`/`!==`, boundaries, booleans, a dropped `!`). The same class is written for COBOL (`.cob`, `.cbl`), Rust, C, C++, Java, Go, Python, JavaScript, and C#. Strings and comments are not mutated. A COBOL `*>` comment and a fixed-format line whose column 7 is `*` or `/` are comments. Each patch is forward: apply it to introduce the bug, and the file says so. When mutants were written, `next` states the count, the suite command if one was discovered, and whether the first run collects a line map.
 
-`run` discovers the suite: `run_tests.sh`, Cargo, Go, Swift, Maven, dotnet, pytest, unittest, node:test, Mocha, then `make test` when COBOL tests sit under that Makefile. An unknown layout stops and asks for `--suite-command`. It does not compile one file and call that the suite. `make test` that would curl or wget a missing file stops, and nothing is fetched. A worktree that has no `node_modules` uses the main checkout's.
+`run` discovers the suite: `run_tests.sh`, Cargo, Go, Swift, Maven, dotnet, pytest, unittest, node:test, Mocha, then `make test` when COBOL tests sit under that Makefile. An unknown layout stops and asks for `--suite-command`. It does not compile one file and call that the suite. `make test` that would curl or wget a missing file stops, and nothing is fetched. A worktree that has no `node_modules` uses the main checkout's. Omitting `--build` runs no build. Pass `--build` with a command when the suite needs one first.
 
-Python, JavaScript, and TypeScript collect a line map on the baseline. C collects one when LLVM coverage was instrumented. A later mutant runs the tests that executed its line. A line no test executed is `no coverage`, not a survivor. Go, Java, Rust, and C# can take a test name. Without a line map they still run the suite you gave them. A baseline of 5 seconds or more, with no line map and more than 30 mutants still pending, stops before the first mutant. `next` names that baseline and tells you to narrow `--src` or pass a smaller patch directory.
+Python, JavaScript, and TypeScript collect a line map on the baseline. C collects one when LLVM coverage was instrumented. Go and Maven/Java collect file, line, and the test names that hit that line. A later mutant runs only those tests (`go test -run`, Maven `-Dtest`). A line no test executed is `no coverage`, and the suite is not started. Rust and C# can take a test name and do not collect a line. A baseline of 5 seconds or more, with no line map and more than 30 mutants still pending, stops before the first mutant. `next` names that baseline and tells you to narrow `--src` or pass a smaller patch directory. A one-file C, C++, Java, COBOL, or assembly launcher is not a suite discovery returns.
 
 The mutant timeout is the baseline duration times 5, and at least 20 seconds, capped by `--suite-timeout-ms`. A timeout is not a kill. `--budget-ms` stops mutant work after the baseline. The first mutant still runs, except for that no-line-map stop. A kill is the test that failed, or a compiler token when the mutant did not build. Confirm is on by default and reruns the failing names. Pytest names that `-k` cannot express are passed as node ids. A usage error, including pytest exit 4, is not a kill. `verify-change` does not confirm a second time. Add `--affected` to limit the file list to tests that can see the change. The default, once a line map exists, runs the tests on the changed line.
 
-`tally` reads that run directory. It names tests that killed a mutant, tests that killed nothing, and one gap for each survivor and each uncovered line. `deletedTests` is 0. It does not delete a file.
+`tally` reads that run directory. The summary leads with the no-coverage count, then the survivors. It names tests that killed a mutant and tests that killed nothing. A gap is a survivor. An unseen line is not a gap and not a pass. A timeout is neither a kill nor a gap. `deletedTests` is 0. It does not delete a file.
 
 ## ledger
 

package/dist/cli.js

@@ -143,12 +143,7 @@ async function runCommand(flags) {
     if (direction !== "auto" && direction !== "forward" && direction !== "reverse") {
         throw new Error("--direction must be auto, forward, or reverse");
     }
-    const buildValues = flags.get("build");
-    const build = !buildValues || buildValues.length === 0
-        ? ["npm", "run", "build:mcp", "--silent"]
-        : buildValues[buildValues.length - 1] === false
-            ? null
-            : String(buildValues[buildValues.length - 1]).split(" ").filter(Boolean);
+    const build = buildCommand(flags);
     const report = await runMutants({
         packageDir,
         repoDir,
@@ -444,12 +439,7 @@ async function checkKillCommand(flags, id) {
     const patchDirs = texts(flags, "patches").map((dir) => path.resolve(dir));
     if (patchDirs.length === 0)
         throw new Error("--patches is required");
-    const buildValues = flags.get("build");
-    const build = !buildValues || buildValues.length === 0
-        ? null
-        : buildValues[buildValues.length - 1] === false
-            ? null
-            : String(buildValues[buildValues.length - 1]).split(" ").filter(Boolean);
+    const build = buildCommand(flags);
     return checkKill(id, {
         packageDir,
         repoDir: path.resolve(text(flags, "repo") ?? gitRoot(packageDir)),
@@ -496,3 +486,14 @@ function finish(envelope, human) {
     process.stdout.write(render(envelope, human));
     process.exit(envelope.ok ? 0 : 1);
 }
+/** Omitted `--build` and `--no-build` both mean no build. `--build <cmd>` opts in. */
+function buildCommand(flags) {
+    const values = flags.get("build");
+    if (!values || values.length === 0)
+        return null;
+    const last = values[values.length - 1];
+    if (typeof last !== "string")
+        return null;
+    const parts = last.split(" ").filter(Boolean);
+    return parts.length > 0 ? parts : null;
+}

package/dist/mcp.js

@@ -1,35 +1,39 @@
 #!/usr/bin/env node
 import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 const here = path.dirname(fileURLToPath(import.meta.url));
-let buffer = Buffer.alloc(0);
+const version = readVersion();
+const tool = {
+    name: "probatio",
+    description: "Run one probatio command. argv is the CLI words and flags.",
+    inputSchema: {
+        type: "object",
+        properties: { argv: { type: "array", items: { type: "string" } } },
+        required: ["argv"],
+    },
+};
+let buffer = "";
+process.stdin.setEncoding("utf8");
 process.stdin.on("data", (chunk) => {
-    buffer = Buffer.concat([buffer, chunk]);
+    buffer += chunk;
     drain();
 });
-process.stdin.on("end", () => process.exit(0));
-function drain() {
-    for (;;) {
-        const headerEnd = buffer.indexOf("\r\n\r\n");
-        if (headerEnd === -1)
-            return;
-        const header = buffer.subarray(0, headerEnd).toString("utf8");
-        const match = header.match(/Content-Length:\s*(\d+)/i);
-        const start = headerEnd + 4;
-        if (!match) {
-            buffer = buffer.subarray(start);
+process.stdin.on("end", () => {
+    drain(true);
+    process.exit(0);
+});
+function drain(flush = false) {
+    const lines = buffer.split("\n");
+    buffer = flush ? "" : lines.pop() ?? "";
+    for (const line of lines) {
+        const text = line.replace(/\r$/, "").trim();
+        if (!text)
             continue;
-        }
-        const length = Number(match[1]);
-        if (buffer.length < start + length)
-            return;
-        const body = buffer.subarray(start, start + length).toString("utf8");
-        buffer = buffer.subarray(start + length);
         let message;
         try {
-            message = JSON.parse(body);
+            message = JSON.parse(text);
         }
         catch {
             continue;
@@ -49,29 +53,14 @@ function handle(message) {
             result: {
                 protocolVersion: "2024-11-05",
                 capabilities: { tools: {} },
-                serverInfo: { name: "probatio", version: "0.0.1" },
+                serverInfo: { name: "probatio", version },
+                tools: [tool],
             },
         });
         return;
     }
     if (message.method === "tools/list") {
-        send({
-            jsonrpc: "2.0",
-            id: message.id,
-            result: {
-                tools: [
-                    {
-                        name: "probatio",
-                        description: "Run one probatio command. argv is the CLI words and flags.",
-                        inputSchema: {
-                            type: "object",
-                            properties: { argv: { type: "array", items: { type: "string" } } },
-                            required: ["argv"],
-                        },
-                    },
-                ],
-            },
-        });
+        send({ jsonrpc: "2.0", id: message.id, result: { tools: [tool] } });
         return;
     }
     if (message.method === "tools/call") {
@@ -112,8 +101,16 @@ function cliCommand() {
     const tsx = path.resolve(here, "..", "node_modules", ".bin", "tsx");
     return { bin: tsx, args: [path.join(here, "cli.ts")] };
 }
+function readVersion() {
+    try {
+        const raw = JSON.parse(readFileSync(path.resolve(here, "..", "package.json"), "utf8"));
+        return typeof raw.version === "string" && raw.version.length > 0 ? raw.version : "0.0.1";
+    }
+    catch {
+        return "0.0.1";
+    }
+}
 function send(message) {
-    const payload = Buffer.from(JSON.stringify(message), "utf8");
-    process.stdout.write(`Content-Length: ${payload.length}\r\n\r\n`);
-    process.stdout.write(payload);
+    const line = JSON.stringify(message);
+    process.stdout.write(`${line}\n`);
 }

package/dist/mutate/go-coverage.js

@@ -0,0 +1,100 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+/** Blocks in a Go cover profile whose count is above zero. */
+export function parseCoverProfile(text, modulePath) {
+    const hits = [];
+    const prefix = modulePath ? `${modulePath}/` : "";
+    for (const raw of text.split("\n")) {
+        const line = raw.trim();
+        if (!line || line.startsWith("mode:"))
+            continue;
+        const match = /^(.+):(\d+)\.\d+,(\d+)\.\d+\s+\d+\s+(\d+)$/.exec(line);
+        if (!match)
+            continue;
+        if (Number(match[4]) <= 0)
+            continue;
+        let file = match[1];
+        if (prefix && file.startsWith(prefix))
+            file = file.slice(prefix.length);
+        file = file.split("\\").join("/");
+        const start = Number(match[2]);
+        const end = Number(match[3]);
+        for (let number = start; number <= end; number++)
+            hits.push({ file, line: number });
+    }
+    return hits;
+}
+/**
+ * One compiled test binary per package, then one profile per test name.
+ * A stock cover profile does not name the test, so each test gets its own.
+ */
+export function writeGoCoverage(pkg, testNames, dest) {
+    const wanted = new Set(testNames.filter((name) => name.length > 0 && !name.includes("/")));
+    if (wanted.size === 0)
+        return { ok: false, detail: "go coverage: no test names" };
+    const mod = run("go", ["list", "-m"], pkg);
+    if (mod.status !== 0)
+        return { ok: false, detail: clip(mod.stderr || mod.stdout || mod.error?.message || "go list -m failed") };
+    const modulePath = mod.stdout.trim().split("\n")[0]?.trim() ?? "";
+    const listed = run("go", ["list", "-f", "{{.ImportPath}}\t{{.Dir}}\t{{len .TestGoFiles}}\t{{len .XTestGoFiles}}", "./..."], pkg);
+    if (listed.status !== 0)
+        return { ok: false, detail: clip(listed.stderr || listed.stdout || listed.error?.message || "go list failed") };
+    const work = path.join(path.dirname(dest), "go-cover");
+    mkdirSync(work, { recursive: true });
+    const files = {};
+    const packages = listed.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+    for (const row of packages) {
+        const [importPath, dir, testFiles, xTestFiles] = row.split("\t");
+        if (!importPath || !dir)
+            continue;
+        if (Number(testFiles ?? "0") + Number(xTestFiles ?? "0") <= 0)
+            continue;
+        const bin = path.join(work, `${safe(importPath)}.test`);
+        const compiled = run("go", ["test", "-c", "-covermode=set", "-o", bin, importPath], pkg);
+        if (compiled.status !== 0 || compiled.error)
+            continue;
+        const listedTests = run(bin, ["-test.list", "."], dir);
+        if (listedTests.status !== 0)
+            continue;
+        for (const name of listedTests.stdout.split("\n").map((item) => item.trim()).filter((item) => wanted.has(item))) {
+            const profile = path.join(work, `${safe(importPath)}-${safe(name)}.out`);
+            run(bin, ["-test.run", `^${escapeRegExp(name)}$`, "-test.coverprofile", profile], dir);
+            let text = "";
+            try {
+                text = readFileSync(profile, "utf8");
+            }
+            catch {
+                continue;
+            }
+            for (const hit of parseCoverProfile(text, modulePath))
+                addHit(files, hit.file, hit.line, name);
+        }
+    }
+    if (Object.keys(files).length === 0)
+        return { ok: false, detail: "go coverage: no covered lines" };
+    writeFileSync(dest, `${JSON.stringify({ files }, null, 2)}\n`);
+    return { ok: true, detail: `${Object.keys(files).length} files` };
+}
+function addHit(files, file, line, test) {
+    const lines = files[file] ?? {};
+    const key = String(line);
+    const names = lines[key] ?? [];
+    if (!names.includes(test))
+        names.push(test);
+    lines[key] = names;
+    files[file] = lines;
+}
+function safe(value) {
+    return value.replace(/[^A-Za-z0-9._-]+/g, "_");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function run(bin, args, cwd) {
+    return spawnSync(bin, args, { cwd, encoding: "utf8", timeout: 120_000 });
+}
+function clip(text) {
+    const line = text.trim().split("\n").find((item) => item.trim()) ?? "go coverage failed";
+    return line.slice(0, 240);
+}

package/dist/mutate/java-coverage.js

@@ -0,0 +1,188 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const JACOCO = "0.8.15";
+const ASM = "9.10.1";
+const RUNNER = fileURLToPath(new URL("./probatio-jacoco-run.java", import.meta.url));
+/**
+ * One JVM, one JaCoCo dump per Surefire test method.
+ * The default jacoco.exec file does not name the test.
+ */
+export function writeJavaCoverage(pkg, testNames, dest) {
+    const tests = testNames.map(junitMethod).filter((name) => name !== null);
+    if (tests.length === 0)
+        return { ok: false, detail: "java coverage: no class.method test names" };
+    const classDirs = findClassDirs(pkg);
+    if (classDirs.length === 0)
+        return { ok: false, detail: "java coverage: no target/classes" };
+    const work = path.join(path.dirname(dest), "java-cover");
+    mkdirSync(work, { recursive: true });
+    const jars = resolveJars(pkg, work);
+    if ("error" in jars)
+        return { ok: false, detail: jars.error };
+    const source = path.join(work, "ProbatioJacocoRun.java");
+    writeFileSync(source, readFileSync(RUNNER));
+    const compileCp = [jars.agent, jars.junit, jars.core, jars.asm, jars.asmCommons, jars.asmTree].join(path.delimiter);
+    const compiled = run(javaTool("javac"), ["-encoding", "UTF-8", "-cp", compileCp, "-d", work, source], pkg);
+    if (compiled.status !== 0)
+        return { ok: false, detail: clip(compiled.stderr || compiled.stdout || compiled.error?.message || "javac failed") };
+    const testsFile = path.join(work, "tests.txt");
+    writeFileSync(testsFile, `${tests.join("\n")}\n`);
+    const projectCp = buildClasspath(pkg, work);
+    if ("error" in projectCp)
+        return { ok: false, detail: projectCp.error };
+    // Our asm and JaCoCo must win over a project that still ships an older asm. That older reader rejects Java 27 class files.
+    const cp = [work, jars.core, jars.asm, jars.asmCommons, jars.asmTree, jars.junit, ...classDirs, ...testClassDirs(pkg), projectCp.cp].filter(Boolean).join(path.delimiter);
+    const dump = path.join(work, "hits.txt");
+    const ran = run(javaTool("java"), [`-javaagent:${jars.agent}=output=none,excludes=ProbatioJacocoRun`, "-cp", cp, "ProbatioJacocoRun", classDirs.join(path.delimiter), testsFile, dump, pkg], pkg);
+    if (ran.error && ran.error.code === "ETIMEDOUT") {
+        return { ok: false, detail: "java coverage: timed out" };
+    }
+    if (ran.status !== 0 || !existsSync(dump)) {
+        return { ok: false, detail: clip(ran.stderr || ran.stdout || ran.error?.message || "java coverage runner failed") };
+    }
+    const files = hitsToMap(readFileSync(dump, "utf8"));
+    if (Object.keys(files).length === 0)
+        return { ok: false, detail: "java coverage: no covered lines" };
+    writeFileSync(dest, `${JSON.stringify({ files }, null, 2)}\n`);
+    return { ok: true, detail: `${Object.keys(files).length} files` };
+}
+export function hitsToMap(text) {
+    const files = {};
+    for (const raw of text.split("\n")) {
+        const line = raw.trim();
+        if (!line.startsWith("HIT "))
+            continue;
+        const parts = line.slice(4).split(" ");
+        if (parts.length < 3)
+            continue;
+        const test = parts.pop() ?? "";
+        const number = parts.pop() ?? "";
+        const file = parts.join(" ");
+        if (!file || !/^\d+$/.test(number) || !test)
+            continue;
+        const lines = files[file] ?? {};
+        const names = lines[number] ?? [];
+        if (!names.includes(test))
+            names.push(test);
+        lines[number] = names;
+        files[file] = lines;
+    }
+    return files;
+}
+function junitMethod(name) {
+    const leaf = name.split("::").pop() ?? name;
+    const dot = leaf.lastIndexOf(".");
+    if (dot <= 0 || dot === leaf.length - 1)
+        return null;
+    if (leaf.startsWith("maven-") || leaf === "javac")
+        return null;
+    return `${leaf.slice(0, dot)}#${leaf.slice(dot + 1)}`;
+}
+function findClassDirs(root) {
+    const found = [];
+    const walk = (dir, depth) => {
+        if (depth > 4)
+            return;
+        let entries = [];
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            if (name === "node_modules" || name === ".git" || name === "java-cover")
+                continue;
+            const full = path.join(dir, name);
+            if (name === "target") {
+                const classes = path.join(full, "classes");
+                if (existsSync(classes))
+                    found.push(classes);
+                continue;
+            }
+            if (name.startsWith("."))
+                continue;
+            walk(full, depth + 1);
+        }
+    };
+    walk(root, 0);
+    return found;
+}
+function testClassDirs(root) {
+    return findClassDirs(root).map((dir) => path.join(path.dirname(dir), "test-classes")).filter((dir) => existsSync(dir));
+}
+function resolveJars(pkg, work) {
+    const copies = [
+        [`org.jacoco:org.jacoco.agent:${JACOCO}:jar:runtime`, "agent.jar"],
+        [`org.jacoco:org.jacoco.core:${JACOCO}`, "core.jar"],
+        [`org.ow2.asm:asm:${ASM}`, "asm.jar"],
+        [`org.ow2.asm:asm-commons:${ASM}`, "asm-commons.jar"],
+        [`org.ow2.asm:asm-tree:${ASM}`, "asm-tree.jar"],
+        ["junit:junit:4.13.2", "junit.jar"],
+    ];
+    const paths = {};
+    for (const [artifact, name] of copies) {
+        const dest = path.join(work, name);
+        if (!existsSync(dest)) {
+            const before = new Set(readdirSync(work));
+            const copied = run("mvn", ["-B", "-q", "org.apache.maven.plugins:maven-dependency-plugin:3.6.1:copy", `-Dartifact=${artifact}`, `-DoutputDirectory=${work}`], pkg);
+            if (copied.status !== 0)
+                return { error: clip(copied.stderr || copied.stdout || copied.error?.message || `mvn copy ${artifact} failed`) };
+            const created = readdirSync(work).find((item) => !before.has(item) && item.endsWith(".jar"));
+            if (!created)
+                return { error: `java coverage: missing ${artifact}` };
+            writeFileSync(dest, readFileSync(path.join(work, created)));
+        }
+        paths[name] = dest;
+    }
+    return {
+        agent: paths["agent.jar"],
+        core: paths["core.jar"],
+        asm: paths["asm.jar"],
+        asmCommons: paths["asm-commons.jar"],
+        asmTree: paths["asm-tree.jar"],
+        junit: paths["junit.jar"],
+    };
+}
+function buildClasspath(pkg, work) {
+    const file = path.join(work, "classpath.txt");
+    const built = run("mvn", ["-B", "-q", "dependency:build-classpath", "-DincludeScope=test", `-Dmdep.outputFile=${file}`], pkg);
+    if (built.status !== 0)
+        return { error: clip(built.stderr || built.stdout || built.error?.message || "mvn classpath failed") };
+    try {
+        return { cp: readFileSync(file, "utf8").trim() };
+    }
+    catch {
+        return { error: "java coverage: classpath file missing" };
+    }
+}
+function javaTool(name) {
+    const home = process.env.JAVA_HOME;
+    if (home) {
+        const candidate = path.join(home, "bin", name);
+        if (existsSync(candidate) && toolWorks(candidate))
+            return candidate;
+    }
+    if (toolWorks(name))
+        return name;
+    for (const dir of ["/opt/homebrew/opt/openjdk/bin", "/usr/local/opt/openjdk/bin"]) {
+        const candidate = path.join(dir, name);
+        if (existsSync(candidate) && toolWorks(candidate))
+            return candidate;
+    }
+    return name;
+}
+function toolWorks(bin) {
+    const probed = spawnSync(bin, ["-version"], { encoding: "utf8" });
+    const text = `${probed.stdout ?? ""}${probed.stderr ?? ""}`;
+    return probed.status === 0 && !/Unable to locate a Java Runtime/i.test(text);
+}
+function run(bin, args, cwd) {
+    return spawnSync(bin, args, { cwd, encoding: "utf8", timeout: 180_000 });
+}
+function clip(text) {
+    const line = text.trim().split("\n").find((item) => item.trim()) ?? "java coverage failed";
+    return line.slice(0, 240);
+}

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

@@ -0,0 +1,81 @@
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.nio.file.Files;
+import java.util.List;
+import org.jacoco.agent.rt.IAgent;
+import org.jacoco.agent.rt.RT;
+import org.jacoco.core.analysis.Analyzer;
+import org.jacoco.core.analysis.CoverageBuilder;
+import org.jacoco.core.analysis.IClassCoverage;
+import org.jacoco.core.analysis.ILine;
+import org.jacoco.core.data.ExecutionDataReader;
+import org.jacoco.core.data.ExecutionDataStore;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+
+/** One JaCoCo dump per JUnit 4 method. Prints "HIT <file> <line>" lines. */
+public class ProbatioJacocoRun {
+  public static void main(String[] args) throws Exception {
+    if (args.length != 4) {
+      System.err.println("usage: ProbatioJacocoRun classDirs testsFile outFile packageRoot");
+      System.exit(2);
+    }
+    String[] classDirs = args[0].split(File.pathSeparator);
+    List<String> tests = Files.readAllLines(new File(args[1]).toPath());
+    File out = new File(args[2]);
+    File root = new File(args[3]);
+    IAgent agent = RT.getAgent();
+    StringBuilder text = new StringBuilder();
+    for (String spec : tests) {
+      int hash = spec.lastIndexOf('#');
+      if (hash <= 0) continue;
+      String className = spec.substring(0, hash);
+      String method = spec.substring(hash + 1);
+      agent.getExecutionData(true);
+      try {
+        new JUnitCore().run(Request.method(Class.forName(className), method));
+      } catch (Throwable ignored) {
+        continue;
+      }
+      byte[] data = agent.getExecutionData(false);
+      ExecutionDataStore store = new ExecutionDataStore();
+      ExecutionDataReader reader = new ExecutionDataReader(new ByteArrayInputStream(data));
+      reader.setExecutionDataVisitor(store);
+      reader.setSessionInfoVisitor(info -> { });
+      reader.read();
+      String testName = className + "." + method;
+      text.append("TEST ").append(testName).append('\n');
+      for (String dir : classDirs) {
+        if (dir.isEmpty()) continue;
+        File classes = new File(dir);
+        if (!classes.isDirectory()) continue;
+        CoverageBuilder builder = new CoverageBuilder();
+        Analyzer analyzer = new Analyzer(store, builder);
+        analyzer.analyzeAll(classes);
+        for (IClassCoverage cc : builder.getClasses()) {
+          String source = cc.getSourceFileName();
+          if (source == null) continue;
+          File file = sourceFile(classes, cc.getPackageName(), source);
+          if (file == null || !file.isFile()) continue;
+          String rel = root.toPath().relativize(file.toPath()).toString().replace('\\', '/');
+          int first = cc.getFirstLine();
+          int last = cc.getLastLine();
+          for (int line = first; line <= last; line++) {
+            ILine cov = cc.getLine(line);
+            if (cov.getInstructionCounter().getCoveredCount() <= 0) continue;
+            text.append("HIT ").append(rel).append(' ').append(line).append(' ').append(testName).append('\n');
+          }
+        }
+      }
+    }
+    Files.writeString(out.toPath(), text.toString());
+  }
+
+  static File sourceFile(File classes, String pkg, String source) {
+    File target = classes.getParentFile();
+    File module = target == null ? null : target.getParentFile();
+    if (module == null) return null;
+    String rel = (pkg == null || pkg.isEmpty() ? "" : pkg + "/") + source;
+    return new File(module, "src/main/java/" + rel);
+  }
+}

package/dist/mutate/run.js

@@ -6,9 +6,11 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { affectedTests } from "./affected.js";
 import { binaryFromCommand, readCoverageMap, selectionFor, writeLlvmCoverage } from "./coverage-map.js";
+import { writeGoCoverage } from "./go-coverage.js";
+import { writeJavaCoverage } from "./java-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, decideSuite, noCoverageNext, resumeNext, scaleStop, timeoutLimitMs, } from "./suite-decision.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 { commandSuite, discoverSuite, runDiscoveredSuite, sourceCandidates } from "./suites.js";
 import { duplicateTitles } from "./titles.js";
 export const reporterPath = fileURLToPath(new URL("./fail-reporter.mjs", import.meta.url));
@@ -71,7 +73,9 @@ export async function runMutants(options) {
         if (!prep.ok)
             return failReport(options.outDir, run.id, commit, prep.error, prep.baselineFailed, prep.next, prep.suiteCommand);
         // The baseline already ran. A slow suite with no line map does not start the batch.
-        const scale = scaleStop({ kind: prep.spec.kind, baselineMs: prep.baselineMs, pending: pending.length });
+        // A kind that can collect a map still refuses when that map was not written.
+        const mapped = prep.coverage !== null && Object.keys(prep.coverage.files).length > 0 && hasLineMap(prep.spec.kind);
+        const scale = scaleStop({ kind: mapped ? prep.spec.kind : "unmapped", baselineMs: prep.baselineMs, pending: pending.length });
         if (scale.action === "stop") {
             const ids = pending.map((file) => path.basename(file, ".patch"));
             return failReport(options.outDir, run.id, commit, scale.summary, undefined, scale.next, prep.spec.command, prep.baselineMs, ids);
@@ -189,14 +193,28 @@ async function prepare(pkg, options, progress) {
         writeFileSync(baselineFile, `${JSON.stringify({ ok: baselineFailed.length === 0, tests: baseline.report.tests, failed: baselineFailed, command: spec.command, durationMs: baselineMs }, null, 2)}\n`);
         progress(`suite report tests=${baseline.report.tests}`);
         progress(baselineFailed.length > 0 ? `baseline failing ${baselineFailed.length}` : "baseline pass");
+        if (baselineFailed.length > 0) {
+            return { ok: false, error: "baseline already failing", baselineFailed, suiteCommand: spec.command };
+        }
+        if (collect && !existsSync(mapPath) && (spec.kind === "go" || spec.kind === "maven")) {
+            progress(spec.kind === "go" ? "go line map" : "java line map");
+            const written = spec.kind === "go"
+                ? writeGoCoverage(pkg, baseline.report.names, mapPath)
+                : writeJavaCoverage(pkg, baseline.report.names, mapPath);
+            if (!written.ok)
+                writeFileSync(path.join(options.outDir, "coverage-error.txt"), `${written.detail}\n`);
+        }
     }
     else {
         const stored = JSON.parse(readFileSync(baselineFile, "utf8"));
-        baselineFailed = stored.ok === false ? stored.failed ?? [] : [];
         baselineMs = typeof stored.durationMs === "number" ? stored.durationMs : null;
+        if (stored.ok !== true) {
+            const failed = Array.isArray(stored.failed) ? stored.failed.filter((name) => typeof name === "string") : [];
+            return { ok: false, error: "baseline already failing", baselineFailed: failed, suiteCommand: spec.command };
+        }
     }
     const affectedMap = options.affected ? affectedTests(pkg, { testsDir: options.testsDir }) : null;
-    return { ok: true, tests, affectedMap, baselineFailed, baselineMs, spec, coverage: readCoverageMap(mapPath) };
+    return { ok: true, tests, affectedMap, baselineMs, spec, coverage: readCoverageMap(mapPath) };
 }
 async function runOne(worktree, pkg, patchPath, options, commit, runId, prep) {
     const id = path.basename(patchPath, ".patch");
@@ -268,15 +286,8 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep) {
             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(" | ") };
-        const now = main.report.failed.map((item) => item.name);
         const whole = main.wholeSuite || forceWhole;
         const chosen = main.selectedTests;
-        if (prep.baselineFailed.length > 0) {
-            if (sameNames(now, prep.baselineFailed))
-                return finishMutant({ ...base(), direction, outcome: "survived" }, pkg, commands.join(" | "), whole, chosen);
-            const noticed = [...new Set([...now.filter((name) => !prep.baselineFailed.includes(name)), ...prep.baselineFailed.filter((name) => !now.includes(name))])];
-            return finishMutant(killed(base, direction, noticed.slice(0, 20)), pkg, commands.join(" | "), whole, chosen);
-        }
         if (main.report.failed.length === 0)
             return finishMutant({ ...base(), direction, outcome: "survived" }, pkg, commands.join(" | "), whole, chosen);
         if (!options.confirm)
@@ -342,10 +353,10 @@ async function rerunGroup(pkg, options, file, failures, counts, pattern, prep, t
     const files = file === "*" ? listTestFiles(pkg, options.testsDir, prep.spec) : [testArg(pkg, file, options.testsDir)];
     const isolated = { ...options, concurrency: 1 };
     let wholeSuite = false;
-    // Pytest confirms by node id. A regex fed to -k is a usage error, not a second look at the failure.
-    const pytestNames = prep.spec.kind === "pytest" ? failures.map((item) => item.name) : null;
+    // Pytest confirms by node id. Maven confirms by class#method. A regex is not a test name for either.
+    const directNames = prep.spec.kind === "pytest" || prep.spec.kind === "maven" ? failures.map((item) => item.name) : null;
     for (let attempt = 0; attempt < 2; attempt++) {
-        const rerun = await runSuite(pkg, files, isolated, pytestNames ? null : pattern, pytestNames, prep.spec, timeoutMs, false, null, null);
+        const rerun = await runSuite(pkg, files, isolated, directNames ? null : pattern, directNames, prep.spec, timeoutMs, false, null, null);
         if (rerun.wholeSuite)
             wholeSuite = true;
         if (rerun.command)
@@ -391,13 +402,6 @@ async function runSuite(pkg, files, options, pattern, names, spec, timeoutMs, fo
         selectedTests: result.selectedTests,
     };
 }
-function sameNames(left, right) {
-    if (left.length !== right.length)
-        return false;
-    const a = [...left].sort();
-    const b = [...right].sort();
-    return a.every((name, index) => name === b[index]);
-}
 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);
@@ -623,21 +627,21 @@ function reportOf(results, context) {
         return { id: result.id, file, line, ...(known?.op ? { op: known.op } : {}) };
     });
     const budgetHit = context.budgetHit || context.pendingLeft > 0;
-    const summary = `${killed} killed, ${survived} survived, ${noCoverage} no coverage, ${flaky} flaky, ${timeouts} timed out, ${errors} errored, of ${results.length} finished.`;
+    const summary = campaignSummary({ noCoverage, survived, killed, flaky, timeouts, errors, finished: results.length });
     const notes = [];
-    if (budgetHit)
-        notes.push(resumeNext(context.notStarted));
-    if (timeouts > 0)
-        notes.push(TIMEOUT_NEXT);
     const uncovered = results.find((result) => result.outcome === "no coverage");
     if (uncovered?.next)
         notes.push(uncovered.next);
+    if (gapResults.length > 0)
+        notes.push(`First gap is ${gaps[0].id} at ${gaps[0].file}:${gaps[0].line}. A survivor is not a pass.`);
+    if (timeouts > 0)
+        notes.push(TIMEOUT_NEXT);
+    if (budgetHit)
+        notes.push(resumeNext(context.notStarted));
     if (results.some((result) => result.wholeSuite))
         notes.push(WHOLE_SUITE_NEXT);
-    if (!budgetHit && gapResults.length > 0 && timeouts === 0)
-        notes.push(`First gap is ${gaps[0].id} at ${gaps[0].file}:${gaps[0].line}.`);
     if (notes.length === 0)
-        notes.push(gapResults.length > 0 ? `First gap is ${gaps[0].id} at ${gaps[0].file}:${gaps[0].line}.` : "No survivor in this batch.");
+        notes.push("No survivor in this batch.");
     return {
         ok: true,
         summary,

package/dist/mutate/suite-decision.js

@@ -17,13 +17,20 @@ export function resumeNext(ids) {
 export function noCoverageNext(file, line) {
     return `No coverage for ${file}:${line}. No test executed that line.`;
 }
+/** Every agent-facing count starts with unseen lines, then survivors. */
+export function leadSummary(noCoverage, survivors, survivorWord, rest) {
+    return `${noCoverage} no coverage, ${survivors} ${survivorWord}, ${rest}`;
+}
+export function campaignSummary(counts) {
+    return leadSummary(counts.noCoverage, counts.survived, "survived", `${counts.killed} killed, ${counts.flaky} flaky, ${counts.timeouts} timed out, ${counts.errors} errored, of ${counts.finished} finished.`);
+}
 export function timeoutLimitMs(baselineMs, multiple, floorMs) {
     const floor = Math.max(1, floorMs);
     const scaled = Math.ceil(Math.max(0, baselineMs) * Math.max(1, multiple));
     return Math.max(floor, scaled);
 }
 /** Kinds that collect a per-line map on the baseline. Other kinds pay the whole suite. */
-const LINE_MAP_KINDS = new Set(["node", "pytest", "c"]);
+const LINE_MAP_KINDS = new Set(["node", "pytest", "c", "go", "maven"]);
 /** A baseline this long, with no line map, is too expensive to repeat for a large batch. */
 export const SLOW_BASELINE_MS = 5_000;
 /** Pending mutants above this count, on a slow unmapped suite, are not started. */

package/dist/mutate/suites.js

@@ -274,6 +274,9 @@ async function launch(pkg, spec, files, pattern, names, timeoutMs, env, hooks) {
         const tests = selection.map(surefireTest).filter((name) => name.length > 0);
         const args = ["-B", "test", ...(tests.length > 0 ? [`-Dtest=${tests.join(",")}`] : [])];
         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.
+        rmSync(path.join(pkg, "target", "surefire-reports"), { recursive: true, force: true });
         return tag(spawnCollected("mvn", args, pkg, javaEnv(env), timeoutMs), shown("mvn", args), whole, selection);
     }
     if (spec.kind === "dotnet") {
@@ -284,9 +287,11 @@ async function launch(pkg, spec, files, pattern, names, timeoutMs, env, hooks) {
         return tag(runDotnetExe(pkg, spec, files, timeoutMs, env), spec.command, wantsNames, selection);
     if (spec.kind === "mocha")
         return tag(runMocha(pkg, files, timeoutMs, env), spec.command, wantsNames, selection);
-    // macOS `script` allocates a tty. tini's suite calls `docker run -it`, which exits immediately without one.
-    if (spec.kind === "script")
-        return tag(runScript(pkg, timeoutMs, env), spec.command, wantsNames, selection);
+    // A tty is only for a suite that runs `docker run -it` (tini). Everything else is bash.
+    if (spec.kind === "script") {
+        const launched = scriptInvocation(pkg);
+        return tag(runScript(pkg, timeoutMs, env, launched), launched.command, wantsNames, selection);
+    }
     if (spec.kind === "c" || spec.kind === "cpp")
         return tag(compileAndRun(pkg, files, spec.kind === "cpp", timeoutMs, env), spec.command, wantsNames, selection);
     if (spec.kind === "java")
@@ -549,7 +554,72 @@ function clearBytecode(pkg) {
         }
     }
 }
-function runScript(pkg, timeoutMs, env) {
+let gnuScriptCache = null;
+function suiteNeedsTty(pkg) {
+    const files = new Set();
+    const rootScript = path.join(pkg, "run_tests.sh");
+    if (existsSync(rootScript))
+        files.add(rootScript);
+    try {
+        for (const name of readdirSync(pkg)) {
+            if (name.endsWith(".sh"))
+                files.add(path.join(pkg, name));
+        }
+    }
+    catch {
+        // A missing directory is not a tty.
+    }
+    let entry = "";
+    try {
+        entry = readFileSync(rootScript, "utf8");
+    }
+    catch {
+        entry = "";
+    }
+    for (const match of entry.matchAll(/(?:^|[\s"'`/])([\w.-]+\.sh)\b/g)) {
+        const full = path.resolve(pkg, match[1]);
+        if (full.startsWith(pkg + path.sep) && existsSync(full))
+            files.add(full);
+    }
+    for (const file of files) {
+        let body = "";
+        try {
+            body = readFileSync(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (dockerWantsTty(body))
+            return true;
+    }
+    return false;
+}
+function dockerWantsTty(text) {
+    return text.split("\n").some((line) => {
+        if (!/\bdocker\s+run\b/.test(line))
+            return false;
+        return /(?:^|\s)--tty(?:\s|=|$)/.test(line) || /(?:^|\s)-[A-Za-z]*t[A-Za-z]*(?:\s|$)/.test(line);
+    });
+}
+function gnuScript() {
+    if (gnuScriptCache !== null)
+        return gnuScriptCache;
+    const probe = spawnSync("script", ["--version"], { encoding: "utf8", timeout: 2000 });
+    const text = `${probe.stdout ?? ""}\n${probe.stderr ?? ""}`;
+    gnuScriptCache = probe.status === 0 && /util-linux|\bGNU\b/.test(text);
+    return gnuScriptCache;
+}
+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"];
+        return { bin: "script", args, command: shown("script", args) };
+    }
+    const args = ["-q", "/dev/null", "bash", "run_tests.sh"];
+    return { bin: "script", args, command: shown("script", args) };
+}
+function runScript(pkg, timeoutMs, env, launched) {
     const next = { ...env };
     const shim = writeDockerShim(pkg);
     if (shim)
@@ -560,7 +630,7 @@ function runScript(pkg, timeoutMs, env) {
     if (!next.ARCH_NATIVE && existsSync(inner) && existsSync(build) && readFileSync(build, "utf8").includes("ARCH_NATIVE")) {
         next.ARCH_NATIVE = "1";
     }
-    return spawnCollected("script", ["-q", "/dev/null", "bash", "run_tests.sh"], pkg, next, timeoutMs);
+    return spawnCollected(launched.bin, launched.args, pkg, next, timeoutMs);
 }
 function writeDockerShim(pkg) {
     const found = spawnSync("sh", ["-c", "command -v docker"], { encoding: "utf8" });
@@ -1132,7 +1202,9 @@ function parseDotnet(text, code) {
     const names = [];
     const failed = [];
     for (const line of text.split("\n")) {
-        const match = line.match(/^\s*(Passed|Failed)\s+(\S+)/);
+        // A result line carries a duration: "Passed StaysClosed [4 ms]".
+        // "Failed to load ..." is a diagnostic, not a test, and must not redden the baseline.
+        const match = line.match(/^\s*(Passed|Failed)\s+(.+?)\s+\[(?:<\s*)?\d+(?:\.\d+)?\s*(?:ms|s)\]\s*$/);
         if (!match)
             continue;
         names.push(match[2]);

package/dist/mutate/tally.js

@@ -3,11 +3,11 @@ import path from "node:path";
 import { SCHEMA_VERSION } from "../contract.js";
 import { advisePrune } from "../matrix/report.js";
 import { isBuildName } from "./kill-label.js";
-import { WHOLE_PROGRAM_TEST } from "./suite-decision.js";
+import { leadSummary, TIMEOUT_NEXT, WHOLE_PROGRAM_TEST } from "./suite-decision.js";
 const NOT_A_TEST = new Set(["suite", "pytest", "unittest", "command", WHOLE_PROGRAM_TEST]);
 /**
  * Read a finished mutate run. Name tests that killed a mutant, tests that killed
- * nothing, and one gap per survivor or uncovered line. This never deletes a file.
+ * nothing, and one gap per survivor. An unseen line is not a gap. This never deletes a file.
  */
 export function tallyRun(outDir) {
     const resultsDir = path.join(outDir, "results");
@@ -75,18 +75,30 @@ export function tallyRun(outDir) {
         .map(([name]) => name)
         .sort();
     const drop = pruning.advice;
+    const noCoverage = results.filter((result) => result.outcome === "no coverage").length;
+    const survived = results.filter((result) => result.outcome === "survived").length;
+    const timeouts = results.filter((result) => result.outcome === "timeout").length;
     const gaps = results
-        .filter((result) => result.outcome === "survived" || result.outcome === "no coverage")
+        .filter((result) => result.outcome === "survived")
         .map((result) => ({
         id: result.id,
         file: result.files?.[0]?.file ?? "",
         line: result.files?.[0]?.line ?? 0,
-        outcome: result.outcome,
+        outcome: "survived",
     }))
         .sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.id.localeCompare(b.id));
     const shown = gaps.slice(0, 10);
-    const summary = `${keep.length} tests to keep, ${drop.length} tests killed nothing, ${gaps.length} gaps. No test file was deleted.`;
-    const next = gaps.length === 0 ? "No gap in this run." : `First gap is ${gaps[0].id} at ${gaps[0].file}:${gaps[0].line}.`;
+    const summary = leadSummary(noCoverage, survived, "survived", `${keep.length} tests to keep, ${drop.length} tests killed nothing, ${gaps.length} gaps. No test file was deleted.`);
+    const notes = [];
+    if (noCoverage > 0)
+        notes.push(`${noCoverage} no coverage. That line was not seen. It is not a pass and not a gap.`);
+    if (gaps.length > 0)
+        notes.push(`First gap is ${gaps[0].id} at ${gaps[0].file}:${gaps[0].line}. A survivor is not a pass.`);
+    if (timeouts > 0)
+        notes.push(TIMEOUT_NEXT);
+    if (notes.length === 0)
+        notes.push("No survivor in this run. No test file was deleted.");
+    const next = notes.join(" ");
     const complete = {
         schemaVersion: SCHEMA_VERSION,
         ok: true,

package/dist/swarm/check-kill.js

@@ -5,6 +5,7 @@ import { directImporters } from "../mutate/affected.js";
 import { filesInDiff } from "../mutate/patch.js";
 import { killLabel } from "../mutate/kill-label.js";
 import { runMutants } from "../mutate/run.js";
+import { campaignSummary } from "../mutate/suite-decision.js";
 /** The gap is done only when this mutant is killed and the baseline suite is green. */
 export async function checkKill(id, options) {
     const importers = importersOf(id, options);
@@ -28,6 +29,21 @@ export async function checkKill(id, options) {
         const baseline = JSON.parse(readFileSync(baselineFile, "utf8"));
         suiteGreen = baseline.ok === true;
     }
+    // A red baseline stops inside the run. Do not read a result that names the broken test.
+    if (!report.ok) {
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            ok: false,
+            command: "check-kill",
+            summary: `${id} is not done. ${report.summary}`,
+            next: "The task is not done.",
+            nextCall: null,
+            done: false,
+            outcome: null,
+            suiteGreen,
+            killedBy: [],
+        };
+    }
     const resultFile = path.join(options.outDir, "results", `${id}.json`);
     let outcome = null;
     let killedBy = [];
@@ -38,11 +54,12 @@ export async function checkKill(id, options) {
     }
     const done = suiteGreen && outcome === "killed";
     const label = done ? killLabel(killedBy) : null;
+    const head = checkHead(report);
     return {
         schemaVersion: SCHEMA_VERSION,
         ok: done,
         command: "check-kill",
-        summary: done ? `${id} is dead and the suite is green.` : `${id} is not done. ${report.summary}`,
+        summary: done ? `${head} ${id} is dead and the suite is green.` : `${head} ${id} is not done.`,
         next: label?.next ?? (done ? "The gap-fixing task is done." : "The task is not done."),
         nextCall: null,
         done,
@@ -60,6 +77,18 @@ function importersOf(id, options) {
     const rels = filesInDiff(readFileSync(patch, "utf8")).map((item) => packageRelative(options.repoDir, options.packageDir, item.file));
     return directImporters(options.packageDir, rels, options.testsDir);
 }
+function checkHead(report) {
+    const finished = report.killed + report.survived + report.flaky + report.timeouts + report.errors + report.noCoverage;
+    return campaignSummary({
+        noCoverage: report.noCoverage,
+        survived: report.survived,
+        killed: report.killed,
+        flaky: report.flaky,
+        timeouts: report.timeouts,
+        errors: report.errors,
+        finished,
+    });
+}
 function packageRelative(repoDir, packageDir, file) {
     const norm = file.split(path.sep).join("/");
     let repo = repoDir;

package/dist/verify/change.js

@@ -7,6 +7,7 @@ import { findInSource } from "../mutate/find.js";
 import { mutantId } from "../mutate/ids.js";
 import { forwardDiff, git } from "../mutate/patch.js";
 import { runMutants } from "../mutate/run.js";
+import { leadSummary } from "../mutate/suite-decision.js";
 import { discoverSuite } from "../mutate/suites.js";
 /** Diff-scoped mutants, the tests that can see the edit, and golden contract rows that changed. */
 export async function verifyChange(options) {
@@ -112,7 +113,7 @@ export async function verifyChange(options) {
 function bodyOf(outDir, ok, affected, ran, notRan, caught, missed, other, goldenContract, notRun, suiteCommand) {
     const uncovered = other.filter((item) => item.outcome === "no coverage");
     const summary = ok
-        ? `${caught.length} caught, ${missed.length} missed, ${notRun.length} not run, ${uncovered.length} no coverage, ${affected.length} affected tests, ${goldenContract.length} golden contract changes.`
+        ? leadSummary(uncovered.length, missed.length, "missed", `${caught.length} caught, ${notRun.length} not run, ${affected.length} affected tests, ${goldenContract.length} golden contract changes.`)
         : "verify-change did not finish.";
     const first = missed[0] ?? uncovered[0] ?? notRun[0] ?? caught[0];
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "probatio",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Mutation runner for AI agents. Scores a test suite by the bugs it catches.",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
     "url": "https://github.com/IronAdamant/Probatio/issues"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && mkdir -p dist/mutate && cp src/mutate/fail-reporter.mjs src/mutate/node-coverage.mjs src/mutate/py-reporter.py src/mutate/py-pytest-reporter.py dist/mutate/",
+    "build": "tsc -p tsconfig.json && mkdir -p dist/mutate && cp src/mutate/fail-reporter.mjs src/mutate/node-coverage.mjs src/mutate/py-reporter.py src/mutate/py-pytest-reporter.py src/mutate/probatio-jacoco-run.java dist/mutate/",
     "test": "tsx --test tests/*.test.ts",
     "probatio": "tsx src/cli.ts"
   },