paperlint 2.0.0

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

@@ -0,0 +1,196 @@
+/**
+ * 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.harness.mjs

@@ -0,0 +1,146 @@
+/**
+ * Both halves for `paper/research-question`, plus two that a test forgets most often: SCOPE
+ * and LANGUAGE.
+ *
+ * The scope is load-bearing here. The rule does not ask "is there a question", it asks "is there
+ * a question FOR SOMETHING THAT HAS ALREADY SHIPPED". Remove the stage gate and the rule starts
+ * scolding every draft in the corpus, and gets turned off within a week. So "silent on a draft"
+ * is checked by its own assert, not treated as a special case of "silent".
+ *
+ * Language is the second forgotten half: a paper in this corpus can be either LaTeX or markdown.
+ * A rule pinned to `.tex` only would LOSE `compile-rules-2026`, where the paper is written in
+ * markdown and states no question — one of the two real findings on the live corpus.
+ */
+import assert from "node:assert/strict";
+import { join, dirname } from "node:path";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { Linter } from "eslint";
+import markdown from "@eslint/markdown";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const FIX = join(HERE, "..", "fixtures", "paper-research-question");
+
+const { texLanguage } = await import(join(HERE, "latex-language.mjs"));
+const rq = (await import(join(HERE, "paper-research-question.mjs"))).default;
+
+let n = 0;
+const check = (label, cond) => {
+  assert.ok(cond, label);
+  n++;
+};
+
+const linter = new Linter();
+
+/** Run against one fixture. The language is picked by extension — exactly like the consumer's config. */
+function lint(dir, file, opts = {}) {
+  const path = join(FIX, dir, file);
+  const tex = file.endsWith(".tex");
+  const cfg = tex
+    ? {
+        files: ["**/*.tex"],
+        plugins: { tex: { languages: { latex: texLanguage } }, paper: rq },
+        language: "tex/latex",
+      }
+    : {
+        // `files` is required, not cosmetic: without it flat config falls back to JS
+        // extensions, and the fixture comes back as "No matching configuration found" — a
+        // message that reads exactly like a clean run.
+        files: ["**/*.md"],
+        plugins: { markdown, paper: rq },
+        language: "markdown/gfm",
+        languageOptions: { frontmatter: "yaml" },
+      };
+  const msgs = linter.verify(
+    readFileSync(path, "utf-8"),
+    [{ ...cfg, rules: { "paper/research-question": ["error", opts] } }],
+    path,
+  );
+  assert.deepEqual(
+    msgs.filter((m) => m.fatal),
+    [],
+    `${dir}/${file}: the rule threw`,
+  );
+  return msgs.map((m) => m.message);
+}
+
+// ── fires on a planted defect ───────────────────────────────────────────────────────────
+const fires = lint("shipped-no-rq", "paper.tex");
+check("shipped and no question — a finding", fires.length === 1);
+// 🔴 The message must name WHERE the requirement comes from. Without this it reads as the
+// linter's taste, but the requirement came from a real venue reviewer.
+check(
+  "and it cites the reviewer, rather than passing this off as the linter's taste",
+  /reviewer/i.test(fires[0]),
+);
+// The stages in the text come from the FIELD. The predecessor derived them with a regex over
+// the scorecard's prose and on agenticdev printed `submitted` where `submitted, camera-ready`
+// was declared.
+check(
+  "the stage list in the message comes from the field and carries BOTH",
+  /submitted\/camera-ready/.test(fires[0]),
+);
+
+// markdown — the second half of LANGUAGE, without it one of the two real findings is lost
+check(
+  "a paper in markdown is checked the same way",
+  lint("markdown-no-rq", "paper.md").length === 1,
+);
+
+// ── THE CASE THE PREDECESSOR COULD NOT EXPRESS ──────────────────────────────────────────
+// 🔴 The point of the 2026-09-19 redesign, in one fixture. The scorecard declares a question,
+// the paper does not carry it — AND the paper contains the words "research question", inside
+// "We leave the research question to future work". The old pattern matched that phrase and went
+// SILENT on a paper stating no question at all. Matching a sentence ABOUT the thing is not
+// finding the thing, and no list of spellings fixes that.
+const drifted = lint("declared-not-in-paper", "paper.tex");
+check(
+  "declared but absent from the paper — a finding, where the old pattern was silent",
+  drifted.length === 1,
+);
+check(
+  "and the message QUOTES what was looked for, so the author can see why it missed",
+  /does pruning reduce review cost\?/i.test(drifted[0]),
+);
+
+// ── stays silent where it must ──────────────────────────────────────────────────────────
+check(
+  "the question is stated — silent",
+  lint("shipped-with-rq", "paper.tex").length === 0,
+);
+// The stage gate: a draft owes nothing, because it never asked anyone to read it.
+check(
+  "a draft (no stages) — silent, even though it has no question either",
+  lint("draft", "paper.tex").length === 0,
+);
+// And the distinguisher against the previous case: the same draft with a SWAPPED scorecard
+// name is also silent — so the silence there is not because the file went unfound, it's
+// because the stage list is empty.
+check(
+  "and with a nonexistent scorecard a shipped paper is also silent — the stage gate is load-bearing",
+  lint("shipped-no-rq", "paper.tex", { statusFile: "NO-SUCH-FILE.md" })
+    .length === 0,
+);
+
+// ── a named hole, pinned down by an assert, and RESHAPED by the redesign ────────────────
+// ⚠️ The hole changed form on 2026-09-19 and did not close. Before, ANY mention of "RQ" in a
+// LaTeX comment silenced the rule. Now the rule no longer hunts for spellings, so this fixture
+// — a comment saying "TODO: state the research question", with no `researchQuestion` field —
+// is a FINDING, which it never was before. What survives is narrower: if the DECLARED sentence
+// appears only inside a comment, the raw-text comparison still accepts it. That is a smaller
+// hole with a named owner, and closing it means walking the parsed tree.
+check(
+  "a paper whose only mention is a comment, with nothing declared, is now a finding",
+  lint("comment-only", "paper.tex").length === 1,
+);
+
+// ── the scorecard's name is consumer data ───────────────────────────────────────────────
+check(
+  "the scorecard's name comes in as an option",
+  lint("shipped-no-rq", "paper.tex", { statusFile: "PIPELINE-STATUS.md" })
+    .length === 1,
+);
+
+console.log(
+  `✓ ${String(n)} assertions passed — paper/research-question, the debt of a shipped paper`,
+);

