paperlint 4.2.0 → 5.0.0

package/src/cli.test.ts

@@ -14,7 +14,6 @@ import type { runToolchain } from "./toolchain.ts";
 import {
   chooseVenue,
   initTexLive,
-  ownVersion,
   paperRuleBlocks,
   parseArgs,
   parseSettings,
@@ -259,7 +258,7 @@ test("build: a markdown-only paper is refused", async () => {
     code: 1,
     out: [
       "papers/md",
-      `  inputs: TEXINPUTS += ${venues}`,
+      `  inputs: TEXINPUTS += the paper's directory, then ${venues}`,
       "  compile: refused — no paper.tex; paperlint compiles LaTeX, and this paper has none",
       "  measure: skipped — nothing is compiled",
       "  references: skipped — nothing is compiled",
@@ -288,7 +287,7 @@ test("build: with no TeX Live a dry run says where a real run stops, and a real
         out: [
           `engine: none — a real run would stop here: paperlint build: no TeX Live with every package these papers need — run \`npx paperlint toolchain\` (${missing})`,
           "papers/tex",
-          `  inputs: TEXINPUTS += ${venues}`,
+          `  inputs: TEXINPUTS += the paper's directory, then ${venues}`,
           "  compile: paper.tex (\\documentclass{article})",
           "  measure: pdf.js → _build/paper.facts.json (facts for the lint rules; nothing is judged here)",
           "  references: online: citations exist, titles and authors match → _build/references.json (never fails the build)",
@@ -529,21 +528,6 @@ test("chooseVenue: a question that fails (the stream ended) takes the default, n
   assert.deepEqual(r, { ok: true, value: null });
 });
 
-test("ownVersion: the manifest's version; an unreadable manifest or a non-string version is undefined", () => {
-  assert.deepEqual(
-    [
-      ownVersion(() => '{"version": "1.2.3"}'),
-      ownVersion(() => "{ nope"),
-      ownVersion(() => '{"version": 3}'),
-      ownVersion(() => {
-        throw new Error("ENOENT");
-      }),
-      typeof ownVersion(),
-    ],
-    ["1.2.3", undefined, undefined, undefined, "string"],
-  );
-});
-
 test("init's TeX Live install runs the toolchain over the project's papers, never a check", () => {
   const dir = writeTree(join(root, "init-tex"), { "package.json": "{}" });
   const calls: Parameters<typeof runToolchain>[0][] = [];

package/src/cli.ts

@@ -9,8 +9,8 @@
  * but that is INTERNAL machinery, and you no longer need to know it in order to run them.
  *
  * Two entry points into the tool, and both are whole now:
- *     npx paperlint lint              ← here
- *     uses: zernie/paperlint@<sha>    ← action.yml
+ *     npx paperlint lint                ← here
+ *     uses: ./node_modules/paperlint    ← action.yml, after `npm ci`
  *
  * ⚠️ THE BOUNDARY THIS UTILITY HAS NO RIGHT TO ERASE: the consumer's data stays with the consumer.
  * Where the papers are and the project's own rule blocks — that is about ONE corpus, so it lives in
@@ -42,6 +42,7 @@ import {
   asEslintResults,
 } from "./structure.ts";
 import { buildPapers, papersIn, anyFailed, remedyFor, MAIN } from "./build.ts";
+import { includeBlocks, paperBodies, unreadLines } from "./paper-includes.ts";
 import { prepareEngine } from "./build-engine.ts";
 import { cacheRoot, cachedTree, runToolchain } from "./toolchain.ts";
 import { banalInstaller, parseBanalSettings } from "./adapters/banal/index.ts";
@@ -52,7 +53,6 @@ import { VENUE_RULE_LEVELS, venueRules } from "./venue-rules.ts";
 import { TEX_VENUE_RULE_LEVELS, texVenueRules } from "./tex-venue-rules.ts";
 import { claimProvenanceRule } from "./claim-provenance.ts";
 import { registerRule } from "./register.ts";
-import { missingInputRule } from "./tex-paper.ts";
 import {
   paperRules,
   stringFields,
@@ -125,7 +125,6 @@ export { init };
 export { nextSteps } from "./init.ts";
 
 import paperStages from "#eslint-rules/paper-stages";
-import researchQuestion from "#eslint-rules/paper-research-question";
 import typography from "#eslint-rules/paper-typography";
 import texBuild from "#eslint-rules/tex-build";
 import bibReachable from "#eslint-rules/bib-reachable-entry";
@@ -228,7 +227,7 @@ export function buildConfig(
   opts: PaperlintConfig = {},
   texLanguage: unknown,
 ): ConfigBlock[] {
-  const paperRules = { ...researchQuestion.rules, ...typography.rules };
+  const paperRules = { ...typography.rules };
   // The reference rules judge `_build/references.json`, and only on `paper.tex`.
   const texPaperRules = {
     ...paperRules,
@@ -236,7 +235,6 @@ export function buildConfig(
   };
   // Each typography rule reports every occurrence where it is, and fixes it (`--fix`).
   const prose = {
-    "paper/research-question": "warn",
     "paper/section-word": "warn",
     "paper/leading-zero": "warn",
   };
@@ -319,10 +317,6 @@ export function buildConfig(
               files: nodeFiles,
               latex: latexReader,
             }),
-            "missing-input": missingInputRule({
-              files: nodeFiles,
-              latex: latexReader,
-            }),
             register: registerRule({
               files: nodeFiles,
               latex: latexReader,
@@ -341,7 +335,6 @@ export function buildConfig(
         "tex/future-promise": "warn",
         // A number with no owner: a prose rule, on beside the others above.
         "tex/claim-provenance": "warn",
-        "tex/missing-input": "warn",
         // Sentence-initial conjunctions over the whole body: register, not vocabulary.
         "tex/register": "warn",
         "tex/acm-frontmatter-override": "error",
@@ -350,17 +343,54 @@ export function buildConfig(
         ...TEX_VENUE_RULE_LEVELS,
       },
     });
+  // THE FILES A paper.tex INCLUDES FROM ITS BODY, each read on its own and reported at its own path
+  // (#144). The block claims every `.tex` but `paper.tex` — yet it is left out of the scope below, so
+  // it reaches only the files `paperlint lint` un-ignores by name for each paper (src/paper-includes.ts):
+  // a frozen version or a macro file is never enumerated. The rules are the ones that read a file as
+  // a fragment (no `document` environment: all of it is body); the whole-paper rules stay on
+  // `paper.tex`, which reads its includes itself (src/tex-paper.ts).
+  const fragments: readonly ConfigBlock[] = texLanguage
+    ? [
+        {
+          files: ["**/*.tex"],
+          ignores: ["**/paper.tex"],
+          plugins: {
+            tex: {
+              languages: { latex: texLanguage },
+              rules: { "future-promise": texBuild["future-promise"] },
+            },
+            paper: {
+              rules: {
+                "section-word": typography.rules["section-word"],
+                "leading-zero": typography.rules["leading-zero"],
+                "figure-ref-style": typography.rules["figure-ref-style"],
+              },
+            },
+          },
+          language: "tex/latex",
+          rules: {
+            "paper/section-word": "warn",
+            "paper/leading-zero": "warn",
+            "paper/figure-ref-style": "warn",
+            "tex/future-promise": "warn",
+          },
+        },
+      ]
+    : [];
   // 🔴 ONLY THE FILES THESE BLOCKS CLAIM ARE LINTED (src/paper-files.ts). Without this block ESLint's
   // built-in defaults lint every .js/.mjs/.cjs under the papers directory — a paper's vendored
   // `repro/` code failed the run with 74 parse errors and not one finding on a paper file. It goes
   // FIRST: the `.template/` ignore below must come after its directory un-ignore to win.
-  const owners = ruleOwners(cfg);
+  const owners = ruleOwners([...cfg, ...fragments]);
   cfg.unshift(scopeToOwned(ownedPatterns(cfg)));
   // The consumer's own blocks, LAST, so a later block wins — ESLint's rule. Parsed by
   // `readConfig`; each carries the settings file's directory as its `basePath`. Each is split so a
   // rule reaches only the files its plugin is registered for: `paper` is a different plugin beside
   // PIPELINE-STATUS.md than beside paper.tex, and ESLint throws on a rule its plugin lacks.
-  cfg.push(...(opts.rules ?? []).flatMap((b) => narrowToOwners(b, owners)));
+  cfg.push(
+    ...fragments,
+    ...(opts.rules ?? []).flatMap((b) => narrowToOwners(b, owners)),
+  );
   return cfg;
 }
 
@@ -501,6 +531,17 @@ export async function silentOptionalRules(
   return [...turnedOn].filter((id) => !reached.has(id));
 }
 
+/**
+ * The paper directories `paths` reach: each directory and the papers under it. A FILE named on the
+ * command line belongs to the paper it sits in.
+ */
+function paperDirs(paths: readonly string[]): readonly string[] {
+  const dirs = paths.map((p) =>
+    existsSync(p) && statSync(p).isFile() ? dirname(p) : p,
+  );
+  return [...new Set(dirs.flatMap((p) => [p, ...papersIn(p)]))];
+}
+
 /**
  * Every linted paper's rules, as ESLint blocks scoped to that paper, in two groups: what its venue
  * preset turns on, and what its own `paperlint.json` says. The caller puts the root's blocks between
@@ -510,11 +551,7 @@ export async function silentOptionalRules(
 export function paperRuleBlocks(
   paths: readonly string[],
 ): Parsed<{ preset: RuleBlock[]; own: RuleBlock[] }> {
-  // A FILE named on the command line belongs to the paper it sits in: that paper's settings apply.
-  const dirs = paths.map((p) =>
-    existsSync(p) && statSync(p).isFile() ? dirname(p) : p,
-  );
-  const papers = [...new Set(dirs.flatMap((p) => [p, ...papersIn(p)]))];
+  const papers = paperDirs(paths);
   const out: { preset: RuleBlock[]; own: RuleBlock[] } = {
     preset: [],
     own: [],
@@ -765,28 +802,6 @@ const VALUE_FLAGS: ReadonlySet<string> = new Set([
   "--max-warnings",
 ]);
 
-/**
- * This package's own version, from the `package.json` beside `src/` and `dist/` alike. `init` pins
- * the CI action to its release tag; an unreadable manifest yields `undefined`, and init then keeps
- * the placeholder instead of guessing.
- */
-export function ownVersion(
-  readManifest: () => string = () =>
-    readFileSync(new URL("../package.json", import.meta.url), "utf8"),
-): string | undefined {
-  try {
-    const manifest: unknown = JSON.parse(readManifest());
-    return typeof manifest === "object" &&
-      manifest !== null &&
-      "version" in manifest &&
-      typeof manifest.version === "string"
-      ? manifest.version
-      : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
 /**
  * Reading the config, ONE reader for all commands. Pulled out of `run()` the moment a second
  * command needed the same config (`build`): two copies of this block would have drifted apart on
@@ -1421,7 +1436,6 @@ async function runInit(
     log,
     err,
     cwd,
-    version: ownVersion(),
     yes: a.yes,
     hooks: !a.noHooks,
     paper: a.paper,
@@ -1557,10 +1571,32 @@ export async function run(
     texLanguage = null;
   }
 
+  // Each paper's body files, resolved the way the build resolves them — only when the LaTeX language
+  // loaded, since only its rules read them. The project's papers too: `paperlint lint .` reaches
+  // papers two levels down, which a directory's immediate papers do not.
+  const bodies = texLanguage
+    ? paperBodies(paperDirs([...paths, ...papersRoots(cfg)]), {
+        files: nodeFiles,
+        latex: latexReader,
+      })
+    : [];
+  // Named only for the papers this run lints: a paper elsewhere in the project is not this run's.
+  const inScope = (dir: string) =>
+    paths.some((p) => dir === p || dir.startsWith(`${p}${sep}`));
+  unreadLines(
+    bodies.filter((b) => inScope(b.dir)),
+    (p) => shown(cwd, p),
+  ).forEach((l) => {
+    err(l);
+  });
+
   const eslint = new ESLint({
     cwd: lintRoot(root, paths),
     overrideConfigFile: true,
-    overrideConfig: eslintConfig(buildConfig(withPapers, texLanguage)),
+    overrideConfig: eslintConfig([
+      ...buildConfig(withPapers, texLanguage),
+      ...includeBlocks(bodies),
+    ]),
     fix: a.fix,
   });
 

package/src/domain/paper-source.ts

@@ -11,8 +11,8 @@
  *
  * ── WHAT IS NOT DONE ─────────────────────────────────────────────────────────────
  * No macro is expanded, so a path built from a macro (`\input{\dir/intro}`) is read as written. A
- * file that cannot be found is reported and left out; a file that includes itself, directly or
- * through others, is spliced once.
+ * file that cannot be found is left out and named in `missing`; a file that includes itself,
+ * directly or through others, is spliced once.
  */
 import { extname, normalize } from "node:path";
 import type { Span } from "./tex-document.ts";

package/src/init.test.ts

@@ -21,8 +21,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import { FRESH_CLONE_NOTE } from "./hooks-settings.ts";
+import { load as yamlLoad } from "js-yaml";
+import { z } from "zod";
 import {
-  UNPINNED_REF,
   WORKFLOW_PATH,
   choosePapers,
   declarePapers,
@@ -33,6 +34,7 @@ import {
   reportSkillLinks,
   reportTexLive,
   reportWorkflow,
+  workflowYaml,
 } from "./init.ts";
 import { runNode } from "../test/support.ts";
 
@@ -353,30 +355,48 @@ describe("paperlint init — how several candidate directories were decided, sai
 const here = (p: string) => `<${p}>`;
 
 describe("paperlint init — the workflow section, whole", () => {
-  it("the workflow: written unpinned, kept, declined, not asked", () => {
-    const ctx = { papersDir: "papers", why: "stdin is not a terminal" };
-    expect(reportWorkflow("written", ctx)).toEqual([
-      `  ✓ wrote ${WORKFLOW_PATH} — pin ${UNPINNED_REF} before pushing it`,
+  it("the written workflow installs the package, then runs the action from node_modules", () => {
+    // Guards: one revision. The action comes from the lockfile-pinned install, so there is no
+    // `zernie/paperlint@<ref>` to drift from package.json, and no `paths` to repeat papersDir.
+    const Workflow = z.object({
+      jobs: z.object({
+        papers: z.object({
+          steps: z.array(z.record(z.string(), z.unknown())),
+        }),
+      }),
+    });
+    expect(Workflow.parse(yamlLoad(workflowYaml())).jobs.papers.steps).toEqual([
+      { uses: "actions/checkout@v4" },
+      { uses: "actions/setup-node@v4", with: { "node-version": 22 } },
+      { run: "npm ci" },
+      { uses: "./node_modules/paperlint" },
     ]);
-    expect(reportWorkflow("written", { ...ctx, version: "1.2.3" })).toEqual([
-      `  ✓ wrote ${WORKFLOW_PATH}, pinned to v1.2.3`,
+  });
+
+  it("the workflow report: written, kept, declined, not asked", () => {
+    const ctx = { why: "stdin is not a terminal" };
+    expect(reportWorkflow("written", ctx)).toEqual([
+      `  ✓ wrote ${WORKFLOW_PATH}`,
     ]);
     expect(reportWorkflow("kept", ctx)).toEqual([
       `  ✓ ${WORKFLOW_PATH} is already there — kept, nothing overwritten`,
     ]);
-    const step = [
-      "      to run the same checks in CI, add this step to a workflow:",
-      `        - uses: zernie/paperlint@${UNPINNED_REF}`,
+    const steps = [
+      "      to run the same checks in CI, add these steps to a workflow:",
+      "        - uses: actions/checkout@v4",
+      "        - uses: actions/setup-node@v4",
       "          with:",
-      "            paths: papers",
+      "            node-version: 22",
+      "        - run: npm ci",
+      "        - uses: ./node_modules/paperlint",
     ];
     expect(reportWorkflow("declined", ctx)).toEqual([
       "  · declined — nothing written",
-      ...step,
+      ...steps,
     ]);
     expect(reportWorkflow("not-asked", ctx)).toEqual([
       "  · stdin is not a terminal, so nothing was asked. Default taken: NO file written.",
-      ...step,
+      ...steps,
     ]);
   });
 });

package/src/init.ts

@@ -55,7 +55,6 @@ import {
 } from "./doctor.ts";
 import { PAPER_MARKERS, papersIn } from "./build.ts";
 import { linkSkills, SKILLS_HOME, type LinkReport } from "./link-skills.ts";
-import { actionRef } from "./action-ref.ts";
 import {
   FRESH_CLONE_NOTE,
   SETTINGS_PATH,
@@ -270,29 +269,33 @@ export async function declarePapers(
 
 export const WORKFLOW_PATH = join(".github", "workflows", "papers.yml");
 
-/** Where the action is pinned when no release tag is known — obviously a placeholder. */
-export const UNPINNED_REF = "<commit-sha>";
-
 /**
- * The CI step, as a whole workflow, pinned to `ref` — the release tag of the running package
- * (`actionRef`). With no tag known (`null`: a git checkout, `npm link`) it keeps the placeholder
- * and says so: a wrong tag written confidently is worse than a placeholder that is obviously one.
+ * The CI steps, one list for the file `init` writes and for the steps it prints. The action is
+ * called from the installed package, after `npm ci`: it and the CLI it runs are then one revision,
+ * set by the lockfile, and the action finds papersDir in paperlint.json itself.
  */
-export function workflowYaml(papers: string, ref: string | null): string {
+const CI_STEPS = [
+  "- uses: actions/checkout@v4",
+  "- uses: actions/setup-node@v4",
+  "  with:",
+  "    node-version: 22",
+  "- run: npm ci",
+  "- uses: ./node_modules/paperlint",
+] as const;
+
+const indent = (by: number) => (line: string) => `${" ".repeat(by)}${line}`;
+
+/** The CI workflow `init` offers to write. */
+export function workflowYaml(): string {
   return [
-    ref === null
-      ? `# Written by \`paperlint init\`. Replace ${UNPINNED_REF} with a commit or release tag of the action.`
-      : `# Written by \`paperlint init\`, pinned to ${ref} — the release you installed.`,
+    `# Written by \`paperlint init\`.`,
     `name: papers`,
     `on: [push, pull_request]`,
     `jobs:`,
     `  papers:`,
     `    runs-on: ubuntu-latest`,
     `    steps:`,
-    `      - uses: actions/checkout@v4`,
-    `      - uses: zernie/paperlint@${ref ?? UNPINNED_REF}`,
-    `        with:`,
-    `          paths: ${papers}`,
+    ...CI_STEPS.map(indent(6)),
     ``,
   ].join("\n");
 }
@@ -301,16 +304,12 @@ export type WorkflowResult = "written" | "kept" | "declined" | "not-asked";
 
 export async function offerWorkflow(
   root: string,
-  papers: string,
   {
     ask,
     interactive,
-    version,
   }: {
     ask?: (q: string) => Promise<string>;
     interactive: boolean;
-    /** The running package's version; see `InitOptions.version`. */
-    version?: string | undefined;
   },
 ): Promise<WorkflowResult> {
   const path = join(root, WORKFLOW_PATH);
@@ -327,27 +326,17 @@ export async function offerWorkflow(
   // No answer — an empty line, or a stream that ended — is the safe default, which is "no file".
   if (answer !== "y" && answer !== "yes") return "declined";
   mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, workflowYaml(papers, actionRef(version)), "utf8");
+  writeFileSync(path, workflowYaml(), "utf8");
   return "written";
 }
 
 /** What `init` says about the CI workflow — and, when none was written, the step to paste. */
 export function reportWorkflow(
   wf: WorkflowResult,
-  {
-    version,
-    papersDir,
-    why,
-  }: { version?: string | undefined; papersDir: string; why: string },
+  { why }: { why: string },
 ): string[] {
-  const ref = actionRef(version);
   const out: string[] = [];
-  if (wf === "written")
-    out.push(
-      ref === null
-        ? `  ✓ wrote ${WORKFLOW_PATH} — pin ${UNPINNED_REF} before pushing it`
-        : `  ✓ wrote ${WORKFLOW_PATH}, pinned to ${ref}`,
-    );
+  if (wf === "written") out.push(`  ✓ wrote ${WORKFLOW_PATH}`);
   else if (wf === "kept")
     out.push(
       `  ✓ ${WORKFLOW_PATH} is already there — kept, nothing overwritten`,
@@ -359,10 +348,8 @@ export function reportWorkflow(
     );
   if (wf !== "written" && wf !== "kept")
     out.push(
-      `      to run the same checks in CI, add this step to a workflow:`,
-      `        - uses: zernie/paperlint@${ref ?? UNPINNED_REF}`,
-      `          with:`,
-      `            paths: ${papersDir}`,
+      `      to run the same checks in CI, add these steps to a workflow:`,
+      ...CI_STEPS.map(indent(8)),
     );
   return out;
 }
@@ -603,11 +590,6 @@ export interface InitOptions {
   resolveCliPapers?: (root: string) => string | null;
   /** Links the skills. Injected only so a test can stand in for the installed package. */
   link?: (root: string) => LinkReport;
-  /**
-   * The version of the running package, read by the CLI from its own `package.json`. The CI
-   * workflow is pinned to its release tag (`actionRef`); absent or unreleased, the placeholder.
-   */
-  version?: string | undefined;
   /**
    * TeX Live for `paperlint build`: whether paperlint's own tree is installed, and how to install
    * it (`paperlint toolchain`). Passed in by the CLI; without them the step only names the command.
@@ -734,7 +716,6 @@ export async function init(
     run = spawnSync,
     resolveCliPapers,
     link = (r: string) => linkSkills(r),
-    version,
   } = opts;
   // An injected `interactive` is a test standing in for a terminal; its reason is the classic one.
   const { interactive, why } =
@@ -816,12 +797,8 @@ export async function init(
   // ── 5. the one expensive, unguessable thing ───────────────────────────────────────────
   log(``);
   log(`CI`);
-  const wf = await offerWorkflow(root, papersDir, {
-    ask,
-    interactive,
-    version,
-  });
-  for (const line of reportWorkflow(wf, { version, papersDir, why })) log(line);
+  const wf = await offerWorkflow(root, { ask, interactive });
+  for (const line of reportWorkflow(wf, { why })) log(line);
 
   // ── 6. a first paper — offered only where there is none, and only to a human ──────────
   log(``);

package/src/linted-set.test.ts

@@ -26,7 +26,11 @@ afterEach(() => {
   for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true });
 });
 
-const TEX = "\\documentclass{article}\n\\begin{document}x\\end{document}\n";
+// The body is partly in `sections/intro.tex`, brought in by `\input` in the document; the preamble
+// `\input`s a macro file and paperlint's own `paper-guards`. Only the body file is the paper.
+const TEX =
+  "\\documentclass{article}\n\\input{macros}\n\\input{paper-guards}\n" +
+  "\\begin{document}x\n\\input{sections/intro}\n\\end{document}\n";
 const JS = "export const x = 1;\n";
 
 /** The files paperlint owns in the fixture paper. */
@@ -35,6 +39,7 @@ const OWNED = [
   "papers/a/PIPELINE-STATUS.md",
   "papers/a/reviews/r1.md",
   "papers/a/siblings/smith2025.md",
+  "papers/a/sections/intro.tex",
 ];
 
 /** Everything else a real paper folder and project carry. None of it may be linted. */
@@ -46,6 +51,10 @@ const NEIGHBOURS = {
   "papers/a/repro/lib/y.mjs": JS,
   "papers/a/repro/z.cjs": "module.exports = 1;\n",
   "papers/a/repro/t.ts": "const t: number = 1;\n",
+  // A preamble include, a frozen version and a .tex nothing includes: none is the paper's body.
+  "papers/a/macros.tex": "\\newcommand{\\x}{y}\n",
+  "papers/a/versions/2026-01-01-submitted.tex": TEX,
+  "papers/a/notes/scratch.tex": "Scratch.\n",
   "script.js": JS,
   "node_modules/pkg/index.js": JS,
 };
@@ -75,6 +84,7 @@ function project(): string {
     "papers/a/PIPELINE-STATUS.md": "---\nstages: []\n---\n",
     "papers/a/reviews/r1.md": "# review\n",
     "papers/a/siblings/smith2025.md": "---\nread: full\n---\n# Smith 2025\n",
+    "papers/a/sections/intro.tex": "Intro.\n",
     ...NEIGHBOURS,
   };
   for (const [p, text] of Object.entries(all)) {

package/src/new-paper.harness.mjs

@@ -5,7 +5,7 @@
  *   - the scaffold is what `paperlint lint` ACCEPTS: the old first run opened with "missing
  *     PIPELINE-STATUS.md", and a scaffold that still produced a finding would move that error
  *     from a missing file into a created one;
- *   - the scorecard carries `researchQuestion` and NO `stages` — a new paper has shipped nothing,
+ *   - the scorecard carries NO `stages` — a new paper has shipped nothing,
  *     and a placeholder stage would be a red `paper/stages` on the very first run;
  *   - the scorecard carries the `**Readiness verdict:**` line the status hook surfaces on every
  *     paper edit — without it the hook reports that the paper cannot say whether it is ready;
@@ -104,10 +104,6 @@ try {
     "🔴 the scorecard has NO `stages` — a new paper has shipped nothing and owes nothing",
     !("stages" in fm),
   );
-  check(
-    "and carries `researchQuestion`, present and empty",
-    "researchQuestion" in fm && fm.researchQuestion === "",
-  );
   check(
     "the name is filled in, and no placeholder survives in any file",
     /PIPELINE-STATUS — demo/.test(status) &&

package/src/package-dirs.ts

@@ -5,6 +5,9 @@
  *
  *   presets/       the venue presets (`paperlint:<name>`) and their JSON Schema
  *   presets/tex/   the LaTeX inputs `paperlint build` puts on TEXINPUTS
+ *
+ * `texSearchPath` is where an `\input` is looked for, in order. The build hands it to TeX and the
+ * lint rules read includes through it, so the two cannot disagree about which file a paper means.
  */
 import { fileURLToPath } from "node:url";
 
@@ -15,3 +18,9 @@ export const presetsDir = (): string =>
 /** The LaTeX inputs a paper `\input`s by name (`paper-guards`, a venue's numbers). */
 export const texInputsDir = (): string =>
   fileURLToPath(new URL("../presets/tex", import.meta.url));
+
+/** Where an `\input` in the paper in `paperDir` is looked for, first to last. */
+export const texSearchPath = (paperDir: string): readonly string[] => [
+  paperDir,
+  texInputsDir(),
+];

package/src/paper-files.ts

@@ -16,8 +16,8 @@
  *
  * 2. **Each rule scoped to the files it was written for** (`ruleOwners` + `narrowToOwners`).
  *    One plugin NAME is bound to different plugin objects in different blocks: `paper` holds
- *    `stages`/`source`/`author-list` beside `PIPELINE-STATUS.md` and `research-question`/
- *    `typography` beside `paper.md`/`paper.tex`. So a consumer block that named `paper/source`
+ *    `stages`/`source`/`author-list` beside `PIPELINE-STATUS.md` and `typography` beside
+ *    `paper.md`/`paper.tex`. So a consumer block that named `paper/source`
  *    for every file under the papers directory reached `paper.tex`, where `paper` has no `source`
  *    — and ESLint threw `Could not find "source" in plugin "paper"` from inside `lintFiles`,
  *    after paperlint's own validation had (correctly) accepted the id. A block is therefore split