paperlint 4.1.0 → 5.0.0

package/src/tex-venue-rules.ts

@@ -28,6 +28,7 @@ import {
   missingOptions,
   runText,
   spanIn,
+  type ClassCandidate,
   type ClassLine,
   type DocumentClass,
   type Heading,
@@ -44,6 +45,8 @@ import {
   shippedPresets,
   type Preset,
 } from "./presets.ts";
+import type { PaperSource } from "./domain/paper-source.ts";
+import { readPaper, reportInPaper } from "./tex-paper.ts";
 import type { RequiredSection } from "./tex-requirements.ts";
 import type { Finding, VenueRuleDeps } from "./venue-rules.ts";
 
@@ -55,19 +58,27 @@ export interface Located extends Finding {
 /** The slice of ESLint's rule context these rules use. `raw` exists on the `.tex` language's. */
 export interface TexRuleContext {
   readonly filename: string;
+  /** The rule's options from the config, as ESLint validated them against its schema. */
+  readonly options?: readonly unknown[];
   readonly sourceCode: {
     readonly text: string;
     readonly raw?: string;
     getLocFromIndex(index: number): Readonly<{ line: number; column: number }>;
   };
-  report(d: {
-    readonly loc: {
-      readonly start: { line: number; column: number };
-      readonly end: { line: number; column: number };
-    };
-    readonly messageId: string;
-    readonly data?: Readonly<Record<string, string | number>>;
-  }): void;
+  report(
+    d: {
+      readonly loc: {
+        readonly start: { line: number; column: number };
+        readonly end: { line: number; column: number };
+      };
+    } & (
+      | {
+          readonly messageId: string;
+          readonly data?: Readonly<Record<string, string | number>>;
+        }
+      | { readonly message: string }
+    ),
+  ): void;
 }
 
 export interface TexRuleModule {
@@ -110,6 +121,30 @@ function judgeClass(
   }));
 }
 
+/** A candidate as the message names it: its line, or an empty `\documentclass{}`. */
+const candidateLine = (c: ClassCandidate): string =>
+  c.kind === "class" ? documentClassLine(c) : "\\documentclass{}";
+
+/**
+ * Several class lines behind a TeX switch: satisfied when any candidate is the template's class
+ * with its options; otherwise one finding, at the first candidate, naming every one.
+ */
+function judgeCandidates(
+  candidates: readonly [ClassCandidate, ...ClassCandidate[]],
+  want: DocumentClass,
+  data: TemplateData,
+): readonly Located[] {
+  const matches = candidates.some(
+    (c) => c.kind === "class" && judgeClass(c, want, data).length === 0,
+  );
+  if (matches) return [];
+  const named = candidates.map((c) => `\`${candidateLine(c)}\``).join(", ");
+  const found = { ...data, count: candidates.length, candidates: named };
+  return [
+    { messageId: "noCandidate", data: found, at: spanOf(candidates[0].place) },
+  ];
+}
+
 /** The paper's class line against a template that was read: present, naming a class, that class. */
 function judgeClassLine(
   line: ClassLine,
@@ -123,6 +158,8 @@ function judgeClassLine(
       return [{ messageId: "emptyClass", data, at: spanOf(line.place) }];
     case "class":
       return judgeClass(line, want, data);
+    case "ambiguous":
+      return judgeCandidates(line.candidates, want, data);
   }
 }
 
@@ -252,7 +289,9 @@ export function judgeLeftover(
 }
 
 /** Where a rule's page lives: `docs/rules/tex/<name>.md` on the default branch. */
-export const ruleDocsUrl = (name: TexVenueRuleName): string =>
+export const ruleDocsUrl = (
+  name: TexVenueRuleName | "claim-provenance" | "register",
+): string =>
   `https://github.com/zernie/paperlint/blob/main/docs/rules/tex/${name}.md`;
 
 /** What a judge reads: the paper's source through the reader, its preset, the other venues. */
@@ -295,6 +334,8 @@ const RULES: Readonly<
           "the class is `{{got}}`, and {{venue}} requires `{{template}}` — the page size, fonts and layout the venue checks come from the class",
         missingOption:
           "the class option `{{option}}` is missing: {{venue}} requires `{{template}}`",
+        noCandidate:
+          "none of the {{count}} \\documentclass lines is `{{template}}`, which {{venue}} requires: {{candidates}}. The source picks one behind a TeX switch, which is not evaluated; make one of them the venue's",
       },
     },
   },
