paperlint 3.1.0 → 3.1.1

package/scripts/mutation-batteries.frozen.json

@@ -1,108 +0,0 @@
-{
-  "issue": "https://github.com/zernie/paperlint/issues/52",
-  "why": "Hand-written *.mutations.mjs batteries are being removed (#52). This list may only shrink: no new batteries, no new cases in existing ones. Delete a battery or a case, then delete its entry or lower its count here. Checked by scripts/mutation-batteries-frozen.mjs, part of npm run check.",
-  "batteries": {
-    "action.mutations.mjs": {
-      "cases": 6
-    },
-    "eslint-rules/install-path-literals.mutations.mjs": {
-      "cases": 3
-    },
-    "eslint-rules/latex-language.mutations.mjs": {
-      "cases": 12
-    },
-    "eslint-rules/paper-research-question.mutations.mjs": {
-      "cases": 6
-    },
-    "eslint-rules/paper-stages.mutations.mjs": {
-      "cases": 4
-    },
-    "eslint-rules/papers.mutations.mjs": {
-      "cases": 10
-    },
-    "eslint-rules/temp-root-realpath.mutations.mjs": {
-      "cases": 5
-    },
-    "eslint-rules/tex-build.mutations.mjs": {
-      "cases": 21
-    },
-    "fixtures/real-markdown-paper/real-markdown-paper.mutations.mjs": {
-      "cases": 3
-    },
-    "hooks/hooks.mutations.mjs": {
-      "cases": 23
-    },
-    "lib/agent-cli-version.mutations.mjs": {
-      "cases": 6
-    },
-    "lib/mutation-driver.mutations.mjs": {
-      "cases": 3
-    },
-    "lib/paper-config.mutations.mjs": {
-      "cases": 7
-    },
-    "lib/skill-trigger-cases.mutations.mjs": {
-      "cases": 3
-    },
-    "scripts/check.mutations.mjs": {
-      "cases": 5
-    },
-    "scripts/rules-are-content-only.mutations.mjs": {
-      "cases": 3
-    },
-    "scripts/rules-see-files.mutations.mjs": {
-      "cases": 2
-    },
-    "skills/paper-pipeline/scripts/artifact-coverage.mutations.mjs": {
-      "cases": 22
-    },
-    "skills/paper-pipeline/scripts/consumer.mutations.mjs": {
-      "cases": 14
-    },
-    "skills/paper-pipeline/scripts/extract-ref-facts.mutations.mjs": {
-      "cases": 1
-    },
-    "skills/paper-pipeline/scripts/generated-code.mutations.mjs": {
-      "cases": 25
-    },
-    "skills/paper-pipeline/scripts/pipeline-check.mutations.mjs": {
-      "cases": 1
-    },
-    "skills/paper-pipeline/scripts/population-map.mutations.mjs": {
-      "cases": 2
-    },
-    "skills/paper-pipeline/scripts/provenance.mutations.mjs": {
-      "cases": 2
-    },
-    "skills/paper-pipeline/scripts/round-diff.mutations.mjs": {
-      "cases": 28
-    },
-    "skills/plan-paper-timeline/plan-paper-timeline.effects.mutations.mjs": {
-      "cases": 2
-    },
-    "skills/skill-contract.mutations.mjs": {
-      "cases": 22
-    },
-    "src/build.mutations.mjs": {
-      "cases": 11
-    },
-    "src/cli.mutations.mjs": {
-      "cases": 25
-    },
-    "src/doctor.mutations.mjs": {
-      "cases": 10
-    },
-    "src/hooks-settings.mutations.mjs": {
-      "cases": 6
-    },
-    "src/link-skills.mutations.mjs": {
-      "cases": 6
-    },
-    "src/new-paper.mutations.mjs": {
-      "cases": 3
-    },
-    "src/structure.mutations.mjs": {
-      "cases": 4
-    }
-  }
-}

package/scripts/rules-are-content-only.mutations.mjs

