paperlint 3.1.0 → 3.1.1

package/src/venue-rules.test.ts

@@ -113,6 +113,7 @@ function lint(
   p: Paper,
   filename = `${PAPER}/paper.tex`,
   options: Json = {},
+  cwd?: string,
 ): Finding[] {
   const files = memoryFiles(paperFiles(p));
   const rules = venueRules({ files, venuesDir: VENUES });
@@ -123,6 +124,7 @@ function lint(
   ][]) {
     const visitor = rule.create({
       filename,
+      ...(cwd === undefined ? {} : { cwd }),
       sourceCode: { text: TEX },
       options:
         name === "geometry" && Object.keys(options).length ? [options] : [],
@@ -555,3 +557,61 @@ describe("paperlint's own config turns the venue rules on for every paper.tex",
     expect(OPTIONAL_RULES.has("pdf/last-page-balance")).toBe(true);
   });
 });
+
+describe("a project's own preset, and the facts' other spellings", () => {
+  // A standalone preset (no `extends`, so it carries a `tex` block) that sets a body size with no
+  // tolerance, a reference range, two columns — and no page size and no font families.
+  const HOUSE = {
+    [`${PAPER}/house.jsonc`]: JSON.stringify({
+      tex: { packages: { acmart: ["acmart.cls"] } },
+      format: { columns: 2, body_pt: 9, ref_pt_min: 7, ref_pt_max: 8 },
+    }),
+  };
+  const house = (patch: (f: Json) => void = () => {}) =>
+    lint({
+      venue: { extends: "./house.jsonc" },
+      facts: withFacts(patch),
+      extra: HOUSE,
+    });
+
+  it("no page size in the preset: nothing to compare, whatever the PDF measures", () => {
+    expect(ids(house((f) => ((f.page_w_in = 5), (f.page_h_in = 5))))).toEqual(
+      [],
+    );
+  });
+
+  it("a body size with no tolerance is not judged; a reference range with none is judged exactly", () => {
+    expect(ids(house((f) => (f.body_pt = 12)))).toEqual([]);
+    // 6.9 pt passes agenticdev (its body_pt_tol widens the range) and fails here, where nothing does.
+    expect(ids(house((f) => (f.ref_pt = 6.9)))).toEqual(["pdf/limits:refPt"]);
+  });
+
+  it("facts naming the PDF by an absolute path are checked against that file", () => {
+    expect(
+      lint({
+        venue: DECL,
+        facts: withFacts((f) => (f.pdf = `${PAPER}/paper.pdf`)),
+      }),
+    ).toEqual([]);
+  });
+
+  it("a PDF with no fonts at all: each missing family says so", () => {
+    const fs = lint({ venue: DECL, facts: withFacts((f) => (f.fonts = [])) });
+    expect(ids(fs)).toEqual(["pdf/fonts:noFamily", "pdf/fonts:noFamily"]);
+    expect(fs[0]?.message).toMatch(/\(no fonts\)/);
+  });
+
+  it("file names in messages are relative to ESLint's cwd — and never empty", () => {
+    const at = (cwd: string) =>
+      lint(
+        { venue: { kind: "short" }, facts: null, pdf: null },
+        undefined,
+        {},
+        cwd,
+      )[0]?.message;
+    expect(at("/work")).toMatch(/set "extends" in papers\/p\/paperlint\.json/);
+    expect(at(`${PAPER}/paperlint.json`)).toMatch(
+      /set "extends" in \/work\/papers\/p\/paperlint\.json/,
+    );
+  });
+});

package/src/venue-rules.ts

@@ -253,17 +253,19 @@ function judgePages(g: FlatGeometry, resolved: Resolved): Finding[] {
     [kind.limits.bodyPagesMax, g.body_pages, "body pages"],
     [kind.limits.refPagesMax, g.ref_pages, "reference pages"],
   ];