@@ -368,35 +409,25 @@ export interface TexVenueRuleDeps extends VenueRuleDeps {
 }
 
 /**
- * What a judge reads for the paper whose `paper.tex` is `filename`, or null when the paper has no
- * resolved preset (`pdf/measured` and `pdf/profile` already say so).
+ * What a judge reads for the paper whose `paper.tex` is `filename` — the paper with its includes
+ * spliced (`readPaper`) — or null when the paper has no resolved preset (`pdf/measured` and
+ * `pdf/profile` already say so).
  */
 function readingOf(
   filename: string,
   src: string,
   deps: TexVenueRuleDeps,
-): Reading | null {
+): { readonly reading: Reading; readonly paper: PaperSource } | null {
   const dir = dirname(filename);
   const p = paperPreset(dir, deps);
   if (p.kind !== "resolved") return null;
   const preset = p.preset;
   const others = () => otherVenues(preset, join(dir, CONFIG_FILE), deps);
-  return { src, latex: deps.latex, preset, others };
-}
-
-/** Each finding reported at its span, or at the top of the file when it has none. */
-function reportAll(
-  context: TexRuleContext,
-  findings: readonly Located[],
-): void {
-  const at = (i: number) => context.sourceCode.getLocFromIndex(i);
-  findings.forEach((f) => {
-    context.report({
-      loc: { start: at(f.at?.start ?? 0), end: at(f.at?.end ?? 0) },
-      messageId: f.messageId,
-      data: f.data,
-    });
-  });
+  const paper = readPaper(filename, src, deps);
+  return {
+    reading: { src: paper.text, latex: deps.latex, preset, others },
+    paper,
+  };
 }
 
 function rule(name: TexVenueRuleName, deps: TexVenueRuleDeps): TexRuleModule {
@@ -409,8 +440,9 @@ function rule(name: TexVenueRuleName, deps: TexVenueRuleDeps): TexRuleModule {
       return {
         root() {
           const sc = context.sourceCode;
-          const reading = readingOf(context.filename, sc.raw ?? sc.text, deps);
-          if (reading !== null) reportAll(context, judge(reading));
+          const r = readingOf(context.filename, sc.raw ?? sc.text, deps);
+          if (r !== null)
+            reportInPaper(context, meta.messages, r.paper, judge(r.reading));
         },
       };
     },

package/templates/paper/PIPELINE-STATUS.md

@@ -1,10 +1,6 @@
 ---
 # Created by `paperlint new` — from <papers>/.template/ when the project keeps one, else from the package.
 #
-# researchQuestion — the paper's question, one sentence, written the way it appears in the paper.
-# `paper/research-question` reads it once the paper has shipped a stage. Empty until you have it.
-researchQuestion: ""
-#
 # There is no `stages` field yet, on purpose: a new paper has shipped nothing and owes nothing.
 # When it reaches a stage, add the record — its shape is in docs/rules.md of the package.
 ---

package/dist/action-ref.d.ts

@@ -1,12 +0,0 @@
-/**
- * The ref `paperlint init` pins the GitHub Action to, decided from the version of the package that is
- * running. semantic-release tags every release `v<version>` on the commit it publishes, so the
- * action at that tag is the same code as the installed package.
- *
- * Only a plain `X.Y.Z` has such a tag. A git checkout or `npm link` carries the unreleased
- * placeholder `0.0.0-semantically-released`, a version that could not be read is `undefined`, and
- * anything else is not known to be tagged: those return `null` ("no pin known"), and the caller
- * keeps the placeholder. A wrong tag written confidently is worse than an obvious placeholder.
- */
-export declare function actionRef(version: string | undefined): string | null;
-//# sourceMappingURL=action-ref.d.ts.map

package/dist/action-ref.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"action-ref.d.ts","sourceRoot":"","sources":["../src/action-ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAIpE"}

package/dist/action-ref.js

@@ -1,16 +0,0 @@
-/**
- * The ref `paperlint init` pins the GitHub Action to, decided from the version of the package that is
- * running. semantic-release tags every release `v<version>` on the commit it publishes, so the
- * action at that tag is the same code as the installed package.
- *
- * Only a plain `X.Y.Z` has such a tag. A git checkout or `npm link` carries the unreleased
- * placeholder `0.0.0-semantically-released`, a version that could not be read is `undefined`, and
- * anything else is not known to be tagged: those return `null` ("no pin known"), and the caller
- * keeps the placeholder. A wrong tag written confidently is worse than an obvious placeholder.
- */
-export function actionRef(version) {
-    return version !== undefined && /^\d+\.\d+\.\d+$/.test(version)
-        ? `v${version}`
-        : null;
-}
-//# sourceMappingURL=action-ref.js.map

package/dist/action-ref.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"action-ref.js","sourceRoot":"","sources":["../src/action-ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,UAAU,SAAS,CAAC,OAA2B;IACnD,OAAO,OAAO,KAAK,SAAS,IAAI,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC;QAC7D,CAAC,CAAC,IAAI,OAAO,EAAE;QACf,CAAC,CAAC,IAAI,CAAC;AACX,CAAC"}

package/dist/eslint-rules/paper-research-question.d.ts

@@ -1,31 +0,0 @@
-import type { RuleContext } from "./rule-context.ts";
-declare const _default: {
-    rules: {
-        "research-question": {
-            meta: {
-                type: "suggestion";
-                docs: {
-                    description: string;
-                };
-                schema: {
-                    type: string;
-                    properties: {
-                        statusFile: {
-                            type: string;
-                        };
-                    };
-                    additionalProperties: boolean;
-                }[];
-                messages: {
-                    notDeclared: string;
-                    notInPaper: string;
-                };
-            };
-            create(context: RuleContext): {
-                "root:exit"(node: object): void;
-            };
-        };
-    };
-};
-export default _default;
-//# sourceMappingURL=paper-research-question.d.ts.map

package/dist/eslint-rules/paper-research-question.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"paper-research-question.d.ts","sourceRoot":"","sources":["../../eslint-rules/paper-research-question.ts"],"names":[],"mappings":"AAsCA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;;;;;;;;;;;;;;;;;;;;;;;4BAuH/B,WAAW;kCAQL,MAAM;;;;;AApClC,wBAqEE"}