@@ -1,81 +0,0 @@
-/**
- * Battery for the "rule does not touch git" gate, `scripts/rules-are-content-only.mjs`.
- *
- * 🔴 This battery needs to be sharper than the rule. Its success state is an EMPTY LIST, which is
- * exactly the state it teaches not to trust. A check seen only silent is indistinguishable from
- * one that never looks.
- *
- * BOTH DIRECTIONS, and they must die on DIFFERENT assertions:
- *   - `undercatch` — stops finding anything. The "quiet on clean" half stays green;
- *     the "fires" half must fail.
- *   - `overcatch` — calls any spawner a finding. The "fires" half stays green
- *     (it still sees `git`), the "quiet on clean" half must fail. MEASURED: it breaks on
- *     LIVE CORPUS (6 findings in the package's own rules) before a planted fixture with
- *     `texcount` — and that is stronger, not weaker: real data.
- * A battery where both mutations die on one assertion proves ONE half exists.
- *
- * ⚠️ The second mutation reproduces a REAL false positive: the first version of the check
- * was keyed on the `child_process` import and in the first hour called `paper-texcount.mjs`
- * a finding in the consumer — it calls `texcount` to count words. On an `error` gate this is
- * worse than a miss: a gate you cannot pass gets turned off. The mutation holds this line.
- */
-import { fileURLToPath } from "node:url";
-import { dirname, join, resolve } from "node:path";
-import { runMutations } from "../lib/mutation-driver.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(HERE, "..");
-const GUARD = join(HERE, "rules-are-content-only.mjs");
-const HARNESS = join(HERE, "rules-are-content-only.harness.mjs");
-
-process.exit(
-  runMutations({
-    root: ROOT,
-    runner: "node",
-    cases: [
-      {
-        name: "undercatch — check stops finding",
-        harness: HARNESS,
-        expect: "FIRES on execFileSync with a git argv",
-        disables:
-          "the verdict itself: the check becomes that very confident green zero it was written " +
-          "to spot — it scans, counts files and renders no judgment",
-        edits: [
-          [
-            GUARD,
-            "if (SPAWNERS.has(String(name)) && isGit(n.arguments?.[0]?.value))",
-            "if (false && SPAWNERS.has(String(name)) && isGit(n.arguments?.[0]?.value))",
-          ],
-        ],
-      },
-      {
-        name: "overcatch — any spawner call becomes a finding",
-        harness: HARNESS,
-        // Fails on LIVE CORPUS, not on the texcount fixture, and this is measured: under this mutation
-        // the package's own rules yield 6 findings, meaning the "quiet on clean" half breaks
-        // before we reach the planted case. Live signal is stronger than fixture — it is real data — so
-        // it is named, not the one I expected to see.
-        expect: "quiet on the real corpus",
-        disables:
-          "the boundary of the predicate 'calls git' vs 'spawns a process' — the one that was " +
-          "set after the texcount false positive in the consumer",
-        edits: [
-          [
-            GUARD,
-            "if (SPAWNERS.has(String(name)) && isGit(n.arguments?.[0]?.value))",
-            "if (SPAWNERS.has(String(name)))",
-          ],
-        ],
-      },
-      {
-        name: "guard for empty scan stops failing",
-        harness: HARNESS,
-        expect: "scanned something",
-        disables:
-          "the answer to 'did you even look': zero found sources become silent success again, " +
-          "indistinguishable from a clean run",
-        edits: [[GUARD, 'f.endsWith(".mjs") &&', "false &&"]],
-      },
-    ],
-  }),
-);

package/scripts/rules-see-files.mutations.mjs

