paperlint 3.0.0 → 3.1.1

package/skills/paper-pipeline/scripts/status.test.mjs

@@ -0,0 +1,232 @@
+/**
+ * status.mjs — the paper's status view, derived from the ledger. Every section it can print is
+ * driven by rows written for the purpose: fresh and stale answers, open findings with and without
+ * a report path, retired-vocabulary rows (an acquittal and a counted one), an orphan check, a check
+ * that has run and never found anything, and the all-answered footer.
+ */
+import assert from "node:assert/strict";
+import { rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, test, vi } from "vitest";
+import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const root = useTempDir("status-");
+const consumer = join(root, "consumer");
+const LEDGER = join(root, "runs.jsonl");
+const paper = join(consumer, "papers", "p");
+writeTree(paper, { "paper.md": "# P\n\ntext\n" });
+Object.assign(process.env, {
+  CLAUDE_PROJECT_DIR: consumer,
+  PIPELINE_LEDGER: LEDGER,
+});
+const { inputHash } = await import("./ledger.mjs");
+const { EXPECTED_GATES, main, unlistedGates } = await import("./status.mjs");
+afterEach(() => rmSync(LEDGER, { force: true }));
+
+const NOW = inputHash(paper);
+const TS = "2026-09-01T10:30:00.000Z";
+/** A ledger row for `key` on paper p. No skill is installed here, so its current hash is null. */
+const row = (key, fields) => {
+  const [skill, check] = key.split("/");
+  return {
+    ts: TS,
+    skill,
+    check: check ?? skill,
+    paper: "p",
+    inputSha: NOW,
+    skillSha: null,
+    ...fields,
+  };
+};
+const NO_WITNESS = { kind: "ABSTAINED", reason: "no-witness", findings: 0 };
+
+function view(rows) {
+  writeFileSync(LEDGER, rows.map((r) => JSON.stringify(r)).join("\n") + "\n");
+  const lines = [];
+  const spy = vi
+    .spyOn(console, "log")
+    .mockImplementation((...a) => lines.push(a.join(" ")));
+  let code;
+  try {
+    code = main(["node", "status.mjs", paper]);
+  } finally {
+    spy.mockRestore();
+  }
+  return { code, text: lines.join("\n") };
+}
+/** The table line for one check, with its padding collapsed. */
+const tableLine = (text, key) =>
+  text
+    .split("\n")
+    .find((l) => l.includes(` ${key} `))
+    ?.trim()
+    .replace(/\s{2,}/g, " | ");
+/** A section: from the line that starts with `head` to the next blank line. */
+const section = (text, head) => {
+  const lines = text.split("\n");
+  const i = lines.findIndex((l) => l.trim().startsWith(head));
+  if (i < 0) return null;
+  const end = lines.findIndex((l, j) => j > i && l.trim() === "");
+  return lines.slice(i, end < 0 ? undefined : end).map((l) => l.trim());
+};
+
+const RAN = [
+  "research-ideate",
+  "find-venue",
+  "map-prior-work",
+  "sweep-design-space",
+  "plan-paper-timeline",
+  "build-benchmark",
+  "draft-paper",
+];
+
+test("every kind of row, and every section it triggers", () => {
+  const { code, text } = view([
+    row("research-ideate", NO_WITNESS),
+    row("find-venue", {
+      kind: "FINDING",
+      findings: 3,
+      blocking: true,
+      report: "r.md",
+    }),
+    row("map-prior-work", { kind: "FINDING", findings: 2, inputSha: "older" }),
+    row("sweep-design-space", { ...NO_WITNESS, skillSha: "a-different-skill" }),
+    row("plan-paper-timeline", { verdict: "PASS" }),
+    row("build-benchmark", { verdict: "FINDINGS", findings: 2 }),
+    row("draft-paper", { kind: "FINDING", findings: 0 }),
+    row("mystery-check", NO_WITNESS),
+    row("paper-status", NO_WITNESS),
+  ]);
+  assert.deepEqual(
+    {
+      code,
+      rows: [
+        "research-ideate",
+        "find-venue",
+        "map-prior-work",
+        "sweep-design-space",
+        "plan-paper-timeline",
+        "build-benchmark",
+        "draft-paper",
+        "camera-ready",
+      ].map((k) => tableLine(text, k)),
+      stale: text
+        .split("\n")
+        .filter((l) => /^\s+(🟠|🟡) [\w/-]+: /.test(l))
+        .map((l) => l.trim()),
+      never: section(text, "⬜ never run:"),
+      mute: section(text, "🔇"),
+      legacy: section(text, "🏷️"),
+      orphans: section(text, "❗"),
+      open: section(text, "📌"),
+      quiet: section(text, "🤍"),
+      footer: text.trim().split("\n").pop().trim(),
+    },
+    {
+      code: 0,
+      rows: [
+        "🟢 research-ideate | FRESH | abstained:no-witness | 1 | 2026-09-01 10:30",
+        "🟢 find-venue | FRESH | 🔴 3 found | 1 | 2026-09-01 10:30",
+        "🟠 map-prior-work | STALE-PAPER | • 2 found | 1 | 2026-09-01 10:30",
+        "🟡 sweep-design-space | STALE-SKILL | abstained:no-witness | 1 | 2026-09-01 10:30",
+        "🟢 plan-paper-timeline | FRESH | legacy:PASS | 1 | 2026-09-01 10:30",
+        "🟢 build-benchmark | FRESH | • 2 found | 1 | 2026-09-01 10:30",
+        "🟢 draft-paper | FRESH | no row | 1 | 2026-09-01 10:30",
+        "⬜ camera-ready | NEVER-RUN | — | 0 | —",
+      ],
+      stale: [
+        // In EXPECTED_GATES order.
+        "🟡 sweep-design-space: the check itself changed since it ran — that answer came from a different tool",
+        "🟠 map-prior-work: the paper changed since it ran — its answer is about a document that is gone",
+      ],
+      never: [
+        `⬜ never run: ${EXPECTED_GATES.filter((k) => !RAN.includes(k)).join(", ")}`,
+        "nobody has asked this question about this paper — an unasked question reads exactly like a clean one in prose.",
+      ],
+      mute: [
+        "🔇 has run and has NEVER recorded a finding: research-ideate, sweep-design-space, plan-paper-timeline",
+        "Borrowed from mutation testing: a test that kills no mutant is not a test. This is",
+        "not proof the check is broken — it is the reason to go plant a defect and watch.",
+        "Precedent here: a tightening pass returned KEEP on 80 of 81 sections and a",
+        'justification pass never once recommended a deletion. Both "ran".',
+      ],
+      legacy: [
+        "🏷️  answered in the RETIRED vocabulary: plan-paper-timeline=PASS, build-benchmark=FINDINGS",
+        "Rows written before 2026-08-10 are kept verbatim and are NOT translated into the",
+        "current constructors — a silent reinterpretation is the class of defect this",
+        "pipeline removed. A retired FINDINGS/FAIL row still shows its count above, because",
+        "it carries evidence and discarding evidence is the destructive direction.",
+        "plan-paper-timeline=PASS carry NOTHING forward:",
+        "they recorded that nothing was wrong, with no evidence attached, which is exactly",
+        "the value that was deleted. Re-run those checks for an answer in a live vocabulary.",
+      ],
+      // `paper-status` records too, but is the view itself, so it is never an orphan.
+      orphans: [
+        "❗ recording but NOT IN THE TABLE: mystery-check",
+        "These ran and said something, and this view showed you nothing. Add them to",
+        "EXPECTED_GATES — an invisible row is the failure this directory exists to end.",
+      ],
+      open: [
+        "📌 open findings: 7 across 3 check(s)",
+        "• map-prior-work: 2 (no report path recorded — the count is all there is)  [STALE-PAPER: this count describes an older text]",
+        "🔴 find-venue: 3 → r.md",
+        "• build-benchmark: 2 (no report path recorded — the count is all there is)",
+        "Nothing here proves anyone acted on these. The ledger records what a check SAID,",
+        "never what was done about it — that lives in the session, not in a file.",
+      ],
+      quiet: [
+        "🤍 ran against the current bytes and recorded nothing: 1 check(s)",
+        "research-ideate (no-witness)",
+        "Read this as the ABSENCE of a finding, which is what it is. `no-witness` means the",
+        "check ran and has no witness for the negative answer — unlike a certifying",
+        "algorithm (McConnell et al. 2011), which ships one for both answers. Our discipline",
+        "is strictly weaker than theirs and this line is where that shows.",
+        "no-witness: ran to completion, produced no finding — NOT a claim that nothing is wrong",
+      ],
+      footer: "🔴 29 check(s) not answering for the current text",
+    },
+  );
+});
+
+test("every expected check answered on the current bytes: the green footer, and nothing to flag", () => {
+  const { code, text } = view(
+    EXPECTED_GATES.map((k) =>
+      row(k, { kind: "FINDING", findings: 1, report: "r.md" }),
+    ),
+  );
+  assert.deepEqual(
+    {
+      code,
+      sections: ["🟠", "🟡", "⬜ never", "🔇", "🏷️", "❗", "🤍"].map((h) =>
+        section(text, h),
+      ),
+      footer: text.trim().split("\n").pop().trim(),
+    },
+    {
+      code: 0,
+      sections: [null, null, null, null, null, null, null],
+      footer: "🟢 every expected check answered for the current text",
+    },
+  );
+});
+
+test("unlistedGates names checks the table does not list, except the view's own rows", () => {
+  assert.deepEqual(
+    unlistedGates([
+      { skill: "find-venue", check: "find-venue" },
+      { skill: "x", check: "y" },
+      { skill: "paper-status", check: "paper-status" },
+    ]),
+    ["x/y"],
+  );
+});
+
+test("as a process, with no argument, it reads the current directory and exits 0", () => {
+  const r = runNode(join(HERE, "status.mjs"), [], {
+    cwd: paper,
+    env: { CLAUDE_PROJECT_DIR: consumer, PIPELINE_LEDGER: LEDGER },
+  });
+  assert.deepEqual([r.status, r.stdout.split("\n")[1]], [0, "  p"]);
+});

