paperlint 3.1.3 → 4.0.0

package/scripts/rules-are-content-only.mjs

@@ -1,148 +0,0 @@
-/**
- * A RULE MAY NOT ASK GIT.
- *
- * 🔴 The defect it exists for, measured 2026-09-16. `paper/source` bound a paper's stage to a
- * commit sha and verified it with `git cat-file -e`. Of four shas recorded in the consumer's
- * front matter, ONE still resolved ninety minutes later: a squash-merge had orphaned the branch
- * commits and `gc` collected them. A recorded sha is a pointer to a pointer, and both hops are
- * removed by ROUTINE maintenance — squash, rebase, gc, force-push, filter-repo. Nobody is at
- * fault, so nobody is on the hook to fix it; the rule simply turns red and gets switched off.
- *
- * ── THE STRONGER LEG, AND THE REASON THIS IS A FLOOR CHECK ──────────────────
- * `actions/checkout` defaults to `fetch-depth: 1` — exactly one commit. Measured in the
- * consumer the same day: six checkouts, not one override. So a git-reading rule does not
- * resolve even a LIVE sha under CI, which is the one place it has to hold. Locally it stays
- * green, so the failure is one-directional and in the flattering direction.
- *
- * ── WHAT IT CHECKS, AND WHY NOT A GREP ──────────────────────────────────────
- * A `child_process` spawner called with `git` as the program, read from the AST. Parsed, not
- * grepped, so the words `git cat-file` in this very comment are not a finding — a text guard
- * would have to exempt itself, which is the failure mode that makes text guards unmaintainable.
- *
- * ⚠️ THE BOUND, stated so the check is not mistaken for more than it is. Two things pass: a
- * rule that opens `.git/` with `fs` (indistinguishable at this level from reading a data file),
- * and a rule that assembles the program name at runtime. Both accepted deliberately — see the
- * note on `SPAWNERS` for the false positive that forced the predicate this narrow.
- *
- * Run: `node scripts/rules-are-content-only.mjs`  (exit 1 and a named rule on a finding)
- * Tested by: `scripts/rules-are-content-only.harness.mjs` — quiet on the real corpus, firing on
- * a planted rule.
- */
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { parse } from "espree";
-import { isMain } from "../skills/paper-pipeline/scripts/consumer.mjs";
-
-/**
- * 🔴 THE PREDICATE IS "RUNS GIT", NOT "SPAWNS A PROCESS", and the narrowing was forced by a
- * FALSE POSITIVE on the consumer's corpus the hour this check shipped: `paper-texcount.mjs`
- * shells out to `texcount` to count words in a .tex, which is a measuring tool, not history.
- * A false positive on an `error` gate is worse than a miss — the gate that cannot be cleared
- * gets switched off, and this one would have been switched off on its first run.
- *
- * ⚠️ THE COST OF NARROWING, stated rather than hidden: a rule that builds the program name at
- * runtime (`const g = "gi" + "t"`) passes. That is accepted. The defect has taken exactly one
- * form — a literal `git` handed to a `child_process` function — and a check that also caught
- * the contrived form would have to claim every spawn, which is the false positive above.
- */
-const SPAWNERS = new Set([
-  "exec",
-  "execSync",
-  "execFile",
-  "execFileSync",
-  "spawn",
-  "spawnSync",
-  "fork",
-]);
-
-/** `"git"` as the program, or `"git …"` as the head of a shell line handed to `exec`. */
-const isGit = (v) =>
-  typeof v === "string" && (v === "git" || v.startsWith("git "));
-
-/** Rule sources only: a harness plants defects on purpose and asserts about them. */
-const isRuleSource = (f) => f.endsWith(".mjs") && !f.endsWith(".harness.mjs");
-
-/** @param {string} src @returns {string[]} the git invocations this source makes */
-export function processImports(src) {
-  const ast = parse(src, {
-    ecmaVersion: "latest",
-    sourceType: "module",
-    range: false,
-  });
-  const found = [];
-  const walk = (n) => {
-    if (n === null || typeof n !== "object") return;
-    if (Array.isArray(n)) return n.forEach(walk);
-    // Both spellings of the callee: `execFileSync(…)` after a named import, and
-    // `cp.execFileSync(…)` after a namespace import. Listed, not described — the node types a
-    // check walks are the only honest statement of its coverage.
-    if (n.type === "CallExpression") {
-      const name =
-        n.callee?.type === "MemberExpression"
-          ? n.callee.property?.name
-          : n.callee?.name;
-      if (SPAWNERS.has(String(name)) && isGit(n.arguments?.[0]?.value))
-        found.push(String(n.arguments[0].value));
-    }
-    for (const k of Object.keys(n)) if (k !== "parent") walk(n[k]);
-  };
-  walk(ast);
-  return found;
-}
-
-/** @param {{cwd: string}} options */
-export function rulesAreContentOnly({ cwd }) {
-  const dir = join(cwd, "eslint-rules");
-  const checked = [];
-  const findings = [];
-  // A repository with no `eslint-rules/` has no rule sources: `checked` stays empty and the gate
-  // says so by name. `readdirSync` would throw ENOENT instead — a stack trace, not the refusal.
-  const names = existsSync(dir) ? readdirSync(dir) : [];
-  for (const f of names.filter(isRuleSource)) {
-    const hits = processImports(readFileSync(join(dir, f), "utf8"));
-    // 🔴 The counter increments WITH the verdict, not before it: a `checked` that keeps
-    // counting while the verdict stops being reached is the failure recorded in the consumer's
-    // rules as "a counter that counts what it ignores".
-    checked.push(f);
-    for (const h of hits) findings.push({ file: f, specifier: h });
-  }
-  return { checked, findings };
-}
-
-/**
- * The gate over `cwd`'s `eslint-rules/`: exit 1 on no rule sources (a silent zero would read as
- * clean) or on any rule asking git; 0 otherwise.
- *
- * 🔴 `cwd` is `process.cwd()`, NOT the package root. A consumer installs this package and runs the
- * script from its own repository, where the rules that matter are ITS `eslint-rules/` — the
- * package's own are already checked by the package's own gate. Anchored to the package root the
- * consumer's gate would re-check the same eight files and report a confident zero about rules it
- * never opened: a counter that counts what it ignores.
- */
-export function main({
-  cwd = process.cwd(),
-  log = console.log,
-  err = console.error,
-} = {}) {
-  const { checked, findings } = rulesAreContentOnly({ cwd });
-  if (checked.length === 0) {
-    err(
-      `${join(cwd, "eslint-rules")}: no rule sources. Either this is not a repository with ` +
-        `ESLint rules, or the directory moved — a silent zero here would read as a clean run.`,
-    );
-    return 1;
-  }
-  for (const { file, specifier } of findings) {
-    err(
-      `${file}: imports \`${specifier}\`. A rule may not ask git: history is rewritten by ` +
-        `routine maintenance and CI clones one commit deep, so the fact does not survive where ` +
-        `the rule has to hold. Put the fact on disk and check it by bytes.`,
-    );
-  }
-  log(
-    `rules-are-content-only: ${checked.length} rule sources under ${cwd}, ${findings.length} findings`,
-  );
-  return findings.length === 0 ? 0 : 1;
-}
-
-if (isMain(import.meta.url)) process.exit(main());

