paperlint 7.2.0 → 9.0.0

package/src/cli.test.ts

@@ -6,7 +6,7 @@
  */
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import { createServer } from "node:http";
 import { dirname, join } from "node:path";
 import { test } from "vitest";
@@ -33,13 +33,18 @@ import { texInputsDir } from "./package-dirs.ts";
 const root = useTempDir("cli-test-");
 
 /** `run(argv)` from `cwd`, the output as one string per stream. */
-async function cli(argv: string[], cwd: string) {
+async function cli(
+  argv: string[],
+  cwd: string,
+  deps: Pick<NonNullable<Parameters<typeof run>[1]>, "loadTexLanguage"> = {},
+) {
   const out: string[] = [];
   const err: string[] = [];
   const code = await run(argv, {
     log: (...a: unknown[]) => out.push(a.join(" ")),
     err: (...a: unknown[]) => err.push(a.join(" ")),
     cwd,
+    ...deps,
   });
   return { code, out: out.join("\n"), err: err.join("\n") };
 }
@@ -50,14 +55,14 @@ test("parseArgs: the boolean flags of build and toolchain, and a value flag with
     [
       parseArgs(["build", "--all", "--dry-run", "papers/p"]),
       parseArgs(["toolchain", "--check"]),
-      parseArgs(["new", "x", "--format"]),
+      parseArgs(["new", "x", "--paper"]),
       parseArgs(["new", "x", "--venue="]),
       parseArgs(["new", "x", "--kind", "short", "--max-warnings=3"]),
     ],
     [
       { ...base, cmd: "build", all: true, dryRun: true, paths: ["papers/p"] },
       { ...base, cmd: "toolchain", check: true },
-      { ...base, cmd: "new", paths: ["x"], missingValue: "--format" },
+      { ...base, cmd: "new", paths: ["x"], missingValue: "--paper" },
       { ...base, cmd: "new", paths: ["x"], missingValue: "--venue" },
       { ...base, cmd: "new", paths: ["x"], kind: "short", maxWarnings: 3 },
     ],
@@ -142,20 +147,18 @@ test("build refuses with no target, and --all over no papers", async () => {
   );
 });
 
-test("new refuses an unknown format, a broken config, and a config that names no papers directory", async () => {
+test("new refuses a broken config, and a config that names no papers directory", async () => {
   const broken = join(root, "new-broken");
   writeTree(broken, { "paperlint.json": "{ not json" });
   const none = join(root, "new-none");
   writeTree(none, { "paperlint.json": JSON.stringify({ papersDir: [] }) });
   const results = [
-    await cli(["new", "p", "--format", "docx"], root),
-    await cli(["new", "p", "--format", "md"], broken),
-    await cli(["new", "p", "--format", "md"], none),
+    await cli(["new", "p"], broken),
+    await cli(["new", "p"], none),
   ];
   assert.deepEqual(
     results.map((r) => ({ code: r.code, err: r.err.split(":")[0] })),
     [
-      { code: 2, err: "--format must be one of tex, md — got `docx`" },
       { code: 2, err: join(broken, "paperlint.json is not valid JSON") },
       {
         code: 2,
@@ -170,7 +173,7 @@ test("new with several papers directories says which one it used", async () => {
   writeTree(dir, {
     "paperlint.json": JSON.stringify({ papersDir: ["a", "b"] }),
   });
-  const r = await cli(["new", "p", "--format", "md", "--yes"], dir);
+  const r = await cli(["new", "p", "--yes"], dir);
   assert.equal(
     r.out.split("\n")[0],
     "several papers directories are declared — using the first: a",
@@ -274,20 +277,20 @@ async function withoutTex<T>(dir: string, fn: () => Promise<T>): Promise<T> {
 const noTexDir = join(root, "build-notex");
 writeTree(noTexDir, {
   "package.json": "{}",
-  "papers/md/paper.md": "# P\n\nx\n",
+  "papers/nosource/notes.txt": "x\n",
   "papers/tex/paper.tex":
     "\\documentclass{article}\\begin{document}x\\end{document}\n",
 });
 const venues = texInputsDir();
 
-test("build: a markdown-only paper is refused", async () => {
-  const md = await withoutTex(noTexDir, () =>
-    cli(["build", "papers/md"], noTexDir),
+test("build: a paper with no paper.tex is refused, naming paper.tex", async () => {
+  const none = await withoutTex(noTexDir, () =>
+    cli(["build", "papers/nosource"], noTexDir),
   );
-  assert.deepEqual(md, {
+  assert.deepEqual(none, {
     code: 1,
     out: [
-      "papers/md",
+      "papers/nosource",
       `  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",
@@ -295,7 +298,7 @@ test("build: a markdown-only paper is refused", async () => {
       "  ✗ nothing to compile: no paper.tex",
     ].join("\n"),
     err:
-      "\nNo paper.tex in: papers/md.\n" +
+      "\nNo paper.tex in: papers/nosource.\n" +
       'This is NOT "nothing to build" — paperlint compiles LaTeX, and these papers have no LaTeX source.\n' +
       "Write the paper in paper.tex; `paperlint new <name>` creates one.",
   });
@@ -399,7 +402,7 @@ test("build --dry-run on a paper with a venue plans for the preset's packages",
 
 test("a paper's paperlint.json that does not parse stops the lint with its path", () => {
   const dir = writeTree(join(root, "rules-broken"), {
-    "p/paper.md": "# P\n",
+    "p/paper.tex": "% P\n",
     "p/paperlint.json": "{ nope",
   });
   const r = paperRuleBlocks([join(dir, "p")]);
@@ -444,15 +447,12 @@ test("silentOptionalRules: a rule no block names for any paper is silent — a g
   );
 });
 
-test("init with no path and --format md sets up the current directory", async () => {
+test("init with no path sets up the current directory, and its first paper is paper.tex", async () => {
   const dir = writeTree(join(root, "init-here"), { "package.json": "{}" });
-  const r = await cli(
-    ["init", "--yes", "--no-hooks", "--paper", "first", "--format", "md"],
-    dir,
-  );
-  assert.equal(
-    existsSync(join(dir, "papers", "first", "paper.md")),
-    true,
+  const r = await cli(["init", "--yes", "--no-hooks", "--paper", "first"], dir);
+  assert.deepEqual(
+    readdirSync(join(dir, "papers", "first")).sort(),
+    ["PIPELINE-STATUS.md", "paper.tex", "paperlint.json"],
     r.out + r.err,
   );
 });
@@ -488,12 +488,9 @@ test("lint: a named directory with nothing paperlint lints is named in full when
 test("new from inside the paper it names adds the missing files and names the paper in full", async () => {
   const dir = writeTree(join(root, "new-inside"), {
     "paperlint.json": JSON.stringify({ papersDir: "papers" }),
-    "papers/p/paper.md": "# P\n",
+    "papers/p/paper.tex": "% P\n",
   });
-  const r = await cli(
-    ["new", "p", "--format", "md", "--yes"],
-    join(dir, "papers", "p"),
-  );
+  const r = await cli(["new", "p", "--yes"], join(dir, "papers", "p"));
   assert.match(
     r.out,
     new RegExp(
@@ -507,7 +504,7 @@ test("new with several directories, run from the first, names it in full", async
     "paperlint.json": JSON.stringify({ papersDir: ["a", "b"] }),
     "a/.keep": "",
   });
-  const r = await cli(["new", "p", "--format", "md", "--yes"], join(dir, "a"));
+  const r = await cli(["new", "p", "--yes"], join(dir, "a"));
   assert.equal(
     r.out.split("\n")[0],
     `several papers directories are declared — using the first: ${join(dir, "a")}`,
@@ -519,7 +516,7 @@ test("lint: an ESLint failure that is not an empty set is not swallowed", async
     "paperlint.json": JSON.stringify({
       rules: { "paper/stages": ["error", { x: 1 }] },
     }),
-    "papers/p/paper.md": "# P\n",
+    "papers/p/paper.tex": "% P\n",
     "papers/p/PIPELINE-STATUS.md": "---\nstages: []\n---\n# S\n",
   });
   await assert.rejects(cli(["lint"], dir), {
@@ -582,11 +579,11 @@ function newAtTerminal(cwd: string, answers: Record<string, string>) {
   });
 }
 
-test("new at a terminal asks for the format and the venue; the answers pick them", async () => {
-  const md = writeTree(join(root, "new-tty-md"), { "package.json": "{}" });
-  const r = await newAtTerminal(md, { "format:": "md\n", "venue:": "none\n" });
+test("new at a terminal asks for the venue; the answer picks it", async () => {
+  const dir = writeTree(join(root, "new-tty"), { "package.json": "{}" });
+  const r = await newAtTerminal(dir, { "venue:": "none\n" });
   assert.equal(r.status, 0, r.out);
-  assert.equal(existsSync(join(md, "papers", "first", "paper.md")), true);
+  assert.equal(existsSync(join(dir, "papers", "first", "paper.tex")), true);
 });
 
 test("chooseVenue: a question that fails (the stream ended) takes the default, no venue", async () => {
@@ -625,21 +622,20 @@ test("init's TeX Live install runs the toolchain over the project's papers, neve
   assert.equal(typeof here.installed(), "boolean");
 });
 
-test("lint with its LaTeX language missing from the install still lints the markdown papers", () => {
+test("lint with its LaTeX language missing from the install still lints the scorecards", async () => {
   const dir = writeTree(join(root, "lint-no-tex-language"), {
-    "papers/p/paper.md": "# P\n\nSome prose.\n",
-    "no-latex.mjs":
-      "import { register } from 'node:module';\n" +
-      "register('data:text/javascript,' + encodeURIComponent(\"export async function resolve(s, c, next) { if (s === '#eslint-rules/latex-language') throw Object.assign(new Error('gone'), { code: 'ERR_MODULE_NOT_FOUND' }); return next(s, c); }\"));\n",
+    "papers/p/PIPELINE-STATUS.md": "---\nstages: []\n---\n# S\n",
+  });
+  const gone = Object.assign(new Error("gone"), {
+    code: "ERR_MODULE_NOT_FOUND",
   });
-  const without = runNode(BIN, ["lint", "papers"], {
-    cwd: dir,
-    nodeArgs: ["--import", join(dir, "no-latex.mjs")],
+  const without = await cli(["lint", "papers"], dir, {
+    loadTexLanguage: () => Promise.reject(gone),
   });
-  const whole = runNode(BIN, ["lint", "papers"], { cwd: dir });
-  // A markdown paper needs no LaTeX language: the same report, the same code.
+  const whole = await cli(["lint", "papers"], dir);
+  // A scorecard needs no LaTeX language: the same report, the same code.
   assert.deepEqual(without, whole);
-  assert.match(whole.stdout, /missing `PIPELINE-STATUS\.md`/);
+  assert.match(whole.out, /missing all of `paper\.tex`/);
 });
 
 test("`paperlint hook` with no name: exit 2, and the usage names an example", async () => {

package/src/cli.ts

@@ -46,11 +46,11 @@ import {
   FRAGMENT_FILES,
   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";
+import { bibReader } from "./adapters/bibtex/index.ts";
 import { curlDownload } from "./adapters/curl/index.ts";
 import { latexReader } from "./adapters/latex/index.ts";
 import {
@@ -93,6 +93,12 @@ import {
   type PaperSettings,
 } from "./paper-settings.ts";
 import { referenceRules, REFERENCE_RULE_LEVELS } from "./reference-rules.ts";
+import { SOURCES_RULE_LEVELS, sourcesRules } from "./sources-rules.ts";
+import { sourcesRecorder } from "./sources-record.ts";
+import { sourcesCodec } from "./adapters/sources-record/index.ts";
+import { texOutput } from "./adapters/tex-output/index.ts";
+import { BIB_RULE_LEVELS, bibRules } from "./bib-rules.ts";
+import { bibliographyReader } from "./references.ts";
 import { onlineReferences } from "./adapters/references/index.ts";
 import { hotcrpPortal } from "./adapters/hotcrp/index.ts";
 import { runSubmission } from "./submission.ts";
@@ -132,15 +138,7 @@ import {
   init,
   processInteractivity,
 } from "./init.ts";
-import {
-  DEFAULT_FORMAT,
-  FORMATS,
-  isFormat,
-  newPaper,
-  reportNewPaper,
-  type PaperFormat,
-  type VenueSetting,
-} from "./new-paper.ts";
+import { newPaper, reportNewPaper, type VenueSetting } from "./new-paper.ts";
 // The one source for the consumer's config key lives in lib/ (the ESLint rules and the skill scripts
 // import it too). It is imported compiled, from dist/, the one path that resolves the same from src/
 // and from dist/ — see CONTRIBUTING.md.
@@ -174,7 +172,6 @@ import {
 } from "./folder-venue-rule.ts";
 import typography from "#eslint-rules/paper-typography";
 import texBuild from "#eslint-rules/tex-build";
-import bibReachable from "#eslint-rules/bib-reachable-entry";
 import reviewFrontmatter from "#eslint-rules/review-frontmatter";
 import siblingFrontmatter from "#eslint-rules/sibling-frontmatter";
 import pdfRules from "#eslint-rules/pdf-last-page-balance";
@@ -189,7 +186,7 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
   npx paperlint init [dir]            set the project up: detect the papers directory, declare it
                                       in package.json, link the skills, wire the hooks into
                                       .claude/settings.json, offer the CI step, report what is missing
-  npx paperlint new <name> [--venue <preset>] [--kind <kind>] [--format tex|md]
+  npx paperlint new <name> [--venue <preset>] [--kind <kind>]
                                       create <papers>/<name>/ from the template; never overwrites,
                                       on an existing folder adds only the missing files, then lints it.
                                       A <name> that names a venue (aisec-2026) is refused: name the
@@ -225,7 +222,6 @@ init:
                       or with CI set, nothing is asked either
   --no-hooks          do not wire the hooks (the default without a human is to wire them)
   --paper <name>      create this paper too (without a human, the only way init creates one)
-  --format tex|md     the new paper's source format; default tex
 
 new:
   --venue <preset>    the venue preset, written as "extends" into the paper's paperlint.json:
@@ -234,7 +230,6 @@ new:
                       On a terminal without --venue, new asks; "none" leaves it unset
   --kind <kind>       the paper's kind at that venue (its page limit), e.g. short — one of the
                       preset's kinds; needs --venue
-  --format tex|md     the paper's source format; default tex
   --allow-venue-name  create the folder even though its name names a venue (a whole word such as
                       "realm" can be the work's own). Without it such a name is refused: a rejected
                       paper moves to another venue and keeps its folder
@@ -312,11 +307,17 @@ settings — paperlint.json, at two levels, one schema. Both are optional.
   unknown key, in either file, is an error.
 `;
 
-/** What the rules over a paper.tex read with: the disk, the shipped presets, the LaTeX reader. */
+/** What reads the build's record of a paper: the disk, and the schema its text is parsed with. */
+const RECORD_DEPS = { files: nodeFiles, codec: sourcesCodec };
+
+/** What reads the bibliography the last build recorded: the record, and the readers of its databases and blocks. */
+const RECORDED_DEPS = { ...RECORD_DEPS, latex: latexReader, bib: bibReader };
+
+/** What the rules over a paper.tex read with: the paper's disk and LaTeX reader, the build's record, and the shipped presets. */
 const TEX_RULE_DEPS = {
-  files: nodeFiles,
-  venuesDir: presetsDir(),
+  ...RECORD_DEPS,
   latex: latexReader,
+  venuesDir: presetsDir(),
 };
 
 /** The register band rules and `tex/heading-case`: the rules of the `tex` plugin that read a paper's words. */
@@ -364,7 +365,8 @@ export function buildConfig(
   // The reference rules judge `_build/references.json`, and only on `paper.tex`.
   const texPaperRules = {
     ...paperRules,
-    ...referenceRules({ files: nodeFiles }),
+    ...referenceRules(RECORDED_DEPS),
+    ...sourcesRules(RECORD_DEPS),
   };
   // Each typography rule reports every occurrence where it is, and fixes it (`--fix`).
   const prose = {
@@ -399,8 +401,8 @@ export function buildConfig(
     },
     {
       files: ["**/PIPELINE-STATUS.md"],
-      // Every paper folder has one, whatever its source format: the rules about the folder itself
-      // (its stages, its frozen sources, its name) are judged here, once per paper.
+      // Every paper folder has one: the rules about the folder itself (its stages, its frozen
+      // sources, its name) are judged here, once per paper.
       plugins: {
         markdown,
         paper: {
@@ -419,12 +421,6 @@ export function buildConfig(
         ...CYCLE_RULE_LEVELS,
       },
     },
-    {
-      files: ["**/paper.md", "**/draft.md"],
-      plugins: { markdown, paper: { rules: paperRules } },
-      ...md,
-      rules: prose,
-    },
     {
       files: ["**/reviews/*.md"],
       plugins: { markdown, review: reviewFrontmatter },
@@ -461,7 +457,7 @@ export function buildConfig(
           },
         },
         paper: { rules: texPaperRules },
-        bib: bibReachable,
+        bib: { rules: bibRules(RECORDED_DEPS) },
         talk: { rules: talkRules(TALK_RULE_DEPS) },
         format: {
           rules: {
@@ -475,8 +471,9 @@ export function buildConfig(
       rules: {
         ...prose,
         ...REFERENCE_RULE_LEVELS,
+        ...SOURCES_RULE_LEVELS,
         "paper/figure-ref-style": "warn",
-        "bib/reachable-entry": "warn",
+        ...BIB_RULE_LEVELS,
         "tex/future-promise": "warn",
         // A number with no owner: a prose rule, on beside the others above.
         "tex/claim-provenance": "warn",
@@ -585,8 +582,7 @@ export interface RulePlugin {
  * file knows every rule id. `@eslint/markdown` is a dependency's plugin and is left out. The LaTeX
  * language rides on `tex` when `texLanguage` is given, and that is how a consumer registers it: a
  * second `tex` plugin of its own is refused by ESLint ("Cannot redefine plugin "tex"", measured
- * with and without the language here). Without it, `tex` carries rules only — for a config that
- * lints markdown papers alone.
+ * with and without the language here). Without it, `tex` carries rules only.
  */
 export function rulePlugins(texLanguage?: unknown): Record<string, RulePlugin> {
   const out: Record<string, { rules: Record<string, unknown> }> = {};
@@ -888,7 +884,6 @@ export function parseArgs(argv: readonly string[]): Args {
     noHooks: false,
     allowVenueName: false,
     paper: null,
-    format: null,
     venue: null,
     kind: null,
     pdf: null,
@@ -987,10 +982,9 @@ const SWITCHES: ReadonlyMap<
 /** The flags whose value is one string field of `Args`. */
 const STRING_FLAGS: ReadonlyMap<
   string,
-  "paper" | "format" | "venue" | "kind" | "pdf" | "abstract"
+  "paper" | "venue" | "kind" | "pdf" | "abstract"
 > = new Map([
   ["--paper", "paper"],
-  ["--format", "format"],
   ["--venue", "venue"],
   ["--kind", "kind"],
   ["--pdf", "pdf"],
@@ -1184,7 +1178,6 @@ export function runHook(
 export async function createPaperAt(
   papersRoot: string,
   name: string,
-  format: PaperFormat,
   {
     log,
     err,
@@ -1201,7 +1194,7 @@ export async function createPaperAt(
     allowVenueName?: boolean;
   },
 ): Promise<number> {
-  const result = newPaper(papersRoot, name, format, {
+  const result = newPaper(papersRoot, name, {
     venue,
     venues: allowVenueName ? [] : shippedVenueNames(PRESET_DEPS),
   });
@@ -1366,25 +1359,10 @@ async function runNew(
   const [name, ...extra] = a.paths;
   if (!name || extra.length > 0) {
     err(
-      `\`new\` takes exactly one paper name: \`paperlint new my-paper [--venue <preset>] [--kind <kind>] [--format tex|md]\``,
+      `\`new\` takes exactly one paper name: \`paperlint new my-paper [--venue <preset>] [--kind <kind>]\``,
     );
     return 2;
   }
-  let format: PaperFormat = DEFAULT_FORMAT;
-  if (a.format !== null) {
-    if (!isFormat(a.format)) {
-      err(
-        `--format must be one of ${FORMATS.join(", ")} — got \`${a.format}\``,
-      );
-      return 2;
-    }
-    format = a.format;
-  } else if (processInteractivity(a.yes).interactive) {
-    const f = (
-      await askOrDefault(ask, `format: tex / md [${DEFAULT_FORMAT}] `)
-    )?.trim();
-    if (isFormat(f)) format = f;
-  }
   const cfg = readConfig({ ...a, json: false }, { log: () => {}, err, cwd });
   if (cfg.code !== undefined) return cfg.code;
   const roots = papersRoots(cfg);
@@ -1417,7 +1395,7 @@ async function runNew(
         ask,
       });
   if (!venue.ok) return (err(venue.error), 2);
-  return createPaperAt(papersRoot, name, format, {
+  return createPaperAt(papersRoot, name, {
     log,
     err,
     cwd,
@@ -1478,6 +1456,12 @@ async function runBuild(
     dryRun: a.dryRun,
     log,
     checkReferences,
+    readBibliography: bibliographyReader(RECORDED_DEPS),
+    recordSources: sourcesRecorder({
+      files: nodeFiles,
+      listDir: nodeListDir,
+      texOutput,
+    }),
     engine: () => engineEnv(targets, a, { log, err }),
   });
   if (out.kind === "no-engine") return 1;
@@ -1668,10 +1652,6 @@ async function runInit(
     );
     return 2;
   }
-  if (a.format !== null && !isFormat(a.format)) {
-    err(`--format must be one of ${FORMATS.join(", ")} — got \`${a.format}\``);
-    return 2;
-  }
   return await init(a.paths[0] ?? ".", {
     log,
     err,
@@ -1679,9 +1659,8 @@ async function runInit(
     yes: a.yes,
     hooks: !a.noHooks,
     paper: a.paper,
-    format: isFormat(a.format) ? a.format : null,
-    createPaper: (papersRoot, name, format) =>
-      createPaperAt(papersRoot, name, format, { log, err, cwd }),
+    createPaper: (papersRoot, name) =>
+      createPaperAt(papersRoot, name, { log, err, cwd }),
     venues: shippedVenueNames(PRESET_DEPS),
     tex: initTexLive(a, { log, err, cwd }),
     resolveCliPapers: (root: string): string | null =>
@@ -1696,10 +1675,17 @@ export async function run(
     err = console.error,
     cwd = process.cwd(),
     checkReferences = onlineReferences,
+    loadTexLanguage = async () =>
+      (await import("#eslint-rules/latex-language")).texLanguage,
   }: {
     log?: typeof console.log;
     err?: typeof console.error;
     cwd?: string;
+    /**
+     * `lint`'s LaTeX language, loaded lazily because only `lint` needs it. A test hands one that
+     * fails, as a broken install would.
+     */
+    loadTexLanguage?: () => Promise<unknown>;
     /**
      * `build`'s online reference check — the real services by default. The e2e build passes a
      * fake: no test depends on Crossref, Semantic Scholar or DBLP answering.
@@ -1803,33 +1789,16 @@ export async function run(
   };
 
   // Loaded lazily because only `lint` needs it. If the module cannot be loaded (a broken install:
-  // the file missing from the package), lint still runs over the markdown papers rather than
-  // failing outright — the LaTeX rules simply have no language to run in.
-  let texLanguage: unknown = null;
-  try {
-    ({ texLanguage } = await import("#eslint-rules/latex-language"));
-  } catch {
-    texLanguage = null;
-  }
+  // the file missing from the package), lint still runs over the scorecards and the review notes
+  // rather than failing outright — the LaTeX rules simply have no language to run in.
+  const texLanguage: unknown = await loadTexLanguage().catch(() => null);
 
-  // Each paper's body files, resolved the way the build resolves them — only when the LaTeX language
+  // Each paper's body files, as the last build recorded TeX reading 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,
-      })
+    ? paperBodies(paperDirs([...paths, ...papersRoots(cfg)]), RECORD_DEPS)
     : [];
-  // 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),
@@ -1870,7 +1839,7 @@ export async function run(
   // is not invoked — and, not being invoked, it physically cannot report that.
   if (results.length === 0) {
     err(
-      `nothing was linted under ${paths.map((x) => shown(cwd, x)).join(", ")} — no PIPELINE-STATUS.md, paper.md/tex or reviews/ found there. A clean report over zero files is not a clean report.`,
+      `nothing was linted under ${paths.map((x) => shown(cwd, x)).join(", ")} — no PIPELINE-STATUS.md, paper.tex or reviews/ found there. A clean report over zero files is not a clean report.`,
     );
     return 1;
   }