paperlint 7.2.0 → 8.0.0

package/skills/paper-pipeline/scripts/extract-ref-facts.mjs

@@ -3,34 +3,32 @@
  * extract-ref-facts.mjs — parse a paper's bibliography, ask the registries and write FACTS to JSON.
  * It judges nothing.
  *
- * Usage: node extract-ref-facts.mjs <paper dir|paper.md|refs.bib> [--offline] [--refresh]
+ * Usage: node extract-ref-facts.mjs <paper dir|paper.tex|refs.bib> [--offline] [--refresh]
  *                                   [--cache=PATH] [--out=PATH] [--quiet]
- * Exit: 0 — facts written · 1 — nothing to write (no source, no entries).
+ * Exit: 0 — facts written · 1 — nothing to write (no source, a source that is neither a .bib nor
+ * a .tex, no entries).
  *
  * WHY THE SPLIT. Before 2026-08-26 measurement and judgement lived in one script
  * (`verify-refs.mjs`, 20 emit sites, 8 kinds of findings) — that is, on the fifth rung of the
  * ladder in `the consumer's papers CLAUDE.md`. The judgement moved into ESLint rules
  * (`eslint-rules/ref-facts.mjs`): a registry of rules, severity from config, `eslint-disable` with a
- * reason, `file:line:col` positions. What stayed here is the plumbing: parsing markup, parsing
- * `.bib`, the network, parsing the registries' responses.
+ * reason, `file:line:col` positions. What stayed here is the plumbing: parsing `.bib`, the network,
+ * parsing the registries' responses.
  *
  * The precedent in this same knowledge base is `render-paper/extract-pdf-facts.mjs` +
  * `eslint-rules/pdf-facts.mjs`. The boundary is exactly the same: the script goes out into the
  * world, the rule passes the judgement.
  *
- * 🔴 WHY THE RULE CANNOT LIVE OVER THE PAPER ITSELF. Of the three papers in the knowledge base one
- * has a `paper.md` (`<paper-a>`); in `<paper-b>` and `<paper-c>` the bibliography is `refs.bib`, and
- * no ESLint language plugin parses `.bib`. The common input that can do both is the facts JSON.
- * The price is known and written down: a finding is addressed into the facts, not into a line of
- * `paper.md`; that is why every entry in the facts carries the `line` of its source, and the rule
- * prints it in the message.
+ * 🔴 WHY THE RULE CANNOT LIVE OVER THE BIBLIOGRAPHY ITSELF. No ESLint language plugin parses
+ * `.bib`, so the rule's input is the facts JSON. The price is known and written down: a finding is
+ * addressed into the facts, not into a line of the `.bib`; that is why every entry in the facts
+ * carries the `line` of its source, and the rule prints it in the message.
  *
  * 🔴 WHAT THIS MOVE FIXED (both legs were DEAD, measured 2026-08-26):
  *
- *  1. `.bib` WAS NEVER OPENED. `resolveSource` walked `paper.md` → `draft.md` →
- *     `build/custom.bib`; `refs.bib` was not on the list, although the error text promised
- *     "or .bib". The run: `verify-refs.mjs <papers-root>/<paper-b>` →
- *     "no paper.md, draft.md or .bib … nothing to check".
+ *  1. `.bib` WAS NEVER OPENED. `resolveSource` did not list `refs.bib`, although the error text
+ *     promised "or .bib". The run: `verify-refs.mjs <papers-root>/<paper-b>` →
+ *     "… or .bib … nothing to check".
  *  2. THE `.bib` PARSER DID NOT TAKE THE REAL FILES. The regex `/@\w+\{([^,]+),([\s\S]*?)\n\}/g`
  *     required a `}` on a line of its own, while both of our `refs.bib` close an entry on the line
  *     of the last field (`note={arXiv:2310.06770}}`). A run straight at the file: "parsed 0