package/scripts/rules-are-content-only.test.mjs

@@ -1,61 +0,0 @@
-/**
- * rules-are-content-only's gate over a consumer's `eslint-rules/`: temp trees with planted rules.
- */
-import assert from "node:assert/strict";
-import { fileURLToPath } from "node:url";
-import { spawnSync } from "node:child_process";
-import { test } from "vitest";
-import { useTempDir, writeTree } from "../test/support.mjs";
-import { main as contentMain } from "./rules-are-content-only.mjs";
-
-const capture = () => {
-  const out = [];
-  const io = { log: (s) => out.push(s), err: (s) => out.push(`E ${s}`) };
-  return { out, io };
-};
-
-const root = useTempDir("content-only-");
-
-test("rules-are-content-only: no rules is a failure, a rule asking git is a finding, clean rules pass", () => {
-  writeTree(root, {
-    "empty/.keep": "",
-    "dirty/eslint-rules/asks-git.mjs":
-      'import { execFileSync } from "node:child_process";\nexecFileSync("git", ["log"]);\n',
-    "dirty/eslint-rules/clean.mjs": "export default {};\n",
-    "clean/eslint-rules/clean.mjs": "export default {};\n",
-  });
-  const runs = ["empty", "dirty", "clean"].map((d) => {
-    const { out, io } = capture();
-    return [
-      contentMain({ cwd: `${root}/${d}`, ...io }),
-      out.map((l) => l.replace(root, "<root>").split(". ")[0]),
-    ];
-  });
-  assert.deepEqual(runs, [
-    [1, ["E <root>/empty/eslint-rules: no rule sources"]],
-    [
-      1,
-      [
-        "E asks-git.mjs: imports `git`",
-        "rules-are-content-only: 2 rule sources under <root>/dirty, 1 findings",
-      ],
-    ],
-    [
-      0,
-      ["rules-are-content-only: 1 rule sources under <root>/clean, 0 findings"],
-    ],
-  ]);
-});
-
-test("run as a program over this repository: every rule source is content-only, exit 0", () => {
-  const r = spawnSync(
-    process.execPath,
-    [fileURLToPath(new URL("./rules-are-content-only.mjs", import.meta.url))],
-    { cwd: fileURLToPath(new URL("..", import.meta.url)), encoding: "utf8" },
-  );
-  assert.equal(r.status, 0, r.stderr);
-  assert.match(
-    r.stdout,
-    /^rules-are-content-only: \d+ rule sources under .*, 0 findings\n$/,
-  );
-});