package/dist/eslint-rules/paper-research-question.js

@@ -1,188 +0,0 @@
-/**
- * `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";
-import { z } from "zod";
-/**
- * The two scorecard fields this rule reads, parsed rather than trusted: a field of the wrong shape
- * reads as absent, the way `data?.stages` on a string or a number always did.
- */
-const Scorecard = z
-    .looseObject({
-    stages: z.array(z.unknown()).catch([]),
-    researchQuestion: z.string().catch(""),
-})
-    .catch({ stages: [], researchQuestion: "" });
-const StageEntry = z.looseObject({ stage: z.unknown().optional() }).catch({});
-const RuleOptions = z
-    .object({ statusFile: z.string().default("PIPELINE-STATUS.md") })
-    .default({ statusFile: "PIPELINE-STATUS.md" });
-/**
- * 🔴 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;
-    const [, front = ""] = m;
-    let data;
-    try {
-        data = load(front);
-    }
-    catch {
-        return none; // the unreadable YAML is already reported by `paper/stages`, on its own file
-    }
-    const { stages: raw, researchQuestion: question } = Scorecard.parse(data);
-    const stages = raw.map((r) => StageEntry.parse(r).stage).filter(Boolean);
-    return { stages, question };
-}
-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 { statusFile: statusName } = RuleOptions.parse(context.options[0]);
-                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) },
-                        });
-                    },
-                };
-            },
-        },
-    },
-};
-//# sourceMappingURL=paper-research-question.js.map

package/dist/eslint-rules/paper-research-question.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"paper-research-question.js","sourceRoot":"","sources":["../../eslint-rules/paper-research-question.ts"],"names":[],"mappings":"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"}

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

@@ -1,212 +0,0 @@
-/**
- * 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 {
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  realpathSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { Linter } from "eslint";
-import markdown from "@eslint/markdown";
-import { createChecker } from "../lib/check.ts";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const FIX = join(HERE, "..", "fixtures", "paper-research-question");
-
-const { texLanguage } = await import(join(HERE, "latex-language.ts"));
-const rq = (await import(join(HERE, "paper-research-question.ts"))).default;
-
-const check = createChecker();
-
-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,
-);
-
-// ── a scorecard that cannot be read is no scorecard: silence, never a crash ────────────
-// A directory where the file should be (EISDIR), and front matter that is not YAML — which
-// `paper/stages` reports on the scorecard itself, so this rule does not report it twice.
-{
-  const work = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-rq-")));
-  try {
-    const paperIn = (name, status) => {
-      const dir = join(work, name);
-      mkdirSync(dir);
-      status(join(dir, "PIPELINE-STATUS.md"));
-      const path = join(dir, "paper.md");
-      writeFileSync(path, "# A paper\n");
-      // A linter rooted at the scratch directory: files outside `cwd` match no config.
-      return new Linter({ cwd: work }).verify(
-        "# A paper\n",
-        [
-          {
-            files: ["**/*.md"],
-            plugins: { markdown, paper: rq },
-            language: "markdown/gfm",
-            rules: { "paper/research-question": "error" },
-          },
-        ],
-        path,
-      );
-    };
-    check(
-      "a scorecard path that is a directory: no finding, no crash",
-      JSON.stringify(paperIn("dir", (p) => mkdirSync(p))) === "[]",
-      () => paperIn("dir2", (p) => mkdirSync(p)),
-    );
-    check(
-      "a scorecard whose front matter is not YAML: no finding, no crash",
-      JSON.stringify(
-        paperIn("yaml", (p) =>
-          writeFileSync(p, "---\nstages: [submitted\n---\n"),
-        ),
-      ) === "[]",
-    );
-  } finally {
-    rmSync(work, { recursive: true, force: true });
-  }
-}
-
-// ── a language whose source code carries no text at all: nothing to compare, silence ───
-{
-  const reports = [];
-  rq.rules["research-question"]
-    .create({
-      options: [],
-      filename: join(FIX, "shipped-no-rq", "paper.tex"),
-      sourceCode: {},
-      report: (r) => reports.push(r),
-    })
-    ["root:exit"]({});
-  check(
-    "a source code with neither `raw` nor `text` is skipped, even for a shipped paper",
-    reports.length === 0,
-  );
-}
-
-console.log(
-  `✓ ${String(check.count)} assertions passed — paper/research-question, the debt of a shipped paper`,
-);