paperlint 2.0.0

package/scripts/run-mutations.mjs

@@ -0,0 +1,100 @@
+/**
+ * run-mutations.mjs — run EVERY mutation battery in the repository, found rather than listed.
+ *
+ * ── WHY THIS EXISTS, AND IT IS NOT TIDINESS ─────────────────────────────────
+ * 🔴 It replaces a hand-written list in `package.json` that had ALREADY ROTTED. On 2026-09-11
+ * the `mutations` script read:
+ *
+ *     node eslint-rules/tex-build.mutations.mjs &&
+ *     node eslint-rules/latex-language.mutations.mjs &&
+ *     node scripts/rules-see-files.mutations.mjs
+ *
+ * — three of the four batteries on disk. `papers.mutations.mjs`, added the same day, was not in
+ * it, and nothing said so: the command exited 0 and printed three confident green tables. A
+ * list of paths maintained by hand is the thing that goes stale, and it goes stale SILENTLY,
+ * which is the same failure class the batteries themselves exist to catch.
+ *
+ * ── THE TWO GUARDS ──────────────────────────────────────────────────────────
+ * 1. FINDING ZERO BATTERIES IS AN ERROR, not an empty success. A run that discovers nothing and
+ *    exits 0 is byte-identical to a run where every battery passed — the exact green zero this
+ *    repository has a dedicated script for (`rules-see-files.mjs`), applied here to itself.
+ * 2. (REMOVED 2026-09-24) A harness without a battery used to be an error. It no longer is —
+ *    see the note above the run loop.
+ *
+ * ⚠️ Batteries WRITE to the file under test and roll it back. They are safe to run on a clean
+ * tree and NOT safe to run with uncommitted edits to a rule: a crash between the write and the
+ * rollback leaves the mutant on disk. Each battery re-reads the file and verifies the rollback
+ * byte for byte, so the window is small, but it is not zero.
+ *
+ * Run: `node scripts/run-mutations.mjs` (also part of `npm run check`)
+ */
+import { execFileSync } from "node:child_process";
+import { readdirSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+// 🔴 `.claude` IS A VIEW OF `skills/`, NOT A SECOND COPY OF IT. This repository is its own first
+// consumer: `.claude/skills/<name>` are symlinks back to `skills/<name>` so that the path every
+// SKILL.md's prose names resolves here too (see `skills/skill-contract.mutations.mjs`). Walking
+// into it counts each harness TWICE under two spellings of one file, and the second spelling is
+// never what a battery names — so every skill harness read as an orphan while being perfectly
+// covered. Measured 2026-09-12: 11 phantom orphans, all of them the same files seen through the
+// symlink. Skipping the view is not an exemption: the real files are still walked under `skills/`.
+const SKIP = new Set(["node_modules", ".git", "fixtures", ".claude"]);
+
+/** Every `*.mutations.mjs` on disk, as repo-relative paths. */
+function collect(dir, found = { mutations: [] }) {
+  for (const entry of readdirSync(dir)) {
+    if (SKIP.has(entry)) continue;
+    const p = join(dir, entry);
+    if (statSync(p).isDirectory()) {
+      collect(p, found);
+      continue;
+    }
+    if (entry.endsWith(".mutations.mjs"))
+      found.mutations.push(relative(ROOT, p));
+  }
+  return found;
+}
+
+const { mutations } = collect(ROOT);
+mutations.sort();
+
+// Guard 1 — the green zero, applied to this script itself.
+if (mutations.length === 0) {
+  console.error(
+    "❌ NO mutation batteries found under " +
+      ROOT +
+      ".\n" +
+      "   This is an error rather than an empty success: a run that discovers nothing and exits " +
+      "0\n   is indistinguishable from a run where every battery passed.",
+  );
+  process.exit(1);
+}
+
+// 🔴 NO ORPHAN GUARD ANY MORE (2026-09-24). Until then this script refused every `*.harness.mjs`
+// that no battery named — so a new harness could not land without a new hand-written battery of
+// string replacements over source lines. Those batteries are the pattern issue #52 is replacing:
+// they break on every reformat, rerun a whole harness per case, and are slow. Forcing more of them
+// into existence was the wrong direction, so the requirement is gone. Existing batteries still run
+// below, and one that fails to kill its mutant still fails the run.
+
+console.log(
+  `Running ${mutations.length} mutation batter${mutations.length === 1 ? "y" : "ies"}:\n`,
+);
+const failed = [];
+for (const m of mutations) {
+  console.log(`──────── ${m}`);
+  try {
+    execFileSync(process.execPath, [m], { cwd: ROOT, stdio: "inherit" });
+  } catch {
+    failed.push(m);
+  }
+}
+
+console.log(
+  `\n${mutations.length - failed.length}/${mutations.length} batter${mutations.length === 1 ? "y" : "ies"} clean` +
+    (failed.length ? `, FAILED: ${failed.join(", ")}` : ""),
+);
+process.exit(failed.length ? 1 : 0);

package/scripts/semantic-release-plugins.d.ts

@@ -0,0 +1,16 @@
+// The two semantic-release plugins ship no types. Only what scripts/release-config.test.ts calls
+// is declared: the plugin step functions, taking the plugin's options and semantic-release's
+// context, as their READMEs document them.
+declare module "@semantic-release/commit-analyzer" {
+  export function analyzeCommits(
+    pluginConfig: Record<string, unknown>,
+    context: Record<string, unknown>,
+  ): Promise<"major" | "minor" | "patch" | null>;
+}
+
+declare module "@semantic-release/release-notes-generator" {
+  export function generateNotes(
+    pluginConfig: Record<string, unknown>,
+    context: Record<string, unknown>,
+  ): Promise<string>;
+}

package/skills/README.md

@@ -0,0 +1,15 @@
+# skills/
+
+The Claude Code skills this package ships, one directory per skill, each with its `SKILL.md`.
+Start with `paper-pipeline/`: it routes to the stage skills.
+
+`paperlint init` links each skill into the project's Claude Code skills directory
+(`src/link-skills.ts`), because Claude Code finds project skills there and never inside the
+installed package. The directory name is `SHIPPED_SKILLS_DIR` in
+`paper-pipeline/scripts/consumer.mjs`; the linker and the install e2e both read that constant, and
+`files` in `package.json` puts the directory in the tarball.
+
+<!--
+  In a public repository, reference private notes WITHOUT the repository's name. Keep the path
+  itself — it is useful to the one person who has access, and tells everyone else nothing.
+-->

package/skills/analyze-sibling-paper/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: analyze-sibling-paper
+description: "Deep-analyze a specific related / competing / concurrent paper — reading the ACTUAL paper, not its abstract — to decide the \"isn't this just X?\" question before a reviewer asks it: what it really does, whether it's prior or concurrent work, the strongest scoop a reviewer could claim, whether your delta is REAL or merely cosmetic, and the exact cite + positioning clause (or a scoop escalation) to apply. Saves the analysis to the paper's research folder and surfaces action points. Use whenever a paper close enough to yours surfaces — via verify-citations' nearest-neighbor, a reviewer's \"this was already done\", your own lit search, or an arXiv alert. Distinct from verify-citations (confirms a cite is real + one-line delta) and study-accepted-papers (mines a venue's accepted corpus for levers); this one does the deep per-competitor overlap/scoop analysis. Compose with verify-citations (feeds it neighbors), harden-paper (its nearest-neighbor-scoop axis calls this), and extend-paper (a scooped angle can become the extension's pivot)."
+context: fork
+allowed-tools: [WebSearch, WebFetch, Read, Write, Grep, Glob, Bash, Agent]
+---
+
+<!-- vigiles:sha256:19d00fe70002d3fa compiled from skills/analyze-sibling-paper/SKILL.md.spec.ts -->
+
+# analyze-sibling-paper — settle "isn't this just X?" before a reviewer does
+
+## Run me
+
+🔴 FIRST, before any other step:
+
+```
+node .claude/skills/paper-pipeline/scripts/announce.mjs analyze-sibling-paper <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 `<paper-dir>` argument is **your** paper, not the sibling — the row belongs to the paper being
+defended. The sibling is named by `<report-path>` when the verdict is recorded.
+
+When a paper close to yours surfaces, the wrong move is to cite it from its abstract and move on — that
+leaves a scoop risk you can't see and a reviewer can. This skill reads the *actual* competitor, judges
+whether your contribution genuinely differs, and produces a saved analysis with concrete action points
+(the exact positioning clause to add, or — if it's a real scoop — an escalation, not a clause).
+
+Grounding: the original-contribution criterion (a paper a
+reviewer thinks is a repackaging earns no authorship credit even if accepted). Composes with
+`verify-citations` (which surfaces the nearest neighbors) and `harden-paper` (whose scoop axis calls this).
+
+## When it fires
+Any paper a reviewer could point at and say "this was already done." Triggers: a nearest-neighbor from
+`verify-citations`; a reviewer/panelist's "isn't this just X?"; a citation you're about to add that's
+suspiciously close; an arXiv alert in your lane. When in doubt, run it — the cost of a 20-minute read is
+far below the cost of a "novelty concern" reject.
+
+## How to run it
+
+1. **Deep-read the ACTUAL paper, not the abstract.** `WebFetch` the arXiv/ar5iv/DOI page and read
+   abstract → intro → method → claims (as much as is accessible). An abstract hides exactly the overlap
+   that matters. Try the fetch routes in order — `arxiv.org/abs/<id>` for metadata, `arxiv.org/html/<id>v1`,
+   `ar5iv.labs.arxiv.org/html/<id>`, then the PDF — and **a 403/404 on one route is not "inaccessible"**;
+   switch channel before concluding. **Record what you actually read** in the card as a
+   `**Read:**` line naming the sections you covered and the ones you could not — an abstract-only
+   verdict is PROVISIONAL and must say so in that same line.
+   🔴 **Verify the abstract's numbers against the body.** They disagree more often than you would expect,
+   and a disagreement is itself a finding worth recording.
+
+2. **Mine their REFERENCE LIST — mandatory, not optional.** A close sibling's bibliography is a map of
+   your field drawn by someone who just surveyed it, and it is frequently worth more than the paper's own
+   findings. Extract every entry, then diff against your own reference list and emit three sets:
+   **in both** (count only) · **in theirs, not in ours, and relevant** — each with a verdict
+   *MUST CITE* (a reviewer would fault you for missing it) / *SHOULD CONSIDER* / *NOT RELEVANT* ·
+   **in ours, not in theirs** (does the gap show you are looking where they are not, or that you cited
+   something obscure?). Be strict: most entries will be NOT RELEVANT, and saying so is the useful part.
+   🔴 **The highest-value find in the whole skill is a MUST CITE entry that is itself a scoop** — a paper
+   in their bibliography doing what you do. Look for it deliberately and state plainly if there is none.
+   Every *MUST CITE* must be **confirmed by fetching its arXiv/DOI page** before it enters your text
+   (`verify-citations` rule: a title is not real until a fetch says so) — mark each CONFIRMED-BY-FETCH or
+   NOT-CONFIRMED.
+3. **Classify by contribution TYPE** — system/defense · measurement · benchmark · framework · SoK ·
+   position. Two papers can share a *concept* and still not collide if their contribution types differ (a
+   *system* that assumes "rules can't catch semantics" and a *measurement* that proves it across a
+   deployed ecosystem are different contributions). Type is the first lever of a real delta.
+4. **Timing: prior vs concurrent.** Compare its arXiv/publication date to your submission.
+   **Prior work** (clearly earlier) — you must engage and build on it; failing to cite is a reject.
+   **Concurrent** (roughly within a few months) — acknowledge it, but you are NOT obligated to have built
+   on it, and workshop/venue norms treat it as parallel discovery. State which, with dates.
+5. **Steelman the scoop.** Write the strongest "isn't this just X?" a hostile reviewer could make,
+   quoting the sibling. If you can't make it hurt, you haven't understood the overlap.
+6. **Judge the delta — brutally.** Is your distinct contribution real and reviewer-proof, or only
+   cosmetic/scope ("same idea, different object")? **Use an adversarial model (a Fable subagent) for this
+   step** — you will flatter your own delta; it won't. A scope-only distinction on a shared core idea is a
+   yellow flag; a different contribution type + a result the sibling doesn't have is a green one.
+7. **Emit action points.** One of:
+   - **Cite + position** (the common case): the exact 1–2 sentence clause to add. If the overlap is
+     *conceptual*, acknowledge the shared idea **head-on** — "X observes this split; we measure it across
+     the deployed ecosystem and show the corner is reachable." Owning it reads as scholarship; hiding it
+     reads as not knowing the field, which is worse.
+   - **Escalate** (rare but real): if it's prior work with the same contribution, a clause won't save you
+     — reframe your contribution around what genuinely remains, or route the un-scooped angle to
+     `extend-paper`. Flag this LOUDLY; it's a novelty problem, not a citation fix.
+
+## Required shape of the saved card — two sections are machine-checked
+
+The card is not free-form. Two of its parts are checked by `.claude/hooks/paper-lint.mjs`
+(`checkSiblingCards`) and a card missing either is reported as an unfinished analysis:
+
+- **`**Read:**`** — one line naming what of the full text you actually read and what you could
+  not. This exists because "I read the paper" is the single easiest thing to skip while producing a
+  card that looks complete.
+- **`## Sibling's References`** — their bibliography mined and diffed against yours (step 2), with the
+  MUST CITE / SHOULD CONSIDER / NOT RELEVANT verdicts.
+
+Enforced only for cards dated on or after 2026-07-29; older cards get one summary nudge instead of
+burying every other finding. Frontmatter needs `title`, `created`, `tags` like any note.
+
+## Save + surface — COLOCATED with the paper (mandatory — do not leave it in context)
+Each paper's competitive landscape lives **with that paper**, not in a shared research folder: write the
+analysis to **`<paper-dir>/siblings/YYYY-MM-DD-<name>.md`** (e.g. `papers/<paper>/siblings/…`) and keep
+a **`<paper-dir>/siblings/README.md`** index listing every sibling + its one-line verdict (scoop-safe /
+must-fix-clause / escalate). Colocation is the rule: when you open the paper's dir you should see its rivals
+and their verdicts right there, and they travel with the paper to camera-ready and rebuttal. Include: what
+it does, contribution type, timing (prior/concurrent + dates), the steelmanned scoop, the delta verdict,
+and the action points (with the exact clause text to add/replace). Per the save-research rule, a competitor
+analysis that lives only in a chat is lost the moment the session ends — and it's exactly what you'll need
+again at rebuttal. **A close sibling with no file in `<paper-dir>/siblings/` is an unfinished analysis.**
+
+## Record the verdict
+
+🔴 LAST step, once the deliverable exists:
+
+```
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record analyze-sibling-paper <paper-dir> FINDING <count> <report-path>
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record analyze-sibling-paper <paper-dir> ABSTAINED <reason> "<one line>"
+```
+
+**FINDING** — `<count>` is the number of action points the card produced (positioning clauses plus
+*MUST CITE* entries), `<report-path>` is the saved card, which names the sibling. Add `--blocking`
+for a genuine scoop, which the skill already treats as an escalation rather than a clause.
+**ABSTAINED** — `no-witness`: the sibling was read in full and the delta needs no text to change.
+`blocked`: the sibling's full text could not be obtained, so only its abstract was seen — which is
+explicitly not an analysis and must never be recorded as one.
+
+🔴 **There is no PASS.** "The delta is real" read identically whether the sibling had been read
+whole or skimmed, and this skill's own first rule is that an abstract-only delta is not a verdict.
+`no-witness` and `blocked` now say which happened.
+
+One row per sibling analysed, filed under its own `--check=<sibling-slug>`; several finding rows
+against one paper is the normal shape here, not a check that keeps failing. Before 2026-08-10 they
+would have overwritten one another.
+
+## Rules
+- **Read the paper, not the abstract.** An abstract-only "delta" is not a verdict — and the card must
+  say, in its `**Read:**` line, which parts you actually read.
+- **Mine their references.** A sibling analysis that never opened the sibling's bibliography is half done;
+  the scoop you missed is more likely to be in their reference list than in their results.
+- **Classify by contribution type** before judging overlap — it's the difference between a shared concept and a collision.
+- **Prior vs concurrent is a date fact, not a vibe** — state the dates.
+- **Own conceptual overlaps head-on**; a reviewer who spots an unacknowledged twin assumes you didn't read the field.
+- **A genuine scoop is an escalation, not a clause** — don't paper over a novelty problem with a sentence.
+- **Judge the delta with an adversarial model**, not your own optimism.
+- **Save the analysis to the repo** and index it.
+
+## Compose with
+- `verify-citations` — surfaces the nearest-neighbor works; hand each genuine sibling to this skill.
+- `harden-paper` — its nearest-neighbor-scoop axis (axis 3) calls this for each close competitor.
+- `study-accepted-papers` — venue-corpus levers (different axis: the venue's bar, not a specific rival).
+- `extend-paper` — a scooped angle, or the un-scooped remainder, can become the next paper's pivot.
+
+## Provenance
+Built from the **AISec 2026 GateBench** run: `verify-citations` flagged **AgentTrust** (yang2026agenttrust,
+arXiv:2606.08539) as making the same lexical-vs-semantic split the paper's spelling→grammar→effect framing
+builds on — the sharpest "isn't this just X?" in the paper. Citing it from the abstract was not enough to
+know whether the framing was a repackaging; only a deep read of the actual paper, classified by
+contribution type (their trust-*system* vs our *measurement + benchmark + existence result*) and dated
+against submission, could settle the delta and produce the head-on positioning clause. That is exactly
+the workflow this skill encodes.
+
+**Extended 2026-07-29** — *What Breaks When LLMs Code?* (arXiv:2605.30777) was cited into the
+`the reference paper` introduction **from its abstract**, and a card was written saying so. Two gaps
+surfaced immediately: the full text was never read (so the "no scoop" verdict rested on an abstract),
+and its reference list — assembled by authors who had just screened 68,816 papers across 22 venues —
+was never opened at all. Both are now steps 1–2, and both are machine-checked in the saved card, because
+the previous version of this rule already said "read the paper, not the abstract" in prose and that did
+not stop it happening. Prose isn't policy.

package/skills/analyze-sibling-paper/SKILL.md.spec.ts

@@ -0,0 +1,186 @@
+// Compiled to SKILL.md by `vigiles compile`. Edit THIS file, never the markdown.
+//
+// Adopted 2026-08-17 (batch 3). Body carried over VERBATIM so the compiled diff shows
+// only what the compiler adds. No `disallowedTools` fence yet — the field landed on
+// `SkillSpec` in vigiles branch `claude/skill-disallowed-tools` and is not in a release
+// this repo installs, so writing one here would not compile.
+import { experimental_skill } from "vigiles/spec";
+
+export default experimental_skill({
+  name: "analyze-sibling-paper",
+  description:
+    "Deep-analyze a specific related / competing / concurrent paper — reading the ACTUAL paper, not its abstract — to decide the \"isn't this just X?\" question before a reviewer asks it: what it really does, whether it's prior or concurrent work, the strongest scoop a reviewer could claim, whether your delta is REAL or merely cosmetic, and the exact cite + positioning clause (or a scoop escalation) to apply. Saves the analysis to the paper's research folder and surfaces action points. Use whenever a paper close enough to yours surfaces — via verify-citations' nearest-neighbor, a reviewer's \"this was already done\", your own lit search, or an arXiv alert. Distinct from verify-citations (confirms a cite is real + one-line delta) and study-accepted-papers (mines a venue's accepted corpus for levers); this one does the deep per-competitor overlap/scoop analysis. Compose with verify-citations (feeds it neighbors), harden-paper (its nearest-neighbor-scoop axis calls this), and extend-paper (a scooped angle can become the extension's pivot).",
+  context: "fork",
+  tools: [
+    "WebSearch",
+    "WebFetch",
+    "Read",
+    "Write",
+    "Grep",
+    "Glob",
+    "Bash",
+    "Agent",
+  ],
+  body: `
+# analyze-sibling-paper — settle "isn't this just X?" before a reviewer does
+
+## Run me
+
+🔴 FIRST, before any other step:
+
+\`\`\`
+node .claude/skills/paper-pipeline/scripts/announce.mjs analyze-sibling-paper <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 \`<paper-dir>\` argument is **your** paper, not the sibling — the row belongs to the paper being
+defended. The sibling is named by \`<report-path>\` when the verdict is recorded.
+
+When a paper close to yours surfaces, the wrong move is to cite it from its abstract and move on — that
+leaves a scoop risk you can't see and a reviewer can. This skill reads the *actual* competitor, judges
+whether your contribution genuinely differs, and produces a saved analysis with concrete action points
+(the exact positioning clause to add, or — if it's a real scoop — an escalation, not a clause).
+
+Grounding: the original-contribution criterion (a paper a
+reviewer thinks is a repackaging earns no authorship credit even if accepted). Composes with
+\`verify-citations\` (which surfaces the nearest neighbors) and \`harden-paper\` (whose scoop axis calls this).
+
+## When it fires
+Any paper a reviewer could point at and say "this was already done." Triggers: a nearest-neighbor from
+\`verify-citations\`; a reviewer/panelist's "isn't this just X?"; a citation you're about to add that's
+suspiciously close; an arXiv alert in your lane. When in doubt, run it — the cost of a 20-minute read is
+far below the cost of a "novelty concern" reject.
+
+## How to run it
+
+1. **Deep-read the ACTUAL paper, not the abstract.** \`WebFetch\` the arXiv/ar5iv/DOI page and read
+   abstract → intro → method → claims (as much as is accessible). An abstract hides exactly the overlap
+   that matters. Try the fetch routes in order — \`arxiv.org/abs/<id>\` for metadata, \`arxiv.org/html/<id>v1\`,
+   \`ar5iv.labs.arxiv.org/html/<id>\`, then the PDF — and **a 403/404 on one route is not "inaccessible"**;
+   switch channel before concluding. **Record what you actually read** in the card as a
+   \`**Read:**\` line naming the sections you covered and the ones you could not — an abstract-only
+   verdict is PROVISIONAL and must say so in that same line.
+   🔴 **Verify the abstract's numbers against the body.** They disagree more often than you would expect,
+   and a disagreement is itself a finding worth recording.
+
+2. **Mine their REFERENCE LIST — mandatory, not optional.** A close sibling's bibliography is a map of
+   your field drawn by someone who just surveyed it, and it is frequently worth more than the paper's own
+   findings. Extract every entry, then diff against your own reference list and emit three sets:
+   **in both** (count only) · **in theirs, not in ours, and relevant** — each with a verdict
+   *MUST CITE* (a reviewer would fault you for missing it) / *SHOULD CONSIDER* / *NOT RELEVANT* ·
+   **in ours, not in theirs** (does the gap show you are looking where they are not, or that you cited
+   something obscure?). Be strict: most entries will be NOT RELEVANT, and saying so is the useful part.
+   🔴 **The highest-value find in the whole skill is a MUST CITE entry that is itself a scoop** — a paper
+   in their bibliography doing what you do. Look for it deliberately and state plainly if there is none.
+   Every *MUST CITE* must be **confirmed by fetching its arXiv/DOI page** before it enters your text
+   (\`verify-citations\` rule: a title is not real until a fetch says so) — mark each CONFIRMED-BY-FETCH or
+   NOT-CONFIRMED.
+3. **Classify by contribution TYPE** — system/defense · measurement · benchmark · framework · SoK ·
+   position. Two papers can share a *concept* and still not collide if their contribution types differ (a
+   *system* that assumes "rules can't catch semantics" and a *measurement* that proves it across a
+   deployed ecosystem are different contributions). Type is the first lever of a real delta.
+4. **Timing: prior vs concurrent.** Compare its arXiv/publication date to your submission.
+   **Prior work** (clearly earlier) — you must engage and build on it; failing to cite is a reject.
+   **Concurrent** (roughly within a few months) — acknowledge it, but you are NOT obligated to have built
+   on it, and workshop/venue norms treat it as parallel discovery. State which, with dates.
+5. **Steelman the scoop.** Write the strongest "isn't this just X?" a hostile reviewer could make,
+   quoting the sibling. If you can't make it hurt, you haven't understood the overlap.
+6. **Judge the delta — brutally.** Is your distinct contribution real and reviewer-proof, or only
+   cosmetic/scope ("same idea, different object")? **Use an adversarial model (a Fable subagent) for this
+   step** — you will flatter your own delta; it won't. A scope-only distinction on a shared core idea is a
+   yellow flag; a different contribution type + a result the sibling doesn't have is a green one.
+7. **Emit action points.** One of:
+   - **Cite + position** (the common case): the exact 1–2 sentence clause to add. If the overlap is
+     *conceptual*, acknowledge the shared idea **head-on** — "X observes this split; we measure it across
+     the deployed ecosystem and show the corner is reachable." Owning it reads as scholarship; hiding it
+     reads as not knowing the field, which is worse.
+   - **Escalate** (rare but real): if it's prior work with the same contribution, a clause won't save you
+     — reframe your contribution around what genuinely remains, or route the un-scooped angle to
+     \`extend-paper\`. Flag this LOUDLY; it's a novelty problem, not a citation fix.
+
+## Required shape of the saved card — two sections are machine-checked
+
+The card is not free-form. Two of its parts are checked by \`.claude/hooks/paper-lint.mjs\`
+(\`checkSiblingCards\`) and a card missing either is reported as an unfinished analysis:
+
+- **\`**Read:**\`** — one line naming what of the full text you actually read and what you could
+  not. This exists because "I read the paper" is the single easiest thing to skip while producing a
+  card that looks complete.
+- **\`## Sibling's References\`** — their bibliography mined and diffed against yours (step 2), with the
+  MUST CITE / SHOULD CONSIDER / NOT RELEVANT verdicts.
+
+Enforced only for cards dated on or after 2026-07-29; older cards get one summary nudge instead of
+burying every other finding. Frontmatter needs \`title\`, \`created\`, \`tags\` like any note.
+
+## Save + surface — COLOCATED with the paper (mandatory — do not leave it in context)
+Each paper's competitive landscape lives **with that paper**, not in a shared research folder: write the
+analysis to **\`<paper-dir>/siblings/YYYY-MM-DD-<name>.md\`** (e.g. \`papers/<paper>/siblings/…\`) and keep
+a **\`<paper-dir>/siblings/README.md\`** index listing every sibling + its one-line verdict (scoop-safe /
+must-fix-clause / escalate). Colocation is the rule: when you open the paper's dir you should see its rivals
+and their verdicts right there, and they travel with the paper to camera-ready and rebuttal. Include: what
+it does, contribution type, timing (prior/concurrent + dates), the steelmanned scoop, the delta verdict,
+and the action points (with the exact clause text to add/replace). Per the save-research rule, a competitor
+analysis that lives only in a chat is lost the moment the session ends — and it's exactly what you'll need
+again at rebuttal. **A close sibling with no file in \`<paper-dir>/siblings/\` is an unfinished analysis.**
+
+## Record the verdict
+
+🔴 LAST step, once the deliverable exists:
+
+\`\`\`
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record analyze-sibling-paper <paper-dir> FINDING <count> <report-path>
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record analyze-sibling-paper <paper-dir> ABSTAINED <reason> "<one line>"
+\`\`\`
+
+**FINDING** — \`<count>\` is the number of action points the card produced (positioning clauses plus
+*MUST CITE* entries), \`<report-path>\` is the saved card, which names the sibling. Add \`--blocking\`
+for a genuine scoop, which the skill already treats as an escalation rather than a clause.
+**ABSTAINED** — \`no-witness\`: the sibling was read in full and the delta needs no text to change.
+\`blocked\`: the sibling's full text could not be obtained, so only its abstract was seen — which is
+explicitly not an analysis and must never be recorded as one.
+
+🔴 **There is no PASS.** "The delta is real" read identically whether the sibling had been read
+whole or skimmed, and this skill's own first rule is that an abstract-only delta is not a verdict.
+\`no-witness\` and \`blocked\` now say which happened.
+
+One row per sibling analysed, filed under its own \`--check=<sibling-slug>\`; several finding rows
+against one paper is the normal shape here, not a check that keeps failing. Before 2026-08-10 they
+would have overwritten one another.
+
+## Rules
+- **Read the paper, not the abstract.** An abstract-only "delta" is not a verdict — and the card must
+  say, in its \`**Read:**\` line, which parts you actually read.
+- **Mine their references.** A sibling analysis that never opened the sibling's bibliography is half done;
+  the scoop you missed is more likely to be in their reference list than in their results.
+- **Classify by contribution type** before judging overlap — it's the difference between a shared concept and a collision.
+- **Prior vs concurrent is a date fact, not a vibe** — state the dates.
+- **Own conceptual overlaps head-on**; a reviewer who spots an unacknowledged twin assumes you didn't read the field.
+- **A genuine scoop is an escalation, not a clause** — don't paper over a novelty problem with a sentence.
+- **Judge the delta with an adversarial model**, not your own optimism.
+- **Save the analysis to the repo** and index it.
+
+## Compose with
+- \`verify-citations\` — surfaces the nearest-neighbor works; hand each genuine sibling to this skill.
+- \`harden-paper\` — its nearest-neighbor-scoop axis (axis 3) calls this for each close competitor.
+- \`study-accepted-papers\` — venue-corpus levers (different axis: the venue's bar, not a specific rival).
+- \`extend-paper\` — a scooped angle, or the un-scooped remainder, can become the next paper's pivot.
+
+## Provenance
+Built from the **AISec 2026 GateBench** run: \`verify-citations\` flagged **AgentTrust** (yang2026agenttrust,
+arXiv:2606.08539) as making the same lexical-vs-semantic split the paper's spelling→grammar→effect framing
+builds on — the sharpest "isn't this just X?" in the paper. Citing it from the abstract was not enough to
+know whether the framing was a repackaging; only a deep read of the actual paper, classified by
+contribution type (their trust-*system* vs our *measurement + benchmark + existence result*) and dated
+against submission, could settle the delta and produce the head-on positioning clause. That is exactly
+the workflow this skill encodes.
+
+**Extended 2026-07-29** — *What Breaks When LLMs Code?* (arXiv:2605.30777) was cited into the
+\`the reference paper\` introduction **from its abstract**, and a card was written saying so. Two gaps
+surfaced immediately: the full text was never read (so the "no scoop" verdict rested on an abstract),
+and its reference list — assembled by authors who had just screened 68,816 papers across 22 venues —
+was never opened at all. Both are now steps 1–2, and both are machine-checked in the saved card, because
+the previous version of this rule already said "read the paper, not the abstract" in prose and that did
+not stop it happening. Prose isn't policy.`,
+});

package/skills/analyze-sibling-paper/analyze-sibling-paper.eval.mjs

@@ -0,0 +1,19 @@
+/**
+ * analyze-sibling-paper — the PAID tier: does this skill's description actually fire?
+ *
+ * COLOCATED ON PURPOSE (vigiles decides coverage by placement as of 2026-08-11).
+ * The prompts live in `.claude/lib/skill-trigger-cases.mjs` so all 21 cases
+ * are reviewed as one table where collisions between siblings are visible;
+ * copying them here would recreate the drift that rule exists to prevent.
+ *
+ * Measures recall (fires on its own territory) AND precision (stays quiet on a
+ * colliding sibling's territory), against the REAL `.claude` harness so the skill
+ * competes with every other installed description — an isolated run overstates
+ * recall and understates false positives.
+ *
+ * Costs money; not CI.
+ *   node .claude/skills/analyze-sibling-paper/analyze-sibling-paper.eval.mjs [trials]
+ */
+import { runSkillTriggerEval } from "../../lib/skill-eval-kit.mjs";
+
+await runSkillTriggerEval("analyze-sibling-paper");

package/skills/analyze-sibling-paper/analyze-sibling-paper.harness.mjs

@@ -0,0 +1,23 @@
+/**
+ * analyze-sibling-paper — the free, deterministic tier. No model, no network.
+ *
+ * COLOCATED ON PURPOSE. vigiles decides coverage by PLACEMENT as of 2026-08-11:
+ * a test that merely names a surface no longer counts, because that tier was
+ * crediting surfaces nothing touched. So each skill needs a file inside its own
+ * directory — this one.
+ *
+ * The assertions live in `.claude/lib/skill-checks.mjs` and are CALLED here with
+ * this skill's name. They are not copied: 22 copies of the same checks is the drift that
+ * module exists to avoid. (Until 2026-08-11 this was an env-var side channel into a
+ * 614-line file named after no surface; it is a function call now.)
+ *
+ * What this proves: this skill's frontmatter parses as strict YAML, its declared
+ * tool contract is sane, its pipeline wiring points at scripts that exist, and it
+ * announces/records under ITS OWN identity rather than a sibling's.
+ *
+ * What it does NOT prove: that the skill fires, or that its guidance produces a
+ * good result. Those need a real model — see `analyze-sibling-paper.eval.mjs`.
+ */
+import { checkSkill } from "../../lib/skill-checks.mjs";
+
+await checkSkill("analyze-sibling-paper");