@@ -71,14 +69,9 @@ import {
 } from "node:fs";
 import { createHash } from "node:crypto";
 import { join, resolve, dirname, basename } from "node:path";
-import { headings as mdHeadings, requireMarkdown } from "#lib/markdown";
+import { bibRange } from "#eslint-rules/paper-typography";
 import { isMain } from "./consumer.mjs";
 
-// Markup is parsed with a parser (`CLAUDE.md`, 2026-08-11). We fail rather than degrade: without
-// the parser the reference list would not be found at all, and the facts would come out empty —
-// that is, a clean verdict about a paper that in fact has forty references.
-requireMarkdown();
-
 const ROOT = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 const CROSSREF = "https://api.crossref.org/works/";
 const ARXIV = "https://export.arxiv.org/api/query?id_list=";
@@ -89,135 +82,12 @@ const UA =
 
 export const SCHEMA = 1;
 
-// ── parsing: the reference list in markdown ──────────────────────────────────
-//
-// The same shape that `repro/md2submission.py` reads, deliberately: that script turns the list into
-// the .bib actually uploaded to the venue, so whatever it counts as an entry is an entry.
-// `^\d{1,2}. ` opens an entry, an indent continues it, a blank line closes it.
-
-const REF_OPEN = /^(\d{1,2})\.\s+(.*)$/;
-/** Working notes that never reach the PDF; md2submission strips them, so we do too. */
-const BRACKET_NOTE = /\[(VERIFY|ANONYMIZ)[^\]]*\]/g;
-
-export function parseMarkdownRefs(text) {
-  // The section is cut by the parser. The former `text.split(/^## References\s*$/m)[1]` opened the
-  // reference list on a `## References` quoted inside a ```-block — and in this repo papers quote
-  // their own markup in chunks.
-  const refsHs = mdHeadings(text).filter(
-    (h) => h.depth === 2 && /^References\s*$/u.test(h.text),
-  );
-  if (refsHs.length === 0) return [];
-  const nl = text.indexOf("\n", refsHs[0].offset);
-  const body = text.slice(
-    nl === -1 ? text.length : nl,
-    refsHs[1] ? refsHs[1].offset : text.length,
-  );
-  // The line where the body starts in the source file — so that an entry has an ADDRESS in
-  // `paper.md` and not just a number in a list. The rule prints it in the message: the facts file
-  // lives in `_build/`, and without the source line a finding would have to be hunted for by eye.
-  const bodyLine = text
-    .slice(0, nl === -1 ? text.length : nl)
-    .split("\n").length;
-  // A heading closes the list — appendices come AFTER the bibliography, and without this their
-  // numbered prose would be parsed as references. The line numbers come from the parser:
-  // `/^#{1,6}\s/` also counted a hash inside a ```-block as a heading.
-  const headingLines = new Set(mdHeadings(body).map((h) => h.line));
-  const entries = [];
-  let cur = null;
-  let buf = [];
-  let curLine = 0;
-  const flush = () => {
-    if (cur !== null)
-      entries.push({
-        n: cur,
-        line: curLine,
-        raw: buf.join(" ").replace(BRACKET_NOTE, "").trim(),
-      });
-    cur = null;
-    buf = [];
-  };
-  const lns = body.split("\n");
-  for (let i = 0; i < lns.length; i++) {
-    const ln = lns[i];
-    if (headingLines.has(i)) break;
-    const m = REF_OPEN.exec(ln);
-    if (m) {
-      flush();
-      cur = Number(m[1]);
-      curLine = bodyLine + i;
-      buf = [m[2].trim()];
-    } else if (cur !== null && ln.trim()) buf.push(ln.trim());
-    else if (cur !== null) flush();
-  }
-  flush();
-  return entries.map(splitEntry).filter(Boolean);
-}
-
-/** `A, B, C. *Title.* rest` → authors / title / remainder — the shape md2submission produces. */
-function splitEntry(e) {
-  const base = { n: e.n, line: e.line, key: null, raw: e.raw };
-  const mt = /\*(.+?)\*/.exec(e.raw);
-  if (!mt)
-    return {
-      ...base,
-      authors: [],
-      truncated: false,
-      title: null,
-      year: yearIn(e.raw),
-      venue_text: e.raw,
-    };
-  const title = mt[1].trim().replace(/\.$/, "");
-  const rawAuthors = splitAuthors(e.raw.slice(0, mt.index));
-  const note = e.raw
-    .slice(mt.index + mt[0].length)
-    .trim()
-    .replace(/^,\s*/, "");
-  const { authors, truncated } = dropEtAl(rawAuthors);
-  return {
-    ...base,
-    authors,
-    truncated,
-    title,
-    year: yearIn(note) ?? yearIn(e.raw),
-    venue_text: note,
-  };
-}
-
-function splitAuthors(a) {
-  const s = a
-    .trim()
-    .replace(/\.\s*$/, "")
-    .trim();
-  if (!s) return [];
-  return s
-    .split(",")
-    .map((p) => p.trim())
-    .filter(Boolean);
-}
-
-/**
- * `Z. Xiang et al.` — the entry deliberately gives a PREFIX of the author list. That is a fact about
- * the entry, not a judgement, so the truncation is removed here and the rule receives an honest
- * prefix plus a flag.
- */
-const ET_AL = /\bet\s+al\.?$/i;
-function dropEtAl(authors) {
-  if (!authors.length || !ET_AL.test(authors[authors.length - 1].trim()))
-    return { authors, truncated: false };
-  const out = authors.slice();
-  out[out.length - 1] = out[out.length - 1].replace(ET_AL, "").trim();
-  return { authors: out.filter(Boolean), truncated: true };
-}
-
-const yearIn = (s) => (/\b(19|20)\d{2}\b/.exec(s) ?? [null])[0];
-
 // ── parsing: .bib WITH A REAL PARSER ─────────────────────────────────────────
 
 /**
- * The name order is normalised to "First name Surname" — the same shape in which authors are written
- * in markdown. Then the rule has ONE `surname()` function (the last alphabetic token) for both
- * sources instead of two branches. Normalising the format is the parser's job; comparing is the
- * rule's job.
+ * The name order is normalised to "First name Surname". Then the rule has ONE `surname()` function
+ * (the last alphabetic token). Normalising the format is the parser's job; comparing is the rule's
+ * job.
  *
  * 🔴 TWO SHAPES, AND BOTH ARE LISTED EXPLICITLY. The parser returns an institution
  * (`author={{Adversa AI}}` — the double brace means "one name as a whole, do not split") as
@@ -527,27 +397,41 @@ export function recordFrom(key, cached) {
 
 // ── assembling the facts ─────────────────────────────────────────────────────
 
-/** `paper.md` → `draft.md` → `refs.bib` → `build/custom.bib`. `refs.bib` ADDED 26.08 (defect #1). */
-export const SOURCE_ORDER = [
-  "paper.md",
-  "draft.md",
-  "refs.bib",
-  "build/custom.bib",
-];
+/**
+ * `paper.tex` when it embeds its `.bib` in `filecontents` → `refs.bib` → `build/custom.bib`.
+ * `refs.bib` ADDED 26.08 (defect #1). The embedded one comes first, as in `paperlint build`
+ * (`bibliographyOf`, src/references.ts): the author edits it there, and the `refs.bib` LaTeX
+ * writes out of it is missing before a build and stale after an edit.
+ */
+export const SOURCE_ORDER = ["paper.tex", "refs.bib", "build/custom.bib"];
+
+/** Whether `p` is a source: any `.bib`, and a `.tex` only when it carries a `.bib`. */
+const isSource = (p) =>
+  !p.endsWith(".tex") || bibRange(readFileSync(p, "utf8")) !== null;
 
 export function resolveSource(target) {
   const t = resolve(target);
   if (existsSync(t) && statSync(t).isFile()) return t;
   for (const c of SOURCE_ORDER) {
     const p = join(t, c);
-    if (existsSync(p)) return p;
+    if (existsSync(p) && isSource(p)) return p;
   }
   return null;
 }
 
