paperlint 3.1.3 → 4.0.0

package/lib/skill-checks.test.mjs

@@ -1,7 +1,6 @@
 /**
  * skill-checks.mjs's two refusing halves, which the per-skill harnesses (all green on the real
- * corpus) never reach: `checkSkill` on an unknown name and on a pipeline skill with a planted
- * defect, and `checkProseSkill` — the check for skills WITHOUT the pipeline, which the package
+ * corpus) never reach: `checkSkill` on an unknown name and on a skill with a planted defect, and `checkProseSkill` — the check for skills WITHOUT the pipeline, which the package
  * exports for a consumer's own skills and no harness here calls.
  *
  * The consumer is a temp root holding a COPY of the shipped skills, so a planted defect edits the
@@ -12,7 +11,7 @@ import { cpSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { test } from "vitest";
-import { useTempDir, writeTree } from "../test/support.mjs";
+import { useTempDir, writeTree } from "../test/support.ts";
 
 const SHIPPED = join(dirname(fileURLToPath(import.meta.url)), "..", "skills");
 const consumer = useTempDir("skill-checks-");
@@ -33,55 +32,13 @@ async function thrown(fn) {
   return null;
 }
 
-test("checkSkill passes a real shipped skill and refuses a name that is not a wired skill", async () => {
+test("checkSkill passes a real shipped skill and refuses a name with no SKILL.md", async () => {
   assert.deepEqual(
     [
       await checkSkill("cold-read-diff"),
       await thrown(() => checkSkill("no-such-skill")),
     ],
-    [
-      1,
-      `"no-such-skill" is not a wired pipeline skill. Known: ${(await import("./skill-corpus.mjs")).SKILLS.join(", ")}`,
-    ],
-  );
-});
-
-test("checkSkill reports EVERY finding of a broken pipeline skill at once", async () => {
-  const md = join(SKILLS, "cold-read-diff", "SKILL.md");
-  const clean = readFileSync(md, "utf8");
-  writeFileSync(
-    md,
-    clean
-      .replace("name: cold-read-diff", "name: renamed")
-      .replace("## Run me", "## Not run"),
-  );
-  try {
-    const first = await thrown(() => checkSkill("cold-read-diff"));
-    assert.equal(
-      first,
-      '2 assertion(s) failed for pipeline skill "cold-read-diff":',
-    );
-  } finally {
-    writeFileSync(md, clean);
-  }
-});
-
-test("a pipeline skill whose record block is gone: ONE finding naming the heading — the ledger checks that read the block skip it", async () => {
-  const md = join(SKILLS, "cold-read-diff", "SKILL.md");
-  const clean = readFileSync(md, "utf8");
-  writeFileSync(md, clean.replaceAll("## Record the verdict", "## Afterwards"));
-  let message = "";
-  try {
-    await checkSkill("cold-read-diff");
-  } catch (e) {
-    message = e.message;
-  } finally {
-    writeFileSync(md, clean);
-  }
-  assert.equal(
-    message,
-    '1 assertion(s) failed for pipeline skill "cold-read-diff":\n\n' +
-      '  [1] cold-read-diff: no "Record the verdict" heading. A run with an announce row and no verdict row is indistinguishable from a skill that started and died.',
+    [1, `"no-such-skill" has no SKILL.md under ${SKILLS}`],
   );
 });
 
@@ -203,95 +160,86 @@ async function brokenBy(name, edit) {
     await checkSkill(name);
     return null;
   } catch (e) {
-    // The header, then the first 90 characters of each numbered finding.
+    // The header, then each numbered finding.
     const lines = e.message.split("\n");
     return [
       lines[0],
-      ...lines
-        .filter((l) => /^  \[\d+\] /.test(l))
-        .map((l) => l.trim().slice(0, 90)),
+      ...lines.filter((l) => /^  \[\d+\] /.test(l)).map((l) => l.trim()),
     ];
   } finally {
     writeFileSync(md, clean);
   }
 }
-const recordSection = /## Record the verdict[\s\S]*?(?=\n## |\n# |$)/;
-
-test("checkSkill on the defects its own corpus never has: no description, no record block, a record block naming no kind", async () => {
-  assert.deepEqual(
-    [
-      await brokenBy("cold-read-diff", (s) =>
-        s.replace(/^description: .*\n/m, ""),
-      ),
-      await brokenBy("argument-arc", (s) =>
-        s.replace(
-          recordSection,
-          "## Record the verdict\n\nNothing named here.\n",
-        ),
-      ),
-      await brokenBy("draft-paper", (s) =>
-        s.replace(
-          recordSection,
-          "## Record the verdict\n\n**ABSTAINED** — and no reason is named.\n",
-        ),
-      ),
-    ],
-    [
-      [
-        '1 assertion(s) failed for pipeline skill "cold-read-diff":',
-        "[1] cold-read-diff: description is missing or trivially short (0 chars). The description i",
-      ],
-      [
-        '3 assertion(s) failed for pipeline skill "argument-arc":',
-        '[1] argument-arc: the "Record the verdict" block instructs no `node .claude/skills/paper-p',
-        "[2] argument-arc: its record block names [nothing] and not FINDING, and does not admit tha",
-        "[3] argument-arc: its record block names no abstention reason from [started, no-witness, i",
-      ],
-      [
-        '5 assertion(s) failed for pipeline skill "draft-paper":',
-        '[1] draft-paper: the "Record the verdict" block instructs no `node .claude/skills/paper-pi',
-        "[2] draft-paper: its record block names [ABSTAINED] and not FINDING, and does not admit th",
-        "[3] draft-paper: its record block names no abstention reason from [started, no-witness, in",
-        "[4] draft-paper: the honest admission is gone from its record block. It is the one skill i",
-        "[5] ABSTAINED needs a reason from started|no-witness|input-missing|blocked|crashed, got nu",
-      ],
-    ],
+test("checkSkill reports EVERY finding at once: a renamed skill with no description", async () => {
+  const lines = await brokenBy("cold-read-diff", (s) =>
+    s
+      .replace("name: cold-read-diff", "name: renamed")
+      .replace(/^description: .*\n/m, ""),
   );
+  assert.deepEqual(lines?.slice(0, 1), [
+    '2 assertion(s) failed for skill "cold-read-diff":',
+  ]);
+  assert.match(lines?.[1] ?? "", /frontmatter name is "renamed"/);
+  assert.match(lines?.[2] ?? "", /description is missing/);
 });
 
-test("a skill may show `ledger.mjs status` — only a `record` call must file under the skill", async () => {
+test("checkSkill refuses an instructed script that does not exist", async () => {
+  const lines = await brokenBy("verify-citations", (s) =>
+    s.replaceAll("scripts/extract-ref-facts.mjs", "scripts/missing.mjs"),
+  );
   assert.equal(
-    await brokenBy("cold-read-diff", (s) =>
-      s.replace(
-        "node .claude/skills/paper-pipeline/scripts/announce.mjs cold-read-diff <paper-dir>",
-        "node .claude/skills/paper-pipeline/scripts/announce.mjs cold-read-diff <paper-dir>\n" +
-          "node .claude/skills/paper-pipeline/scripts/ledger.mjs status <paper-dir>",
-      ),
-    ),
-    null,
+    lines?.[0],
+    '2 assertion(s) failed for skill "verify-citations":',
+  );
+  assert.match(
+    lines?.[1] ?? "",
+    /instructs `node .*missing\.mjs.*` but .*missing\.mjs does not exist/,
   );
 });
 
-test("a skill whose only ledger call is `status` records nothing, and is told so", async () => {
-  assert.deepEqual(
-    await brokenBy("cold-read-diff", (s) =>
-      s.replaceAll(
-        /ledger\.mjs record cold-read-diff <paper-dir> \w+[^\n]*/g,
-        "ledger.mjs status <paper-dir>",
-      ),
+test("checkSkill refuses a pipeline script the skill's allowed-tools do not permit", async () => {
+  const lines = await brokenBy("verify-citations", (s) =>
+    s.replace(
+      /^allowed-tools: \[(.*)\]$/m,
+      (_, list) =>
+        `allowed-tools: [${list
+          .split(", ")
+          .filter((t) => t !== "Bash")
+          .join(", ")}]`,
     ),
-    [
-      '1 assertion(s) failed for pipeline skill "cold-read-diff":',
-      '[1] cold-read-diff: the "Record the verdict" block instructs no `node .claude/skills/paper',
-    ],
+  );
+  assert.equal(
+    lines?.[0],
+    '2 assertion(s) failed for skill "verify-citations":',
+  );
+  assert.match(
+    lines?.[1] ?? "",
+    /extract-ref-facts\.mjs.* permit no such Bash command/,
   );
 });
 