@@ -1,131 +0,0 @@
-/**
- * Mutation battery for the guard against a green zero, `scripts/rules-see-files.mjs`.
- * Run: `node scripts/rules-see-files.mutations.mjs` (not `vigiles test` — not a harness).
- *
- * 🔴 WHY THIS GUARD NEEDS A MUTATION BATTERY MORE THAN ANYTHING ELSE HERE. Its success state
- * is an empty list, which is the exact state it was built to distrust. A guard that has only
- * been observed quiet is indistinguishable from a guard that does nothing — that is the whole
- * premise of the thing being guarded, applied to the guard itself.
- *
- * BOTH DIRECTIONS, one mutation each, and they must die on DIFFERENT assertions:
- *   - `under-report` makes the guard incapable of ever calling a rule blind. The quiet half of
- *     its harness stays green; the FIRING half must go red.
- *   - `over-report` makes it call everything blind. The firing half stays green (it still names
- *     `probe/dead`, among others); the QUIET half must go red.
- * A battery in which both mutations died on the same assertion would prove only that one of the
- * two halves exists.
- */
-import { readFileSync, writeFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-
-const GUARD = "scripts/rules-see-files.mjs";
-const HARNESS = "scripts/rules-see-files.harness.mjs";
-
-// Coverage mode — see `scripts/run-mutations.mjs` guard 2.
-if (process.env.MUTATIONS_REPORT_COVERAGE) {
-  console.log(`MUTATION-COVERS\t${HARNESS}`);
-  process.exit(0);
-}
-
-const PRISTINE = readFileSync(GUARD, "utf8");
-
-const M = [
-  [
-    "under-report",
-    "never call a rule blind — the guard becomes the silent green it exists to catch",
-    "blind: rules.filter((r) => r.files === 0).map((r) => r.rule)",
-    "blind: [] /* MUT */",
-  ],
-  [
-    "over-report",
-    "call every rule blind — the guard becomes noise, and noise gets switched off within a day",
-    "      if (effective.rules?.[id] && !isOff(effective.rules[id]))\n        seen.set(id, seen.get(id) + 1);",
-    "      if (false)\n        seen.set(id, seen.get(id) + 1); /* MUT */",
-  ],
-];
-
-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 ?? "") };
-  }
-};
-
-{
-  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 [label, what, from, to] of M) {
-  const hits = PRISTINE.split(from).length - 1;
-  if (hits !== 1) {
-    console.log(
-      `❌ ${label}: TARGET ${hits === 0 ? "NOT FOUND" : `NOT UNIQUE (${hits})`} — ${from.slice(0, 70)}`,
-    );
-    bad++;
-    continue;
-  }
-  writeFileSync(GUARD, PRISTINE.replace(from, to));
-  const on = readFileSync(GUARD, "utf8");
-  if (!on.includes(to) || on.includes(from)) {
-    console.log(
-      `❌ ${label}: THE MUTATION DID NOT LAND (checked by re-reading the file)`,
-    );
-    bad++;
-    writeFileSync(GUARD, PRISTINE);
-    continue;
-  }
-  const { failed, out } = runHarness();
-  writeFileSync(GUARD, PRISTINE);
-  if (readFileSync(GUARD, "utf8") !== PRISTINE) {
-    console.log(`❌ ${label}: THE ROLLBACK FAILED`);
-    bad++;
-    continue;
-  }
-  const at = (out.match(/rules-see-files\.harness\.mjs:(\d+)/) ?? [])[1];
-  const msg = (out.match(/AssertionError[^:]*: ([^\n]+)/) ?? [])[1] ?? "";
-  if (failed) {
-    ok++;
-    rows.push([
-      label,
-      what,
-      ((at ? `harness:${at} · ` : "") + msg).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 guard`,
-    );
-    bad++;
-  }
-}
-console.log("\n| direction | mutation | what the harness died on |");
-console.log("|---|---|---|");
-for (const [a, b, c] of rows)
-  console.log(`| \`${a}\` | ${b} | ${c.replace(/\|/g, "\\|")} |`);
-// The two must die on DIFFERENT lines, or only one half of the guard is actually tested.
-const lines = rows.map(
-  ([, , where]) => (where.match(/harness:(\d+)/) ?? [])[1],
-);
-if (rows.length === 2 && lines[0] && lines[0] === lines[1]) {
-  console.log(
-    "\n🔴 BOTH mutations died on the SAME assertion — only one half of the guard is tested",
-  );
-  bad++;
-}
-console.log(`\n${ok} mutation(s) killed, ${bad} problem(s)`);
-process.exit(bad ? 1 : 0);

package/scripts/run-mutations.mjs

@@ -1,100 +0,0 @@
-/**
- * run-mutations.mjs — run EVERY mutation battery in the repository, found rather than listed.
- *
- * ── WHY THIS EXISTS, AND IT IS NOT TIDINESS ─────────────────────────────────
- * 🔴 It replaces a hand-written list in `package.json` that had ALREADY ROTTED. On 2026-09-11
- * the `mutations` script read:
- *
- *     node eslint-rules/tex-build.mutations.mjs &&
- *     node eslint-rules/latex-language.mutations.mjs &&
- *     node scripts/rules-see-files.mutations.mjs
- *
- * — three of the four batteries on disk. `papers.mutations.mjs`, added the same day, was not in
- * it, and nothing said so: the command exited 0 and printed three confident green tables. A
- * list of paths maintained by hand is the thing that goes stale, and it goes stale SILENTLY,
- * which is the same failure class the batteries themselves exist to catch.
- *
- * ── THE TWO GUARDS ──────────────────────────────────────────────────────────
- * 1. FINDING ZERO BATTERIES IS AN ERROR, not an empty success. A run that discovers nothing and
- *    exits 0 is byte-identical to a run where every battery passed — the exact green zero this
- *    repository has a dedicated script for (`rules-see-files.mjs`), applied here to itself.
- * 2. (REMOVED 2026-09-24) A harness without a battery used to be an error. It no longer is —
- *    see the note above the run loop.
- *
- * ⚠️ Batteries WRITE to the file under test and roll it back. They are safe to run on a clean
- * tree and NOT safe to run with uncommitted edits to a rule: a crash between the write and the
- * rollback leaves the mutant on disk. Each battery re-reads the file and verifies the rollback
- * byte for byte, so the window is small, but it is not zero.
- *
- * Run: `node scripts/run-mutations.mjs` (also part of `npm run check`)
- */
-import { execFileSync } from "node:child_process";
-import { readdirSync, statSync } from "node:fs";
-import { dirname, join, relative } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
-// 🔴 `.claude` IS A VIEW OF `skills/`, NOT A SECOND COPY OF IT. This repository is its own first
-// consumer: `.claude/skills/<name>` are symlinks back to `skills/<name>` so that the path every
-// SKILL.md's prose names resolves here too (see `skills/skill-contract.mutations.mjs`). Walking
-// into it counts each harness TWICE under two spellings of one file, and the second spelling is
-// never what a battery names — so every skill harness read as an orphan while being perfectly
-// covered. Measured 2026-09-12: 11 phantom orphans, all of them the same files seen through the
-// symlink. Skipping the view is not an exemption: the real files are still walked under `skills/`.
-const SKIP = new Set(["node_modules", ".git", "fixtures", ".claude"]);
-
-/** Every `*.mutations.mjs` on disk, as repo-relative paths. */
-function collect(dir, found = { mutations: [] }) {
-  for (const entry of readdirSync(dir)) {
-    if (SKIP.has(entry)) continue;
-    const p = join(dir, entry);
-    if (statSync(p).isDirectory()) {
-      collect(p, found);
-      continue;
-    }
-    if (entry.endsWith(".mutations.mjs"))
-      found.mutations.push(relative(ROOT, p));
-  }
-  return found;
-}
-
-const { mutations } = collect(ROOT);
-mutations.sort();
-
-// Guard 1 — the green zero, applied to this script itself.
-if (mutations.length === 0) {
-  console.error(
-    "❌ NO mutation batteries found under " +
-      ROOT +
-      ".\n" +
-      "   This is an error rather than an empty success: a run that discovers nothing and exits " +
-      "0\n   is indistinguishable from a run where every battery passed.",
-  );
-  process.exit(1);
-}
-
-// 🔴 NO ORPHAN GUARD ANY MORE (2026-09-24). Until then this script refused every `*.harness.mjs`
-// that no battery named — so a new harness could not land without a new hand-written battery of
-// string replacements over source lines. Those batteries are the pattern issue #52 is replacing:
-// they break on every reformat, rerun a whole harness per case, and are slow. Forcing more of them
-// into existence was the wrong direction, so the requirement is gone. Existing batteries still run
-// below, and one that fails to kill its mutant still fails the run.
-
-console.log(
-  `Running ${mutations.length} mutation batter${mutations.length === 1 ? "y" : "ies"}:\n`,
-);
-const failed = [];
-for (const m of mutations) {
-  console.log(`──────── ${m}`);
-  try {
-    execFileSync(process.execPath, [m], { cwd: ROOT, stdio: "inherit" });
-  } catch {
-    failed.push(m);
-  }
-}
-
-console.log(
-  `\n${mutations.length - failed.length}/${mutations.length} batter${mutations.length === 1 ? "y" : "ies"} clean` +
-    (failed.length ? `, FAILED: ${failed.join(", ")}` : ""),
-);
-process.exit(failed.length ? 1 : 0);

package/skills/paper-pipeline/scripts/artifact-coverage.mutations.mjs

@@ -1,218 +0,0 @@
-/**
- * artifact-coverage.mutations.mjs — proof that every check in `artifact-coverage.mjs` is watched
- * FAILING, with the reverse (DISK_UNREPORTED) leg and its ignore set as the reason this file exists.
- * Run: `node .claude/skills/paper-pipeline/scripts/artifact-coverage.mutations.mjs`
- *
- * This is not a test. It is the evidence behind the claim that the tests test something.
- *
- * WHY THIS LEG IN PARTICULAR. The reverse leg is the only thing in the pipeline that looks for a
- * result nobody reported, and it is guarded by an ignore set. Both halves fail silently in the same
- * direction: a broken detector finds nothing, and an over-wide ignore set also finds nothing, and
- * from outside those are the same output. A green harness proves the CHECKER fires on planted
- * defects; it does not prove the HARNESS would notice if a check were deleted. Every mutations file
- * written in this repository has found something on its first run, and this one is no exception —
- * see the notes in the table.
- *
- * WHAT IT DOES. For each check, it neuters exactly that check in the source, runs the harness, and
- * requires the harness to go RED with the named assertion. Then it restores the file. A mutation
- * the harness survives is a check nobody is watching, and it is reported as SURVIVED.
- *
- * The source is restored in a `finally`, and the run refuses to start on a dirty working tree, so
- * an interrupted run cannot leave a neutered checker behind.
- */
-import { runMutations } from "../../../lib/mutation-driver.mjs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { consumerRoot } from "./consumer.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = consumerRoot();
-const SRC = join(HERE, "artifact-coverage.mjs");
-const HARNESS = join(HERE, "artifact-coverage.harness.mjs");
-
-/** [name, what it disables, exact source substring, replacement, harness case expected to go red] */
-const MUTATIONS = [
-  // ── the two forward legs, which had a harness and no mutation proof until today ──
-  [
-    "fwd/section-indexed",
-    "the rule that a number-reporting section must be named in the index",
-    "    if (!named)\n",
-    "    if (false)\n",
-    "is named NOWHERE",
-  ],
-  [
-    "fwd/index-path-exists",
-    "the rule that a path the index names must exist",
-    "  if (!existsSync(join(bundle, head)) && !readdirSync(bundle).includes(head))",
-    "  if (false)",
-    "is not in the bundle",
-  ],
-  [
-    "fwd/no-index",
-    "the refusal to accept a bundle that maps nothing to anything",
-    "if (!indexPath) {",
-    "if (false) {",
-    "a bundle that maps nothing to anything was accepted",
-  ],
-  [
-    "fwd/repo-not-path",
-    "the guard that `owner/repo` is not a path (extension required)",
-    "  if (!/\\.[a-z0-9]{1,5}$/i.test(p)) continue;",
-    "  if (false) continue;",
-    "a complete bundle was failed",
-  ],
-
-  // ── the reverse leg: the detector itself ──
-  [
-    "rev/finding",
-    "the DISK_UNREPORTED finding",
-    "  for (const c of unreported)\n    findings.push(",
-    "  for (const c of [])\n    findings.push(",
-    "cherry-picking case this leg was ported for",
-  ],
-  [
-    "rev/headline-results",
-    "RESULTS.md as a headline write-up",
-    "/^(RESULTS|SUMMARY|FINDINGS|METRICS)\\.",
-    "/^(SUMMARY|FINDINGS|METRICS)\\.",
-    "cherry-picking case this leg was ported for",
-  ],
-  [
-    "rev/paper-mention",
-    "crediting a mention in the paper",
-    "if (named(paper)) {",
-    "if (false) {",
-    "an experiment the paper discusses by name was reported as unmentioned",
-  ],
-  [
-    "rev/index-mention",
-    "crediting a mention in the index",
-    "if (named(indexAll)) {",
-    "if (false) {",
-    "named in the bundle's README.md and nowhere else",
-  ],
-  [
-    "rev/all-index-files",
-    "reading BOTH index files (reverts to check 1's single indexPath)",
-    "    if (named(indexAll)) {",
-    "    if (named(index)) {",
-    "named in the bundle's README.md and nowhere else",
-  ],
-  [
-    "rev/date-slug",
-    "stripping the -YYYY-MM-DD suffix before matching",
-    'const slug = c.name.replace(/-\\d{4}-\\d{2}-\\d{2}$/, "");',
-    "const slug = c.name;",
-    "names without its date suffix",
-  ],
-  [
-    "rev/whole-token",
-    "whole-token matching (reverts to substring `includes`)",
-    "const mentions = (t, s) =>\n    s.length >= 4 && new RegExp(`(?<![\\\\w-])${esc(s)}(?![\\\\w-])`).test(t);",
-    "const mentions = (t, s) => t.includes(s);",
-    "the header does not state the real finding count",
-  ],
-  [
-    "rev/bundle-skipped",
-    "the structural ignore that skips the released bundle",
-    "    if (name === bundleName) {\n      swallowed.get([...swallowed.keys()][0]).push(name);\n      continue;\n    }",
-    "    if (false) {\n      swallowed.get([...swallowed.keys()][0]).push(name);\n      continue;\n    }",
-    "the bundle's own RESULTS.md was counted",
-  ],
-
-  // ── the ignore set, which can neuter the detector without changing a line of it ──
-  [
-    "ign/applied",
-    "applying an allow row at all",
-    "if (allowed.has(c.name)) {",
-    "if (false) {",
-    "an allowed row still counted as a finding",
-  ],
-  [
-    "ign/rows-parsed",
-    "parsing the allow file",
-    "      if (name)\n        allowed.set(",
-    "      if (false)\n        allowed.set(",
-    "an allowed row still counted as a finding",
-  ],
-  [
-    "ign/ships-as-verified",
-    "re-verifying a `ships-as:` claim against the bundle",
-    "if (m && !existsSync(join(bundle, m[1])))",
-    "if (false)",
-    "the allowance has rotted",
-  ],
-  [
-    "ign/stale-rows",
-    "reporting a row that names no directory",
-    "    if (!candidates.some((c) => c.name === name))",
-    "    if (false)",
-    "sat in the ignore file unreported",
-  ],
-  [
-    "ign/printed-on-clean",
-    "printing the ledger when there are no findings",
-    '  console.log(\n    "   every number-reporting section is indexed, every named path exists",\n  );\n  ledger.forEach((l) => console.log(l));',
-    '  console.log(\n    "   every number-reporting section is indexed, every named path exists",\n  );',
-    // Killed by case 9 rather than case 12: case 9 is also a 0-finding report-mode run and asserts
-    // the same line, and it runs first. Both cases assert the property; the row records WHICH one
-    // catches it so a future reader does not mistake this for an off-target kill.
-    "was applied and NOT printed",
-  ],
-  [
-    "ign/reasons-printed",
-    "printing each allow row's reason",
-    "  for (const [name, reason] of ignored)\n    ledger.push(`       ${name}  →  ${reason}`);",
-    "  for (const [name, reason] of ignored)\n    ledger.push(`       ${name}`);",
-    "was applied and NOT printed",
-  ],
-  [
-    "ign/empty-file-said",
-    "saying so when nothing is being waved through",
-    '  if (!ignored.length)\n    ledger.push("       (the file is empty — nothing is being waved through)");',
-    '  if (false)\n    ledger.push("       (the file is empty — nothing is being waved through)");',
-    "an empty allow file printed nothing at all",
-  ],
-  [
-    "ign/ratio",
-    "the ratio line that says whether this check still does anything",
-    "    `   Ratio: ${unreported.length} reported as unreported, ${ignored.length} deliberately ignored, ` +",
-    "    `   Ratio: ` +",
-    "printed no ratio",
-  ],
-
-  // ── the machine-readable contract with run-mechanical.mjs ──
-  [
-    "out/stated-count",
-    "the stated finding count in the header",
-    "const header = `📦 artifact coverage — ${findings.length} finding(s) in ${dir}`;",
-    "const header = `📦 artifact coverage — ${dir}`;",
-    "does not state `— 0 finding(s)`",
-  ],
-  [
-    "out/flags-quiet",
-    "the silence of --flags-only on a clean tree",
-    "if (!flagsOnly) {\n  console.log(header);",
-    "if (true) {\n  console.log(header);",
-    "--flags-only printed something about a complete bundle",
-  ],
-];
-
-// The table above is DATA about this checker; the engine below is shared with the other mutation
-// files (`mutation-driver.mjs`). The split gave this file two protections it never had: the no-op
-// guard (a replacement equal to the original leaves a green harness proving nothing) and one retry
-// on a non-kill (a flake reported as a survivor sends the next reader to rewrite a working
-// assertion). It also refuses to start when a named harness does not exist — the defect that made
-// three files report SURVIVED for every case after the 2026-08-11 colocation.
-process.exit(
-  runMutations({
-    root: ROOT,
-    cases: MUTATIONS.map(([name, disables, find, replace, expect]) => ({
-      name,
-      disables,
-      edits: [[SRC, find, replace]],
-      harness: HARNESS,
-      expect,
-    })),
-  }),
-);