+/**
+ * The entries of a `.bib`, or of the `.bib` a `.tex` embeds (none when it embeds none) — each
+ * entry's `line` its line in the file read, so a finding points where the author edits.
+ */
 export async function loadEntries(path) {
   const text = readFileSync(path, "utf8");
-  return path.endsWith(".bib") ? parseBib(text) : parseMarkdownRefs(text);
+  if (!path.endsWith(".tex")) return parseBib(text);
+  const bib = bibRange(text);
+  if (bib === null) return [];
+  const above = text.slice(0, bib.bodyStart).split("\n").length - 1;
+  return (await parseBib(bib.body)).map((e) =>
+    e.line === 0 ? e : { ...e, line: e.line + above },
+  );
 }
 
 /** Every registry key a list of entries needs. Computed once so the requests go in one batch. */
@@ -571,7 +455,7 @@ export function buildFacts({ source, text, entries, cache, cachePath }) {
   return {
     schema: SCHEMA,
     source: rel(source),
-    source_kind: source.endsWith(".bib") ? "bibtex" : "markdown",
+    source_kind: "bibtex",
     source_sha256: createHash("sha256").update(text).digest("hex"),
     cache: cachePath ? rel(cachePath) : null,
     generated: new Date().toISOString().slice(0, 10),
@@ -601,6 +485,14 @@ async function main(argv) {
     );
     return 1;
   }
+  // A paper's references are read from a `.bib`, or the one a `.tex` embeds: any other file
+  // parsed as BibTeX would report zero entries for the wrong reason.
+  if (!src.endsWith(".bib") && !src.endsWith(".tex")) {
+    console.error(
+      `🛑 ${rel(src)} is neither a .bib nor a .tex — the bibliography is read from ${SOURCE_ORDER.join(", ")}.`,
+    );
+    return 1;
+  }
   const paperDir = statSync(resolve(target)).isFile()
     ? dirname(src)
     : resolve(target);

package/skills/paper-pipeline/scripts/extract-ref-facts.test.mjs

@@ -1,6 +1,6 @@
 /**
- * extract-ref-facts.mjs beyond its harness: the edges of each reader (markdown list, .bib, CrossRef,
- * arXiv, cache) and the command itself — sources, flags, the network loop (with `fetch` stubbed in
+ * extract-ref-facts.mjs beyond its harness: the edges of each reader (.bib, CrossRef, arXiv,
+ * cache) and the command itself — sources, flags, the network loop (with `fetch` stubbed in
  * the child process), and the refusals.
  */
 import assert from "node:assert/strict";
@@ -15,7 +15,6 @@ import {
   loadCache,
   loadEntries,
   parseBib,
-  parseMarkdownRefs,
   primaryOf,
   readArxiv,
   readCrossref,
@@ -29,68 +28,6 @@ const SCRIPT = join(
 );
 const root = useTempDir("extract-ref-facts-");
 
-test("markdown: the list ends at the file's end or a second References heading; lines continue an entry", () => {
-  assert.deepEqual(parseMarkdownRefs("# P\n\n## References"), []);
-  const refs = parseMarkdownRefs(
-    [
-      "## References",
-      "",
-      "1. A. Author, B. Author. *A Title.* Venue,",
-      "   continued 2021.",
-      "2. *Untitled Authors.* 2019 note",
-      "3. C. Writer 2018. *Late Year.* Venue",
-      "4. No title here at all",
-      "",
-      "## References",
-      "5. Never read. *X.* 2000",
-    ].join("\n"),
-  );
-  assert.deepEqual(
-    refs.map(({ n, line, authors, title, year, venue_text }) => ({
-      n,
-      line,
-      authors,
-      title,
-      year,
-      venue_text,
-    })),
-    [
-      {
-        n: 1,
-        line: 3,
-        authors: ["A. Author", "B. Author"],
-        title: "A Title",
-        year: "2021",
-        venue_text: "Venue, continued 2021.",
-      },
-      {
-        n: 2,
-        line: 5,
-        authors: [],
-        title: "Untitled Authors",
-        year: "2019",
-        venue_text: "2019 note",
-      },
-      {
-        n: 3,
-        line: 6,
-        authors: ["C. Writer 2018"],
-        title: "Late Year",
-        year: "2018",
-        venue_text: "Venue",
-      },
-      {
-        n: 4,
-        line: 7,
-        authors: [],
-        title: null,
-        year: null,
-        venue_text: "No title here at all",
-      },
-    ],
-  );
-});
-
 test(".bib: a key the text spells with spaces has no line; a missing title or year is null, not empty", async () => {
   const [entry] = await parseBib(
     "@misc{ spaced ,\n  note={see arXiv:2101.00001}\n}\n",
@@ -269,9 +206,11 @@ const CROSSREF_OK = JSON.stringify({
   },
 });
 writeTree(root, {
-  "paper/paper.md":
-    "## References\n\n1. A. A. *Found.* doi:10.1234/ok\n2. B. B. *Lost.* doi:10.1234/down\n",
-  "empty/paper.md": "# Nothing cited\n",
+  "paper/refs.bib":
+    "@misc{a, author={A. A}, title={Found}, note={doi:10.1234/ok}}\n" +
+    "@misc{b, author={B. B}, title={Lost}, note={doi:10.1234/down}}\n",
+  "empty/refs.bib": "% nothing cited\n",
+  "notes/notes.txt": "A. A. Found. doi:10.1234/ok\n",
   // `fetch` in the child: 10.1234/down fails at the transport, anything else is a CrossRef hit.
   "fetch.mjs":
     `globalThis.fetch = async (url) => {\n` +
@@ -286,6 +225,18 @@ writeTree(root, {
     "import { register } from 'node:module';\n" +
     "register('data:text/javascript,' + encodeURIComponent(\"export async function resolve(s, c, next) { if (s === '@retorquere/bibtex-parser') throw Object.assign(new Error('broken install'), { code: 'EACCES' }); return next(s, c); }\"));\n",
   "bib/refs.bib": "@misc{k, title={T}, note={doi:10.1234/ok}}\n",
+  // The bibliography is embedded in paper.tex; the refs.bib beside it is a stale build output.
+  "inline/paper.tex":
+    "\\documentclass{article}\n" +
+    "\\begin{filecontents*}[overwrite]{refs.bib}\n" +
+    "@misc{a, author={A. A}, title={Found}, note={doi:10.1234/ok}}\n" +
+    "@misc{b, author={B. B}, title={Lost}, note={doi:10.1234/down}}\n" +
+    "\\end{filecontents*}\n\\begin{document}x\\end{document}\n",
+  "inline/refs.bib": "@misc{stale, title={Stale}, note={doi:10.1234/old}}\n",
+  // A paper.tex with no embedded .bib is not a source: the refs.bib beside it is.
+  "plain/paper.tex":
+    "\\documentclass{article}\\begin{document}x\\end{document}\n",
+  "plain/refs.bib": "@misc{k, title={T}, note={doi:10.1234/ok}}\n",
 });
 const cli = (args, { cwd = root, nodeArgs = [] } = {}) =>
   runNode(SCRIPT, args, {
@@ -309,7 +260,7 @@ test("online: hits are fetched and cached, a transport failure is named and stay
     {
       status: 0,
       stdout:
-        "📚 paper.md → paper/_build/refs.facts.json (2 entries, 2 identifiers, 1 resolved, +1 fetched)\n",
+        "📚 refs.bib → paper/_build/refs.facts.json (2 entries, 2 identifiers, 1 resolved, +1 fetched)\n",
       stderr: "   … doi:10.1234/down: network down\n",
       cached: ["doi:10.1234/ok"],
     },
@@ -321,7 +272,7 @@ test("online again: cached keys are not refetched; --quiet hides the failure; --
   assert.deepEqual(again, {
     status: 0,
     stdout:
-      "📚 paper.md → paper/_build/refs.facts.json (2 entries, 2 identifiers, 1 resolved, all from cache)\n",
+      "📚 refs.bib → paper/_build/refs.facts.json (2 entries, 2 identifiers, 1 resolved, all from cache)\n",
     stderr: "",
   });
   const refresh = cli(["paper", "--refresh", "--quiet"], { nodeArgs: FETCH });
@@ -330,7 +281,7 @@ test("online again: cached keys are not refetched; --quiet hides the failure; --
 
 test("the paper file itself as the target, with --cache, --out and --offline", () => {
   const r = cli([
-    join(root, "paper/paper.md"),
+    join(root, "paper/refs.bib"),
     "--offline",
     `--cache=${join(root, "paper/repro/refs-cache.json")}`,
     `--out=${join(root, "out/facts.json")}`,
@@ -338,7 +289,7 @@ test("the paper file itself as the target, with --cache, --out and --offline", (
   assert.deepEqual(r, {
     status: 0,
     stdout:
-      "📚 paper.md → out/facts.json (2 entries, 2 identifiers, 1 resolved, offline)\n",
+      "📚 refs.bib → out/facts.json (2 entries, 2 identifiers, 1 resolved, offline)\n",
     stderr: "",
   });
 });
@@ -348,17 +299,24 @@ test("no target: the current directory", () => {
   assert.equal(r.status, 0, r.stderr);
 });
 
-test("refusals: nowhere to read from, and zero entries (not written as a clean bibliography)", () => {
+test("refusals: nowhere to read from, a file that is not a .bib, and zero entries (not written as a clean bibliography)", () => {
   assert.deepEqual(cli([join(root, "nope"), "--offline"]), {
     status: 1,
     stdout: "",
-    stderr: `🛑 no paper.md, draft.md, refs.bib, build/custom.bib under ${join(root, "nope")} — nowhere to take a bibliography from.\n`,
+    stderr: `🛑 no paper.tex, refs.bib, build/custom.bib under ${join(root, "nope")} — nowhere to take a bibliography from.\n`,
   });
   assert.deepEqual(cli(["empty", "--offline"]), {
     status: 1,
     stdout: "",
     stderr:
-      "🛑 parsed 0 entries out of empty/paper.md. Silence here would look like a clean bibliography.\n",
+      "🛑 parsed 0 entries out of empty/refs.bib. Silence here would look like a clean bibliography.\n",
+  });
+  // Guards: a file that is neither a .bib nor a .tex is named, not parsed as BibTeX, and nothing is written.
+  assert.deepEqual(cli([join(root, "notes/notes.txt"), "--offline"]), {
+    status: 1,
+    stdout: "",
+    stderr:
+      "🛑 notes/notes.txt is neither a .bib nor a .tex — the bibliography is read from paper.tex, refs.bib, build/custom.bib.\n",
   });
 });
 
@@ -378,3 +336,51 @@ test(".bib without its optional parser: the error names the install; any other f
   assert.match(broken.stderr, /broken install/);
   assert.doesNotMatch(broken.stderr, /npm i -D/);
 });
+
+test("🔴 a paper directory whose paper.tex embeds its .bib: the embedded one is read, not a stale refs.bib", () => {
+  const r = cli(["inline", "--offline"]);
+  // Guards: only materialized .bib files were looked for, so a paper with its bibliography in
+  // `filecontents` was refused before a build and read from a stale refs.bib after an edit.
+  assert.deepEqual(r, {
+    status: 0,
+    stdout:
+      "📚 paper.tex → inline/_build/refs.facts.json (2 entries, 2 identifiers, 0 resolved, offline)\n",
+    stderr: "",
+  });
+  const facts = JSON.parse(
+    readFileSync(join(root, "inline/_build/refs.facts.json"), "utf8"),
+  );
+  // Each entry's line is its line in paper.tex, where the author edits it.
+  assert.deepEqual(
+    facts.entries.map((e) => [e.key, e.line]),
+    [
+      ["a", 3],
+      ["b", 4],
+    ],
+  );
+});
+
+test("a paper.tex that embeds no .bib: in a directory the refs.bib beside it is read; named alone, it has no entries", () => {
+  assert.deepEqual(
+    cli(["plain", "--offline"]).stdout,
+    "📚 refs.bib → plain/_build/refs.facts.json (1 entries, 1 identifiers, 0 resolved, offline)\n",
+  );
+  assert.deepEqual(cli([join(root, "plain/paper.tex"), "--offline"]), {
+    status: 1,
+    stdout: "",
+    stderr:
+      "🛑 parsed 0 entries out of plain/paper.tex. Silence here would look like a clean bibliography.\n",
+  });
+});
+
+test("an embedded entry whose key has no line of its own keeps line 0, not a shifted 0", async () => {
+  const tex = join(root, "spaced.tex");
+  writeFileSync(
+    tex,
+    "x\n\\begin{filecontents*}{refs.bib}\n@misc{ spaced ,\n  note={arXiv:2101.00001}\n}\n\\end{filecontents*}\n",
+  );
+  assert.deepEqual(
+    (await loadEntries(tex)).map((e) => e.line),
+    [0],
+  );
+});

package/skills/paper-pipeline/scripts/generated-code.harness.mjs

@@ -68,7 +68,7 @@ function run(dir, flagsOnly = true) {
 function fixture({ scripts = {}, allow = null, bundle = {}, at = "repro" }) {
   const d = join(tmp, `f${++n}`);
   mkdirSync(d, { recursive: true });
-  writeFileSync(join(d, "paper.md"), "## 1. x\n\nprose\n");
+  writeFileSync(join(d, "paper.tex"), "\\section{x}\nprose\n");
   if (at === null) return d;
   mkdirSync(join(d, at), { recursive: true });
   for (const [p, src] of Object.entries(scripts)) {
@@ -142,13 +142,13 @@ function fixture({ scripts = {}, allow = null, bundle = {}, at = "repro" }) {
     fixture({
       scripts: {
         "wc.py":
-          'text = open("/home/example/papers/paper.md").read()\nprint(len(text.split()))\n',
+          'text = open("/home/example/papers/paper.tex").read()\nprint(len(text.split()))\n',
       },
     }),
   );
   assert.match(
     r.out,
-    /ABS_PATH\s+repro\/wc\.py — hard-codes 1 absolute path\(s\), e\.g\. `\/home\/example\/papers\/paper\.md`/,
+    /ABS_PATH\s+repro\/wc\.py — hard-codes 1 absolute path\(s\), e\.g\. `\/home\/example\/papers\/paper\.tex`/,
     "a script that only runs on its author's laptop shipped in the reproduction directory unremarked:\n" +
       r.out,
   );

package/skills/paper-status/SKILL.md

@@ -4,7 +4,7 @@ description: Answer "what's the status of the paper?" in one pass — MEASURE wh
 allowed-tools: [Bash, Read, Grep, Glob]
 ---
 
-<!-- vigiles:sha256:cdf5e1fcefdb916d compiled from skills/paper-status/SKILL.md.spec.ts -->
+<!-- vigiles:sha256:c90bd362b565fa22 compiled from skills/paper-status/SKILL.md.spec.ts -->
 
 # paper-status — state, measured before it is narrated
 
@@ -65,7 +65,7 @@ git log --oneline @{u}..HEAD                # unpushed commits
 A gate is stale if the paper changed after the gate ran. Check it mechanically, not by recall:
 
 ```bash
-git log -1 --format=%cd --date=short -- paper.md          # when the text last moved
+git log -1 --format=%cd --date=short -- paper.tex         # when the text last moved
 ls -la reviews/ | tail -20                                # when each gate last reported
 ```
 

package/skills/paper-status/SKILL.md.spec.ts

@@ -71,7 +71,7 @@ git log --oneline @{u}..HEAD                # unpushed commits
 A gate is stale if the paper changed after the gate ran. Check it mechanically, not by recall:
 
 \`\`\`bash
-git log -1 --format=%cd --date=short -- paper.md          # when the text last moved
+git log -1 --format=%cd --date=short -- paper.tex         # when the text last moved
 ls -la reviews/ | tail -20                                # when each gate last reported
 \`\`\`
 

package/skills/render-paper/SKILL.md

@@ -4,7 +4,7 @@ description: Compile a LaTeX paper (ACM/IEEE/arXiv) to PDF and render its pages
 allowed-tools: [Read, Write, Edit, Grep, Glob, Bash, SendUserFile]
 ---
 
-<!-- vigiles:sha256:5e2ee8850c098375 compiled from skills/render-paper/SKILL.md.spec.ts -->
+<!-- vigiles:sha256:ff8dca1e1be3977e compiled from skills/render-paper/SKILL.md.spec.ts -->
 
 # render-paper — .tex → PDF → readable page PNGs
 
@@ -15,7 +15,7 @@ first try.
 ## 🔴 This is a COMMAND, not a stage
 
 You run it twenty times a day. It has no position in the pipeline and nothing waits its turn to reach
-it: **any `.tex` / `paper.md` edit is the trigger** — render, then eyeball pages 1–2 before believing
+it: **any `.tex` edit is the trigger** — render, then eyeball pages 1–2 before believing
 anything you say about the paper. Scorecard row **`render`** (in the CONTINUOUS section of
 `paper-pipeline`) records the last render and its page count; that page count is the hard input the
 `tighten-paper` structure gate is blocked on, which is the only sense in which anything "comes after"

package/skills/render-paper/SKILL.md.spec.ts

@@ -21,7 +21,7 @@ first try.
 ## 🔴 This is a COMMAND, not a stage
 
 You run it twenty times a day. It has no position in the pipeline and nothing waits its turn to reach
-it: **any \`.tex\` / \`paper.md\` edit is the trigger** — render, then eyeball pages 1–2 before believing
+it: **any \`.tex\` edit is the trigger** — render, then eyeball pages 1–2 before believing
 anything you say about the paper. Scorecard row **\`render\`** (in the CONTINUOUS section of
 \`paper-pipeline\`) records the last render and its page count; that page count is the hard input the
 \`tighten-paper\` structure gate is blocked on, which is the only sense in which anything "comes after"

package/skills/render-paper/extract-pdf-facts.mjs

@@ -56,8 +56,8 @@ const ROOT = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 /**
  * Accept either a path to a PDF or a PAPER DIRECTORY — and in the second case find the artifact on
  * its own: the path the paper declares in the `pdf` field of `paperlint.json`, else `paper.pdf` beside
- * it. A paper written in markdown and built by its own script into `build/acl_latex.pdf` would
- * otherwise be skipped silently. The facts ALWAYS go into `<paper directory>/_build/`, not next to
+ * it. A paper built by its own script into `build/acl_latex.pdf` would otherwise be skipped
+ * silently. The facts ALWAYS go into `<paper directory>/_build/`, not next to
  * the PDF, where neither a rule's glob nor a human looks.
  */
 export function resolveTarget(arg) {