package/scripts/test.mjs

@@ -1,44 +0,0 @@
-/**
- * `npm test`: the unit tests (vitest), then the harnesses (`vigiles test`). BOTH always run.
- *
- * Until #52 this was `vitest run && vigiles test --min=1`. Under `npm run coverage` a single
- * failing vitest test then skipped every harness, and what the run printed last was c8's summary:
- * lines, branches and functions each some six points below the floor. The one failing test sat
- * above that, looking like a consequence rather than the cause. Running both suites keeps the
- * coverage report whole, so a failing test is reported as itself and the coverage figures still
- * mean what they say.
- *
- * Arguments are the harness runner's (`npm test -- --no-skip`), as they were before.
- */
-import { spawnSync } from "node:child_process";
-import { isMain } from "../skills/paper-pipeline/scripts/consumer.mjs";
-
-/** The two suites, in order: what a failure is named as, and the command. */
-export const SUITES = [
-  { name: "vitest", command: ["vitest", "run"] },
-  { name: "harnesses", command: ["vigiles", "test", "--min=1"] },
-];
-
-/**
- * Run every suite, whatever the one before it returned, and name the ones that failed.
- * @returns 0 when every suite passed; otherwise the first failing suite's exit code (1 for a signal).
- */
-export function runSuites(
-  args,
-  { spawn = spawnSync, err = console.error, suites = SUITES } = {},
-) {
-  const failed = suites.flatMap(({ name, command }) => {
-    const [file, ...rest] = command;
-    const r = spawn(file, [...rest, ...(name === "harnesses" ? args : [])], {
-      stdio: "inherit",
-    });
-    return r.status === 0 ? [] : [{ name, code: r.status ?? 1 }];
-  });
-  for (const f of failed)
-    err(
-      `✗ ${f.name} failed (exit ${String(f.code)}) — its own report is above`,
-    );
-  return failed.length === 0 ? 0 : failed[0].code;
-}
-
-if (isMain(import.meta.url)) process.exit(runSuites(process.argv.slice(2)));

package/scripts/test.test.mjs

