paperlint 3.0.0 → 3.1.1

package/hooks/hooks.mutations.mjs

@@ -1,337 +0,0 @@
-/**
- * Mutation battery for the three shipped hooks and their tool.
- * Run: `node hooks/hooks.mutations.mjs` (not `vigiles test` — this is not a harness).
- *
- * 🔴 EVERY MUTATION CARRIES A "THE PATCH LANDED" ASSERTION: the file is re-read FROM DISK, the
- * mutant must be in it, and after the rollback the contents must return byte for byte. A green
- * mutation in this repository has repeatedly meant not "the defence holds" but "the patch never
- * landed" / "the test is looking somewhere else".
- *
- * WHAT A GREEN HARNESS UNDER A MUTATION MEANS: a finding about the TEST, not a conclusion about
- * the defence. Rank the causes in this order — the test greps PROSE ABOUT a value instead of the
- * value · the test looks in the wrong place · the test is the wrong test · the patch did not
- * land · the set is too narrow · the run was already red BEFORE the mutation. The last is closed
- * by the baseline run below.
- *
- * ⚠️ WHY THESE HOOKS ARE WORTH A BATTERY MORE THAN MOST. Two of the three are ADVISORY — silence
- * is their success state — and the third is a `PreToolUse` gate whose failure mode is to refuse
- * EVERYTHING. In both directions the broken state resembles the working one from outside: a
- * silent nudge looks like a clean edit, and a gate that refuses everything looks like a gate
- * doing its job until you notice `echo hi` is also blocked. The harness is the only instrument
- * that tells them apart, so the harness itself needs one.
- *
- * 🔴 ONE MUTATION IS DELIBERATELY ABSENT, and naming it is part of the record: replacing
- * `require.resolve("<this package>/hooks/paper-status-gates.sh")` with a hard-coded
- * `node_modules/<name>/hooks/…` path is NOT KILLABLE here, because the harness's fixture
- * consumer installs this package at exactly that path (a symlink, which is what `npm install`
- * of a local package produces). The mutant would be wrong for a consumer using an install alias
- * or a pnpm layout, and right for every fixture. Rather than assert it with a test that cannot
- * fail, it is left out and written down.
- *
- * 🔴 A SECOND ABSENCE, and this one CHANGED THE SOURCE. The nudge used to normalise the papers
- * root to one trailing slash, with a comment claiming `under()` needed it. The mutation that
- * removed the normalise left the harness GREEN — and the cause was none of the six ranked above:
- * the CLAIM was false. vigiles normalises a prefix itself (`normalizePrefix` →
- * `trimTrailingSeparators`), so the line defended nothing. It was deleted rather than given a
- * test, because a line no mutation can kill is a line documenting a defence that does not exist.
- * The guard keeps ITS normalise — that one hand-writes `startsWith(p + "/")` and is killable,
- * and the mutation for it is below.
- */
-import { readFileSync, writeFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-
-const HARNESS = "hooks/hooks.harness.mjs";
-const GUARD = "hooks/paper-edit-guard.hook.mjs";
-const NUDGE = "hooks/paper-skills-nudge.hook.mjs";
-const GATES = "hooks/paper-status-gates.hook.mjs";
-const SH = "hooks/paper-status-gates.sh";
-
-// Coverage mode — see `scripts/run-mutations.mjs` guard 2. Says what this battery can kill,
-// without touching a file.
-if (process.env.MUTATIONS_REPORT_COVERAGE) {
-  console.log(`MUTATION-COVERS\t${HARNESS}`);
-  process.exit(0);
-}
-
-/** [file, label, what it would break, from, to] */
-const M = [
-  // ── the carrier, in the GATE, where an unreadable root must REFUSE ──────────
-  [
-    GUARD,
-    "guard carrier/null read as absence",
-    'go back to `??` — an explicit `"papersDir": null` is read as «nothing was declared» and ' +
-      "silently falls back to the default, i.e. a typed keystroke treated as an absence",
-    '  const root = declared === undefined ? DEFAULT_PAPERS_ROOT : declared;\n  if (typeof root !== "string" || root.length === 0)\n    return deny(',
-    '  const root = declared ?? DEFAULT_PAPERS_ROOT;\n  if (typeof root !== "string" || root.length === 0)\n    return deny(',
-  ],
-  [
-    GUARD,
-    "guard carrier/empty root accepted",
-    "accept any string including the empty one — every prefix test becomes vacuous and the gate " +
-      "passes every paper write while still looking installed",
-    '  if (typeof root !== "string" || root.length === 0)\n    return deny(',
-    '  if (typeof root !== "string")\n    return deny(',
-  ],
-  [
-    GUARD,
-    "guard carrier/parse failure DEFAULTS instead of denying",
-    "treat an unreadable paperlint.json as «nothing declared» — the measured failure: the provider " +
-      "hands back the EMPTY STRING in silence, so the gate quietly re-roots at the default",
-    "  } catch {\n    return deny(\n      `${CONFIG_KEY}: this gate could not read",
-    "  } catch {\n    config = {};\n    void deny(\n      `${CONFIG_KEY}: this gate could not read",
-  ],
-  [
-    GUARD,
-    "guard carrier/trailing slash not normalised",
-    'keep the slash the consumer typed — `prefix + "/"` becomes `//`, which matches NOTHING, ' +
-      "and the gate is a silent no-op (this exact defect shipped once)",
-    '  return root.replace(/\\/+$/, "");\n};',
-    "  return root;\n};",
-  ],
-  // ── the guard's four measured bypasses ──────────────────────────────────────
-  [
-    GUARD,
-    "guard/redirection targets invisible",
-    "stop scanning redirections — `echo x > paper.md` is the canonical write and its target is " +
-      "not an argv token, so `touches` cannot see it",
-    "    const hits = writesViaArgv || redirectsInto(e.command.raw, PAPER_SOURCES);",
-    "    const hits = writesViaArgv;",
-  ],
-  [
-    GUARD,
-    "guard/quoted path deleted instead of unquoted",
-    "go back to DELETING quoted spans — a quoted path vanishes before it can be matched, and the " +
-      "gate was one quote from open",
-    '    .replace(/\'([^\']*)\'/g, "$1")\n    .replace(/"((?:[^"\\\\]|\\\\.)*)"/g, "$1");',
-    '    .replace(/\'([^\']*)\'/g, "")\n    .replace(/"((?:[^"\\\\]|\\\\.)*)"/g, "");',
-  ],
-  [
-    GUARD,
-    "guard/the mutator list loses `sed -i`",
-    "drop the commonest in-place editor from MUTATORS — the write is no longer recognised as a " +
-      "write, so `sed -i` on a paper sails past the gate that exists for it",
-    'const MUTATORS = [\n  "sed -i",\n',
-    "const MUTATORS = [\n",
-  ],
-  [
-    GUARD,
-    "guard/the whole subtree guarded, not just sources",
-    "drop the extension filter — copying a script into a paper's repro bundle is denied, which is " +
-      "ordinary work being refused, and a guard that refuses ordinary work gets muted",
-    // 🔴 The target moved on 09-16: `isPaperSource` was split into "not a snapshot" AND "has a
-    // source extension" once `versions/` got its carve-out. This mutation targets exactly the
-    // EXTENSION FILTER — removing the carve-out is a different property with its own mutation
-    // below.
-    'const hasSourceExtension = (p) =>\n  p.endsWith(".tex") ||\n  /\\/(paper|draft)\\.md$/.test(p) ||\n  /^(paper|draft)\\.md$/.test(p);',
-    "const hasSourceExtension = (p) => p.length > 0;",
-  ],
-  [
-    GUARD,
-    "guard/manifest read goes relative again",
-    "drop the anchor to the project root — the read fails once cwd drifts, and under the rule " +
-      '"an unreadable declaration denies" the guard blocks ANY Bash command, including the one ' +
-      "that would fix it",
-    'const READ_CONFIG = `f="\\${CLAUDE_PROJECT_DIR:-.}/${CONFIG_FILE}";',
-    'const READ_CONFIG = `f="${CONFIG_FILE}";',
-  ],
-  [
-    "hooks/paper-skills-nudge.hook.mjs",
-    "nudge/manifest read goes relative again",
-    "the same defect in the SIBLING, and the failure there is the OPPOSITE one: a PostToolUse " +
-      "hook does not deny, it returns `nothing()` — i.e. it just quietly stops firing. Silence " +
-      "is exactly what a nudge's success state looks like, so a dead hook is indistinguishable " +
-      "from a working one except by this mutation",
-    'const READ_CONFIG = `f="\\${CLAUDE_PROJECT_DIR:-.}/${CONFIG_FILE}";',
-    'const READ_CONFIG = `f="${CONFIG_FILE}";',
-  ],
-  [
-    GUARD,
-    "guard/versions/ carve-out stops exempting",
-    "remove the exemption for frozen snapshots — an archival record under `versions/` is denied " +
-      "again, and there is nothing left to restore the paper's source from: the gate locks down " +
-      "an immutable artifact while leaving the live `paper.tex` it exists to protect open",
-    "const isPaperSource = (p) => !isFrozenSnapshot(p) && hasSourceExtension(p);",
-    "const isPaperSource = (p) => hasSourceExtension(p);",
-  ],
-  [
-    GUARD,
-    "guard/versions/ carve-out becomes WIDER than it should",
-    "declare anything a snapshot — the carve-out swallows the live `paper.tex`, and the guard " +
-      "stops being a guard while still looking installed. Paired with the previous one: one " +
-      "proves the exemption EXISTS, the other proves it does not overreach into what it " +
-      "protects",
-    "const isFrozenSnapshot = (p) => /(^|\\/)versions\\/[^/]+$/.test(p);",
-    "const isFrozenSnapshot = () => true;",
-  ],
-  [
-    GUARD,
-    "guard/the read-vs-write conjunct dropped",
-    "remove `runsMutator` — `cat <root>/x/paper.tex` touches a paper and names a paper source, so " +
-      "a plain READ is denied (this happened, and it cost real work)",
-    "      runsMutator(e.command) &&\n      (e.command.writesTo(PAPER_SOURCES)",
-    "      (e.command.writesTo(PAPER_SOURCES)",
-  ],
-  // ── the nudge: it must LAND, and only for a paper ───────────────────────────
-  [
-    NUDGE,
-    "nudge/fires on everything",
-    "drop the path test — the checklist lands on every Edit anywhere, which is how an advisory " +
-      "hook gets muted and then stays muted when it matters",
-    "    return e.path.under([root]) && isPaperSource(e.path.raw)\n      ? notice(CHECKLIST)\n      : nothing();",
-    "    return notice(CHECKLIST);",
-  ],
-  [
-    NUDGE,
-    "nudge/every file under the root is a paper",
-    "drop the source-shape test — a README or a note under the papers root gets the pre-submit " +
-      "checklist",
-    "    return e.path.under([root]) && isPaperSource(e.path.raw)\n      ? notice(CHECKLIST)\n      : nothing();",
-    "    return e.path.under([root])\n      ? notice(CHECKLIST)\n      : nothing();",
-  ],
-  [
-    NUDGE,
-    "nudge carrier/null read as absence",
-    "`??` again, in this hook's own copy of the carrier — the nudge starts firing about the " +
-      "default tree the consumer never named",
-    '  const root = declared === undefined ? DEFAULT_PAPERS_ROOT : declared;\n  if (typeof root !== "string" || root.length === 0) return null;',
-    '  const root = declared ?? DEFAULT_PAPERS_ROOT;\n  if (typeof root !== "string" || root.length === 0) return null;',
-  ],
-  // ── the gates hook: anchors, escaping, and the name that reaches a shell ────
-  [
-    GATES,
-    "gates/the root is not regex-escaped",
-    "interpolate the declared root raw — a `.` in it becomes a wildcard, so the hook fires about " +
-      "a sibling tree whose name merely resembles the declared one",
-    '`(?:^|/)${root.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&")}/([A-Za-z0-9._-]+)/',
-    "`(?:^|/)${root}/([A-Za-z0-9._-]+)/",
-  ],
-  [
-    GATES,
-    "gates/the `(?:^|/)` boundary removed",
-    "anchor with a bare `^` — the live harness sends ABSOLUTE paths, so the hook would be dead in " +
-      "production and green in any test that builds relative ones",
-    "    `(?:^|/)${root.replace(",
-    "    `^${root.replace(",
-  ],
-  [
-    GATES,
-    "gates/the directory charclass widened",
-    "accept any non-slash directory name — a name carrying `;` or a space reaches a `run()` " +
-      "command string, and `run()` goes through a shell",
-    "/([A-Za-z0-9._-]+)/(?:[^/]*",
-    "/([^/]+)/(?:[^/]*",
-  ],
-  [
-    GATES,
-    "gates carrier/null read as absence",
-    "`??` in the third copy of the carrier — the hook surfaces a status file from the default tree",
-    '  const root = declared === undefined ? DEFAULT_PAPERS_ROOT : declared;\n  if (typeof root !== "string" || root.length === 0) return null;',
-    '  const root = declared ?? DEFAULT_PAPERS_ROOT;\n  if (typeof root !== "string" || root.length === 0) return null;',
-  ],
-  // ── the tool ───────────────────────────────────────────────────────────────
-  [
-    SH,
-    "sh/the papers root hard-coded again",
-    "put the literal back — the tool serves exactly one consumer's layout, which is the thing the " +
-      "extraction exists to undo",
-    'papers_root="$(read_key papersDir papers)"',
-    'papers_root="papers"',
-  ],
-  [
-    SH,
-    "sh/the defence-in-depth name check removed",
-    "trust the hook's validation — the file stops being safe to call directly, and it is a " +
-      "documented entry point",
-    '  *[!A-Za-z0-9._-]* | "" | . | ..) exit 0 ;;',
-    '  "") exit 0 ;;',
-  ],
-  [
-    SH,
-    "sh/answers to being called as a hook",
-    "drop the usage branch — the file silently does nothing when misused instead of saying it is " +
-      "a tool, which is how it was misregistered as a hook before",
-    '  echo "paper-status-gates.sh: a tool, not a hook. Use --surface <paper-dir>." >&2',
-    "  : >&2",
-  ],
-];
-
-const runHarness = () => {
-  try {
-    execFileSync("npx", ["vigiles", "test", HARNESS], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    return { failed: false, out: "" };
-  } catch (e) {
-    return { failed: true, out: (e.stdout ?? "") + (e.stderr ?? "") };
-  }
-};
-
-// 🔴 A BASELINE RUN BEFORE ANY MUTATION. A red harness makes EVERY mutation look "killed", and
-// the battery would print a confident green verdict about a defence that is not there.
-{
-  const base = runHarness();
-  if (base.failed) {
-    console.log(
-      "❌ THE HARNESS IS RED BEFORE ANY MUTATION — the battery cannot tell a killed mutation " +
-        "from that:\n" +
-        base.out.slice(-1500),
-    );
-    process.exit(1);
-  }
-}
-
-let ok = 0;
-let bad = 0;
-const rows = [];
-for (const [file, label, what, from, to] of M) {
-  const pristine = readFileSync(file, "utf8");
-  const hits = pristine.split(from).length - 1;
-  if (hits !== 1) {
-    console.log(
-      `❌ ${label}: TARGET ${hits === 0 ? "NOT FOUND" : `NOT UNIQUE (${hits})`} in ${file} — ${from.slice(0, 70)}`,
-    );
-    bad++;
-    continue;
-  }
-  writeFileSync(file, pristine.replace(from, to));
-  const on = readFileSync(file, "utf8");
-  if (!on.includes(to) || on.includes(from)) {
-    console.log(
-      `❌ ${label}: THE MUTATION DID NOT LAND (checked by re-reading ${file})`,
-    );
-    bad++;
-    writeFileSync(file, pristine);
-    continue;
-  }
-  const { failed, out } = runHarness();
-  writeFileSync(file, pristine);
-  if (readFileSync(file, "utf8") !== pristine) {
-    console.log(`❌ ${label}: THE ROLLBACK FAILED on ${file}`);
-    bad++;
-    continue;
-  }
-  // The verdict carries the assertion text: "killed" without saying by what is half an answer.
-  const at = (out.match(/hooks\.harness\.mjs:(\d+)/) ?? [])[1];
-  const msg =
-    (out.match(/AssertionError[^:]*: ([^\n]+)/) ?? [])[1] ??
-    (out.match(/((?:Error|ENOENT|SyntaxError)[^\n]*)/) ?? [])[1] ??
-    "";
-  const where = (at ? `harness:${at} · ` : "") + msg;
-  if (failed) {
-    ok++;
-    rows.push([label, what, where.trim().slice(0, 130)]);
-  } else {
-    console.log(
-      `🔴 ${label}: THE HARNESS IS GREEN UNDER THE MUTATION — a finding about the TEST, not a ` +
-        `conclusion about the defence`,
-    );
-    bad++;
-  }
-}
-console.log("\n| property | mutation | what the harness died on |");
-console.log("|---|---|---|");
-for (const [a, b, c] of rows)
-  console.log(`| \`${a}\` | ${b} | ${c.replace(/\|/g, "\\|")} |`);
-console.log(`\n${ok} mutation(s) killed, ${bad} problem(s)`);
-process.exit(bad ? 1 : 0);

package/lib/agent-cli-version.mutations.mjs

@@ -1,109 +0,0 @@
-/**
- * Battery for `observeAgentCli`. Five mutations, five different assertions.
- *
- * 🔴 The first one is the issue #7 defect itself, restored verbatim: bring back
- * `stdio: "ignore"`. It is the whole point of this battery. Before the observation was pulled
- * out into its own module, there was NOWHERE to place this mutation: the spawn was baked into
- * the harness, which brings up the real CLI, and "ask the binary to print nothing" is not
- * something you can do. A green battery against a baked-in spawn would have been a finding
- * about the test, not about the defense.
- */
-import { fileURLToPath } from "node:url";
-import { dirname, join, resolve } from "node:path";
-import { runMutations } from "./mutation-driver.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(HERE, "..");
-const MOD = join(HERE, "agent-cli-version.mjs");
-const HARNESS = join(HERE, "agent-cli-version.harness.mjs");
-
-process.exit(
-  runMutations({
-    root: ROOT,
-    runner: "node",
-    cases: [
-      {
-        name: '🔴 revert to `stdio: "ignore"` — the issue #7 defect verbatim',
-        harness: HARNESS,
-        // ⚠️ The assertion this trips is NOT the one I was aiming for, and this was corrected
-        // BY RUNNING IT, not from memory. The double hands back stdout regardless of the
-        // options, so the observation succeeds, and the first thing to go red is the
-        // `encoding` assertion. The `stdio` assertion itself is hit by the next case.
-        expect: "without an encoding the output is a Buffer nobody reads",
-        disables:
-          "the observation itself — the version is printed into the void again, and the tier characterizes nothing",
-        edits: [
-          [
-            MOD,
-            'spawnSync(program, ["--version"], { encoding: "utf8" })',
-            'spawnSync(program, ["--version"], { stdio: "ignore" })',
-          ],
-        ],
-      },
-      {
-        name: '`stdio: "ignore"` added ALONGSIDE encoding — output still goes nowhere',
-        harness: HARNESS,
-        expect: "is the discarded-output defect itself",
-        disables:
-          "the second call-shape assertion: `encoding` is present, but the stream is still killed",
-        edits: [
-          [
-            MOD,
-            'spawnSync(program, ["--version"], { encoding: "utf8" })',
-            'spawnSync(program, ["--version"], { encoding: "utf8", stdio: "ignore" })',
-          ],
-        ],
-      },
-      {
-        name: "empty stdout at exit code 0 stops being a failure",
-        harness: HARNESS,
-        expect: "must fail loudly, not be reported as a version",
-        disables:
-          "rule 4 — `exit 0` with empty output reads as a clean measurement again",
-        edits: [[MOD, 'if (version === "")', "if (false)"]],
-      },
-      {
-        name: "drift is computed as a constant, not a comparison",
-        harness: HARNESS,
-        expect: "must be computed, not eyeballed",
-        disables:
-          "the comparison of observed against characterized — the divergence becomes invisible again",
-        edits: [
-          [
-            MOD,
-            "const drifted = version !== characterized;",
-            "const drifted = false;",
-          ],
-        ],
-      },
-      {
-        name: "only one of the two numbers survives into the message",
-        harness: HARNESS,
-        expect: "must name BOTH numbers",
-        disables:
-          "showing the divergence — the reader is back to having to remember the second number",
-        edits: [
-          [
-            MOD,
-            "`observed \\`${program}\\` ${version} — the assertions here were characterized against ` +\n        `${characterized}.",
-            "`observed \\`${program}\\` ${version} — characterized elsewhere.",
-          ],
-        ],
-      },
-      {
-        name: "the version is not parsed out of the string, taken whole instead",
-        harness: HARNESS,
-        expect: "must be PARSED out of the line, not left raw",
-        disables:
-          "parsing the version string — `2.1.273 (Claude Code)` stops being comparable to `2.1.227`",
-        edits: [
-          [
-            MOD,
-            'const version = VERSION_IN.exec(raw)?.[1] ?? "";',
-            "const version = raw;",
-          ],
-        ],
-      },
-    ],
-  }),
-);

package/lib/mutation-driver.harness.mjs

@@ -1,227 +0,0 @@
-/**
- * `runMutations` — three harness outcomes, not two.
- *
- * ── WHY THIS FILE SHOWED UP LAST, NOT FIRST ────────────────────────────
- * The engine that renders a verdict for EVERY battery in the repository was, until 2026-09-15,
- * checked by nothing. Every one of its defenses (a harness path pointing at nothing · a no-op
- * mutation · retrying a non-kill · a baseline of already-red harnesses) was written AFTER it
- * caught a real defect, and none of them had a test. So the next defect of the same class
- * arrived in CI and was read as "two mutations survived".
- *
- * The third outcome — SKIP — is pinned down here. The fixtures are real: the skipping harness
- * calls `skip()` FROM vigiles rather than faking it with exit code 77 by hand, because the
- * latter would test my mental model of the protocol instead of the protocol itself.
- */
-import assert from "node:assert/strict";
-import {
-  mkdtempSync,
-  writeFileSync,
-  readFileSync,
-  rmSync,
-  realpathSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-import { recordCheck } from "vigiles";
-import { runMutations } from "./mutation-driver.mjs";
-
-// The fixture lives in a temp directory where `node` will not find `vigiles` by walking up
-// the tree. The specifier is resolved HERE, by node's own resolver, and substituted in
-// absolute — that way the skip is done by a real `skip()`, not an imitation via exit code 77.
-// An imitation would test my mental model of the protocol instead of the protocol itself.
-const VIGILES = pathToFileURL(
-  createRequire(import.meta.url).resolve("vigiles"),
-).href;
-
-const SUBJECT = "export const MARKER = 'keep-me';\n";
-const cases = [];
-
-/** Temp root: a fixture subject + the harness that judges it. */
-function fixture(harnessBody) {
-  const root = realpathSync(mkdtempSync(join(tmpdir(), "mutdrv-")));
-  const subject = join(root, "subject.mjs");
-  const harness = join(root, "probe.harness.mjs");
-  writeFileSync(subject, SUBJECT);
-  writeFileSync(harness, harnessBody(subject));
-  return { root, subject, harness };
-}
-
-const quiet = { log: console.log, error: console.error };
-/** The verdict is read from the exit code and output, so the driver's output is intercepted. */
-function silently(fn) {
-  const lines = [];
-  console.log = console.error = (...a) => lines.push(a.join(" "));
-  try {
-    return { code: fn(), out: lines.join("\n") };
-  } finally {
-    console.log = quiet.log;
-    console.error = quiet.error;
-  }
-}
-
-// ── 1. THE HARNESS SKIPS ⇒ the battery REFUSES, rather than declaring the mutation survived.
-// Observed failure (run 34966606186): CI had no `claude` binary, the harness skipped,
-// `vigiles test` returned 0, and the driver printed "🔴 SURVIVED" — a claim about the TEST
-// that was really a claim about the ENVIRONMENT.
-{
-  const { root, subject, harness } = fixture(
-    () =>
-      `import { skip } from ${JSON.stringify(VIGILES)};\nskip("fixture: the capability this tier observes is absent");\n`,
-  );
-  try {
-    const before = readFileSync(subject, "utf8");
-    const { code, out } = silently(() =>
-      runMutations({
-        root,
-        runner: "node",
-        cases: [
-          {
-            name: "marker removed",
-            harness,
-            expect: "MARKER",
-            disables: "fixture",
-            edits: [[subject, "keep-me", "gone"]],
-          },
-        ],
-      }),
-    );
-    assert.equal(code, 2, `a skip must REFUSE, not judge; got ${code}\n${out}`);
-    assert.doesNotMatch(
-      out,
-      /SURVIVED/,
-      "and not claim a survived mutation — that's a false diagnosis",
-    );
-    assert.match(
-      out,
-      /SKIP on clean source/,
-      "the refusal must name the cause",
-    );
-    assert.match(
-      out,
-      /probe\.harness\.mjs/,
-      "and name WHICH harness is skipping",
-    );
-    assert.equal(
-      readFileSync(subject, "utf8"),
-      before,
-      "the refusal must happen BEFORE any file is edited — the message arrives with a clean tree",
-    );
-    cases.push(
-      "harness skips → refusal before editing files, no verdict about the mutation",
-    );
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-}
-
-// ── 2. THE HARNESS WORKS ⇒ the prior behavior is intact. Without this half, case 1 is
-// indistinguishable from an engine that just always refuses.
-{
-  const { root, subject, harness } = fixture(
-    (s) =>
-      `import assert from "node:assert/strict";\nimport { readFileSync } from "node:fs";\nassert.match(readFileSync(${JSON.stringify(s)}, "utf8"), /keep-me/, "MARKER is gone");\n`,
-  );
-  try {
-    const { code, out } = silently(() =>
-      runMutations({
-        root,
-        runner: "node",
-        cases: [
-          {
-            name: "marker removed",
-            harness,
-            expect: "MARKER is gone",
-            disables: "fixture",
-            edits: [[subject, "keep-me", "gone"]],
-          },
-        ],
-      }),
-    );
-    assert.equal(
-      code,
-      0,
-      `a working harness must kill the mutation; got ${code}\n${out}`,
-    );
-    assert.match(
-      out,
-      /RED \(expected case\)/,
-      "and kill it with ITS OWN message, not just any red",
-    );
-    assert.equal(
-      readFileSync(subject, "utf8"),
-      SUBJECT,
-      "the source must be restored",
-    );
-    cases.push(
-      "harness works → mutation killed by its own assertion, source restored",
-    );
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-}
-
-// ── 3. THE PATCH NEVER LANDED ⇒ that is NOT a survived mutation. The third outcome, and until
-// 09-17 the engine dumped it into the second one: anything that was not `RED (expected` counted
-// as survived — including NOT FOUND, AMBIGUOUS and NO-OP, where the file was never edited at all.
-//
-// 🔴 The two verdicts send the reader in OPPOSITE directions: survived means STRENGTHEN THE
-// TEST, unusable means FIX THE MUTATION. Observed the same day: a `find` string went stale
-// after the rule was rewritten, the engine reported "1 mutation survived", and the next step
-// would have been rewriting a harness that was fine.
-{
-  const { root, subject, harness } = fixture(
-    (s) =>
-      `import assert from "node:assert/strict";\nimport { readFileSync } from "node:fs";\nassert.match(readFileSync(${JSON.stringify(s)}, "utf8"), /keep-me/, "MARKER is gone");\n`,
-  );
-  try {
-    const { code, out } = silently(() =>
-      runMutations({
-        root,
-        runner: "node",
-        cases: [
-          {
-            name: "stale target",
-            harness,
-            expect: "MARKER is gone",
-            disables: "fixture",
-            // The string is not in the file — exactly the case of a stale target.
-            edits: [[subject, "no-such-string-anywhere", "x"]],
-          },
-        ],
-      }),
-    );
-    assert.equal(
-      code,
-      1,
-      `an unusable mutation must REFUSE the run; got ${code}\n${out}`,
-    );
-    assert.match(
-      out,
-      /UNUSABLE/,
-      "the verdict must be named unusable, not survived",
-    );
-    assert.match(
-      out,
-      /NOT FOUND/,
-      "and name the CAUSE — what exactly was not found",
-    );
-    assert.doesNotMatch(
-      out,
-      /mutation\(s\) survived/,
-      "and must NOT claim a survived mutation: that would send someone to fix a working test",
-    );
-    cases.push(
-      'patch never landed → UNUSABLE with a cause, not "mutation survived"',
-    );
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-}
-
-// Report to the tool, or the surface counts as UNCOVERED despite a working test —
-// "0 checks" and "no test" look identical in the ledger.
-recordCheck(cases.length);
-console.log(`mutation-driver: ${cases.length} outcome(s) pinned down:`);
-for (const c of cases) console.log(`  ok  ${c}`);