paperlint 3.1.3 → 4.0.0

package/skills/paper-pipeline/scripts/consumer.mjs

@@ -7,11 +7,9 @@
  *
  *   1. where is the consumer's repository root, now that walking `..` from here lands in
  *      `node_modules/` instead;
- *   2. where does the run ledger live, now that the directory next to this file is wiped by
- *      `npm ci`;
- *   3. was this file executed, or merely imported — a question whose usual answer stops
+ *   2. was this file executed, or merely imported — a question whose usual answer stops
  *      working the moment the file is reached through a symlink;
- *   4. by what path a SKILL'S PROSE names these scripts, so that a checker can tell an
+ *   3. by what path a SKILL'S PROSE names these scripts, so that a checker can tell an
  *      instruction that runs them from one that runs something else. See the fourth-carrier
  *      section at the bottom of this file.
  *
@@ -23,7 +21,7 @@
  *                                                paper-pipeline/scripts
  *
  * so every command a skill's prose already names — `node .claude/skills/paper-pipeline/scripts/
- * ledger.mjs …` — keeps working unchanged. That is the whole reason the symlink exists: the
+ * <script>.mjs …` — keeps working unchanged. That is the whole reason the symlink exists: the
  * first consumer names those paths 306 times across 129 files, almost all of it in the PROSE of
  * skills, which no refactor can rewrite.
  *
@@ -35,12 +33,11 @@
  *     process.cwd()     /…/<the consumer repository root>
  *
  * Node resolves the entry point to its realpath (`--preserve-symlinks-main` is off by default)
- * but leaves `argv[1]` as typed. Three consequences, each one a function here:
+ * but leaves `argv[1]` as typed. Two consequences, each one a function here:
  *
  *   🔴 `import.meta.url === \`file://${process.argv[1]}\`` — the main guard nine scripts in this
  *      directory used — is `false` through the symlink. NOT an error: the process exits 0 having
- *      done nothing. `ledger.mjs record …` would silently record nothing, `announce.mjs` would
- *      silently announce nothing, and every caller would read success. `isMain()` compares
+ *      done nothing, and every caller reads success. `isMain()` compares
  *      against the REALPATH of `argv[1]` instead, which is true through both routes.
  *
  *   🔴 `resolve(import.meta.dirname, "..", "..", "..", "..")` — the repository root, correct
@@ -48,30 +45,9 @@
  *      by `process.cwd()`, which is the consumer root because every one of those 306 invocations
  *      is `node .claude/skills/…` typed from the repository root. `consumerRoot()`.
  *