-  return pages
-    .filter(([max, got]) => max !== null && got > max)
-    .map(([max, got, what]) =>
-      finding("pages", {
-        what,
-        got,
-        max: max ?? 0,
-        venue: resolved.venue,
-        kind: kind.name,
-      }),
-    );
+  return pages.flatMap(([max, got, what]) =>
+    max !== null && got > max
+      ? [
+          finding("pages", {
+            what,
+            got,
+            max,
+            venue: resolved.venue,
+            kind: kind.name,
+          }),
+        ]
+      : [],
+  );
 }
 
 function judgeRefPt(g: FlatGeometry, resolved: Resolved): Finding[] {

package/action.mutations.mjs

@@ -1,162 +0,0 @@
-/**
- * Mutation battery over `action.yml` and `scripts/eslint-report-guard.mjs`.
- * Run: `node action.mutations.mjs` (not `vigiles test` — this is not a harness).
- *
- * 🔴 EVERY MUTATION CARRIES A "THE PATCH LANDED" ASSERTION: the target must occur EXACTLY ONCE,
- * the mutant must be present in the file re-read from disk, the original text must be GONE, and
- * after the rollback the contents must return byte for byte. In this corpus a green mutation has
- * three times meant not "the defence holds" but "the patch never applied".
- *
- * A GREEN HARNESS UNDER A MUTATION is a finding about the TEST, not a conclusion about the defence.
- * Rank the causes: the wrong test · the patch did not land · the set is too narrow · THE RUN WAS
- * ALREADY RED BEFORE THE MUTATION. The last is why the baseline runs FIRST and its failure stops
- * the battery.
- *
- * ⚠️ Mutation 1 is the load-bearing one and it is deliberately asymmetric: it sends the step back
- * to calling `npx eslint` directly while LEAVING the words `paperlint lint` in the comments above. A
- * harness that grepped the file would stay green; this one parses the YAML and addresses the step
- * as a node, so it dies. That is the whole argument for the parser, made executable.
- *
- * It replaced a mutation over `--no-config-lookup`, which stopped having a target on 2026-09-18:
- * the flag went away with the eslint call, and the guarantee it carried moved INTO the CLI
- * (`overrideConfigFile: true`). The bypass it protected against is the same one — a consumer's
- * nested config deciding the rule set — so the case moved rather than disappeared.
- */
-import { readFileSync, writeFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-
-const HARNESS = "action.harness.mjs";
-
-if (process.env.MUTATIONS_REPORT_COVERAGE) {
-  console.log(`MUTATION-COVERS\t${HARNESS}`);
-  process.exit(0);
-}
-
-const ACTION = "action.yml";
-const GUARD = "scripts/eslint-report-guard.mjs";
-const PRISTINE = new Map(
-  [ACTION, GUARD].map((f) => [f, readFileSync(f, "utf8")]),
-);
-const restoreAll = () => {
-  for (const [f, body] of PRISTINE) writeFileSync(f, body);
-};
-
-const M = [
-  [
-    ACTION,
-    "the step goes back around the CLI to eslint (the words `paperlint lint` left in the comments)",
-    "reinstate the bypass: the settings unread, the directory-structure check absent in CI, and a " +
-      "consumer's nested config free to decide the rule set — while a grep still finds `paperlint lint`",
-    "npx paperlint lint $PAPERLINT_PATHS",
-    'npx eslint --config "$PAPERLINT_CONFIG" $PAPERLINT_PATHS',
-  ],
-  [
-    ACTION,
-    "the guard is no longer called",
-    "keep the lint run and drop the green-zero check — the job passes loudest when it measured nothing",
-    'node "$GITHUB_ACTION_PATH/scripts/eslint-report-guard.mjs" \\',
-    "true # MUT \\",
-  ],
-  [
-    ACTION,
-    "texcount probed by the installer's exit code instead of by the binary",
-    "trust an installer that can put nothing in place and report success",
-    "command -v texcount >/dev/null || {",
-    "true || {",
-  ],
-  [
-    GUARD,
-    "a report of ZERO linted files treated as clean",
-    "reinstate the exact indistinguishability the guard exists to break",
-    "  if (res.length === 0) {",
-    "  if (false) { /* MUT */",
-  ],
-  [
-    GUARD,
-    "ESLint's return code masked",
-    "swallow a real ESLint failure and report success",
-    "  return { code: eslintRc, lines };",
-    "  return { code: 0, lines }; /* MUT */",
-  ],
-  [
-    GUARD,
-    "an unparsable report treated as clean",
-    "let a missing or corrupt report pass — nothing was measured either way",
-    "    lines.push(\n      `::error::ESLint wrote no parsable report to ${reportPath} (rc=${eslintRc}). Nothing was measured.`,\n    );\n    return { code: 1, lines };",
-    "    return { code: 0, lines }; /* MUT */",
-  ],
-];
-
-const run = () => {
-  try {
-    return {
-      ok: true,
-      out: execFileSync("npx", ["vigiles", "test", HARNESS], {
-        encoding: "utf8",
-        stdio: "pipe",
-      }),
-    };
-  } catch (e) {
-    return { ok: false, out: `${e.stdout ?? ""}${e.stderr ?? ""}` };
-  }
-};
-
-const base = run();
-if (!base.ok) {
-  console.log(
-    "❌ THE HARNESS IS RED BEFORE ANY MUTATION — the battery cannot tell a killed mutation from that:\n" +
-      base.out.slice(-1200),
-  );
-  process.exit(1);
-}
-
-let ok = 0;
-let bad = 0;
-const rows = [];
-
-for (const [file, label, what, from, to] of M) {
-  const pristine = PRISTINE.get(file);
-  const hits = pristine.split(from).length - 1;
-  if (hits !== 1) {
-    console.log(
-      `❌ ${label}: TARGET ${hits === 0 ? "NOT FOUND" : `NOT UNIQUE (${hits})`} in ${file}`,
-    );
-    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++;
-    restoreAll();
-    continue;
-  }
-  const res = run();
-  restoreAll();
-  if (readFileSync(file, "utf8") !== pristine) {
-    console.log(`❌ ${label}: THE ROLLBACK FAILED on ${file}`);
-    bad++;
-    continue;
-  }
-  if (!res.ok) {
-    ok++;
-    const why =
-      (res.out.match(/AssertionError[^\n]*?: ([^\n]*)/) ?? [])[1] ??
-      "(the harness died)";
-    rows.push([label, what, why.trim().slice(0, 100)]);
-  } 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 r of rows) console.log(`| ${r[0]} | ${r[1]} | ${r[2]} |`);
-console.log(`\n${ok} mutation(s) killed, ${bad} problem(s)`);
-process.exit(bad === 0 ? 0 : 1);

package/eslint-rules/install-path-literals.mutations.mjs

@@ -1,62 +0,0 @@
-/**
- * Battery on the two `port/*-install-path` rules: four mutations, each removing one
- * load-bearing property — the detection itself, the markdown carriers, the template form on
- * the code side, and the ratchet.
- *
- * There is no fourth mutation here anymore — for the ratchet: the ratchet itself was removed.
- */
-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, "install-path-literals.mjs");
-const HARNESS = join(HERE, "install-path-literals.harness.mjs");
-
-process.exit(
-  runMutations({
-    root: ROOT,
-    runner: "node",
-    cases: [
-      {
-        name: "the detector stops finding anything",
-        harness: HARNESS,
-        expect: "expected at least three findings",
-        disables:
-          "the check itself — an install-specific path passes silently in both languages",
-        edits: [
-          [
-            RULE,
-            "for (const p of CHANNEL_PREFIXES) if (s.includes(p)) return p;",
-            "void CHANNEL_PREFIXES;",
-          ],
-        ],
-      },
-      {
-        name: "markdown stops seeing frontmatter and code",
-        harness: HARNESS,
-        expect: "expected at least three findings",
-        disables:
-          "the carriers in a skill — only prose is left, while the command lives in a fence and in allowed-tools",
-        edits: [
-          [
-            RULE,
-            "return { yaml: check, code: check, inlineCode: check, text: check };",
-            "return { text: check };",
-          ],
-        ],
-      },
-      {
-        name: "code stops seeing the template string",
-        harness: HARNESS,
-        expect: "expected one plain and one template finding",
-        disables:
-          "the second literal form — a path assembled by a template stays a path",
-        edits: [
-          [RULE, "TemplateElement(node) {", "TemplateElement_disabled(node) {"],
-        ],
-      },
-    ],
-  }),
-);

package/eslint-rules/latex-language.mutations.mjs

@@ -1,196 +0,0 @@
-/**
- * Mutation battery for the LaTeX language `eslint-rules/latex-language.mjs`.
- * Run: `node eslint-rules/latex-language.mutations.mjs` (not `vigiles test` — not a harness).
- *
- * 🔴 EVERY MUTATION CARRIES A "THE PATCH LANDED" ASSERTION: the file is re-read from disk, the
- * mutant must be in it, the original text must be GONE (otherwise the target was not unique),
- * and after the rollback the contents must return byte for byte. In the repository this came
- * from, a green mutation has three times meant not "the defence holds" but "the patch never
- * applied".
- *
- * A GREEN HARNESS UNDER A MUTATION is a finding about the TEST, not a conclusion about the
- * defence. Rank the causes:
- *   1. the wrong test — it pins a side effect rather than the property itself;
- *   2. the patch did not land — removed by the assertion above;
- *   3. the set is too narrow — the property is observable in no fixture;
- *   4. 🔴 THE RUN WAS ALREADY RED BEFORE THE MUTATION — then "killed" and "was failing anyway"
- *      are indistinguishable.
- * Cause 4 is why the baseline run comes FIRST and why its failure stops the battery.
- *
- * ⚠️ WHAT IS NOT HERE ANY MORE. The original battery had a second group of three mutations
- * against the `case "html"` patch in three consumer rule modules — the patch that taught them to
- * recognise a `%` comment, not only an `<!--` one. Those modules were not extracted, so the
- * mutations have no target. The property itself did NOT disappear with them: the language still
- * trims both edges of a comment node, and the two mutations named
- * `comment/RIGHT edge` and `comment/LEFT edge` below cover the language's half of it. What is
- * genuinely gone is the evidence that a CONSUMER acts on it.
- */
-import { readFileSync, writeFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-
-const HARNESS = "eslint-rules/latex-language.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 LANG = "eslint-rules/latex-language.mjs";
-const PRISTINE = readFileSync(LANG, "utf8");
-
-const M = [
-  [
-    "synthesis of `## References` from `\\bibliography{}`",
-    "stop declaring the bibliography a heading",
-    '      if (node.content === "bibliography" && pos) {',
-    "      if (false && pos) { /* MUT */",
-  ],
-  [
-    "synthesis of `## Abstract` from the environment",
-    "stop declaring the abstract a heading",
-    '      if (env === "abstract" && pos) {',
-    "      if (false && pos) { /* MUT */",
-  ],
-  [
-    "preamble cut-off during synthesis",
-    "treat preamble constructs (e.g. `\\AtBeginDocument{\\bibliography{}}`) as nodes of the document",
-    '    if (pos && pos.start.offset < preEnd) {\n      for (const k of ["content", "args"]) if (node[k]) walk(node[k]);\n      return;\n    }',
-    "    if (false) { return; } /* MUT */",
-  ],
-  [
-    "preamble blanking",
-    "leave the preamble (package list, author macros) visible as prose",
-    "  if (preEnd) {\n    blank(0, preEnd);",
-    "  if (preEnd) {\n    void 0; /* MUT */",
-  ],
-  [
-    "comment/RIGHT edge trim",
-    "leave the trailing `\\n` inside the comment node",
-    '      while (\n        ce > pos.start.offset &&\n        (src[ce - 1] === "\\n" || src[ce - 1] === "\\r")\n      )\n        ce--;',
-    "      /* MUT */",
-  ],
-  [
-    "comment/LEFT edge trim",
-    "leave the preceding `\\n` inside the comment node",
-    '      while (cs < ce && src[cs] !== "%") cs++;',
-    "      /* MUT */",
-  ],
-  [
-    "`**` written in place of `\\te`",
-    "write the `**` before the content, leaving the line to start with spaces",
-    '      while (pendingStrong.length) {\n        const o = pendingStrong.pop();\n        chars[o] = "*";\n        chars[o + 1] = "*";\n      }',
-    "      while (pendingStrong.length) { pendingStrong.pop(); } /* MUT */",
-  ],
-  [
-    "`\\texttt{X}` → `` `X` ``",
-    "stop reproducing the one markdown markup the projection can express",
-    '      if (node.content === "texttt" || node.content === "lstinline") {',
-    "      if (false) { /* MUT */",
-  ],
-  [
-    "heading projected to ATX",
-    "stop writing `#` where `\\section` was",
-    '        for (let i = 0; i < depth; i++) chars[pos.start.offset + i] = "#";',
-    '        for (let i = 0; i < 0; i++) chars[pos.start.offset + i] = "#"; /* MUT */',
-  ],
-  [
-    "OPAQUE macro blanking",
-    "leave `\\cite` / `\\label` / `\\input` as prose",
-    "      if (OPAQUE.test(node.content)) {\n        blank(pos.start.offset, argEnd(node).offset + 1);\n        return;\n      }",
-    "      if (false) { return; } /* MUT */",
-  ],
-  [
-    "math blanking",
-    "leave formulas as prose",
-    '    if (\n      (node.type === "inlinemath" ||\n        node.type === "displaymath" ||\n        node.type === "verbatim") &&\n      pos\n    ) {',
-    "    if (false) { /* MUT */",
-  ],
-  [
-    "float prose kept (caption / footnote)",
-    "swallow the caption together with the float again — the double lock returns",
-    "const FLOAT_PROSE = /^(caption|footnote)$/;",
-    "const FLOAT_PROSE = /^(?!)$/; /* 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 ?? "") };
-  }
-};
-
-// 🔴 A BASELINE RUN BEFORE ANY MUTATION — see cause 4 in the header.
-{
-  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(LANG, PRISTINE.replace(from, to));
-  const on = readFileSync(LANG, "utf8");
-  if (!on.includes(to) || on.includes(from)) {
-    console.log(
-      `❌ ${label}: THE MUTATION DID NOT LAND (checked by re-reading the file)`,
-    );
-    bad++;
-    writeFileSync(LANG, PRISTINE);
-    continue;
-  }
-  const { failed, out } = runHarness();
-  writeFileSync(LANG, PRISTINE);
-  if (readFileSync(LANG, "utf8") !== PRISTINE) {
-    console.log(`❌ ${label}: THE ROLLBACK FAILED`);
-    bad++;
-    continue;
-  }
-  const at = (out.match(/latex-language\.harness\.mjs:(\d+)/) ?? [])[1];
-  const msg =
-    (out.match(/AssertionError[^:]*: ([^\n]+)/) ?? [])[1] ??
-    (out.match(/((?:Error|ENOENT)[^\n]*)/) ?? [])[1] ??
-    (out.match(
-      /([^\n]*(?:must|drifted|was lost|is stale|leaked|swallowed)[^\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/paper-research-question.mutations.mjs

@@ -1,127 +0,0 @@
-/**
- * Battery for `paper/research-question` — five mutations, each removes ITS OWN load-bearing
- * property.
- *
- * 🔴 Why the battery matters here specifically. The rule's success state is SILENCE, and on the
- * live corpus it only produces two findings out of four papers. "It passed" and "it cannot fire"
- * look identical from the outside, and only this tells them apart.
- *
- * Two mutations do not target the finding but the SCOPE and the LANGUAGE — the halves a test
- * forgets. Without the stage gate the rule scolds every draft; without markdown it loses
- * `compile-rules`, i.e. half of the real findings, while staying green.
- */
-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-research-question.mjs");
-const HARNESS = join(HERE, "paper-research-question.harness.mjs");
-
-process.exit(
-  runMutations({
-    root: ROOT,
-    runner: "node",
-    cases: [
-      {
-        name: "the rule stops noticing that nothing was declared",
-        harness: HARNESS,
-        expect: "shipped and no question — a finding",
-        disables:
-          "the subject itself: the rule stays silent across the whole corpus, and silence is " +
-          "its success state — from the outside a disabled rule is indistinguishable from a clean paper",
-        edits: [[RULE, 'if (question.trim() === "") {', "if (false) {"]],
-      },
-      {
-        // 🔴 The half that did not exist before 2026-09-19, and the reason the redesign happened.
-        // Without this case the second step could be deleted and the battery would stay green on
-        // the strength of the first — which is how a two-step check quietly becomes a one-step one.
-        name: "the CONTENT check is dropped — a declaration nobody carries passes",
-        harness: HARNESS,
-        expect:
-          "declared but absent from the paper — a finding, where the old pattern was silent",
-        disables:
-          "step two. The scorecard would only have to SAY a question exists, never to have it in " +
-          "the paper — which is the checklist the `bytes` field exists to not be. The predecessor " +
-          "failed the same way from the other side: it matched «we leave the research question to " +
-          "future work» and reported a paper that states no question as clean",
-        edits: [
-          [
-            RULE,
-            "if (flatten(raw).includes(flatten(question))) return;",
-            "return;",
-          ],
-        ],
-      },
-      {
-        name: "the STAGE GATE is removed — drafts get scolded too",
-        harness: HARNESS,
-        expect:
-          "a draft (no stages) — silent, even though it has no question either",
-        disables:
-          "the scope. The rule does not ask 'is there a question', it asks 'is there a question " +
-          "FOR SOMETHING SHIPPED'. Without the gate every draft gets a finding — and a rule that " +
-          "scolds drafts gets turned off within a week, at which point both real findings disappear too",
-        edits: [
-          [
-            RULE,
-            "if (stages.length === 0) return; // not shipped — owes nothing",
-            "",
-          ],
-        ],
-      },
-      {
-        name: "the LANGUAGE narrows to LaTeX — a markdown paper becomes invisible",
-        harness: HARNESS,
-        expect: "a paper in markdown is checked the same way",
-        disables:
-          "the second half of the language. For the `tex/latex` language the text sits in `raw`, " +
-          "for markdown it sits in `text`. The mutation keeps only the first, and " +
-          "`compile-rules-2026` (paper written in markdown, no question) stops being found — HALF " +
-          "of the live corpus's findings disappear silently, and the run stays green",
-        edits: [
-          [
-            RULE,
-            "const raw = context.sourceCode.raw ?? context.sourceCode.text;",
-            "const raw = context.sourceCode.raw;",
-          ],
-        ],
-      },
-      {
-        name: "the stage list is taken from somewhere OTHER than the field again",
-        harness: HARNESS,
-        expect:
-          "the stage list in the message comes from the field and carries BOTH",
-        disables:
-          "the whole reason the move was made. The predecessor derived the stage with a regex " +
-          "over the scorecard's prose and on agenticdev printed `submitted` where `submitted, " +
-          "camera-ready` was declared. The mutation does not change the set of findings — only " +
-          "the TEXT lies, and without its own assert the regression would have passed silently",
-        edits: [
-          [
-            RULE,
-            'data: { stages: stages.join("/") }',
-            'data: { stages: "submitted" }',
-          ],
-        ],
-      },
-      {
-        name: "the scorecard's name stops arriving as an option",
-        harness: HARNESS,
-        expect:
-          "and with a nonexistent scorecard a shipped paper is also silent — the stage gate is load-bearing",
-        disables:
-          "the boundary 'the mechanism goes in the package, the data stays with the consumer'. " +
-          "`PIPELINE-STATUS.md` is ONE repository's convention, and hardcoding it makes the rule unusable for everyone else",
-        edits: [
-          [
-            RULE,
-            'const statusName =\n          context.options?.[0]?.statusFile ?? "PIPELINE-STATUS.md";',
-            'const statusName =\n          "PIPELINE-STATUS.md";',
-          ],
-        ],
-      },
-    ],
-  }),
-);