paperlint 2.0.0

package/skills/camera-ready/camera-ready.eval.mjs

@@ -0,0 +1,19 @@
+/**
+ * camera-ready — 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/camera-ready/camera-ready.eval.mjs [trials]
+ */
+import { runSkillTriggerEval } from "../../lib/skill-eval-kit.mjs";
+
+await runSkillTriggerEval("camera-ready");

package/skills/camera-ready/camera-ready.harness.mjs

@@ -0,0 +1,23 @@
+/**
+ * camera-ready — 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 `camera-ready.eval.mjs`.
+ */
+import { checkSkill } from "../../lib/skill-checks.mjs";
+
+await checkSkill("camera-ready");

package/skills/cold-read-diff/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: cold-read-diff
+description: Send just-changed paper prose to a reader with NO context and ask what each sentence claims — the only check that catches a sentence which is short, true, jargon-free and still meaningless to anyone who does not already know the idea. Run after every prose edit to a paper, before calling the edit done, and before reporting a section as fixed. Scoped to the diff, so it is cheap enough to run every time. Not a writing grade (grade-paper-writing), not a structural pass (tighten-paper), not a defect review.
+context: fork
+allowed-tools: [Bash, Read, Agent]
+---
+
+<!-- vigiles:sha256:f3c36e3e56bbd3cd compiled from skills/cold-read-diff/SKILL.md.spec.ts -->
+
+# cold-read-diff — the reader who cannot fake understanding
+
+## Run me
+
+🔴 FIRST, before any other step:
+
+```
+node .claude/skills/paper-pipeline/scripts/announce.mjs cold-read-diff <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 failure this exists for
+
+On 2026-08-05 the author of `the reference paper` found eleven unreadable passages by eye, in a paper
+that had passed six writing grades, four structural passes and five review panels. Every one of them
+was short, factually correct, free of every word on the jargon list, and inside every mechanical
+threshold. Samples, with his reactions:
+
+> *"The state to remove is therefore not the rule but its claim about itself"* — **«wtf»**
+> *"these files are filled with constructions nobody built"* — **«wtf»**
+> *"Three answers, all of them after the fact"* — **«VAGUE AF»**
+> *"Both numbers carry a caveat…"* — **«WTF.»**
+
+They share one property: **they parse only for a reader who already holds the idea.** That is not a
+style defect and no metric can see it. Sentence length, number density, hedge share, tic frequency —
+all green on every one of these.
+
+## Why the existing pipeline could not catch it
+
+Every reader in it knows too much or cannot read at all:
+
+| reader | holds the idea? | can judge meaning? |
+|---|---|---|
+| the author | maximally — that is the curse of knowledge | yes |
+| the persona subagent | **yes: it is handed the paper and the framing** | yes |
+| the review panel | yes | yes |
+| `prose-lint` | no | **no — it counts patterns** |
+
+The gap between "knows too much" and "cannot read" is exactly where these sentences live. Closing it
+needs a reader who is competent and **structurally uninformed**, and the only way to guarantee that
+is to withhold the context rather than ask them to ignore it.
+
+## Why the DIFF, and not the paper
+
+A full cold read costs a long agent run, so it gets run once a day, which means prose written after
+it ships unread. Scoped to the changed paragraphs it costs a couple of minutes, so it runs every
+time — and coverage beats depth here, because the defect is per-sentence.
+
+Scoping also makes the check honest. Hand an agent the whole paper and it reconstructs the idea from
+the surrounding text, then reports that the sentence is clear. Hand it three paragraphs and there is
+nothing to reconstruct from: if the sentence does not carry its own meaning, the agent cannot invent
+one, and its confusion is the finding.
+
+## How to run it
+
+1. **Take the diff.** `git diff -U0 -- <paper.md>` since the last commit, or the `new_string` of the
+   edits just applied. Prose only — skip comments, tables, bibliography.
+2. **Spawn ONE agent with no repository context.** Give it the changed paragraphs **as text in the
+   prompt**, not as a file path. A path is an invitation to read the neighbours, and reading the
+   neighbours is how the check fails silently. `sonnet` is the right model: competent, cheap,
+   and not the one that wrote the sentence.
+3. **Ask exactly two questions per sentence:**
+   - *What does this sentence claim? Restate it in your own words.* If restating requires guessing,
+     the answer is `CANNOT PARSE` plus what stopped them — an undefined term, a pronoun with no
+     referent, a number with no denominator, two clauses that do not connect.
+   - *Would a reader who stops here understand it?* Yes / No / Only-if-they-know-X.
+4. **Ask for the dangerous class explicitly:** *which sentences sound clever but say less than they
+   appear to?* Those read fine and carry nothing, and they are the ones a knowing reader waves
+   through.
+5. **Apply the fixes — as rewrites of the whole thought, never as excisions.** See the rule below.
+6. **Re-run on the fix.** An edit is not done until the same kind of reader parses the replacement.
+   One confirming round; do not loop past it.
+
+## 🔴 Hand the reader WHOLE PARAGRAPHS, never `+` lines
+
+Measured on 2026-08-05, first machine run of this skill: about a third of the reader's stalls were
+artefacts of the extract, not defects in the paper — *"`it` has no referent"*, *"this sentence is cut
+off mid-clause"*, *"those populations have no antecedent"*. The neighbouring sentences simply had not
+changed, so they were not in the diff.
+
+Two more things the same run proved:
+
+- **Expand build-time macros first.** The reader saw seven raw `{{placeholders}}` and correctly
+  reported that every headline number was missing. That is a true statement about the extract and a
+  false one about the paper.
+- **Strip working comments.** He graded `<!-- JUSTIFY … -->` notes as prose because he could not tell
+  them apart — and said so, which is itself a finding about the extract.
+
+**So:** take the changed lines, then widen each to its enclosing paragraph, expand macros, drop
+comments, and hand the reader continuous prose. The findings that survive that are worth the run; the
+ones that do not are noise, and noise is how this check gets muted.
+
+## Record the verdict
+
+🔴 LAST step, once the deliverable exists:
+
+```
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record cold-read-diff <paper-dir> FINDING <count> <report-path>
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record cold-read-diff <paper-dir> ABSTAINED <reason> "<one line>"
+```
+
+**FINDING** — `<count>` is the number of changed sentences the cold reader could not restate (every
+`CANNOT PARSE` counts), `<report-path>` is the `reviews/*cold-read*.md` file.
+**ABSTAINED** — `no-witness`: every changed sentence came back restated correctly.
+`input-missing`: the diff held no prose to read.
+
+🔴 These two are different answers and the difference is the whole reason the vocabulary is closed:
+one says a reader read it and found nothing, the other says there was nothing to hand a reader.
+Prose collapses them and the old `PASS`/`ABSENT` pair only half-separated them, because `PASS` also
+got recorded when nobody had run a reader at all. There is no `PASS` now; the reason is the answer.
+
+## Rules
+
+- 🔴 **No context in the prompt. Ever.** Not the title, not the abstract, not "this is a paper about
+  agent rules files". Every sentence of background handed to the reader is a sentence of confusion
+  they will no longer report.
+- 🔴 **A fix that removes the flagged construction and keeps the compression is not a fix.** Proven
+  twice in one hour: *"not through any defect in how we write it, but because that is what English
+  is"* → *"that is what English is for"* (tic gone, meaning inverted into nonsense); *"the agent
+  turns out not to be the weak link"* → *"The agent obeys"* (three words, zero flags, wrong finding).
+  Rewrite the **thought** in plain words. The tic is usually a symptom of a compressed idea, and
+  decompressing removes it as a side effect.
+- **Length is not the constraint here — meaning is.** If plain language needs more words, take them
+  and pay from an appendix, which is outside the page limit. Paying by shortening another sentence
+  is what created the problem.
+- **`CANNOT PARSE` is a result, not a failure of the reader.** Never argue with it. The author's
+  ability to understand his own sentence is not evidence about anyone else's.
+- **Run it on your own fixes too.** The author is the least qualified judge of whether his repair
+  reads, and that is exactly when he feels most certain.
+
+## Enforcement
+
+`pipeline-check.mjs` raises `stale-cold-read` when the newest `reviews/*cold-read*.md` is older than
+the paper source, and `no-cold-read` when none exists. The date comparison is the whole mechanism:
+a cold read that predates the current text describes prose that no longer exists.
+
+## Compose with
+
+- `grade-paper-writing` — the batch readability gate; this is its continuous counterpart. That one
+  produces a stall inventory over the whole paper; this one asks whether the last edit means anything.
+- `tighten-paper` — structural cuts. Note the interaction: a tighten pass that pays for an addition
+  by shortening sentences elsewhere is precisely what generates work for this skill.
+- `paper-pipeline` — owns the text-pass / evidence-pass split; this belongs to the text pass.
+
+## Provenance
+
+Built 2026-08-05, the day before the `the reference paper` deadline, after the corpus owner read the built PDF and
+found eleven unreadable passages in twenty minutes — none of which any automated check had flagged,
+and several of which had been introduced that same morning by fixes to other automated checks.

package/skills/cold-read-diff/SKILL.md.spec.ts

@@ -0,0 +1,166 @@
+// Compiled to SKILL.md by `vigiles compile`. Edit THIS file, never the markdown.
+//
+// Adopted 2026-08-17. Body VERBATIM from the previous SKILL.md. This is the only one
+// of the batch that runs FORKED — `context: "fork"` is what gives a skill a real
+// call→return boundary, so it is carried explicitly rather than dropped.
+import { experimental_skill } from "vigiles/spec";
+
+export default experimental_skill({
+  name: "cold-read-diff",
+  description:
+    "Send just-changed paper prose to a reader with NO context and ask what each sentence claims — the only check that catches a sentence which is short, true, jargon-free and still meaningless to anyone who does not already know the idea. Run after every prose edit to a paper, before calling the edit done, and before reporting a section as fixed. Scoped to the diff, so it is cheap enough to run every time. Not a writing grade (grade-paper-writing), not a structural pass (tighten-paper), not a defect review.",
+  context: "fork",
+  tools: ["Bash", "Read", "Agent"],
+  body: `
+# cold-read-diff — the reader who cannot fake understanding
+
+## Run me
+
+🔴 FIRST, before any other step:
+
+\`\`\`
+node .claude/skills/paper-pipeline/scripts/announce.mjs cold-read-diff <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 failure this exists for
+
+On 2026-08-05 the author of \`the reference paper\` found eleven unreadable passages by eye, in a paper
+that had passed six writing grades, four structural passes and five review panels. Every one of them
+was short, factually correct, free of every word on the jargon list, and inside every mechanical
+threshold. Samples, with his reactions:
+
+> *"The state to remove is therefore not the rule but its claim about itself"* — **«wtf»**
+> *"these files are filled with constructions nobody built"* — **«wtf»**
+> *"Three answers, all of them after the fact"* — **«VAGUE AF»**
+> *"Both numbers carry a caveat…"* — **«WTF.»**
+
+They share one property: **they parse only for a reader who already holds the idea.** That is not a
+style defect and no metric can see it. Sentence length, number density, hedge share, tic frequency —
+all green on every one of these.
+
+## Why the existing pipeline could not catch it
+
+Every reader in it knows too much or cannot read at all:
+
+| reader | holds the idea? | can judge meaning? |
+|---|---|---|
+| the author | maximally — that is the curse of knowledge | yes |
+| the persona subagent | **yes: it is handed the paper and the framing** | yes |
+| the review panel | yes | yes |
+| \`prose-lint\` | no | **no — it counts patterns** |
+
+The gap between "knows too much" and "cannot read" is exactly where these sentences live. Closing it
+needs a reader who is competent and **structurally uninformed**, and the only way to guarantee that
+is to withhold the context rather than ask them to ignore it.
+
+## Why the DIFF, and not the paper
+
+A full cold read costs a long agent run, so it gets run once a day, which means prose written after
+it ships unread. Scoped to the changed paragraphs it costs a couple of minutes, so it runs every
+time — and coverage beats depth here, because the defect is per-sentence.
+
+Scoping also makes the check honest. Hand an agent the whole paper and it reconstructs the idea from
+the surrounding text, then reports that the sentence is clear. Hand it three paragraphs and there is
+nothing to reconstruct from: if the sentence does not carry its own meaning, the agent cannot invent
+one, and its confusion is the finding.
+
+## How to run it
+
+1. **Take the diff.** \`git diff -U0 -- <paper.md>\` since the last commit, or the \`new_string\` of the
+   edits just applied. Prose only — skip comments, tables, bibliography.
+2. **Spawn ONE agent with no repository context.** Give it the changed paragraphs **as text in the
+   prompt**, not as a file path. A path is an invitation to read the neighbours, and reading the
+   neighbours is how the check fails silently. \`sonnet\` is the right model: competent, cheap,
+   and not the one that wrote the sentence.
+3. **Ask exactly two questions per sentence:**
+   - *What does this sentence claim? Restate it in your own words.* If restating requires guessing,
+     the answer is \`CANNOT PARSE\` plus what stopped them — an undefined term, a pronoun with no
+     referent, a number with no denominator, two clauses that do not connect.
+   - *Would a reader who stops here understand it?* Yes / No / Only-if-they-know-X.
+4. **Ask for the dangerous class explicitly:** *which sentences sound clever but say less than they
+   appear to?* Those read fine and carry nothing, and they are the ones a knowing reader waves
+   through.
+5. **Apply the fixes — as rewrites of the whole thought, never as excisions.** See the rule below.
+6. **Re-run on the fix.** An edit is not done until the same kind of reader parses the replacement.
+   One confirming round; do not loop past it.
+
+## 🔴 Hand the reader WHOLE PARAGRAPHS, never \`+\` lines
+
+Measured on 2026-08-05, first machine run of this skill: about a third of the reader's stalls were
+artefacts of the extract, not defects in the paper — *"\`it\` has no referent"*, *"this sentence is cut
+off mid-clause"*, *"those populations have no antecedent"*. The neighbouring sentences simply had not
+changed, so they were not in the diff.
+
+Two more things the same run proved:
+
+- **Expand build-time macros first.** The reader saw seven raw \`{{placeholders}}\` and correctly
+  reported that every headline number was missing. That is a true statement about the extract and a
+  false one about the paper.
+- **Strip working comments.** He graded \`<!-- JUSTIFY … -->\` notes as prose because he could not tell
+  them apart — and said so, which is itself a finding about the extract.
+
+**So:** take the changed lines, then widen each to its enclosing paragraph, expand macros, drop
+comments, and hand the reader continuous prose. The findings that survive that are worth the run; the
+ones that do not are noise, and noise is how this check gets muted.
+
+## Record the verdict
+
+🔴 LAST step, once the deliverable exists:
+
+\`\`\`
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record cold-read-diff <paper-dir> FINDING <count> <report-path>
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record cold-read-diff <paper-dir> ABSTAINED <reason> "<one line>"
+\`\`\`
+
+**FINDING** — \`<count>\` is the number of changed sentences the cold reader could not restate (every
+\`CANNOT PARSE\` counts), \`<report-path>\` is the \`reviews/*cold-read*.md\` file.
+**ABSTAINED** — \`no-witness\`: every changed sentence came back restated correctly.
+\`input-missing\`: the diff held no prose to read.
+
+🔴 These two are different answers and the difference is the whole reason the vocabulary is closed:
+one says a reader read it and found nothing, the other says there was nothing to hand a reader.
+Prose collapses them and the old \`PASS\`/\`ABSENT\` pair only half-separated them, because \`PASS\` also
+got recorded when nobody had run a reader at all. There is no \`PASS\` now; the reason is the answer.
+
+## Rules
+
+- 🔴 **No context in the prompt. Ever.** Not the title, not the abstract, not "this is a paper about
+  agent rules files". Every sentence of background handed to the reader is a sentence of confusion
+  they will no longer report.
+- 🔴 **A fix that removes the flagged construction and keeps the compression is not a fix.** Proven
+  twice in one hour: *"not through any defect in how we write it, but because that is what English
+  is"* → *"that is what English is for"* (tic gone, meaning inverted into nonsense); *"the agent
+  turns out not to be the weak link"* → *"The agent obeys"* (three words, zero flags, wrong finding).
+  Rewrite the **thought** in plain words. The tic is usually a symptom of a compressed idea, and
+  decompressing removes it as a side effect.
+- **Length is not the constraint here — meaning is.** If plain language needs more words, take them
+  and pay from an appendix, which is outside the page limit. Paying by shortening another sentence
+  is what created the problem.
+- **\`CANNOT PARSE\` is a result, not a failure of the reader.** Never argue with it. The author's
+  ability to understand his own sentence is not evidence about anyone else's.
+- **Run it on your own fixes too.** The author is the least qualified judge of whether his repair
+  reads, and that is exactly when he feels most certain.
+
+## Enforcement
+
+\`pipeline-check.mjs\` raises \`stale-cold-read\` when the newest \`reviews/*cold-read*.md\` is older than
+the paper source, and \`no-cold-read\` when none exists. The date comparison is the whole mechanism:
+a cold read that predates the current text describes prose that no longer exists.
+
+## Compose with
+
+- \`grade-paper-writing\` — the batch readability gate; this is its continuous counterpart. That one
+  produces a stall inventory over the whole paper; this one asks whether the last edit means anything.
+- \`tighten-paper\` — structural cuts. Note the interaction: a tighten pass that pays for an addition
+  by shortening sentences elsewhere is precisely what generates work for this skill.
+- \`paper-pipeline\` — owns the text-pass / evidence-pass split; this belongs to the text pass.
+
+## Provenance
+
+Built 2026-08-05, the day before the \`the reference paper\` deadline, after the corpus owner read the built PDF and
+found eleven unreadable passages in twenty minutes — none of which any automated check had flagged,
+and several of which had been introduced that same morning by fixes to other automated checks.`,
+});

package/skills/cold-read-diff/cold-read-diff.eval.mjs

@@ -0,0 +1,19 @@
+/**
+ * cold-read-diff — 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/cold-read-diff/cold-read-diff.eval.mjs [trials]
+ */
+import { runSkillTriggerEval } from "../../lib/skill-eval-kit.mjs";
+
+await runSkillTriggerEval("cold-read-diff");