@@ -1,52 +0,0 @@
-/**
- * `npm test`'s runner: both suites run whatever the first returned, each failure is named, and
- * the harness arguments reach the harness runner only.
- */
-import assert from "node:assert/strict";
-import { test } from "vitest";
-import { runSuites, SUITES } from "./test.mjs";
-
-const fake = (status) => {
-  const calls = [];
-  return {
-    calls,
-    spawn: (file, args) => {
-      calls.push([file, ...args]);
-      return { status: status[file] };
-    },
-  };
-};
-
-test("a failing vitest does not skip the harnesses, and is named as the failure", () => {
-  const { calls, spawn } = fake({ vitest: 1, vigiles: 0 });
-  const said = [];
-  assert.equal(
-    runSuites(["--no-skip"], { spawn, err: (s) => said.push(s) }),
-    1,
-  );
-  assert.deepEqual(calls, [
-    ["vitest", "run"],
-    ["vigiles", "test", "--min=1", "--no-skip"],
-  ]);
-  assert.deepEqual(said, [
-    "✗ vitest failed (exit 1) — its own report is above",
-  ]);
-});
-
-test("both passing is 0 and silent; a harness killed by a signal is exit 1, named", () => {
-  const ok = fake({ vitest: 0, vigiles: 0 });
-  assert.equal(runSuites([], { spawn: ok.spawn, err: assert.fail }), 0);
-  const killed = fake({ vitest: 0, vigiles: null });
-  const said = [];
-  assert.equal(
-    runSuites([], { spawn: killed.spawn, err: (s) => said.push(s) }),
-    1,
-  );
-  assert.deepEqual(said, [
-    "✗ harnesses failed (exit 1) — its own report is above",
-  ]);
-  assert.deepEqual(
-    SUITES.map((s) => s.name),
-    ["vitest", "harnesses"],
-  );
-});

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

@@ -1,67 +0,0 @@
-// announce.mjs — a skill says out loud that it started, and the ledger remembers that it did.
-//
-// vigiles:local-by-design — takes a skill name as an argument and so names none itself, which reads
-// generic; it is not. It writes THIS repo's ledger row format, consumed by `status.mjs`'s gate table
-// and `ledger.mjs`'s verdict vocabulary, both of which are conventions of this knowledge base rather
-// than of any product. Moving it would export a schema nobody else has.
-//
-// WHY. Repository owner's request, 2026-08-07: "lack observability into pipeline status and whether
-// skills are actually being called — let's ensure each skill outputs something when activated".
-//
-// The failure behind that sentence is specific and it has happened three times in this repo. An
-// advisory check CANNOT BE SEEN FAILING: silence is both its error state and its normal state.
-// `paper-skills-nudge.sh` was dead for twelve days and was found only because it writes a throttle
-// stamp whose mtime had frozen. Two inline hooks were dead for their entire existence and nobody
-// noticed at all. And on 2026-08-06 a whole session of paper work ran with no skill invoked once.
-//
-// So: starting is an EVENT, and events get written down. A skill that announces leaves two traces —
-// one the human sees immediately, one the ledger keeps. Their disagreement is itself information:
-//
-//   announced, never recorded  → the skill started and died, or the author abandoned it midway
-//   recorded, never announced  → someone wrote a verdict without running the gate
-//   neither                    → it did not run, whatever any status file claims
-//
-// This is the "no trace means it did not work" rule the project already applies to hooks, made
-// available to skills, which had no equivalent.
-
-import { record, skillHash, inputHash } from "./ledger.mjs";
-import { existsSync } from "node:fs";
-import { resolve, basename } from "node:path";
-import { isMain } from "./consumer.mjs";
-
-export function announce(skill, paperDir) {
-  const dir = resolve(paperDir || ".");
-  const has = existsSync(dir);
-  const input = has ? inputHash(dir) : null;
-
-  const lines = [
-    `▶ ${skill}  —  ${has ? basename(dir) : "no paper dir"}`,
-    `  paper ${input ? input.slice(0, 8) : "(none)"} · skill ${(skillHash(skill) || "????????").slice(0, 8)}`,
-  ];
-  // stderr, not stdout: the skill's own output is the product, and a banner that pollutes a pipe
-  // is a banner someone will remove.
-  console.error(lines.join("\n"));
-
-  // An abstention with reason `started`, not an ERROR row. Before 2026-08-10 this wrote `ERROR`,
-  // which meant "the check errored" — so every announce looked like a crash until its terminal row
-  // landed, and `started` and `crashed` were the same word. Both are abstentions and neither is a
-  // judgement about the paper; the reason is what tells them apart.
-  record({
-    skill,
-    check: skill,
-    paper: dir,
-    kind: "ABSTAINED",
-    reason: "started",
-    note: "no verdict recorded yet",
-  });
-  return { skill, paper: basename(dir), input };
-}
-
-if (isMain(import.meta.url)) {
-  const [skill, paperDir] = process.argv.slice(2);
-  if (!skill) {
-    console.error("usage: announce.mjs <skill-name> [paper-dir]");
-    process.exit(2);
-  }
-  announce(skill, paperDir);
-}

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