package/skills/plan-paper-timeline/plan-paper-timeline.effects.harness.mjs

@@ -343,8 +343,8 @@ try {
     // matters more than it looks. The first version of this guard keyed on `evt_fake_`,
     // a string the stand-in prints only on SUCCESS — so a perfectly correct schema
     // REJECTION arrived with no marker and was reported as "something else served this
-    // tool". The guard meant to protect the verdict was hiding it, and it took a
-    // mutation run to notice (2026-08-17). The log is written on both paths, so a
+    // tool". The guard meant to protect the verdict was hiding it, and that went
+    // unnoticed until 2026-08-17. The log is written on both paths, so a
     // non-empty log means our server handled the call, whatever it decided.
     const logged = existsSync(callLog)
       ? readFileSync(callLog, "utf8")

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

@@ -10,7 +10,6 @@
  *
  * The shim imports the compiled package (`dist/`), so `npm run build` runs before this.
  */
-import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
 import {
   cpSync,
@@ -25,16 +24,13 @@ import {
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createChecker } from "../../lib/check.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const SHIM = join(HERE, "extract-pdf-facts.mjs");
 const FIX = resolve(HERE, "..", "..", "fixtures", "pdf-facts");
 
-let n = 0;
-const check = (label, cond, detail = "") => {
-  assert.ok(cond, detail ? `${label} — ${detail}` : label);
-  n++;
-};
+const check = createChecker();
 
 const root = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-extract-")));
 /**
@@ -49,6 +45,16 @@ const shim = (args, env = {}) =>
       PATH: process.env.PATH,
       HOME: root,
       CLAUDE_PROJECT_DIR: root,
+      // Forwarded, not chosen: under `npm run coverage` these carry the coverage directory and the
+      // preload that resolves dist/ to src/. Dropping them measured the shim's dist/ imports as a
+      // second copy of each module (the function map remapped through source maps, with shifted
+      // columns), so every function it did not call counted as uncovered in src/.
+      ...(process.env.NODE_OPTIONS
+        ? { NODE_OPTIONS: process.env.NODE_OPTIONS }
+        : {}),
+      ...(process.env.NODE_V8_COVERAGE
+        ? { NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE }
+        : {}),
       ...env,
     },
   });
@@ -157,10 +163,53 @@ try {
     missing.status === 3 && /not built/.test(said(missing)),
     said(missing),
   );
+
+  // ── a PDF named directly, in a directory with no paperlint.json, no project dir set ──
+  const loose = join(root, "papers", "loose");
+  mkdirSync(loose, { recursive: true });
+  cpSync(join(FIX, "t3-mixed.pdf"), join(loose, "draft.pdf"));
+  const direct = shim([join(loose, "draft.pdf")], { CLAUDE_PROJECT_DIR: "" });
+  const looseFacts = join(loose, "_build", "paper.facts.json");
+  check(
+    "a PDF path: facts go to its directory's _build/, the path printed relative to the cwd",
+    direct.status === 0 &&
+      direct.stdout.startsWith(
+        "✅ draft.pdf → papers/loose/_build/paper.facts.json (",
+      ) &&
+      JSON.parse(readFileSync(looseFacts, "utf8")).venue === null,
+    said(direct),
+  );
+  // The project directory IS the facts file (nonsense, but an environment can say it): the
+  // relative path would be empty, so the absolute one is printed instead of nothing.
+  const same = shim([join(loose, "draft.pdf")], {
+    CLAUDE_PROJECT_DIR: looseFacts,
+  });
+  check(
+    "a project dir equal to the facts file prints the absolute path, never an empty one",
+    same.stdout.startsWith(`✅ draft.pdf → ${looseFacts} (`),
+    said(same),
+  );
+
+  // ── a file that is not a PDF: refused, strict or not, in the words for the mode ──
+  writeFileSync(join(loose, "broken.pdf"), "not a pdf at all\n");
+  const brokenStrict = shim([join(loose, "broken.pdf"), "--strict"]);
+  const brokenLocal = shim([join(loose, "broken.pdf")]);
+  check(
+    "an unreadable PDF: --strict exits 1 as an environment error; locally exit 0, saying THE PDF IS NOT CHECKED",
+    brokenStrict.status === 1 &&
+      /🛑 facts not taken: .* — in CI this is an environment error/.test(
+        brokenStrict.stderr,
+      ) &&
+      brokenLocal.status === 0 &&
+      /⏭️ {2}facts not taken: .*THE PDF IS NOT CHECKED/.test(
+        brokenLocal.stderr,
+      ),
+    `${said(brokenStrict)}\n---\n${said(brokenLocal)}`,
+  );
 } finally {
   rmSync(root, { recursive: true, force: true });
 }
 
 console.log(
-  `✓ ${String(n)} assertions passed — extract-pdf-facts: the exit-code contract, schema 2, and the no-no-yes font`,
+  `✓ ${String(check.count)} assertions passed — extract-pdf-facts: the exit-code contract, schema 2, and the no-no-yes font`,
 );

package/skills/tighten-paper/__snapshots__/structure.test.mjs.snap

@@ -0,0 +1,133 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`--section=1 keeps section 1 and its sub-sections, and nothing before it 1`] = `
+"
+=== full.md — outline, in order ===
+   own  total  share  section
+    10     16  53.3%  1 Introduction
+                     ↳ [7/10 KEEP] carries: the claim
+     4                    1.1 Detail
+                         ↳ carries: a sub-point
+     2                    1.2 Bare sub
+                         ↳ 🔴 no carries: note — nobody has said why this section is here
+
+body total 30 words across 4 sections
+
+=== outside the page limit ===
+    40               Limitations
+                     ↳ 🔴 no carries: note — and no page limit forcing the question
+     5                   Scope
+                         ↳ carries: why the scope note
+    30               Appendix A
+                     ↳ carries: the raw tables
+
+free total 75 words = 250% of the body
+🔴 The unbudgeted half is LARGER than the paper. Nothing prices these sections, which
+   is exactly why prose settles here. Ask of each: would a reviewer miss it?
+
+The rest is judgement and stays with the skill: is this the ORDER a stranger needs, does each
+heading name a thing, and does each section earn its place. Read the headings as a set — a
+stranger should be able to reconstruct the argument from them alone.
+"
+`;
+
+exports[`the inventory of body-only.md 1`] = `
+"
+=== body-only.md — outline, in order ===
+   own  total  share  section
+     8      8  66.7%  1 Intro
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+     4      4  33.3%  2 Rest
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+     0      0   0.0%  3 Empty
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+
+body total 12 words across 3 sections
+
+The rest is judgement and stays with the skill: is this the ORDER a stranger needs, does each
+heading name a thing, and does each section earn its place. Read the headings as a set — a
+stranger should be able to reconstruct the argument from them alone.
+"
+`;
+
+exports[`the inventory of full.md 1`] = `
+"
+=== full.md — outline, in order ===
+   own  total  share  section
+     3                    Orphan sub
+    10     16  53.3%  1 Introduction
+                     ↳ [7/10 KEEP] carries: the claim
+     4                    1.1 Detail
+                         ↳ carries: a sub-point
+     2                    1.2 Bare sub
+                         ↳ 🔴 no carries: note — nobody has said why this section is here
+     6      6  20.0%  2 Method
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+     5      5  16.7%  3 Results
+                     ↳ [?/10 CUT] carries: only a verdict
+     3      3  10.0%  Discussion
+                     ↳ [4/10 NO VERDICT] carries: score only
+
+body total 30 words across 4 sections
+
+=== outside the page limit ===
+    40               Limitations
+                     ↳ 🔴 no carries: note — and no page limit forcing the question
+     5                   Scope
+                         ↳ carries: why the scope note
+    30               Appendix A
+                     ↳ carries: the raw tables
+
+free total 75 words = 250% of the body
+🔴 The unbudgeted half is LARGER than the paper. Nothing prices these sections, which
+   is exactly why prose settles here. Ask of each: would a reviewer miss it?
+
+The rest is judgement and stays with the skill: is this the ORDER a stranger needs, does each
+heading name a thing, and does each section earn its place. Read the headings as a set — a
+stranger should be able to reconstruct the argument from them alone.
+"
+`;
+
+exports[`the inventory of no-appendix.md 1`] = `
+"
+=== no-appendix.md — outline, in order ===
+   own  total  share  section
+     8      8 100.0%  1 Intro
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+
+body total 8 words across 1 sections
+
+=== outside the page limit ===
+     3               Limitations
+                     ↳ 🔴 no carries: note — and no page limit forcing the question
+
+free total 3 words = 38% of the body
+
+The rest is judgement and stays with the skill: is this the ORDER a stranger needs, does each
+heading name a thing, and does each section earn its place. Read the headings as a set — a
+stranger should be able to reconstruct the argument from them alone.
+"
+`;
+
+exports[`the inventory of refs-first.md 1`] = `
+"
+=== refs-first.md — outline, in order ===
+   own  total  share  section
+     8      8 100.0%  1 Intro
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+
+body total 8 words across 1 sections
+
+=== outside the page limit ===
+     2               References
+                     ↳ 🔴 no carries: note — and no page limit forcing the question
+     2               Ethical note
+                     ↳ 🔴 no carries: note — and no page limit forcing the question
+
+free total 4 words = 50% of the body
+
+The rest is judgement and stays with the skill: is this the ORDER a stranger needs, does each
+heading name a thing, and does each section earn its place. Read the headings as a set — a
+stranger should be able to reconstruct the argument from them alone.
+"
+`;

package/skills/tighten-paper/structure.test.mjs

@@ -0,0 +1,116 @@
+/**
+ * structure.mjs — the section inventory the tighten-paper skill prints for a human to read. No
+ * threshold, no finding: the table IS the product, so the whole printed table is compared.
+ */
+import assert from "node:assert/strict";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { expect, test } from "vitest";
+import { runNode, useTempDir, writeTree } from "../../test/support.mjs";
+
+const SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "structure.mjs");
+const root = useTempDir("structure-");
+const words = (n) => Array.from({ length: n }, (_, i) => `w${i}`).join(" ");
+
+writeTree(root, {
+  // Every row shape: a sub-section before any section, carries notes with a score and a verdict,
+  // with only one of them, with neither, a numbered section with no note, and a free half — after
+  // Limitations, between References and the Appendix — larger than the body.
+  "full.md": `---
+title: x
+---
+Preamble before any heading.
+
+### Orphan sub
+${words(3)}
+
+<!-- carries: the claim · score: 7/10 · verdict: keep -->
+## 1 Introduction
+${words(10)}
+
+<!-- carries: a sub-point -->
+### 1.1 Detail
+${words(4)}
+
+### 1.2 Bare sub
+${words(2)}
+
+## 2 Method
+${words(6)}
+
+<!-- carries: only a verdict · verdict: CUT -->
+## 3 Results
+${words(5)}
+
+<!-- carries: score only · score: 4 -->
+## Discussion
+${words(3)}
+
+## Limitations
+${words(40)}
+
+<!-- carries: why the scope note -->
+### Scope
+${words(5)}
+
+## References
+[1] Not counted.
+
+<!-- carries: the raw tables -->
+## Appendix A
+${words(30)}
+`,
+  // References come first, so the free half runs from it to the end; no appendix.
+  "refs-first.md": `## 1 Intro\n${words(8)}\n\n## References\n[1] x\n\n## Ethical note\n${words(2)}\n`,
+  // Limitations then References and no appendix: the free half stops at References.
+  "no-appendix.md": `## 1 Intro\n${words(8)}\n\n## Limitations\n${words(3)}\n\n## References\n[1] x\n`,
+  // No free half at all.
+  // ...and a section with no words at all.
+  "body-only.md": `## 1 Intro\n${words(8)}\n\n## 2 Rest\n${words(4)}\n\n## 3 Empty\n`,
+});
+
+const run = (...args) => {
+  const r = runNode(
+    SCRIPT,
+    args.map((a) => (a.startsWith("--") ? a : join(root, a))),
+  );
+  return { ...r, stdout: r.stdout.replaceAll(root, "<root>") };
+};
+
+test("no file: the usage line, exit 0", () => {
+  assert.deepEqual(run(), {
+    status: 0,
+    stdout: "",
+    stderr:
+      "usage: node structure.mjs <paper.md> [--section=N]   (--flags-only is accepted and stays silent)\n",
+  });
+});
+
+test("--flags-only stays silent and exits 0 — every check moved to ESLint", () => {
+  assert.deepEqual(run("--flags-only", "full.md"), {
+    status: 0,
+    stdout: "",
+    stderr: "",
+  });
+});
+
+test.each(["full.md", "refs-first.md", "no-appendix.md", "body-only.md"])(
+  "the inventory of %s",
+  (file) => {
+    const r = run(file);
+    assert.deepEqual(
+      { status: r.status, stderr: r.stderr },
+      { status: 0, stderr: "" },
+    );
+    expect(r.stdout).toMatchSnapshot();
+  },
+);
+
+test("--section=1 keeps section 1 and its sub-sections, and nothing before it", () => {
+  const r = run("full.md", "--section=1");
+  assert.deepEqual(
+    { status: r.status, stderr: r.stderr },
+    { status: 0, stderr: "" },
+  );
+  expect(r.stdout).toMatchSnapshot();
+});

package/skills/verify-citations/SKILL.md

@@ -4,7 +4,7 @@ description: Verify every citation is a real work with correct metadata, and tha
 allowed-tools: [Read, Write, Edit, Grep, Glob, Bash, WebSearch, WebFetch, Agent]
 ---
 
-<!-- vigiles:sha256:2bb9f6f1233094cf compiled from skills/verify-citations/SKILL.md.spec.ts -->
+<!-- vigiles:sha256:9973bd8fef7e0927 compiled from skills/verify-citations/SKILL.md.spec.ts -->
 
 # verify-citations — every cite real, the delta explicit
 
@@ -259,7 +259,7 @@ the same one MedSci Skills (arXiv:2606.09500) closes with `verify_refs.py`.
 | year | ±1 on a title search | exact, and only against the record that dates the cited version |
 | preprint→published | not asked | arXiv `journal_ref`/`doi` present and no venue named → say so |
 | what it could not check | folded into `unresolvable` | **enumerated, one rule per reason, never counted as verified** |
-| tests | `verify-cites.test.mjs` — not a `*.harness.mjs`, so `npx vigiles test` never runs it | `eslint-rules/ref-facts.harness.mjs` + `.claude/skills/paper-pipeline/scripts/extract-ref-facts.harness.mjs`, plus `eslint-rules/ref-facts.mutations.mjs` |
+| tests | `verify-cites.test.mjs` — not a `*.harness.mjs`, so `npx vigiles test` never runs it | `src/references.test.ts` (the `refs/*` rules in `src/reference-rules.ts`) + `skills/paper-pipeline/scripts/extract-ref-facts.test.mjs` and `.harness.mjs`, under the package's 100% line and branch coverage gate |
 
 **The uncovered set is the point.** A reference with no resolvable identifier is a FINDING here
 (`refs/no-identifier`), and every partial comparison is another (`refs/partial-check`, one messageId per
@@ -274,9 +274,9 @@ and its `.bib` regex required a closing `}` on its own line, which neither real
 references`). The `.bib` half now goes through `@retorquere/bibtex-parser`. Two of the three papers are
 therefore being checked for the first time.
 
-**Every check is watched failing.** `node eslint-rules/ref-facts.mutations.mjs` neuters each rule in turn
-and requires the harness to go red at the named case — 21 mutations, all killed, and three of them were
-findings about the TEST rather than the rule. Run it after any edit to the rules.
+**Every check is exercised.** `src/references.test.ts` drives the `refs/*` rules, and `npm run coverage`
+fails CI if any line or branch of them goes unexercised. Run `npx vitest run src/references.test.ts`
+after any edit to the rules.
 
 ## 6. Record the verdict
 

package/skills/verify-citations/SKILL.md.spec.ts

@@ -275,7 +275,7 @@ the same one MedSci Skills (arXiv:2606.09500) closes with \`verify_refs.py\`.
 | year | ±1 on a title search | exact, and only against the record that dates the cited version |
 | preprint→published | not asked | arXiv \`journal_ref\`/\`doi\` present and no venue named → say so |
 | what it could not check | folded into \`unresolvable\` | **enumerated, one rule per reason, never counted as verified** |
-| tests | \`verify-cites.test.mjs\` — not a \`*.harness.mjs\`, so \`npx vigiles test\` never runs it | \`eslint-rules/ref-facts.harness.mjs\` + \`.claude/skills/paper-pipeline/scripts/extract-ref-facts.harness.mjs\`, plus \`eslint-rules/ref-facts.mutations.mjs\` |
+| tests | \`verify-cites.test.mjs\` — not a \`*.harness.mjs\`, so \`npx vigiles test\` never runs it | \`src/references.test.ts\` (the \`refs/*\` rules in \`src/reference-rules.ts\`) + \`skills/paper-pipeline/scripts/extract-ref-facts.test.mjs\` and \`.harness.mjs\`, under the package's 100% line and branch coverage gate |
 
 **The uncovered set is the point.** A reference with no resolvable identifier is a FINDING here
 (\`refs/no-identifier\`), and every partial comparison is another (\`refs/partial-check\`, one messageId per
@@ -290,9 +290,9 @@ and its \`.bib\` regex required a closing \`}\` on its own line, which neither r
 references\`). The \`.bib\` half now goes through \`@retorquere/bibtex-parser\`. Two of the three papers are
 therefore being checked for the first time.
 
-**Every check is watched failing.** \`node eslint-rules/ref-facts.mutations.mjs\` neuters each rule in turn
-and requires the harness to go red at the named case — 21 mutations, all killed, and three of them were
-findings about the TEST rather than the rule. Run it after any edit to the rules.
+**Every check is exercised.** \`src/references.test.ts\` drives the \`refs/*\` rules, and \`npm run coverage\`
+fails CI if any line or branch of them goes unexercised. Run \`npx vitest run src/references.test.ts\`
+after any edit to the rules.
 
 ## 6. Record the verdict