paperlint 3.1.0 → 3.1.1

package/eslint-rules/paper-stages.mutations.mjs

@@ -1,81 +0,0 @@
-/**
- * Battery for `paper/stages` and `paper/source` — four mutations, chosen so that each one
- * removes ITS OWN load-bearing property, rather than just breaking the file.
- *
- * 🔴 Why the battery matters here specifically. For both rules the success state is SILENCE, and
- * the harness catches them on fixtures that it lays out itself. "It passed" and "it cannot fail"
- * look identical from the outside; the battery is the only thing that tells them apart.
- *
- * The first two mutations hit the TWO DIRECTIONS of `paper/stages`, and this is not symmetry for
- * its own sake: without the second direction the rule turns itself off by deleting the
- * frontmatter — no declarations, so no mismatches, so green. The `declared-without-bytes`
- * mutation and the `bytes-without-declaration` mutation must die on DIFFERENT asserts, or only
- * one half is proven.
- */
-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 RULE = join(HERE, "paper-stages.mjs");
-const HARNESS = join(HERE, "paper-stages.harness.mjs");
-
-process.exit(
-  runMutations({
-    root: ROOT,
-    runner: "node",
-    cases: [
-      {
-        name: "the DECLARED→BYTES direction stops checking",
-        harness: HARNESS,
-        expect: "wrong byte count is reported",
-        disables:
-          "the check of declared `bytes` against the file on disk — a stage could declare any " +
-          "number, and the pdf underneath it could be anything",
-        edits: [[RULE, "if (got !== Number(rec.bytes)) {", "if (false) {"]],
-      },
-      {
-        name: "the BYTES→DECLARED direction stops checking",
-        harness: HARNESS,
-        expect: "a frozen version nobody declared is reported",
-        disables:
-          "the second half — the one without which the rule is muted by deleting the " +
-          "frontmatter: no declarations ⇒ no mismatches ⇒ green",
-        edits: [
-          [
-            RULE,
-            "if (records.some((r) => r.stage === f.stage && r.date === f.date))\n                continue;",
-            "if (true)\n                continue;",
-          ],
-        ],
-      },
-      {
-        name: "`paper/source` stops checking the source's size",
-        harness: HARNESS,
-        expect: "a byte mismatch on the source is reported",
-        disables:
-          "the IDENTITY check on a frozen source: `existsSync` answers 'a file exists', " +
-          "and only the size answers 'this is that exact file'",
-        edits: [
-          [RULE, "if (Number.isFinite(want) && got !== want)", "if (false)"],
-        ],
-      },
-      {
-        name: "acknowledging a loss starts EXEMPTING instead of recording",
-        harness: HARNESS,
-        expect: "an acknowledged loss is still reported, not silenced",
-        disables:
-          "the decision that `sourceLost` is a RECORD, not an indulgence: the rule must keep " +
-          "speaking, because the state is still defective, merely unfixable today",
-        edits: [
-          [
-            RULE,
-            "if (rec?.sourceLost === true) {",
-            "if (rec?.sourceLost === true && false) {",
-          ],
-        ],
-      },
-    ],
-  }),
-);

package/eslint-rules/papers.mutations.mjs