package/skills/cold-read-diff/cold-read-diff.harness.mjs

@@ -0,0 +1,23 @@
+/**
+ * cold-read-diff — 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 `cold-read-diff.eval.mjs`.
+ */
+import { checkSkill } from "../../lib/skill-checks.mjs";
+
+await checkSkill("cold-read-diff");

package/skills/draft-paper/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: draft-paper
+description: Use when the numbers exist and it's time to WRITE the paper — "draft the paper", "turn these findings into a submission", "write the abstract/intro/threats". Gives the section skeleton of a measurement/benchmark paper plus what gets it accepted AND cited — precise claim-sizing (including an explicit "what we do NOT claim"), a construct-validity frame, an honest threats-to-validity section that turns limitations in your favor, and one memorable stat that travels. Encodes the two theses that carried real measurement papers ("measuring the wrong number", "safety theater"). NOT for grading finished prose (grade-paper-writing) or structural editing (tighten-paper) — this is the generative counterpart. Compose with build-benchmark (numbers), grade-paper-writing (prose QA), render-paper, verify-citations, then the review skills.
+allowed-tools: [Read, Write, Edit, Grep, Glob, Agent, Skill, Bash(node .claude/skills/paper-pipeline/scripts/announce.mjs:*), Bash(node .claude/skills/paper-pipeline/scripts/ledger.mjs:*)]
+---
+
+<!-- vigiles:sha256:1b6a7bdc0ea402ec compiled from skills/draft-paper/SKILL.md.spec.ts -->
+
+# draft-paper — prose that survives review and gets cited
+
+## Run me
+
+🔴 FIRST, before any other step:
+
+```
+node .claude/skills/paper-pipeline/scripts/announce.mjs draft-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.
+
+A measurement paper lives or dies on two things reviewers actually reward: a **reusable method/norm**
+they can apply to the next system, and **claim-sizing so precise it can't be attacked**. Numbers alone
+are a blog post. This skill turns `build-benchmark`'s output into that kind of draft.
+
+The bar is not "is the result true" — it's "will a stranger cite this in two years." That happens when
+you gave them a *way to measure something* or a *bound they can quote*, not a verdict on one tool.
+
+## Section skeleton (measurement/benchmark paper)
+Write in this order; it's also roughly the read order a reviewer skims.
+
+🔴 **Decide body vs appendix as you write, not when the page limit forces it** —
+`paper-pipeline/references/body-vs-appendix.md`. A page limit with no rule behind it evicts whatever
+was written last, which is reliably the honest qualification nobody had room for. The rule in one
+line: the body carries everything a reviewer's decision depends on, and **a bound that narrows a
+number in the body stays in the body**.
+
+1. **Abstract** — the ONE contribution, sized. Problem → the method/insight → the single headline
+   number → what it means. Tight (see "Scope the abstract" below).
+2. **Introduction + contributions** — the gap (what everyone measures / assumes today and why it's
+   wrong or unmeasured), then a bulleted **contributions** list. Each contribution is a *thing you
+   built or established* (a method, a benchmark, a bound, a norm), not "we ran experiments."
+3. **Background + threat model** (security) / **Setup** (non-security) — define terms, the system under
+   study, and — for security — the explicit threat model (attacker goals/capabilities/knowledge). A
+   fuzzy threat model is the fastest reject at a security venue.
+4. **Method** — the reusable core. How the measurement/benchmark is *constructed* so someone else can
+   run it on a different target. This is the part that gets cited; give it the most care.
+5. **Results** — the numbers from `build-benchmark`, each tied to a claim. Report ranges/CIs, not
+   rounded maxes. One figure or table carries the paper — make it legible standalone.
+6. **Threats to validity** — construct / internal / external, honestly (see below). This section is a
+   trust signal, not a confession.
+7. **Related work** — position against the *nearest* neighbor explicitly ("X measures A; we measure B
+   because A is the wrong number"). Credit generously; that's where the framing lands.
+8. **Ethics** (security papers) — responsible disclosure, who could be harmed, punching-down check.
+   Point to `paper-pipeline/references/anonymization.md` before naming any real system/maintainer.
+9. **Conclusion** — restate the method and the one insight; no new claims.
+10. **Availability** — the anonymized artifact link (see `submit-paper`). Reviewers reward a runnable
+    artifact more than another paragraph.
+
+## What makes it ACCEPTED and CITED
+- **A reusable method/norm over a one-off result.** "Tool Y scores 40%" dies; "here's how to measure
+  Z, and by it Y scores 40%" survives, because the method outlives Y. Frame every result as an instance
+  of a general procedure.
+- **A crisp, generalizable bound or insight** the reader can quote without your paper open — one
+  sentence they'll paraphrase back to you in review. That sentence is the abstract's spine.
+- **Precise claim-sizing.** Say exactly how big the claim is and no bigger. Include an explicit
+  **"What we do NOT claim"** paragraph — it pre-empts Reviewer 2's whole attack surface and reads as
+  rigor, not weakness. (Both real papers have one; it's the highest-leverage paragraph in the draft.)
+- **A construct-validity frame.** State plainly what quantity you're measuring and why it's the *right*
+  quantity — "measuring the wrong number" only works if you've defined the right one. Make the mapping
+  from concept → metric explicit; that's what separates a benchmark from a leaderboard.
+- **An honest threats section that turns limitations in your favor.** Every limitation you name first,
+  bounded, is one a reviewer can't wield against you. "N is small, so we claim a lower bound not a
+  point estimate" converts a weakness into a scoped claim. Don't hide; scope.
+- **One memorable stat or figure that travels.** Pick the single number/image that survives out of
+  context (a tweet, a related-work sentence in someone else's paper). Everything else supports it.
+- **Credit-the-humans tone.** Dunk on the *claim or the metric*, never the authors. "The field measures
+  X; X is the wrong number" — not "prior work is naive." Punching down reads as insecurity and invites
+  a hostile review; generous framing invites a citation.
+
+## Scope the abstract tightly
+The abstract sells ONE contribution and ONE headline number. Do **not** cram every hedged sub-result —
+each extra qualified number dilutes the one that matters and invites nitpicks before the reviewer
+reaches the method. Hedge in Results/Threats, not the abstract. If you can't say the contribution in one
+sentence, you haven't found it yet — go back to the method. Structure it against the five-move template
+(context → gap → approach → one number → so-what) in `../paper-pipeline/references/writing-craft.md`, which
+also holds the craft rules and the writing rubric `grade-paper-writing` grades against — write toward the
+grade.
+
+## Run the prose through the PAPER suite's QA (do not skip — and do not use the blog skills)
+Before any review pass, run the draft through the paper-side prose QA — it catches what a self-read won't:
+- **`grade-paper-writing`** — the 9-dim rubric + the PERSONA cold-read stall pass (a committed
+  non-academic persona, per-section — the localized "wait, what does that even mean?" axis authors are
+  blind to). Its avoid-list grep also strips the AI-writing tropes (hedge-stacking, "it's worth
+  noting", limp connectives, fake balance) that make a draft read unserious to a human PC.
+- **`../paper-pipeline/references/writing-craft.md`** — write toward the rubric; its
+  register-calibration buckets decide which jargon to keep / gloss / rename for the venue's actual reader.
+
+**Boundary:** the site repo's `writing-quality` + `audience-test` skills are for **blog posts only**.
+For papers they duplicate — and are superseded by — `grade-paper-writing` + writing-craft's persona
+pass (the blog skills lack the persona fix, so they under-fire on paper prose). Never route paper
+prose QA to them.
+
+## Record the verdict
+
+🔴 LAST step, once the deliverable exists:
+
+```
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record draft-paper <paper-dir> FINDING <count> <report-path>
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record draft-paper <paper-dir> ABSTAINED <reason> "<one line>"
+```
+
+This skill generates rather than judges, so what it records is about the run, not about the paper.
+
+**FINDING** — it declined to draft because a required input was missing: no numbers from
+`build-benchmark`, or an empty `frame` paragraph from `argument-arc`. `--blocking`, always, because
+drafting past it produces prose about numbers that do not exist.
+**ABSTAINED** — `no-witness`: sections were written and the generator has nothing to report about
+the paper. Put the drafted sections in the note; they are the deliverable, not evidence of a defect.
+
+🔴 **Design smell, stated plainly: this gate will almost always record an abstention**, and
+`status.mjs` will flag it as one that has never returned a finding. Leave the flag standing — it is
+telling the truth. A generator is not a gate, and the only honest negative it can produce is the
+refusal above. If a run ever ends with prose written from numbers that do not exist, that is a
+`FINDING --blocking` and must be recorded as one rather than quietly upgraded.
+
+🔴 Deleting `PASS` did not fix this skill and was never going to: the old vocabulary let it write
+down "I produced sections" as though that were an answer about the manuscript, and the new one
+simply refuses to. The generator is still not a gate. `draft-paper/population-map` — a real check —
+is the row that can say no about this skill's output.
+
+## Compose with
+- **`build-benchmark`** — its numbers/CIs are the Results section's raw material; never hand-type a
+  number that isn't in its output (that's how paper↔artifact mismatches get born).
+- **`grade-paper-writing`** (+ `../paper-pipeline/references/writing-craft.md`) — the paper-side prose
+  QA, above. (Site-repo `writing-quality` / `audience-test` = blog posts only.)
+- **`render-paper`** — compile + eyeball pages 1–2 once prose is in.
+- **`verify-citations`** — every cite in Related Work must exist AND say what you claim.
+- Then the review loop: **`paper-adversarial-review`** → **`pc-panel-review`** (venue-fit mode for a
+  quick fit score, then the full panel as the gate).
+
+## Provenance (two real papers)
+- **AgenticDev 2026 @ ASE — "Measuring the Wrong Number."** The thesis IS the construct-validity frame:
+  the field optimizes a metric that isn't the thing anyone cares about. The method (how to measure the
+  *right* number) is the contribution; the tool verdict is just the demonstration. Its "what we do NOT
+  claim" paragraph and lower-bound-not-point-estimate threats framing are what moved it through review.
+- **AISec 2026 @ ACM CCS — "Safety Theater."** A security-venue measurement paper: a defense that
+  *looks* like safety without measurably being it. Needs the explicit threat model + ethics/disclosure
+  sections above, and dunks on the *defense pattern*, never the maintainers who shipped it — the
+  credit-the-humans rule is load-bearing at a top-tier security venue where a hostile framing draws a
+  hostile review. Both papers win on precise claim-sizing and an honest threats section, not on the
+  size of the effect.