@@ -1,102 +0,0 @@
-/**
- * announce.mjs — the first line of every wired skill's `## Run me` block: a banner on stderr naming
- * the paper and skill versions, and a `started` abstention in the ledger. Run as the skills run it,
- * against a temp consumer and a temp ledger.
- */
-import assert from "node:assert/strict";
-import { cpSync, readFileSync, rmSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { afterEach, test } from "vitest";
-import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const SCRIPT = join(HERE, "announce.mjs");
-const root = useTempDir("announce-");
-const consumer = join(root, "consumer");
-const LEDGER = join(root, "runs.jsonl");
-writeTree(root, { "consumer/papers/p/paper.md": "# P\n\ntext\n" });
-cpSync(
-  join(HERE, "..", "..", "cold-read-diff"),
-  join(consumer, ".claude", "skills", "cold-read-diff"),
-  {
-    recursive: true,
-    verbatimSymlinks: true,
-  },
-);
-const env = { CLAUDE_PROJECT_DIR: consumer, PIPELINE_LEDGER: LEDGER };
-process.env.CLAUDE_PROJECT_DIR = consumer;
-process.env.PIPELINE_LEDGER = LEDGER;
-const { inputHash, skillHash } = await import("./ledger.mjs");
-
-const rows = () =>
-  readFileSync(LEDGER, "utf8")
-    .trim()
-    .split("\n")
-    .map((l) => JSON.parse(l))
-    .map(({ skill, check, paper, kind, reason, note }) => ({
-      skill,
-      check,
-      paper,
-      kind,
-      reason,
-      note,
-    }));
-afterEach(() => rmSync(LEDGER, { force: true }));
-
-test("no skill name: the usage line, exit 2, nothing recorded", () => {
-  assert.deepEqual(runNode(SCRIPT, [], { env }), {
-    status: 2,
-    stdout: "",
-    stderr: "usage: announce.mjs <skill-name> [paper-dir]\n",
-  });
-});
-
-test("a skill on a paper: the banner names both versions, and a `started` row is recorded", () => {
-  const paper = join(consumer, "papers", "p");
-  const r = runNode(SCRIPT, ["cold-read-diff", paper], { env });
-  assert.deepEqual(
-    { ...r, rows: rows() },
-    {
-      status: 0,
-      stdout: "",
-      stderr:
-        "▶ cold-read-diff  —  p\n" +
-        `  paper ${inputHash(paper).slice(0, 8)} · skill ${skillHash("cold-read-diff").slice(0, 8)}\n`,
-      rows: [
-        {
-          skill: "cold-read-diff",
-          check: "cold-read-diff",
-          paper: "p",
-          kind: "ABSTAINED",
-          reason: "started",
-          note: "no verdict recorded yet",
-        },
-      ],
-    },
-  );
-});
-
-test("no paper directory and an unknown skill still announce, with placeholders", () => {
-  const r = runNode(SCRIPT, ["no-such-skill", join(root, "nowhere")], { env });
-  assert.deepEqual(
-    { status: r.status, stderr: r.stderr, kind: rows()[0].kind },
-    {
-      status: 0,
-      stderr:
-        "▶ no-such-skill  —  no paper dir\n  paper (none) · skill ????????\n",
-      kind: "ABSTAINED",
-    },
-  );
-});
-
-test("no paper argument means the current directory", () => {
-  const r = runNode(SCRIPT, ["cold-read-diff"], {
-    env,
-    cwd: join(consumer, "papers", "p"),
-  });
-  assert.deepEqual(
-    { status: r.status, firstLine: r.stderr.split("\n")[0] },
-    { status: 0, firstLine: "▶ cold-read-diff  —  p" },
-  );
-});

package/skills/paper-pipeline/scripts/fixtures/clean/PIPELINE-STATUS.md

@@ -1,51 +0,0 @@
-# PIPELINE-STATUS — fixture: nothing to report
-Venue: Fixture Workshop · Deadline: 2027-12-31 · Blind: double · State: drafting
-Updated: 2026-08-03
-
-**Readiness verdict:** Submit-ready — every gate green, artifact reproduces clean, nothing blocking.
-
-This fixture deliberately carries NO paper source file, so `newestSourceDate` is null and the
-staleness comparison has nothing to compare against. That keeps the clean case deterministic
-regardless of when the repo was checked out — the staleness rule is exercised by `dirty/`.
-
-### SETUP
-| id | Work | Skill | Status | Date | Result | Open |
-|----|------|-------|--------|------|--------|------|
-| idea | Validate idea | research-ideate | ☑ | 2026-08-01 | go. judge: opus, judge: author | — |
-| priorwork | Map competitors | map-prior-work | ☑ | 2026-08-01 | 6 siblings. judge: sonnet, judge: author | siblings/ |
-| venue | Pick venue | find-venue | ☑ | 2026-08-01 | fixture. judge: sonnet, judge: author | — |
-| venuebar | Venue bar / levers | study-accepted-papers | ☑ | 2026-08-01 | 34 measured. judge: sonnet, judge: author | — |
-| **access** | 🔴 **Can you physically submit?** | plan-paper-timeline | ☑ | 2026-08-01 | profile ACTIVE since 2026-08-01. judge: author, judge: author | — |
-| schedule | Schedule + calendar | plan-paper-timeline | ☑ | 2026-08-01 | —. judge: author, judge: author | — |
-| **frame** | **Claim stated before the runs** | argument-arc (frame) | ☑ | 2026-07-20 | one paragraph filed | — |
-
-### LOOP
-| id | Work | Skill | Status | Date | Result | Open |
-|----|------|-------|--------|------|--------|------|
-| study | Study + artifact | build-benchmark | ☑ | 2026-08-01 | ran | — |
-| draft | Draft | draft-paper | ☑ | 2026-08-01 | — | — |
-| arc | Argument arc | argument-arc | ☑ | 2026-08-01 | holds. judge: opus, judge: author | — |
-
-### CONTINUOUS
-| id | Trigger | Skill | Status | Date | Result | Open |
-|----|---------|-------|--------|------|--------|------|
-| cites | any cite added/moved | verify-citations | ☑ | 2026-08-02 | clean | — |
-| siblings | a sibling surfaces | analyze-sibling-paper | ☑ | 2026-08-02 | 6 read. judge: opus, judge: author | siblings/ |
-| priordelta | framing moved | map-prior-work (delta) | ☑ | 2026-08-02 | no new | — |
-| render | any source edit | render-paper + page count | ☑ | 2026-08-02 | 8 pages / limit 8 | — |
-
-### GATES
-| id | Gate | Skill | Requires | Status | Date | Result | Open |
-|----|------|-------|----------|--------|------|--------|------|
-| structure | Structure | tighten-paper | render, arc | ☑ | 2026-08-02 | cut plan applied. judge: opus, judge: author | — |
-| writing | Writing craft | grade-paper-writing | draft, arc, structure | ☑ | 2026-08-02 | 44/60. judge: sonnet, judge: author | — |
-| panel | Review decision | pc-panel-review | structure, writing | ☑ | 2026-08-03 | accept; judge: opus, judge: author | — |
-| claims | Claim preservation | Fable diff | draft, writing | ☑ | 2026-08-03 | clean | — |
-| harden | Harden (all axes) | harden-paper | panel, structure, writing, cites, priordelta | ☑ | 2026-08-03 | all axes green ; judge: opus, judge: author | — |
-| submit | Submit | submit-paper | harden, access | ☑ | 2026-08-03 | uploaded | — |
-
-### AFTER
-| id | Work | Skill | Status | Date | Result | Open |
-|----|------|-------|--------|------|--------|------|
-| cameraready | Camera-ready | camera-ready | n/a | — | pre-acceptance | — |
-| extend | Extend | extend-paper | n/a | — | post-acceptance | — |

package/skills/paper-pipeline/scripts/fixtures/dirty/PIPELINE-STATUS.md

@@ -1,52 +0,0 @@
-# PIPELINE-STATUS — fixture: every failure this checker exists for
-Venue: Fixture Workshop · Deadline: 2026-08-06 · Blind: double · State: drafting
-Updated: 2026-01-01
-
-**Readiness verdict:** 88% accept probability, looking good.
-
-The `structure` row is missing `arc` from its Requires cell **on purpose** — that is the planted
-`undeclared-input`, copied from a defect found live on a real paper in August 2026. Every
-other gate cell here is the canonical set from `../../pipeline-edges.mjs`, so exactly one edge is
-undeclared and the finding cannot come from somewhere else.
-
-### SETUP
-| id | Work | Skill | Status | Date | Result | Open |
-|----|------|-------|--------|------|--------|------|
-| idea | Validate idea | research-ideate | ☑ | 2026-01-01 | go | — |
-| priorwork | Map competitors | map-prior-work | ☑ | 2026-01-01 | 6 siblings | siblings/ |
-| venue | Pick venue | find-venue | ☑ | 2026-01-01 | fixture | — |
-| venuebar | Venue bar / levers | study-accepted-papers | ☐ | — | — | — |
-| **access** | 🔴 **Can you physically submit?** | plan-paper-timeline | ☐ | — | profile pending moderation | — |
-| schedule | Schedule + calendar | plan-paper-timeline | ☑ | 2026-01-01 | — | — |
-| **frame** | **Claim stated before the runs** | argument-arc (frame) | ☐ | — | — | — |
-
-### LOOP
-| id | Work | Skill | Status | Date | Result | Open |
-|----|------|-------|--------|------|--------|------|
-| study | Study + artifact | build-benchmark | ☑ | 2026-01-01 | ran | — |
-| draft | Draft | draft-paper | ☑ | 2026-01-01 | — | — |
-| arc | Argument arc | argument-arc | ☐ | — | — | — |
-
-### CONTINUOUS
-| id | Trigger | Skill | Status | Date | Result | Open |
-|----|---------|-------|--------|------|--------|------|
-| cites | any cite added/moved | verify-citations | ☑ | 2026-01-01 | clean | — |
-| siblings | a sibling surfaces | analyze-sibling-paper | ☑ | — | done | siblings/ |
-| priordelta | framing moved | map-prior-work (delta) | ☐ | — | — | — |
-| render | any source edit | render-paper + page count | ☑ | 2026-01-01 | 8 pages / limit 8 | — |
-
-### GATES
-| id | Gate | Skill | Requires | Status | Date | Result | Open |
-|----|------|-------|----------|--------|------|--------|------|
-| structure | Structure | tighten-paper | render | ☑ | 2026-01-01 | cut plan | — |
-| writing | Writing craft | grade-paper-writing | draft, arc, structure | ☐ | — | — | — |
-| panel | Review decision | pc-panel-review | structure, writing | ☑ | 2026-01-01 | borderline | — |
-| claims | Claim preservation | Fable diff | draft, writing | ☐ | — | — | — |
-| harden | Harden (all axes) | harden-paper | panel, structure, writing, cites, priordelta | ☐ | — | — | — |
-| submit | Submit | submit-paper | harden, access | ☐ | — | — | — |
-
-### AFTER
-| id | Work | Skill | Status | Date | Result | Open |
-|----|------|-------|--------|------|--------|------|
-| cameraready | Camera-ready | camera-ready | n/a | — | pre-acceptance | — |
-| extend | Extend | extend-paper | n/a | — | post-acceptance | — |

package/skills/paper-pipeline/scripts/fixtures/dirty/paper.md

@@ -1,6 +0,0 @@
-# Fixture paper source
-
-This file exists only so `newestSourceDate` finds something. Its mtime is whenever the
-repo was checked out, which is always later than the 2026-01-01 dates in the fixture's
-CONTINUOUS rows — so the `stale-continuous` check fires deterministically without the
-test having to touch mtimes.

package/skills/paper-pipeline/scripts/fixtures/scorecard.mjs

@@ -1,71 +0,0 @@
-/**
- * A PIPELINE-STATUS.md fixture shared by the pipeline-check harness and its CLI test: the four
- * template sections, every row green and dated `today`, so a test plants exactly one defect.
- */
-export const FAR = "2027-12-31";
-
-/**
- * A scorecard with the four sections the template requires, all green. `over` replaces individual
- * cells: `{ cites: { date: "2020-01-01" } }`, `{ verdict: "…" }`, `{ deadline: "2026-08-18" }`,
- * `{ tail: "…" }` for anything appended after the last section, `{ preamble: "…" }` for anything
- * inserted BEFORE the first heading (the only way to plant a row under no heading at all).
- */
-export function scorecard(
-  over = {},
-  today = new Date().toISOString().slice(0, 10),
-) {
-  const r = (id, status = "☑", date = today) => ({
-    id,
-    status,
-    date,
-    ...(over[id] ?? {}),
-  });
-  const row = (o, ...mid) =>
-    `| ${o.id} | work | ${o.skill ?? "skill"} | ${mid.length ? mid.join(" | ") + " | " : ""}${o.status} | ${o.date} | ${o.result ?? "result"} | — |`;
-  // The GATES `Requires` cell, canonical by default so the baseline is silent — `{ structure: {
-  // requires: "render" } }` plants a dropped edge. `harden` deliberately declares four of its five
-  // canonical inputs: the fifth (`priordelta`) has no row in this fixture, and the clean case asserts that the checker stays
-  // quiet about an edge there is nowhere to point at.
-  const req = (id, dflt) => over[id]?.requires ?? dflt;
-  const verdict =
-    over.verdict ??
-    "Submit-ready — every gate green, artifact reproduces clean, nothing blocking.";
-  return [
-    "# PIPELINE-STATUS — harness fixture",
-    `Venue: Fixture Workshop · Deadline: ${over.deadline ?? FAR} · Blind: double · State: drafting`,
-    "",
-    `**Readiness verdict:** ${verdict}`,
-    "",
-    over.preamble ?? "",
-    "",
-    "### SETUP",
-    "| id | Work | Skill | Status | Date | Result | Open |",
-    "|----|------|-------|--------|------|--------|------|",
-    row(r("idea")),
-    row(r("access")),
-    row(r("frame")),
-    "",
-    "### LOOP",
-    "| id | Work | Skill | Status | Date | Result | Open |",
-    "|----|------|-------|--------|------|--------|------|",
-    row(r("study")),
-    row(r("draft")),
-    row(r("arc")),
-    "",
-    "### CONTINUOUS",
-    "| id | Trigger | Skill | Status | Date | Result | Open |",
-    "|----|---------|-------|--------|------|--------|------|",
-    row(r("cites")),
-    row(r("render")),
-    "",
-    "### GATES",
-    "| id | Gate | Skill | Requires | Status | Date | Result | Open |",
-    "|----|------|-------|----------|--------|------|--------|------|",
-    row(r("structure"), req("structure", "render, arc")),
-    row(r("writing"), req("writing", "draft, arc, structure")),
-    row(r("panel"), req("panel", "structure, writing")),
-    row(r("harden"), req("harden", "panel, structure, writing, cites")),
-    "",
-    over.tail ?? "",
-  ].join("\n");
-}