-test("the record CALL is the contract, not the heading: a renamed record section still passes", async () => {
+test("a Bash entry narrowed to the instructed script permits it, and one narrowed elsewhere does not", async () => {
+  const narrowTo = (script) => (s) =>
+    s.replace(
+      /^allowed-tools: \[(.*)\]$/m,
+      (_, list) =>
+        `allowed-tools: [${list
+          .split(", ")
+          .map((t) =>
+            t === "Bash"
+              ? `"Bash(node .claude/skills/paper-pipeline/scripts/${script}:*)"`
+              : t,
+          )
+          .join(", ")}]`,
+    );
   assert.equal(
-    await brokenBy("camera-ready", (s) =>
-      s.replace("## Record the verdict", "## Something else"),
-    ),
+    await brokenBy("verify-citations", narrowTo("extract-ref-facts.mjs")),
     null,
   );
+  const lines = await brokenBy("verify-citations", narrowTo("round-diff.mjs"));
+  assert.equal(
+    lines?.[0],
+    '2 assertion(s) failed for skill "verify-citations":',
+  );
+  assert.match(lines?.[1] ?? "", /permit no such Bash command/);
 });

package/lib/skill-corpus.mjs

@@ -1,50 +1,18 @@
 /**
- * skill-corpus.mjs — WHAT the pipeline's skills ARE. Derivation and helpers, no assertions.
- *
- * 🔴 THIS FILE MAKES NO CLAIMS AND RUNS NO TESTS. Importing it must be free of verdicts —
- * that is the whole reason it was split out of `skills.harness.mjs` on 2026-08-11. That file
- * held three things under one name: this derivation, the per-skill assertions, and the
- * corpus-wide ones. It answered to no surface (there is no skill called `skills`), so the
- * 21 colocated per-skill harnesses could only reach it by setting an env var and importing
- * a script for its SIDE EFFECTS — 21 wrappers around one bag.
- *
- * Now: this module derives, `skill-checks.mjs` asserts about ONE skill, and
- * `pipeline-corpus.harness.mjs` asserts about the SET. Each colocated file calls a
- * function with its own name in it, and there is no env-var side channel.
- *
- * The ledger is redirected to a scratch path at import time, BEFORE `ledger.mjs` loads, so
- * that an assertion which calls `record()` cannot leave fixture rows in real history. That
- * import order is load-bearing and is the reason this is a module rather than a plain
- * export list. Save-and-restore is not isolation — it lost that race on its first day.
+ * skill-corpus.mjs — what a skill IS, read from its directory: the frontmatter, the tool contract,
+ * the commands its text instructs. Derivation and helpers, no assertions — `skill-checks.mjs`
+ * asserts about one skill by calling these.
  */
 import assert from "node:assert/strict";
-// ⚠️ 2026-08-28: `rmSync` and `writeFileSync` were removed from here — nothing called them.
-// `rmSync` is NOT a harmless finding here, though: `tmp` below is a `mkdtempSync` that is never
-// removed, so every import of this library leaves a directory behind in `/tmp` (two dozen per
-// full sweep of the harnesses). Cleanup is DELIBERATELY not added in this edit: it would change
-// the lifecycle of the directory that holds `PIPELINE_LEDGER` for every child run, and today's
-// edit is about turning the lint on, not about harness behavior. Written down as an open item
-// in the report, not swept under an import-that-does-something-silently.
-import { existsSync, readFileSync, mkdtempSync, realpathSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { existsSync, readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as yaml from "js-yaml";
-import {
-  consumerRoot,
-  installedSkills,
-} from "../skills/paper-pipeline/scripts/consumer.mjs";
-import {
-  headings as mdHeadings,
-  requireMarkdown,
-  frontmatterBlock,
-} from "./markdown.mjs";
+import { consumerRoot } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { requireMarkdown, frontmatterBlock } from "#lib/markdown";
 
-// Markup is parsed with a real parser (`CLAUDE.md`, 2026-08-11). Here we THROW rather than
-// degrade: this module answers the question "what does the skill corpus contain", and an empty
-// heading list with no parser would read as "not one skill has a `Record the verdict` block" —
-// i.e. as a finding about the corpus. A confident zero has already been mistaken for a fact in
-// this repo four times.
+// Markup is parsed with a real parser. Here we THROW rather than degrade: with no parser every
+// frontmatter would read as absent, which is a finding about the corpus, not about the install.
 requireMarkdown();
 
 export const HERE = dirname(fileURLToPath(import.meta.url));
@@ -54,122 +22,10 @@ export const HERE = dirname(fileURLToPath(import.meta.url));
 // below it — the skills directory above all — would be a directory that does not exist. That
 // failure is silent in the worst way: `readdirSync` throws while this module is still LOADING, and
 // a harness whose module fails to load is reported by `vigiles test` as SKIPPED with exit code 0.
-// `consumerRoot()` is the carrier the package already uses for the ledger and the papers root.
+// `consumerRoot()` is the carrier the package already uses for the papers root.
 export const ROOT = consumerRoot();
 export const SKILLS_DIR = join(ROOT, ".claude", "skills");
 
-// Redirected BEFORE ledger.mjs is imported, so a crash cannot leave fixture rows in real history.
-// Save-and-restore is not isolation — it lost that race on its first day (see ledger.mjs's comment).
-export const tmp = realpathSync(mkdtempSync(join(tmpdir(), "skills-harness-")));
-process.env.PIPELINE_LEDGER = join(tmp, "runs.jsonl");
-const { KINDS, RETIRED, ABSTENTIONS, record, parseGate } =
-  await import("../skills/paper-pipeline/scripts/ledger.mjs");
-export { KINDS, RETIRED, ABSTENTIONS, record, parseGate };
-const { EXPECTED_GATES } =
-  await import("../skills/paper-pipeline/scripts/status.mjs");
-export { EXPECTED_GATES };
-/** The skills EXPECTED_GATES names, with the `skill/check` rows collapsed onto their skill. */
-export const GATE_SKILLS = new Set(
-  EXPECTED_GATES.map((g) => parseGate(g).skill),
-);
-
-// The paper-pipeline skills, DERIVED FROM DISK — a skill is one iff its SKILL.md instructs
-// `node .claude/skills/paper-pipeline/scripts/announce.mjs <its own name>`. Minus EXCLUDED below.
-//
-// 🔴 THIS WAS A PINNED ARRAY UNTIL 2026-08-07, AND THE PIN MADE ASSERTION 12b VACUOUS IN THE ONE
-// CASE IT EXISTS FOR. That assertion reads "<skill> is a wired pipeline skill but is absent from
-// status.mjs EXPECTED_GATES" — and it iterated the pinned array. So it could only ever catch a skill
-// present in the array and missing from EXPECTED_GATES. A skill wired on disk and absent from BOTH
-// lists — the actual "I added a skill and forgot" failure — was structurally invisible.
-//
-// Measured, not theorised: `paper-status` is in exactly that state right now. It carries an announce
-// command and is in neither list. That is DELIBERATE (see EXCLUDED), but nothing checked that the
-// deliberateness was still true, and the old comment asserting it was the only thing holding it.
-//
-// A defect that removes a skill from EXPECTED_GATES while leaving it in the pinned array passed
-// silently the whole time. A check proving a narrower property than its own error message claims
-// is exactly the vacuity this file was built to hunt, sitting in this file.
-//
-// The old comment's objection to globbing was real and is answered rather than ignored: `.claude/skills/`
-// does hold daily skills (search-krisha, food-log-entry, …) with no pipeline contract, so the filter
-// cannot be "every directory". But it need not be a guess either — carrying an announce command that
-// names YOURSELF is the pipeline contract, checked below by assertion 5c, and it is a fact on disk.
-export const PIPELINE_MARKER =
-  /^\s*node\s+\.claude\/skills\/paper-pipeline\/scripts\/announce\.mjs\s+([a-z0-9-]+)/m;
-
-/**
- * Skills wired into the pipeline but deliberately NOT graded as gates, each with the reason.
- * A reason is required because these are the entries that rot: an exclusion with no argument is
- * indistinguishable from an omission, and the previous version of this file held both in prose.
- *
- * 🔴 UNTIL 2026-08-11 THIS SUBTRACTED FROM THE CHECKED SET, WHICH IS NOT WHAT ITS OWN REASON SAYS.
- * The recorded reason for `paper-status` is "it has no gate row" — a statement about ONE assertion
- * (12b: every checked skill must appear in EXPECTED_GATES). The implementation filtered it out of
- * `SKILLS` entirely, so it received NONE of the structural checks either: not the strict-YAML
- * frontmatter parse, not the tool contract, not "your wiring points at scripts that exist", not
- * "you announce under your OWN identity". A skill was silently unexamined because it lacked a
- * grade — and this file's own governing comment, four lines below, says a defect that shrinks the
- * checked set is worse than the defect itself.
- *
- * Found by the coverage sweep of 2026-08-11: `paper-status` showed as untested, and the reason was
- * not a missing test file but this line. Now the exclusion means what it says — skipped at 12b,
- * checked everywhere else.
- */
-export const EXCLUDED = new Map([
-  [
-    "paper-status",
-    "reports on the pipeline; produces no verdict ABOUT the paper, so it has no gate row",
-  ],
-]);
-
-// 🔴 MEMBERSHIP IS THE UNION OF TWO SOURCES, AND THAT IS THE WHOLE POINT. A skill is checked if the
-// gate table names it OR its SKILL.md carries pipeline wiring. Either alone is corruptible by the very
-// defects this file hunts, and a defect that shrinks the checked set is worse than the defect itself:
-// the harness goes green by no longer looking.
-//
-// Both narrower versions were written and both failed within minutes, on the same two planted
-// defects:
-//
-//   filter `announce.mjs <own name>`  -> a typo in the announced NAME dropped harden-paper out
-//                                        of scope; harness printed "20 pipeline skills", said nothing
-//   filter `announce.mjs` path        -> a typo in the announce PATH dropped camera-ready the
-//                                        same way
-//
-// Each time, the same planted defect that used to turn the harness red went GREEN because it
-// erased its own subject. Scope decided by a property the defect corrupts is not scope.
-//
-// The union cannot be shrunk by a single-point edit: break the wiring and the gate table still holds
-// the skill; forget the gate table and the disk still does. Only removing it from BOTH — which is
-// what actually leaving the pipeline looks like — takes it out of scope, and EXCLUDED makes that
-// deliberate and reasoned rather than silent.
-const wiredOnDisk = installedSkills(SKILLS_DIR).filter((d) =>
-  PIPELINE_MARKER.test(readFileSync(join(SKILLS_DIR, d, "SKILL.md"), "utf-8")),
-);
-
-// EXCLUDED deliberately does NOT filter here — see its comment. An entry means "no gate row",
-// and that is applied at assertion 12b alone; everything structural still looks at it.
-export const SKILLS = [...new Set([...GATE_SKILLS, ...wiredOnDisk])]
-  .filter((d) => existsSync(join(SKILLS_DIR, d, "SKILL.md"))) // 12a reports a gate with no directory
-  .sort();
-
-// The nine that gained Bash ONLY so they could write the ledger, per
-// `.claude/skills/ALLOWED-TOOLS-AUDIT-2026-08-03.md`. PINNED because the property is not derivable:
-// from the frontmatter alone a plain `Bash` on `render-paper` (pdflatex, bibtex, apt-get — it needs
-// it) is indistinguishable from a plain `Bash` on `argument-arc` (which would be a regression). The
-// audit decided that per skill by reading each one's text; this list is that decision, made checkable.
-// A skill moving off this list is a deliberate act and should require editing this line.
-export const LEDGER_ONLY_BASH = new Set([
-  "argument-arc",
-  "tighten-paper",
-  "grade-paper-writing",
-  "paper-adversarial-review",
-  "draft-paper",
-  "extend-paper",
-  "research-ideate",
-  "find-venue",
-  "plan-paper-timeline",
-]);
-
 // ── parsing ────────────────────────────────────────────────────────────────────────────────────
 
 /** Raw text between the opening `---` and the next `---`. Null if there is no frontmatter at all. */
@@ -233,7 +89,7 @@ export function parseFm(fmText, where = "frontmatter") {
  * round trip (vigiles #107). This split understood only the scalar, so on 2026-08-17
  * adopting five pipeline skills turned four harnesses red: the checker read the whole
  * bracketed list as a single entry named `[Bash` and reported that the skill's own
- * `Bash(node …announce.mjs:*)` instruction was denied. The skills were fine; the reader
+ * narrowed `Bash(node …:*)` instruction was denied. The skills were fine; the reader
  * was not.
  *
  * Entries themselves carry no commas (`Bash(node …:*)` has none), so a plain split is
@@ -287,74 +143,6 @@ export function commands(src) {
   }));
 }
 
-/**
- * The `Record the verdict` block: from its heading to the next heading of the same or higher level.
- *
- * 🔴 The first version of this sliced `rest.slice(1).search(/^#{1,3} /m)` and `^` matched at offset 0
- * of the slice, so every block came back as the single character "#". Assertions 10 and 11 then read
- * an empty block, found no verdicts, and 10 fired on all 21 skills while 11 checked nothing at all —
- * a checker firing on clean input and a checker that is vacuous, from one off-by-one. Caught by
- * running it, not by reading it. Matching on `\n#` rather than `^#` is the fix.
- *
- * 2026-08-11 — switched to a real parser (`CLAUDE.md`: "markdown is parsed with a parser"). The
- * same off-by-one is now INEXPRESSIBLE: a heading from the parser already carries the offset of
- * its line start, so the block boundary no longer has to be computed from a newline's position.
- * Along with it went two defects the old expression carried silently: `#{1,3}` counted a hash
- * inside a ``` block as a heading (a skill QUOTING someone else's `## Run me` in an example cut
- * its own block short at the quote), and `\n#{1,3} ` did not see a heading indented by 1-3
- * spaces, which CommonMark still counts as a heading. The block boundary is preserved byte for
- * byte: end = start of the next heading.
- */
-export function recordBlock(src) {
-  const hs = mdHeadings(src);
-  const i = hs.findIndex(
-    (h) => h.depth <= 3 && /record the verdict/i.test(h.text),
-  );
-  if (i < 0) return null;
-  const next = hs.slice(i + 1).find((h) => h.depth <= 3);
-  return src.slice(hs[i].offset, next ? next.offset : src.length);
-}
-
-// Three extractors, because they answer different questions and a single one would be wrong for one.
-//
-//   `allBold`  — every all-caps bolded token, whatever it is. The raw material for the other two.
-//                Bold-only on purpose: several blocks write a retired word in prose ("There is no
-//                PASS") or in backticks, and a looser match would read those DENIALS as claims —
-//                which is the exact reading error that would make the turned-around assertion below
-//                fire on every correct file.
-//   `namedKinds`   — bolded tokens that are live constructors. Used to ask "can this check report a
-//                    finding at all?".
-//   `namedRetired` — bolded tokens from the DELETED vocabulary. Used to ask "does this block still
-//                    instruct something `record()` refuses?".
-export const allBold = (blk) => [
-  ...new Set(
-    [...blk.matchAll(/\*\*`?([A-Z][A-Z-]{2,})`?\*\*/g)].map((m) => m[1]),
-  ),
-];
-export const namedKinds = (blk) =>
-  allBold(blk).filter((v) => KINDS.includes(v));
-export const namedRetired = (blk) => allBold(blk).filter((v) => RETIRED.has(v));
-export const definedKinds = (blk) => [
-  ...new Set(
-    [...blk.matchAll(/\*\*`?([A-Z][A-Z-]{2,})`?\*\*\s*(?=[—(:]| \()/g)].map(
-      (m) => m[1],
-    ),
-  ),
-];
-
-// The abstention reasons a block names, as backticked tokens: `no-witness`, `blocked`, …
-export const namedReasons = (blk) =>
-  [
-    ...new Set([...blk.matchAll(/`([a-z][a-z-]{3,})`/g)].map((m) => m[1])),
-  ].filter((r) => ABSTENTIONS.has(r));
-
-// The honest-admission escape hatch, for a skill whose nature is to generate rather than judge.
-// `draft-paper` is the designed case: it will abstain nearly always and its text says so, in the
-// terms status.mjs uses. The regex matches that ARGUMENT, not a keyword, so an admission cannot be
-// satisfied by pasting the word "smell".
-export const ADMISSION =
-  /(almost always record|never returned a (negative|finding)|a generator is not a gate|only honest negative)/i;
-
 export const load = (name) => {
   const path = join(SKILLS_DIR, name, "SKILL.md");
   assert.ok(
@@ -370,32 +158,3 @@ export const load = (name) => {
   const fm = parseFm(fmText, name);
   return { name, path, src, fmText, fm, tools: toolList(fm["allowed-tools"]) };
 };
-
-// One-skill mode, for the COLOCATED per-skill harness files that sit next to each
-// SKILL.md. Coverage is decided by placement (vigiles, 2026-08-11: a test that only
-// NAMES a surface no longer counts), so each skill needs a file inside its own
-// directory. Rather than copy these assertions 21 times — the drift this file was
-// built to avoid — each colocated file sets ONLY and imports this one.
-//
-// 🔴 2026-08-28: THERE USED TO BE TWO MORE LINES BELOW, AND THEY WERE DEAD LOGIC, NOT CLUTTER.
-//
-//     const skills = (ONLY ? [ONLY] : SKILLS).map(load);
-//     const skillDirs = new Set(readdirSync(SKILLS_DIR).filter((d) => existsSync(…)));
-//
-// Both were computed and read by NOBODY — not here, not on export. This is a leftover from the
-// 2026-08-11 split, when the cross-skill checks moved into `pipeline-corpus.harness.mjs`: the
-// bodies of the checks were carried over, and their inputs were forgotten. The paragraph above
-// about "cross-skill assertions below" described exactly that block, now gone; after the move
-// there is NOT A SINGLE CHECK below it, i.e. the comment promised a mechanism that does not
-// exist — exactly what this base's "prose isn't policy" rule exists to catch.
-//
-// The second, less obvious cost: `.map(load)` is not an inert computation. `load()` carries an
-// `assert.ok`, so this line was an UNDECLARED check of the whole corpus, run as a side effect of
-// `import` and costing a read of all 22 `SKILL.md` files on every import of the library. This is
-// exactly the kind of "via an import's side effect" coupling the file was moving away from (see
-// the header of `skill-checks.mjs`). The real, declared carrier of this check is `checkSkill()`,
-// which does it one skill at a time and with a legible message.
-//
-// `PIPELINE_SKILL_ONLY` used to stay here, validated against SKILLS. Nothing read the variable
-// any more — the validation was all that was left of the feature — so it was removed with it
-// (2026-09-27).

package/lib/skill-corpus.test.mjs

@@ -1,11 +1,10 @@
 /**
  * skill-corpus.mjs's pure readers on the inputs the shipped corpus never contains: frontmatter
- * that is not a mapping or not YAML, an `allowed-tools` that is absent, a skill with no record
- * block and one whose record block ends the file.
+ * that is not a mapping or not YAML, and an `allowed-tools` that is absent.
  */
 import assert from "node:assert/strict";
 import { test } from "vitest";
-import { parseFm, recordBlock, toolList } from "./skill-corpus.mjs";
+import { parseFm, toolList } from "./skill-corpus.mjs";
 
 const refusal = (fn) => {
   try {
@@ -42,13 +41,3 @@ test("toolList of nothing is an empty contract, and a flow list or a comma scala
     [[], ["Bash", "Read"], ["Read", "Write"], ["Read"]],
   );
 });
-
-test("recordBlock: none without the heading; to the end of the file when it is the last section", () => {
-  assert.deepEqual(
-    [
-      recordBlock("# S\n\n## Run me\n\nx\n"),
-      recordBlock("# S\n\n## Record the verdict\n\nlast\n"),
-    ],
-    [null, "## Record the verdict\n\nlast\n"],
-  );
-});

package/lib/skill-eval-kit.mjs

@@ -54,7 +54,7 @@ import { resolve } from "node:path";
 import { consumerRoot } from "../skills/paper-pipeline/scripts/consumer.mjs";
 
 import { BY_SKILL, irrelevantFor } from "./skill-trigger-cases.mjs";
-import { FIXTURE } from "./skill-eval-fixture.mjs";
+import { FIXTURE } from "#lib/skill-eval-fixture";
 
 // The CONSUMER's root — the live harness being measured is the consumer's, not this package's.
 const REPO = consumerRoot();

package/lib/skill-trigger-cases.mjs

@@ -330,7 +330,7 @@ const PACKAGE_CASES = [
 //
 // 🔴 AND THEY CANNOT SIMPLY BE CARRIED HERE: the first consumer's cases name private skills and
 // quote private prose. A package that ships one user's private vocabulary has one possible user —
-// the same argument that moved `papersRoot()`, `ledgerPath()`, `citeChecks` and `scriptsRoot()`
+// the same argument that moved `papersRoot()` and `scriptsRoot()`
 // out of the code and into a declaration. This is the fifth of those carriers and reads the same
 // key from the same file.
 //