- *   🔴 `join(import.meta.dirname, "runs.jsonl")` — the ledger's default home — now points inside
- *      `node_modules`, which `npm ci` deletes. Appending there is SILENT DATA LOSS: the write
- *      succeeds, the rows are real, and they vanish at the next install with no error anywhere.
- *      `ledgerPath()` refuses to return that path at all.
- *
- * ── THE LEDGER, THREE RUNGS ─────────────────────────────────────────────────
- *   1. `PIPELINE_LEDGER` in the environment — always wins. This is what test harnesses set to
- *      keep fixture rows out of real history, so it must outrank a declaration on disk.
- *   2. `{ "ledger": "…" }` in the CONSUMER's root `paperlint.json`, read
- *      from `process.cwd()`, resolved relative to it.
- *   3. `runs.jsonl` beside this file — ONLY when this file is not inside `node_modules`, i.e.
- *      when the package is being developed in its own checkout. Inside `node_modules` with
- *      nothing declared, this THROWS.
- *
- * 🔴 WHY RUNG 3 THROWS RATHER THAN GUESSING. Every other candidate default is worse in the same
- * direction. Writing beside the file loses data at the next `npm ci`. Writing to
- * `<cwd>/runs.jsonl` puts an append-only journal at the top of someone's repository without
- * asking. Writing nowhere makes `record()` a no-op, which is the stored "nothing was wrong" this
- * ledger exists to abolish. A throw is the only one of the four that cannot be mistaken for
- * having worked — and it carries the cure, naming the key and the file to put it in.
- *
- * ⚠️ THE EXAMPLES HERE ARE DELIBERATELY GENERIC (`docs/pipeline-runs.jsonl`). The first
- * consumer's own directory names are absent by the same rule `papers.harness.mjs` part IV
- * enforces for `papers.mjs`: a package that spells out one user's private tree has one user.
+ * ⚠️ THE EXAMPLES HERE ARE DELIBERATELY GENERIC. The first consumer's own directory names are
+ * absent by the same rule `papers.harness.mjs` part IV enforces for `papers.mjs`: a package that
+ * spells out one user's private tree has one user.
  */
 import {
   existsSync,
@@ -85,11 +61,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 
 // Re-exported, not re-declared — see the note in `lib/paper-config.mjs`. This file is not a hook
 // and never needed its own copy.
-import {
-  CONFIG_FILE,
-  CONFIG_KEY,
-  settingsOf,
-} from "../../../lib/paper-config.mjs";
+import { CONFIG_FILE, CONFIG_KEY, settingsOf } from "#lib/paper-config";
 export { CONFIG_KEY, settingsOf };
 
 /**
@@ -250,68 +222,22 @@ function readlinkOr(entry, readlink) {
  * True when `dir` lies inside a `node_modules` directory.
  *
  * Segment-wise, not `includes("node_modules")`: a repository legitimately named
- * `my-node_modules-inspector` is not an installed package, and a substring test would refuse to
- * write its ledger. Cheap to get right, and the failure it prevents is a throw in someone's face.
+ * `my-node_modules-inspector` is not an installed package, and a substring test would refuse it.
+ * Cheap to get right, and the failure it prevents is a throw in someone's face.
  */
 export function insideNodeModules(dir) {
   return dir.split(sep).includes("node_modules");
 }
 
-/**
- * Where the run ledger lives. Three rungs; see the docblock.
- *
- * @param hereDir  the directory of the module that owns the ledger — pass `import.meta.dirname`.
- * @returns an absolute path. Never a path inside `node_modules`.
- */
-export function ledgerPath(
-  hereDir,
-  { env = process.env, cwd = process.cwd() } = {},
-) {
-  // Rung 1 — the environment. Deliberately first: harnesses redirect the ledger BEFORE importing
-  // it, and a declaration on disk that could override that would put fixture rows in real history.
-  if (env.PIPELINE_LEDGER) return resolve(env.PIPELINE_LEDGER);
-
-  // Rung 2 — the consumer's declaration.
-  const root = consumerRoot({ env, cwd });
-  const declared = settingsOf(consumerRoot({ env, cwd }))?.ledger;
-  // 🔴 `declared === undefined`, NOT `declared ?? default` — the same distinction `papersRoot()`
-  // makes and for the same reason: `"ledger": null` is a keystroke, not an absence, and reading
-  // it as "nothing was declared" would silently pick a different file than the one asked for.
-  if (declared !== undefined) {
-    if (typeof declared !== "string" || declared.length === 0)
-      throw new TypeError(
-        `${CONFIG_KEY}: "ledger" must be a non-empty string, got ${JSON.stringify(declared)}`,
-      );
-    return resolve(root, declared);
-  }
-
-  // Rung 3 — beside this file, but only in the package's own checkout.
-  if (insideNodeModules(hereDir))
-    throw new Error(
-      `${CONFIG_KEY}: no ledger location is declared, and the default (a file beside this ` +
-        `module) is inside node_modules, which \`npm ci\` deletes.\n` +
-        `Declare where the ledger lives, in ${join(root, CONFIG_FILE)}:\n` +
-        `  { "ledger": "docs/pipeline-runs.jsonl" }\n` +
-        `or set PIPELINE_LEDGER for a single run.\n` +
-        `This is thrown rather than defaulted on purpose: appending to a path under ` +
-        `node_modules succeeds, so the rows would look recorded right up until the next ` +
-        `install removed them, with no error at any point.`,
-    );
-  return join(hereDir, "runs.jsonl");
-}
-
 // ═════════════════════════════════════════════════════════════════════════════════════════════
-// THE FOURTH CARRIER — WHERE A SKILL'S PROSE NAMES THESE SCRIPTS
+// WHERE A SKILL'S PROSE NAMES THESE SCRIPTS
 //
-// `papersRoot()` answers "where does the consumer keep its papers"; `ledgerPath()` answers
-// "where does the run journal live"; `citeChecks` (read in `run-mechanical.mjs`) answers "where
-// are the consumer's own citation checkers". This answers the fourth: BY WHAT PATH does a skill
-// instruct the model to run `announce.mjs` and `ledger.mjs`.
+// `papersRoot()` answers "where does the consumer keep its papers". This answers: BY WHAT PATH
+// does a skill instruct the model to run this package's scripts.
 //
-// 🔴 IT IS A DIFFERENT KIND OF PATH FROM THE OTHER THREE, and the difference decides the API.
-// The other three are read by CODE and may be absolute. This one is compared against text a
-// human wrote inside a SKILL.md — `node .claude/skills/paper-pipeline/scripts/ledger.mjs record
-// …` — so it must stay relative to the consumer root and spelled with `/`, exactly as the prose
+// 🔴 IT IS A DIFFERENT KIND OF PATH, and the difference decides the API. `papersRoot()` is read by
+// CODE and may be absolute. This one is compared against text a human wrote inside a SKILL.md —
+// `node .claude/skills/paper-pipeline/scripts/<script>.mjs …` — so it must stay relative to the consumer root and spelled with `/`, exactly as the prose
 // spells it. Returning an absolute path here would make every `startsWith` test false and every
 // check that depends on it pass over an empty set.
 //
@@ -350,7 +276,7 @@ export function scriptsRoot({ env = process.env, cwd = process.cwd() } = {}) {
   const root = consumerRoot({ env, cwd });
   const declared = settingsOf(consumerRoot({ env, cwd }))?.scripts;
   // 🔴 `declared === undefined`, NOT `declared ?? DEFAULT` — the same distinction `papersRoot()`
-  // and `ledgerPath()` make, for the same reason: `"scripts": null` is a keystroke, not an
+  // makes, for the same reason: `"scripts": null` is a keystroke, not an
   // absence, and silently substituting the default for it hides a typo behind a working run.
   const rel = declared === undefined ? DEFAULT_SCRIPTS_ROOT : declared;
   if (typeof rel !== "string" || rel.length === 0)
@@ -389,12 +315,11 @@ export function scriptsRoot({ env = process.env, cwd = process.cwd() } = {}) {
 }
 
 // ═════════════════════════════════════════════════════════════════════════════════════════════
-// THE SIXTH CARRIER — WHICH WALL CLOCK THE CONSUMER SCHEDULES AGAINST
+// WHICH WALL CLOCK THE CONSUMER SCHEDULES AGAINST
 //
-// `papersRoot()` answers "where are the papers", `ledgerPath()` "where is the journal",
-// `citeChecks` "where are the consumer's citation checkers", `scriptsRoot()` "by what path does
-// prose name these scripts", `triggerCases` "where are the consumer's own trigger cases". This
-// answers the sixth: IN WHAT TIME ZONE does a deadline anchor get written.
+// `papersRoot()` answers "where are the papers", `scriptsRoot()` "by what path does prose name
+// these scripts", `triggerCases` "where are the consumer's own trigger cases". This answers: IN
+// WHAT TIME ZONE does a deadline anchor get written.
 //
 // 🔴 WHY IT IS A DECLARATION AND NOT A CONSTANT. A deadline is the one quantity in this pipeline
 // that is meaningless without a zone, and the zone belongs to the PERSON, not to the pipeline —
@@ -450,7 +375,7 @@ export function consumerTimezone({
 }
 
 // ═════════════════════════════════════════════════════════════════════════════════════════════
-// THE SEVENTH CARRIER — WHOM THE SCHOLARLY APIs SHOULD CONTACT
+// WHOM THE SCHOLARLY APIs SHOULD CONTACT
 //
 // Crossref and friends run a "polite pool": send a `mailto:` in the User-Agent and you get the
 // faster, more reliable tier, plus a warning by email instead of a silent block if your usage
@@ -489,13 +414,7 @@ export function consumerContactEmail({
   return declared;
 }
 
-/**
- * The individual script paths, derived from one root.
- *
- * 🔴 THE NAMES LIVE HERE, NOT IN THE CONSUMER — the same half that keeps `paperFiles()` honest.
- * `announce.mjs` and `ledger.mjs` are this package's contract; a consumer that spelled them out
- * itself would keep its copy of the list in step by hand, and a hand-kept list rots silently.
- */
+/** The prefix every prose path to this package's scripts starts with, derived from one root. */
 export function pipelineScripts(root) {
   // 🔴 ONE TRAILING SLASH, NOT THE ONE THAT WAS TYPED. `scriptsRoot()` returns the declaration
   // verbatim — it must, the value is compared against prose — so `"scripts": "tools/pipeline/"`
@@ -508,9 +427,5 @@ export function pipelineScripts(root) {
   return {
     /** What every prose path under this root starts with. Trailing slash, for `startsWith`. */
     prefix: `${base}/`,
-    /** Announces that a gate has started. */
-    announce: `${base}/announce.mjs`,
-    /** Appends the verdict row. */
-    ledger: `${base}/ledger.mjs`,
   };
 }

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

@@ -6,7 +6,7 @@ import assert from "node:assert/strict";
 import { mkdirSync, symlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { afterEach, test } from "vitest";
-import { useTempDir, writeTree } from "../../../test/support.mjs";
+import { useTempDir, writeTree } from "../../../test/support.ts";
 import {
   consumerContactEmail,
   consumerTimezone,

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

@@ -25,7 +25,7 @@ import {
   DEFAULT_PAPERS_ROOT,
   PAPERS_DIR_FIELD,
   settingsOf,
-} from "../../../lib/paper-config.mjs";
+} from "#lib/paper-config";
 import {
   existsSync,
   mkdirSync,

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

@@ -71,10 +71,7 @@ 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.mjs";
+import { headings as mdHeadings, requireMarkdown } from "#lib/markdown";
 import { isMain } from "./consumer.mjs";
 
 // Markup is parsed with a parser (`CLAUDE.md`, 2026-08-11). We fail rather than degrade: without

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

@@ -8,7 +8,7 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { test } from "vitest";
-import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+import { runNode, useTempDir, writeTree } from "../../../test/support.ts";
 import {
   buildFacts,
   extractIds,

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

@@ -317,9 +317,8 @@ function fixture({ scripts = {}, allow = null, bundle = {}, at = "repro" }) {
 }
 
 // ── 11. the ledger prints on a CLEAN run, and the header states the count ───────────────────────
-// The count matters beyond tidiness: `run-mechanical.mjs` reads this check in `flags` mode, where
-// it prefers a stated count and otherwise COUNTS OUTPUT LINES. The ledger is ~20 lines that are not
-// findings, so without the stated count a clean paper would be recorded as twenty findings.
+// The count matters beyond tidiness: the ledger is ~20 lines that are not findings, so a caller
+// counting output lines would read a clean paper as twenty findings.
 {
   const r = run(
     fixture({

package/skills/paper-pipeline/scripts/{generated-code.test.mjs → generated-code.test.ts}

@@ -8,14 +8,14 @@ import { symlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { test } from "vitest";
-import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+import { runNode, useTempDir, writeTree } from "../../../test/support.ts";
 
 const SCRIPT = join(
   dirname(fileURLToPath(import.meta.url)),
   "generated-code.mjs",
 );
 const root = useTempDir("generated-code-");
-const run = (...args) => runNode(SCRIPT, args);
+const run = (...args: string[]) => runNode(SCRIPT, args);
 
 test("no argument prints the usage; a directory that does not exist scanned nothing, and says so", () => {
   assert.deepEqual(run(), {
@@ -41,7 +41,7 @@ test("repro/: a dangling link is passed over; skipped trees are named, more than
   const dir = writeTree(join(root, "paper"), {
     ...deep,
     "repro/.cache/x.py": "",
-    // eslint-disable-next-line port/js-install-path -- a fixture directory the scan must skip, not an install location
+    // A fixture directory the scan must skip, not an install location.
     "repro/node_modules/x.js": "",
     "repro/__pycache__/x.py": "",
     // Draws randomness unseeded: a NO_SEED finding, which the reasonless row below waves through.

package/skills/paper-pipeline/scripts/population-map.harness.mjs

@@ -11,7 +11,7 @@
  * The findings themselves are planted in `population-map.test.mjs` (vitest; until #52 a
  * self-test script this harness spawned). This file keeps what only the command shows: finding
  * paper.md and repro/populations.tsv, and `--flags-only` staying silent on a clean paper — the
- * wiring the CI step and `run-mechanical.mjs` actually invoke.
+ * wiring the CI step actually invokes.
  */
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
@@ -107,8 +107,8 @@ const REG = [
 }
 
 // ── 4. KNOWN GAP, asserted so it stays visible ─────────────────────────────────────────
-// 🔴 A paper with NO repro/populations.tsv exits 0 in silence, and `run-mechanical.mjs` records
-// that silence as PASS for draft-paper. So a paper that never declared its populations scores
+// 🔴 A paper with NO repro/populations.tsv exits 0 in silence, which reads as a pass for
+// draft-paper. So a paper that never declared its populations scores
 // identically to one that declared them and tied every one. Absence is invisible again — the same
 // shape artifact-coverage.mjs was written to close for the released bundle.
 //

package/skills/paper-pipeline/scripts/population-map.mjs

@@ -48,10 +48,7 @@
  */
 import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
-import {
-  headings as mdHeadings,
-  requireMarkdown,
-} from "../../../lib/markdown.mjs";
+import { headings as mdHeadings, requireMarkdown } from "#lib/markdown";
 import { isMain } from "./consumer.mjs";
 
 // Markup is parsed with a parser (`CLAUDE.md`, 2026-08-11). We fail rather than degrade: without

package/skills/paper-pipeline/scripts/population-map.test.mjs

@@ -11,7 +11,7 @@ import assert from "node:assert/strict";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { test } from "vitest";
-import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+import { runNode, useTempDir, writeTree } from "../../../test/support.ts";
 import { bodyOf, findings } from "./population-map.mjs";
 
 const SCRIPT = join(

package/skills/paper-pipeline/scripts/{round-diff.harness.mjs → round-diff.harness.ts}

@@ -1,5 +1,5 @@
 /**
- * round-diff.harness.mjs — plant the defect each check in `round-diff.mjs` claims to catch, assert
+ * round-diff.harness.ts — plant the defect each check in `round-diff.mjs` claims to catch, assert
  * it says no with the RIGHT WORDS, and assert it stays silent on the clean case. `npx vigiles test`.
  *
  * WHAT IS UNDER TEST. `.claude/skills/paper-pipeline/scripts/round-diff.mjs`: a review round may only
@@ -49,6 +49,7 @@ import {
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { z } from "zod";
 const HERE = dirname(fileURLToPath(import.meta.url));
 
 const SCRIPT = join(HERE, "round-diff.mjs");
@@ -60,7 +61,9 @@ const tmp = realpathSync(mkdtempSync(join(tmpdir(), "round-diff-harness-")));
 // numbered body, a `## References` boundary and an appendix after it. The boundary is load-bearing
 // — the ratchet must not charge for words moved into an appendix.
 
-const P = (o = {}) => `---
+type Section =
+  "abstract" | "s1" | "s2" | "s21" | "s3" | "lim" | "refs" | "appendix";
+const P = (o: Partial<Record<Section, string>> = {}) => `---
 title: "A fixture"
 ---
 
@@ -108,10 +111,16 @@ function fixture({
   now = null,
   rounds = {},
   commitRounds = false,
+}: {
+  base?: string;
+  now?: string | null;
+  rounds?: Record<string, string>;
+  commitRounds?: boolean;
 } = {}) {
-  const dir = join(tmp, `f${++n}`, "paper-x");
+  const dir = join(tmp, `f${String(++n)}`, "paper-x");
   mkdirSync(dir, { recursive: true });
-  const g = (...a) => spawnSync("git", a, { cwd: dir, encoding: "utf8" });
+  const g = (...a: string[]) =>
+    spawnSync("git", a, { cwd: dir, encoding: "utf8" });
   g("init", "-q", "-b", "main");
   g("config", "user.email", "h@example.com");
   g("config", "user.name", "harness");
@@ -150,18 +159,34 @@ const M = ({
   hedge,
   closed,
   base = "__BASE__",
+}: {
+  round?: number;
+  touches?: readonly string[];
+  allows?: readonly string[];
+  budget?: number;
+  hedge?: number;
+  closed?: string;
+  base?: string;
 } = {}) =>
   `---
-round: ${round}
+round: ${String(round)}
 opened: 2026-08-10
 base: ${base}
 touches: [${touches.map((t) => `"${t}"`).join(", ")}]
-${allows ? `allows: [${allows.join(", ")}]\n` : ""}${budget !== undefined ? `budget: ${budget}\n` : ""}${hedge !== undefined ? `hedge-budget: ${hedge}\n` : ""}${closed ? `closed: ${closed}\n` : ""}---
+${allows ? `allows: [${allows.join(", ")}]\n` : ""}${budget !== undefined ? `budget: ${String(budget)}\n` : ""}${hedge !== undefined ? `hedge-budget: ${String(hedge)}\n` : ""}${closed ? `closed: ${closed}\n` : ""}---
 
-Round ${round}.
+Round ${String(round)}.
 `;
 
-function run(dir, ...args) {
+/** One finding of the gate's `--json` output, with the two fields these checks read. */
+const Findings = z.array(z.looseObject({ kind: z.string(), msg: z.string() }));
+type Run = {
+  findings: z.infer<typeof Findings>;
+  kinds: string[];
+  text: string;
+};
+
+function run(dir: string, ...args: string[]): Run {
   const json = spawnSync("node", [SCRIPT, dir, "--json", ...args], {
     encoding: "utf8",
   });
@@ -169,11 +194,11 @@ function run(dir, ...args) {
   assert.equal(
     json.status,
     0,
-    `the gate must always exit 0 (advisory); it exited ${json.status}:\n${json.stderr}`,
+    `the gate must always exit 0 (advisory); it exited ${String(json.status)}:\n${json.stderr}`,
   );
-  let findings;
+  let findings: z.infer<typeof Findings>;
   try {
-    findings = JSON.parse(json.stdout);
+    findings = Findings.parse(JSON.parse(json.stdout));
   } catch {
     throw new Error(
       `--json did not produce JSON.\nstdout:\n${json.stdout}\nstderr:\n${json.stderr}`,
@@ -187,15 +212,16 @@ function run(dir, ...args) {
 }
 
 /** Exactly these kinds, in any order — never `.includes`, which is how a deleted check stays green. */
-const only = (r, expected, why) =>
+const only = (r: Run, expected: readonly string[], why: string) => {
   assert.deepEqual(
     [...r.kinds].sort(),
     [...expected].sort(),
     `${why}\n  got: ${JSON.stringify(r.findings, null, 2)}`,
   );
+};
 
 /** The finding of this kind must say this. A kind alone does not prove which branch produced it. */
-const msg = (r, kind, needle, why) => {
+const msg = (r: Run, kind: string, needle: string, why: string) => {
   const f = r.findings.find((x) => x.kind === kind);
   assert.ok(
     f,
@@ -452,7 +478,7 @@ const msg = (r, kind, needle, why) => {
 // paid it back — which is exactly the failure the cumulative check exists for, and exactly what a
 // per-round gate forgets the moment the round is closed.
 {
-  const grow = (k) =>
+  const grow = (k: number) =>
     P({
       s3:
         "The direction holds across all four rules. " +
@@ -460,7 +486,8 @@ const msg = (r, kind, needle, why) => {
     });
   const dir = join(tmp, "cumulative", "paper-x");
   mkdirSync(dir, { recursive: true });
-  const g = (...a) => spawnSync("git", a, { cwd: dir, encoding: "utf8" });
+  const g = (...a: string[]) =>
+    spawnSync("git", a, { cwd: dir, encoding: "utf8" });
   g("init", "-q", "-b", "main");
   g("config", "user.email", "h@e.com");
   g("config", "user.name", "h");
@@ -468,20 +495,20 @@ const msg = (r, kind, needle, why) => {
   for (const k of [0, 10, 16]) {
     writeFileSync(join(dir, "paper.md"), grow(k));
     g("add", "-A");
-    g("commit", "-qm", `r${k}`);
+    g("commit", "-qm", `r${String(k)}`);
     shas.push(g("rev-parse", "HEAD").stdout.trim());
   }
   writeFileSync(join(dir, "paper.md"), grow(22));
   mkdirSync(join(dir, "rounds"), { recursive: true });
   for (const [i, sha] of shas.entries()) {
     writeFileSync(
-      join(dir, "rounds", `0${i + 1}.md`),
+      join(dir, "rounds", `0${String(i + 1)}.md`),
       M({
         round: i + 1,
         touches: ["3"],
         budget: 20,
         base: sha,
-        closed: i < 2 ? "2026-08-1" + i : undefined,
+        ...(i < 2 ? { closed: `2026-08-1${String(i)}` } : {}),
       }),
     );
   }

package/skills/paper-pipeline/scripts/round-diff.mjs

@@ -66,7 +66,7 @@
 import { readFileSync, existsSync, readdirSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { basename, join, resolve, relative } from "node:path";
-import { stripFrontmatter, frontmatterBlock } from "../../../lib/markdown.mjs";
+import { stripFrontmatter, frontmatterBlock } from "#lib/markdown";
 import { isMain } from "./consumer.mjs";
 
 // ── the lexicon ──────────────────────────────────────────────────────────────────────────────

package/skills/paper-pipeline/scripts/round-diff.test.mjs

@@ -10,7 +10,7 @@ import { chmodSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { test } from "vitest";
-import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+import { runNode, useTempDir, writeTree } from "../../../test/support.ts";
 import { census, check, covers, parseManifest } from "./round-diff.mjs";
 
 const SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "round-diff.mjs");

package/skills/paper-status/SKILL.md

@@ -4,21 +4,10 @@ description: Answer "what's the status of the paper?" in one pass — MEASURE wh
 allowed-tools: [Bash, Read, Grep, Glob]
 ---
 
-<!-- vigiles:sha256:51bc50b2485782e4 compiled from skills/paper-status/SKILL.md.spec.ts -->
+<!-- vigiles:sha256:cdf5e1fcefdb916d compiled from skills/paper-status/SKILL.md.spec.ts -->
 
 # paper-status — state, measured before it is narrated
 
-## Run me
-
-🔴 FIRST, before any other step:
-
-```
-node .claude/skills/paper-pipeline/scripts/announce.mjs paper-status <paper-dir>
-```
-
-An advisory pass cannot be observed failing — silence is both its error state and its normal
-state — so starting is an event, and events get written down.
-
 The author asks "what's the status there?" constantly, and the answer keeps coming from the wrong place: my
 memory of the session, which drifts, or a 200-line scorecard he cannot skim. Both fail the same way —
 **they narrate state instead of measuring it.**
@@ -49,18 +38,13 @@ So on any turn that touched a paper, the reply ends with **three lines, unprompt
 Three failures make this a rule rather than a preference, all in one session:
 - I finished a page-fit cut and stopped, so he asked what the status was;
 - I left artifact hosting on his side of the split for a day and a half while the credential to clear
-  it sat in the environment (see `credential-available` in `pipeline-check.mjs`);
+  it sat in the environment;
 - three consecutive panels returned Weak Accept and the ceiling they named was never the next task,
   because nothing turned "here is the score" into "here is what to do about it".
 
 **Never end a paper turn on a completed sub-task alone.** "Fits in 8 pages" is a measurement, not a
 status; the status is what that measurement makes possible next.
 
-**Enforcement leg.** `pipeline-check.mjs` prints its banner **unconditionally**, including when it has
-zero findings — deadline countdown, verdict row, and `➡️ NEXT`. It runs from `paper-status-gates.sh`
-on every edit to a paper source, so the state arrives without anyone pulling it. If that banner and
-this section ever disagree, the banner is a measurement and this is prose: believe the banner.
-
 ## How to run it
 
 ### 1. Measure (no reading yet)
@@ -90,8 +74,6 @@ gate's verdict **does not describe the current paper** — say so explicitly, an
 An accept-probability from a superseded draft is not evidence about this one; carrying it forward is
 the single most common way a status report lies.
 
-If the project ships a checker (`.claude/skills/paper-pipeline/scripts/pipeline-check.mjs`), run it.
-
 ### 3. Read the judgement rows — from BOTH checklists, they answer different questions
 
 The project already carries the checklists this skill should report against. Do not invent a new list
@@ -126,28 +108,6 @@ Short. He is asking because he wants to decide what to do next, not to read a re
 5. **What moved since he last asked**, three lines maximum.
 6. **The deadline, in his timezone**, and what is on the critical path to it.
 
-## Record the verdict
-
-🔴 LAST step, once the deliverable exists:
-
-```
-node .claude/skills/paper-pipeline/scripts/ledger.mjs record paper-status <paper-dir> FINDING <count> <report-path>
-node .claude/skills/paper-pipeline/scripts/ledger.mjs record paper-status <paper-dir> ABSTAINED <reason> "<one line>"
-```
-
-This skill reports state and does not judge the paper, so what it records is about the **status run**:
-**FINDING** — `<count>` blockers printed, `<report-path>` the status output.
-**ABSTAINED** — `no-witness`: the status run measured everything it can and printed zero blockers.
-`crashed`: the build did not run, so nothing was measured.
-
-🔴 `crashed` is the one outcome that must never be narrated as a status. This skill exists because
-state was being narrated instead of measured; a status report built on a build that did not happen
-is that same failure with a fresh timestamp on it. Under the old vocabulary this was `ERROR`, which
-sat in the same column as a verdict about the paper — it does not any more.
-
-🔴 **There is no PASS**, so "zero blockers" cannot be stored. Print it, and let the reader draw the
-conclusion from an empty blocker list they can see.
-
 ## Rules
 
 - **Never report a gate as run because I intended to run it.** Predicting a background agent's result,