@@ -1,186 +0,0 @@
-/**
- * Mutation battery for `eslint-rules/papers.mjs`.
- * Run: `node eslint-rules/papers.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. In this
- * project a green mutation 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 one is closed by the baseline run below.
- */
-import { readFileSync, writeFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-
-const RULES = "eslint-rules/papers.mjs";
-const HARNESS = "eslint-rules/papers.harness.mjs";
-
-// Coverage mode — see `scripts/run-mutations.mjs` guard 2 and the block in
-// `lib/mutation-driver.mjs`. 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);
-}
-
-const PRISTINE = readFileSync(RULES, "utf8");
-
-const M = [
-  [
-    "existsSync/the central refusal",
-    "stop checking that the root is on disk — a wrong root stops being an error and becomes a " +
-      "run that lints zero files and exits 0, which reads exactly like a clean pass",
-    "  if (!existsSync(resolve(baseDir, root)))",
-    "  if (false)",
-  ],
-  [
-    "baseDir/ignored in favour of cwd",
-    "resolve against `process.cwd()` instead of the given base — passes every run started from " +
-      "the repository root and fails in a worktree or from an editor started elsewhere",
-    "  if (!existsSync(resolve(baseDir, root)))",
-    "  if (!existsSync(resolve(process.cwd(), root)))",
-  ],
-  [
-    "default/absence",
-    "drop the default — a consumer that declares nothing gets `undefined` instead of `papers`",
-    "  const root = declared === undefined ? DEFAULT_PAPERS_ROOT : declared;",
-    "  const root = declared;",
-  ],
-  [
-    "declared === undefined/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;",
-    "  const root = declared ?? DEFAULT_PAPERS_ROOT;",
-  ],
-  [
-    "type guard/empty string",
-    "accept any string, including the empty one — every glob becomes `/*/paper.tex`, rooted at " +
-      "the filesystem, matching nothing, silently",
-    '  if (typeof root !== "string" || root.length === 0)',
-    '  if (typeof root !== "string")',
-  ],
-  [
-    "return shape/absolute path",
-    "return the RESOLVED root — ESLint interprets `files:` globs relative to the config, so an " +
-      "absolute path there is a different pattern, and the breakage shows up as silence",
-    "  return root;\n}",
-    "  return resolve(baseDir, root);\n}",
-  ],
-  [
-    "message/which value was declared",
-    "drop the declared value from the error — the reader is told something is missing but not " +
-      "which of several candidate paths the tool was looking at",
-    'the papers root "${root}" does not exist under ${baseDir}.',
-    "the papers root does not exist.",
-  ],
-  [
-    "message/default vs declared",
-    "collapse the two failures into one message — «you declared the wrong thing» and «you " +
-      "declared nothing and the default does not fit» have different fixes",
-    "        (declared === undefined",
-    "        (false",
-  ],
-  [
-    "paperFiles/one glob set stops interpolating the root",
-    "hard-code the `tex` set — the block keeps matching whatever layout the author had in mind",
-    "    tex: [`${root}/*/paper.tex`],",
-    "    tex: [`docs/papers/*/paper.tex`],",
-  ],
-  [
-    "paperFiles/a set disappears",
-    "drop `status` — a consumer's block named it, so that block now lints nothing at all",
-    "    status: [`${root}/*/PIPELINE-STATUS.md`],",
-    "",
-  ],
-];
-
-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 [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(RULES, PRISTINE.replace(from, to));
-  const on = readFileSync(RULES, "utf8");
-  if (!on.includes(to) || on.includes(from)) {
-    console.log(
-      `❌ ${label}: THE MUTATION DID NOT LAND (checked by re-reading the file)`,
-    );
-    bad++;
-    writeFileSync(RULES, PRISTINE);
-    continue;
-  }
-  const { failed, out } = runHarness();
-  writeFileSync(RULES, PRISTINE);
-  if (readFileSync(RULES, "utf8") !== PRISTINE) {
-    console.log(`❌ ${label}: THE ROLLBACK FAILED`);
-    bad++;
-    continue;
-  }
-  // The verdict carries the HARNESS LINE and the assertion text: "killed" without saying by
-  // what is half an answer. The battery must show that each mutation died on ITS OWN assertion.
-  const at = (out.match(/papers\.harness\.mjs:(\d+)/) ?? [])[1];
-  const msg =
-    (out.match(/AssertionError[^:]*: ([^\n]+)/) ?? [])[1] ??
-    // Not every mutation dies on an assertion: removing the `try/catch` crashes the linter
-    // itself, and then "what it died on" is a thrown error. Without this branch the column
-    // would come out EMPTY — "killed by something unknown", which is the half-answer this
-    // battery forbids.
-    (out.match(/((?:Error|ENOENT)[^\n]*)/) ?? [])[1] ??
-    (out.match(
-      /([^\n]*(?:must|the wrong|drifted|was lost|did not fire)[^\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/eslint-rules/temp-root-realpath.mutations.mjs

@@ -1,99 +0,0 @@
-/**
- * Battery for `local/temp-root-realpath`. Five mutations, five DIFFERENT asserts: the rule
- * must fire, must exempt a resolved root, must not scream at a nested one, must understand
- * the namespaced spelling — and, separately, case 6 must catch a REGRESSION IN THE CORPUS,
- * not just in a made-up string.
- *
- * 🔴 The last mutation is the only thing that makes issue #9's fix guarded. The defect
- * cannot be reproduced on Linux: removing the `realpathSync` wrapper leaves all 52 harnesses
- * green. If removing it turns NOTHING red, then the twenty-four fixes rest entirely on the
- * next author's memory.
- */
-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 RULE = join(HERE, "temp-root-realpath.mjs");
-const HARNESS = join(HERE, "temp-root-realpath.harness.mjs");
-const CORPUS = join(
-  ROOT,
-  "skills",
-  "paper-pipeline",
-  "scripts",
-  "consumer.harness.mjs",
-);
-
-process.exit(
-  runMutations({
-    root: ROOT,
-    runner: "node",
-    cases: [
-      {
-        name: "the rule stops reporting",
-        harness: HARNESS,
-        expect: "one finding was expected",
-        disables: "the verdict itself — an unresolved root passes silently",
-        edits: [
-          [
-            RULE,
-            'context.report({ node, messageId: "unresolved" });',
-            "void node;",
-          ],
-        ],
-      },
-      {
-        name: "the realpathSync exemption is removed",
-        harness: HARNESS,
-        expect: "the rule must stay silent",
-        disables:
-          "the exemption — an already-fixed root starts going red, and for an error-level rule a false positive is worse than a miss",
-        edits: [
-          [
-            RULE,
-            "if (isRealpathCall(parent) && parent.arguments[0] === node) return;",
-            "void parent;",
-          ],
-        ],
-      },
-      {
-        name: "the 'tmpdir() is in the arguments' condition is removed",
-        harness: HARNESS,
-        expect: "a nested root inherits its spelling from the parent",
-        disables:
-          "narrowing the predicate — the rule starts demanding a resolve on nested roots too",
-        edits: [
-          [RULE, "if (!mentionsTmpdir(node.arguments)) return;", "void node;"],
-        ],
-      },
-      {
-        name: "the namespaced spelling stops being recognized",
-        harness: HARNESS,
-        expect: "the namespaced spelling must be caught",
-        disables: "parsing of `fs.mkdtempSync` — the defect hides behind a dot",
-        edits: [
-          [
-            RULE,
-            'if (\n    c.type === "MemberExpression" &&\n    !c.computed &&\n    c.property.type === "Identifier"\n  )\n    return c.property.name;',
-            'if (false) return "";',
-          ],
-        ],
-      },
-      {
-        name: "🔴 REGRESSION IN THE CORPUS: the wrapper is removed from one real root",
-        harness: HARNESS,
-        expect: "the corpus must be clean of unresolved roots",
-        disables:
-          "the guard over the #9 fix itself — on Linux removing the wrapper does not turn a single behavioral test red",
-        edits: [
-          [
-            CORPUS,
-            'const TMP = realpathSync(mkdtempSync(join(tmpdir(), "consumer-harness-")));',
-            'const TMP = mkdtempSync(join(tmpdir(), "consumer-harness-"));',
-          ],
-        ],
-      },
-    ],
-  }),
-);

package/eslint-rules/tex-build.mutations.mjs

@@ -1,258 +0,0 @@
-/**
- * Mutation battery for `eslint-rules/tex-build.mjs`.
- * Run: `node eslint-rules/tex-build.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. In the
- * repository this came from, a green mutation has FOUR TIMES meant not "the defence holds" but
- * "the patch never landed" / "the test is looking somewhere else".
- *
- * WHAT A GREEN HARNESS UNDER A MUTATION MEANS: it is 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 one
- * is closed by the baseline run below.
- */
-import { readFileSync, writeFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-
-const RULES = "eslint-rules/tex-build.mjs";
-const HARNESS = "eslint-rules/tex-build.harness.mjs";
-
-// Coverage mode — see `scripts/run-mutations.mjs` guard 2 and the block in
-// `lib/mutation-driver.mjs`. 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);
-}
-
-const PRISTINE = readFileSync(RULES, "utf8");
-
-const M = [
-  [
-    "vocabulary/camera-ready",
-    "remove the «at camera-ready» branch — the very one the check was added for on 2026-08-24",
-    "  /\\b(?:at (?:the )?camera[-\\s]?ready|upon acceptance|on acceptance|will be (?:released|published|made (?:publicly )?available|public|open[-\\s]?sourced))\\b/i;",
-    "  /\\b(?:upon acceptance|on acceptance|will be (?:released|published|made (?:publicly )?available|public|open[-\\s]?sourced))\\b/i; /* MUT */",
-  ],
-  [
-    "vocabulary/will be …",
-    "keep only camera-ready — the «will be released/published/public» family dies",
-    "  /\\b(?:at (?:the )?camera[-\\s]?ready|upon acceptance|on acceptance|will be (?:released|published|made (?:publicly )?available|public|open[-\\s]?sourced))\\b/i;",
-    "  /\\b(?:at (?:the )?camera[-\\s]?ready)\\b/i; /* MUT */",
-  ],
-  [
-    "review/exemption",
-    "stop exempting a review build — a promise made during peer review becomes a finding",
-    "        if (REVIEW_MODE_RE.test(text)) return;",
-    "        if (false) return; /* MUT */",
-  ],
-  [
-    "review/anchor against comments",
-    "drop `^[^%\\n]*` — a COMMENTED-OUT `\\documentclass[review]` starts exempting the build " +
-      "(a live case in the source corpus: a paper carrying its previous class a few lines above the real one)",
-    "  /^[^%\\n]*(?:\\\\documentclass\\[[^\\]]*\\breview\\b|printacmref=false)/m;",
-    "  /(?:\\\\documentclass\\[[^\\]]*\\breview\\b|printacmref=false)/m; /* MUT */",
-  ],
-  [
-    "review/printacmref",
-    "remove the second sign of the mode — a build with `printacmref=false` stops being exempt",
-    "  /^[^%\\n]*(?:\\\\documentclass\\[[^\\]]*\\breview\\b|printacmref=false)/m;",
-    "  /^[^%\\n]*(?:\\\\documentclass\\[[^\\]]*\\breview\\b)/m; /* MUT */",
-  ],
-  [
-    "comments/blanking",
-    "stop cutting LaTeX comments — an author note `% camera-ready blocker` becomes a finding",
-    '          .map((l) => l.replace(/(^|[^\\\\])%.*$/, "$1"));\n        lines.forEach((line, i) => {',
-    "          .map((l) => l); /* MUT */\n        lines.forEach((line, i) => {",
-  ],
-  [
-    "comments/escaped percent",
-    "treat `\\%` as the start of a comment — the rest of the line behind the percent goes invisible",
-    '          .map((l) => l.replace(/(^|[^\\\\])%.*$/, "$1"));\n        lines.forEach((line, i) => {',
-    '          .map((l) => l.replace(/%.*$/, "")); /* MUT */\n        lines.forEach((line, i) => {',
-  ],
-  [
-    "address/line",
-    "report every finding on line 1 — the address, which is what the move to a lint rule bought, is lost",
-    "            loc: {\n              start: { line: i + 1, column },",
-    "            loc: {\n              start: { line: 1, column: 1 }, /* MUT */",
-  ],
-  [
-    "address/column",
-    "report the start of the line instead of the start of the match",
-    "          if (!m) return;\n          const column = m.index + 1;",
-    "          if (!m) return;\n          const column = 1; /* MUT */",
-  ],
-  [
-    "capture/finding text",
-    "print the whole line in the message instead of the captured substring — «how many» would still match, «what» would not",
-    "            data: { text: m[0] },",
-    "            data: { text: line.trim() }, /* MUT */",
-  ],
-  // ── tex/acm-frontmatter-override ───────────────────────────────────────────
-  [
-    "frontmatter/acmart guard",
-    "drop the `acmart` guard — `\\pagestyle{plain}` in an ordinary `article` becomes a finding, " +
-      "which is the false positive that gets a rule switched off on its first day",
-    "        if (!ACMART_RE.test(code)) return;",
-    "        if (false) return; /* MUT */",
-  ],
-  [
-    "frontmatter/nonacm exemption",
-    "stop exempting `nonacm` — the rule punishes the very escape hatch its own message recommends",
-    "        if (NONACM_RE.test(code)) return;",
-    "        if (false) return; /* MUT */",
-  ],
-  [
-    "frontmatter/setcopyright",
-    "remove `\\setcopyright{none}` from the set — the first of the three lines of the " +
-      "desk-rejected preamble stops being caught",
-    "    re: /\\\\setcopyright\\s*\\{\\s*none\\s*\\}/g,",
-    "    re: /\\\\setcopyright\\s*\\{\\s*NEVER\\s*\\}/g, /* MUT */",
-  ],
-  [
-    "frontmatter/permission footnote",
-    "remove the `\\renewcommand\\footnotetextcopyrightpermission` branch — the permission block " +
-      "on page 1 can be blanked silently",
-    "    re: /\\\\renewcommand\\s*\\*?\\s*\\{?\\s*\\\\footnotetextcopyrightpermission/g,",
-    "    re: /\\\\renewcommand\\s*\\*?\\s*\\{?\\s*\\\\NEVERfootnotetext/g, /* MUT */",
-  ],
-  [
-    "frontmatter/pagestyle empty",
-    "narrow the page-style branch to `plain` — `\\pagestyle{empty}` strips the same furniture and " +
-      "goes unnoticed",
-    "    re: /\\\\(?:this)?pagestyle\\s*\\{\\s*(?:plain|empty)\\s*\\}/g,",
-    "    re: /\\\\(?:this)?pagestyle\\s*\\{\\s*(?:plain)\\s*\\}/g, /* MUT */",
-  ],
-  [
-    "frontmatter/thispagestyle",
-    "drop `(?:this)?` — `\\thispagestyle{empty}`, which targets page 1 SPECIFICALLY, stops being caught",
-    "    re: /\\\\(?:this)?pagestyle\\s*\\{\\s*(?:plain|empty)\\s*\\}/g,",
-    "    re: /\\\\pagestyle\\s*\\{\\s*(?:plain|empty)\\s*\\}/g, /* MUT */",
-  ],
-  [
-    "frontmatter/comment blanking",
-    "stop cutting LaTeX comments — the accepted sibling paper's COMMENTED record of its old " +
-      "preamble becomes three findings, and the arming `\\documentclass` may come from a comment too",
-    '          .map((l) => l.replace(/(^|[^\\\\])%.*$/, "$1"));\n        const code = lines.join("\\n");',
-    '          .map((l) => l);\n        const code = lines.join("\\n"); /* MUT */',
-  ],
-  // ⚠️ `frontmatter/lastIndex reset` STOOD HERE AND WAS REMOVED, not silenced. It mutated away
-  // an explicit `re.lastIndex = 0` and the harness stayed GREEN — which by this file's own
-  // ranking is a finding about the TEST or about the CODE, never a pass. It was the code: a
-  // `/g` `exec` that returns `null` resets `lastIndex` itself, and the loop always drains the
-  // regex, so the line was a guard nothing could kill. The line is gone; the property is held
-  // by the harness assertion that lints one input twice in a single process.
-  [
-    "frontmatter/line",
-    "report every finding on line 1 — the address of the offending preamble line is lost",
-    "                  start: { line: i + 1, column },",
-    "                  start: { line: 1, column: 1 }, /* MUT */",
-  ],
-  [
-    "frontmatter/all matches per line",
-    "take only the FIRST match of each pattern per line — a compacted preamble is under-counted",
-    "            while ((m = re.exec(line)) !== null) {",
-    "            if ((m = re.exec(line)) !== null) { /* MUT */",
-  ],
-  [
-    "frontmatter/column",
-    "report the start of the line instead of the start of the match (second rule's copy)",
-    "              const column = m.index + 1;",
-    "              const column = 1; /* MUT */",
-  ],
-  [
-    "disk read/quiet instead of throwing",
-    "remove the `try/catch` around the read — the rule THROWS on a stdin run where there is no file",
-    '        try {\n          text = readFileSync(context.filename, "utf8");\n        } catch {\n          return;\n        }\n        if (REVIEW_MODE_RE.test(text)) return;',
-    '        text = readFileSync(context.filename, "utf8"); /* MUT */\n        if (REVIEW_MODE_RE.test(text)) return;',
-  ],
-];
-
-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 [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(RULES, PRISTINE.replace(from, to));
-  const on = readFileSync(RULES, "utf8");
-  if (!on.includes(to) || on.includes(from)) {
-    console.log(
-      `❌ ${label}: THE MUTATION DID NOT LAND (checked by re-reading the file)`,
-    );
-    bad++;
-    writeFileSync(RULES, PRISTINE);
-    continue;
-  }
-  const { failed, out } = runHarness();
-  writeFileSync(RULES, PRISTINE);
-  if (readFileSync(RULES, "utf8") !== PRISTINE) {
-    console.log(`❌ ${label}: THE ROLLBACK FAILED`);
-    bad++;
-    continue;
-  }
-  // The verdict carries the HARNESS LINE and the assertion text: "killed" without saying by
-  // what is half an answer. The battery must show that each mutation died on ITS OWN assertion.
-  const at = (out.match(/tex-build\.harness\.mjs:(\d+)/) ?? [])[1];
-  const msg =
-    (out.match(/AssertionError[^:]*: ([^\n]+)/) ?? [])[1] ??
-    // Not every mutation dies on an assertion: removing the `try/catch` crashes the linter
-    // itself, and then "what it died on" is a thrown error. Without this branch the column
-    // would come out EMPTY — "killed by something unknown", which is the half-answer this
-    // battery forbids.
-    (out.match(/((?:Error|ENOENT)[^\n]*)/) ?? [])[1] ??
-    (out.match(
-      /([^\n]*(?:must|the wrong|drifted|was lost|did not fire)[^\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);