package/eslint-rules/paper-research-question.mjs

@@ -0,0 +1,180 @@
+/**
+ * `paper/research-question` — a shipped paper states its research question EXPLICITLY.
+ *
+ * Reviewer A's verbatim point on agenticdev (#20), as it was parsed: "State the goal as a
+ * research question." This is a venue expectation, not taste: an empirical paper that never
+ * names the question it answers forces the reviewer to reconstruct it — and they say so.
+ *
+ * ── WHY THE SCOPE IS SHIPPED PAPERS ONLY ─────────────────────────────────────────────────
+ * A draft never asked anyone to read it. The scope deliberately matches `paper/author-list`:
+ * both are about the DEBT of a shipped paper, and an unshipped one has no debt. Measured on the
+ * live corpus before the move:
+ *     agenticdev-2026   has RQ,   shipped        -> silent  (added because of this very review)
+ *     aisec-2026        no RQ,    shipped        -> a finding
+ *     compile-rules     no RQ,    shipped        -> a finding
+ *     scored-2026       no RQ,    NOT shipped    -> silent
+ *
+ * ── WHAT THE MOVE CHANGED ─────────────────────────────────────────────────────────────────
+ * The predecessor read the stage with a REGEX OVER THE SCORECARD'S PROSE. Remeasured 2026-09-17:
+ * for `agenticdev-2026` the prose reads `submitted`, while the `stages` field declares
+ * `submitted, camera-ready`. Here the stage comes from the FIELD — the same one `paper/stages`
+ * checks against the bytes in both directions.
+ *
+ * ⚠️ WHAT THE MOVE DOES NOT FIX, AND THIS IS MEASURED, NOT ASSUMED. The rule reads RAW text, not
+ * the parsed tree, so a mention of RQ inside a LaTeX comment (`% add an RQ`) will put it to
+ * sleep. Measured 2026-09-17 across all four papers: ZERO such cases — not a single match inside
+ * a comment. So the hole is LATENT, not observed, and closing it with a tree walk would
+ * complicate the rule without a measured difference. The neighboring `paper/typography` is built
+ * the same way and for the same reason. Once a real case shows up, there will be something to
+ * cite here.
+ *
+ * The rule is ADVISORY by decision, not by coincidence: a position paper may legitimately have
+ * no question. Then its absence is the author's decision, and the rule says exactly that,
+ * rather than declaring the absence a defect on its own.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { load } from "js-yaml";
+
+/**
+ * 🔴 THE REGEX IS GONE, AND THE REASON IS NOT "regexes are bad" — IT IS THAT IT ANSWERED THE
+ * WRONG QUESTION (2026-09-19).
+ *
+ * What stood here was `/\\textbf\{RQ|\bRQ[0-9]?\b|research question/i`, defended in this very
+ * file with: "a regex is LEGITIMATE here: the subject is human prose, which has no structure by
+ * definition, and no parser can tell a question's statement apart from a paragraph about it."
+ *
+ * The premise is true. The conclusion does not follow. From "the text cannot decide this" the
+ * answer is not "so pattern-match harder" — it is "so the HUMAN declares it, and the check
+ * compares the declaration against the text." The three spellings were an undeclared schema
+ * field: someone added a fact and invented a convention for how it would look in prose, which is
+ * the design running backwards.
+ *
+ * What the pattern actually decided, in both directions:
+ *   • a paper that says "we leave the research question to future work" — MATCHED, and the rule
+ *     went silent on a paper that states no question at all;
+ *   • a paper whose question is written plainly ("Does pruning reduce review cost?") with no
+ *     "RQ" anywhere — NOT matched, and the rule reported a paper that does exactly what is asked.
+ * An open list of spellings cannot be completed, so both failures are structural, not bugs.
+ *
+ * ── WHAT REPLACES IT: ONE UNDECIDABLE QUESTION BECOMES TWO DECIDABLE ONES ──────────────────
+ *   1. Is the question WRITTEN DOWN? — `researchQuestion` in the scorecard's front matter. A
+ *      field, parsed by js-yaml, not a phrase hunted for in prose.
+ *   2. Does the paper CONTAIN what was written down? — the declared sentence, whitespace
+ *      collapsed, compared against the source. Bytes, not spelling.
+ *
+ * This is the shape this package already uses twice, and for the same reason: `bytes`/
+ * `sourceBytes` (a recorded number compared against the file on disk) and `paper/author-list`
+ * (a recorded marker, because whether a cross-check ran is not visible in the paper). Neither
+ * asks the prose a question the prose cannot answer.
+ *
+ * ⚠️ WHAT THIS STILL CANNOT DO, said plainly rather than implied: nothing here decides that the
+ * declared sentence IS a research question. A declaration of "banana" passes step 1 and, if the
+ * word appears in the paper, step 2. The rule guarantees that the author wrote a question down
+ * and that the paper carries it — it does not grade the question. That is a human's job, and
+ * pretending otherwise is what the regex was doing.
+ */
+
+/** Whitespace is the only thing normalised: a sentence wrapped across lines is the same sentence. */
+const flatten = (t) => t.replace(/\s+/g, " ").trim().toLowerCase();
+
+/**
+ * Both facts come out of ONE parse of the scorecard's front matter: the stages (has this paper
+ * shipped?) and the declared question. Reading them separately would invite the two to be taken
+ * from different revisions of the same file.
+ */
+function scorecard(dir, statusName) {
+  const p = join(dir, statusName);
+  const none = { stages: [], question: "" };
+  if (!existsSync(p)) return none;
+  let text;
+  try {
+    text = readFileSync(p, "utf-8");
+  } catch {
+    return none;
+  }
+  const m = /^---\n([\s\S]*?)\n---/.exec(text);
+  if (!m) return none;
+  let data;
+  try {
+    data = load(m[1]);
+  } catch {
+    return none; // the unreadable YAML is already reported by `paper/stages`, on its own file
+  }
+  const raw = data?.stages;
+  const stages = Array.isArray(raw)
+    ? raw.map((r) => r?.stage).filter(Boolean)
+    : [];
+  const q = data?.researchQuestion;
+  return { stages, question: typeof q === "string" ? q : "" };
+}
+
+export default {
+  rules: {
+    "research-question": {
+      meta: {
+        type: "suggestion",
+        docs: {
+          description:
+            "a paper that declares a stage states its research question explicitly — otherwise the reviewer reconstructs it themselves, and says so",
+        },
+        schema: [
+          {
+            type: "object",
+            properties: {
+              // The scorecard's name is a CONSUMER convention. The rule is declared on the
+              // paper's source, so it has to name its neighbor itself rather than get it via a
+              // config glob.
+              statusFile: { type: "string" },
+            },
+            additionalProperties: false,
+          },
+        ],
+        messages: {
+          notDeclared:
+            "the paper shipped (stage «{{stages}}») and its scorecard declares no `researchQuestion`. This is reviewer A's verbatim point on agenticdev (#20), not the linter's taste. Write the question down as a field, in your own words — the check cannot infer it from the prose, and the pattern that used to try matched «we leave the research question to future work» while missing a question stated plainly. Advisory: a position paper may legitimately have none, and then leaving the field out is a DECISION — record it as one",
+          notInPaper:
+            "the scorecard declares a research question the paper does not contain. Looked for «{{needle}}» with whitespace collapsed, and the source has no such run of text. Either the paper dropped it or the declaration drifted from what was written — and which of the two it is, only you know",
+        },
+      },
+      create(context) {
+        const statusName =
+          context.options?.[0]?.statusFile ?? "PIPELINE-STATUS.md";
+        return {
+          // `root:exit` exists for both markdown and the `tex/latex` language — the same place
+          // `paper/typography` lives, and for the same reason: a paper in this corpus can be
+          // either.
+          "root:exit"(node) {
+            const raw = context.sourceCode.raw ?? context.sourceCode.text;
+            if (typeof raw !== "string") return;
+            const { stages, question } = scorecard(
+              dirname(context.filename),
+              statusName,
+            );
+            if (stages.length === 0) return; // not shipped — owes nothing
+
+            // Step 1 — is it written down? A field, not a phrase hunted for in prose.
+            if (question.trim() === "") {
+              context.report({
+                node,
+                messageId: "notDeclared",
+                data: { stages: stages.join("/") },
+              });
+              return;
+            }
+
+            // Step 2 — does the paper carry what was written down? Bytes, not spelling. Only
+            // whitespace is normalised, because a sentence wrapped across source lines is the
+            // same sentence; everything else stays the author's.
+            if (flatten(raw).includes(flatten(question))) return;
+            context.report({
+              node,
+              messageId: "notInPaper",
+              data: { needle: flatten(question) },
+            });
+          },
+        };
+      },
+    },
+  },
+};

package/eslint-rules/paper-research-question.mutations.mjs

@@ -0,0 +1,127 @@
+/**
+ * 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";',
+          ],
+        ],
+      },
+    ],
+  }),
+);