paperlint 2.0.0

package/skills/map-prior-work/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: map-prior-work
+description: Sweep the competitive landscape for a paper idea BEFORE drafting — find everyone already working on it, date each against your submission (prior vs concurrent is a five-month question, not a vibe), triage by whether they threaten your claimed contribution, deep-read the ones that do, and emit a verdict on WHAT YOU CAN STILL CLAIM plus a related-work skeleton. Saves the full map, not a summary. Use right after research-ideate and before draft-paper, and re-run as a cheap delta pass before submit (hot fields move). Distinct from analyze-sibling-paper (one known competitor, deep) — this one FINDS the competitors and decides which deserve that treatment; distinct from verify-citations (checks cites you already wrote, too late to reshape a contribution); distinct from study-accepted-papers (mines a venue's bar, not your rivals). Compose with research-ideate (upstream), analyze-sibling-paper (it hands off), draft-paper and find-venue (downstream).
+context: fork
+allowed-tools: [WebSearch, WebFetch, Read, Write, Grep, Glob, Bash, Agent]
+---
+
+<!-- vigiles:sha256:353e5a21b731a548 compiled from skills/map-prior-work/SKILL.md.spec.ts -->
+
+# map-prior-work — find out who already did it, while you can still change course
+
+## Run me
+
+🔴 FIRST, before any other step:
+
+```
+node .claude/skills/paper-pipeline/scripts/announce.mjs map-prior-work <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 expensive failure this prevents, in one sentence: **you discover the paper that already did your
+contribution after the draft is finished, when the only move left is rewriting the claim under deadline.**
+
+Grounding: the original-contribution criterion. A paper
+a reviewer reads as a repackaging earns no authorship credit even if it is accepted. Composes with
+`research-ideate` (upstream: it validated *whether* the idea is worth doing; this validates whether it is
+still *yours*), `analyze-sibling-paper` (this hands it the papers that need a full read), and
+`draft-paper` (which consumes the related-work skeleton).
+
+## Why this exists — the failure it was written from
+
+**Real case, 2026-07 (paper #3).** The idea was validated, the venue picked, the study run, the paper
+drafted, the artifact built. At **T−10 days** a *citation audit* — a late mechanical check, not a search —
+stumbled onto a paper that had shipped the same construction **five months earlier**, with an
+implementation matching the paper's own §6. Consequences:
+
+- The headline contribution had to be rewritten under deadline.
+- The related-work section had described that paper **incorrectly**, in exactly the direction that made
+  room for the claimed novelty — the reading a reviewer punishes hardest.
+- Two more neighbors then had to be read in one night, and one of them overturned a second claim.
+
+None of that was bad luck. **No unit of work in the pipeline was responsible for looking.**
+`verify-citations` surfaces neighbors, but it is a CONTINUOUS check over cites **already written** —
+it fires after the draft exists, and it can only see what you already decided to cite. This skill is
+the work that was missing.
+
+## Two modes, and they live in different parts of the pipeline
+
+This skill is deliberately **not one thing in one place**. It has two modes, and the scorecard
+(`paper-pipeline/references/pipeline-status-template.md`) gives them two separate rows, because a
+green sweep from month one says nothing about the field today.
+
+| Mode | Where it lives | Scorecard row | When it fires |
+|---|---|---|---|
+| **SETUP sweep** (the full thing below) | SETUP, right after `research-ideate` says go | **`priorwork`** | Once, before any drafting. Cheapest moment — the contribution is still a sentence, not a structure. |
+| **CONTINUOUS delta** (re-sweep, restricted to work posted since) | CONTINUOUS — a trigger, never "done" | **`priordelta`** | **Whenever the contribution's framing moves**, and again before `harden-paper`. In a hot area a two-month-old sweep is stale. |
+
+Also fires **reactively** in delta mode: a reviewer says "this was already done", an arXiv alert
+surfaces something close, or a `verify-citations` run turns up a neighbor you had never seen.
+
+⚠️ **If a rival first surfaces during citation checking, the SETUP sweep (`priorwork`) was skipped** — and
+you are now reshaping the contribution under deadline, which is exactly the failure above. Treat that
+as a finding about the process, not only about the rival.
+
+*The two modes used to be one entry in a numbered stage list, which could only show one of them; that
+list was replaced on 2026-08-03 by the four kinds of work in `paper-pipeline`.*
+
+---
+
+## Step 1 — write down what you are claiming, before searching
+
+One sentence, falsifiable, in the form: **"We are first to ___."** Then split it:
+
+| Layer | Example | Who can take it |
+|---|---|---|
+| **Construction** | "compile prose rules into executable checks" | anyone who built it first, *regardless of quality* |
+| **Measurement** | "measure how often stated rules are enforced in real repos" | anyone with the same corpus study |
+| **Guarantee** | "abstain unless the synthesized checker survives a blind gold set" | anyone with the same decision procedure |
+
+🔴 **These are lost independently.** Losing the construction does not lose the guarantee. Write all three
+down *now* — otherwise a single hit feels like total loss and you rewrite more than you must.
+
+## Step 2 — sweep, from multiple angles
+
+Do not run one query. Run **at least five angles**, because a neighbor that uses different vocabulary is
+exactly the one you will miss:
+
+1. **Your own terms** — the phrasing you use in the claim.
+2. **Their likely terms** — what would a group from a different subfield call this? (Same idea travels as
+   "policy", "constraint", "specification", "guardrail", "contract", "config".)
+3. **By artifact** — the thing you built, not the idea (tool names, file formats, benchmark names).
+4. **By venue** — recent proceedings of the venues you'd submit to, and their workshops.
+5. **By citation graph** — who cites the 2–3 works you consider closest, and what those works cite.
+
+Sources, in order of reliability: **arXiv listings + full-text search · ACL Anthology · DBLP · Semantic
+Scholar · venue proceedings pages · OpenReview**. Blogs and social posts count as leads, never as
+findings.
+
+**Parallelize.** One subagent per angle, each returning candidates with title, authors, venue, date, and
+two sentences on what it does. Deduplicate afterwards in plain code, not by another agent.
+
+## Step 3 — date everything against YOUR submission date
+
+For each candidate record **v1 date**, latest revision, and acceptance status.
+
+| Gap to your submission | Status | What you may write |
+|---|---|---|
+| Published **before** by more than ~3 months | **prior work** | Cite it. You may not call it concurrent. |
+| Within roughly ±3 months | **concurrent** | "independently and concurrently" is defensible — say so explicitly |
+| After your submission | not your problem | ignore for this cycle; note for the extension |
+
+🔴 **Five months is prior work, not concurrent.** Wanting it to be concurrent does not make it so, and a
+reviewer checks the arXiv date in one click. Also record **acceptance**: a preprint and a paper accepted
+at a real venue carry different weight, and describing an *accepted* work incorrectly costs more.
+
+## Step 4 — triage against the three layers
+
+For each candidate, mark which layer it threatens:
+
+| Verdict | Meaning | Action |
+|---|---|---|
+| 🔴 **SCOOPED** | takes a layer outright | that layer is gone — reshape the claim **now**, while it's cheap |
+| 🟠 **OVERLAP** | same territory, different question or method | must be read in full and positioned precisely |
+| 🟡 **ADJACENT** | cited for context, threatens nothing | one accurate sentence in related work |
+| ⚪ **IRRELEVANT** | surfaced by the sweep, doesn't apply | list it anyway, so the next sweep doesn't re-litigate |
+
+## Step 5 — deep-read everything 🔴 and 🟠 — hand off to `analyze-sibling-paper`
+
+**Never triage a close paper from its abstract.** Two abstracts in the real case above were actively
+misleading:
+
+- one made a *constructive* system read as a measurement tool (the word its title implies appears **zero
+  times** in its body);
+- another **omitted its matched-pair design**, so a check based on the abstract concluded "no present/absent
+  control" when the full text has one, with real effect sizes in a table.
+
+Both errors pointed the same way: **toward believing we were more novel than we were, or that a rival was
+weaker than it was.** Read the paper.
+
+**Formulate the read as refutation:** *"try to show this scoops us."* A clean negative is a valid result;
+a confirmation you did not try to break is not.
+
+## Step 6 — the output that matters: what you can still claim
+
+Do not stop at a list of papers. The deliverable is a **verdict on the claim**:
+
+- ✅ **HOLDS** — the sentence from Step 1 survives as written.
+- ⚠️ **HOLDS NARROWED** — give the exact replacement sentence, ready to paste.
+- 🔴 **DOES NOT HOLD** — say which layer is gone and what remains. If nothing remains, say that: killing
+  an idea at sweep stage costs days, killing it at review stage costs a cycle.
+
+Plus a **related-work skeleton**: for each 🔴/🟠, two to four sentences in English, correct about *them*
+first and about your delta second. Correctness about the rival is the load-bearing half — a reviewer who
+knows the work reads a wrong description as a stretch, and that contaminates trust in your measurements.
+
+## Step 7 — save the map, not a summary
+
+Per `../../CLAUDE.md` (research is recorded verbatim, in detail):
+
+```
+<papers-root>/<paper>/siblings/
+├── README.md                      # index: table of every candidate + verdict + what's unread
+├── <date>-<name>.md               # one file per deep-read (analyze-sibling-paper's output)
+└── <date>-sweep.md                # the sweep itself: queries run, sources hit, candidates
+                                   # dropped and WHY, coverage gaps stated honestly
+```
+
+**Record what you did NOT find and could not reach** — a paywalled venue, a dead repo link, a search that
+returned nothing. The next sweep starts from that, and "nothing found" is only useful if it says where
+you looked.
+
+---
+
+## Step 8 — record the verdict
+
+🔴 LAST step, once the deliverable exists:
+
+```
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record map-prior-work <paper-dir> FINDING <count> <report-path>
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record map-prior-work <paper-dir> ABSTAINED <reason> "<one line>"
+```
+
+**FINDING** — `<count>` is the number of rivals triaged 🔴 or 🟠 (they threaten the claim),
+`<report-path>` is the sweep file. Add `--blocking` when a rival did the contribution first and the
+claim has to change.
+**ABSTAINED** — `no-witness`: swept, and nothing found threatens what you claim. `blocked`: the
+paper has no stated contribution yet, so there is nothing to sweep against.
+
+That blocking finding is the outcome this skill was written from, discovered at T−10 days by
+accident. Recorded here it is a dated fact about the field rather than a memory of a bad night.
+
+🔴 **There is no PASS**, and this skill is where the reason is easiest to see. "Nothing threatens
+the claim" is a statement about everything that exists, made by a sweep that read a bounded list —
+so it can never be witnessed, only ever failed to be refuted. `no-witness` says that in one word,
+and the sweep's own coverage-gaps section says how far the reading actually went.
+
+## Rules
+
+- **Mark evidence level on every claim:** `[A]` full text · `[B]` abstract/metadata · `[C]` your
+  inference. The distinction between "I read this" and "I concluded this" must survive being retold —
+  it is precisely what erodes when a finding is summarized twice.
+- **Dates are facts, not judgment calls.** Record them; do not characterize a five-month-old paper as
+  concurrent because it reads better.
+- **A rival being weak does not restore your precedence.** Their evidence quality and who was first are
+  independent questions. "Second with better evidence" is an honest, publishable position; "first" when
+  you are second is what gets caught and taints the rest of the paper.
+- **Their weaknesses are your motivation, quotable from their own text.** A gap in a rival's validation
+  that you can quote justifies your section far better than any adjective.
+- **Do not delegate the claim decision.** A subagent maps; you decide what the paper claims.

package/skills/map-prior-work/SKILL.md.spec.ts

@@ -0,0 +1,227 @@
+// 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: "map-prior-work",
+  description:
+    "Sweep the competitive landscape for a paper idea BEFORE drafting — find everyone already working on it, date each against your submission (prior vs concurrent is a five-month question, not a vibe), triage by whether they threaten your claimed contribution, deep-read the ones that do, and emit a verdict on WHAT YOU CAN STILL CLAIM plus a related-work skeleton. Saves the full map, not a summary. Use right after research-ideate and before draft-paper, and re-run as a cheap delta pass before submit (hot fields move). Distinct from analyze-sibling-paper (one known competitor, deep) — this one FINDS the competitors and decides which deserve that treatment; distinct from verify-citations (checks cites you already wrote, too late to reshape a contribution); distinct from study-accepted-papers (mines a venue's bar, not your rivals). Compose with research-ideate (upstream), analyze-sibling-paper (it hands off), draft-paper and find-venue (downstream).",
+  context: "fork",
+  tools: [
+    "WebSearch",
+    "WebFetch",
+    "Read",
+    "Write",
+    "Grep",
+    "Glob",
+    "Bash",
+    "Agent",
+  ],
+  body: `
+# map-prior-work — find out who already did it, while you can still change course
+
+## Run me
+
+🔴 FIRST, before any other step:
+
+\`\`\`
+node .claude/skills/paper-pipeline/scripts/announce.mjs map-prior-work <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 expensive failure this prevents, in one sentence: **you discover the paper that already did your
+contribution after the draft is finished, when the only move left is rewriting the claim under deadline.**
+
+Grounding: the original-contribution criterion. A paper
+a reviewer reads as a repackaging earns no authorship credit even if it is accepted. Composes with
+\`research-ideate\` (upstream: it validated *whether* the idea is worth doing; this validates whether it is
+still *yours*), \`analyze-sibling-paper\` (this hands it the papers that need a full read), and
+\`draft-paper\` (which consumes the related-work skeleton).
+
+## Why this exists — the failure it was written from
+
+**Real case, 2026-07 (paper #3).** The idea was validated, the venue picked, the study run, the paper
+drafted, the artifact built. At **T−10 days** a *citation audit* — a late mechanical check, not a search —
+stumbled onto a paper that had shipped the same construction **five months earlier**, with an
+implementation matching the paper's own §6. Consequences:
+
+- The headline contribution had to be rewritten under deadline.
+- The related-work section had described that paper **incorrectly**, in exactly the direction that made
+  room for the claimed novelty — the reading a reviewer punishes hardest.
+- Two more neighbors then had to be read in one night, and one of them overturned a second claim.
+
+None of that was bad luck. **No unit of work in the pipeline was responsible for looking.**
+\`verify-citations\` surfaces neighbors, but it is a CONTINUOUS check over cites **already written** —
+it fires after the draft exists, and it can only see what you already decided to cite. This skill is
+the work that was missing.
+
+## Two modes, and they live in different parts of the pipeline
+
+This skill is deliberately **not one thing in one place**. It has two modes, and the scorecard
+(\`paper-pipeline/references/pipeline-status-template.md\`) gives them two separate rows, because a
+green sweep from month one says nothing about the field today.
+
+| Mode | Where it lives | Scorecard row | When it fires |
+|---|---|---|---|
+| **SETUP sweep** (the full thing below) | SETUP, right after \`research-ideate\` says go | **\`priorwork\`** | Once, before any drafting. Cheapest moment — the contribution is still a sentence, not a structure. |
+| **CONTINUOUS delta** (re-sweep, restricted to work posted since) | CONTINUOUS — a trigger, never "done" | **\`priordelta\`** | **Whenever the contribution's framing moves**, and again before \`harden-paper\`. In a hot area a two-month-old sweep is stale. |
+
+Also fires **reactively** in delta mode: a reviewer says "this was already done", an arXiv alert
+surfaces something close, or a \`verify-citations\` run turns up a neighbor you had never seen.
+
+⚠️ **If a rival first surfaces during citation checking, the SETUP sweep (\`priorwork\`) was skipped** — and
+you are now reshaping the contribution under deadline, which is exactly the failure above. Treat that
+as a finding about the process, not only about the rival.
+
+*The two modes used to be one entry in a numbered stage list, which could only show one of them; that
+list was replaced on 2026-08-03 by the four kinds of work in \`paper-pipeline\`.*
+
+---
+
+## Step 1 — write down what you are claiming, before searching
+
+One sentence, falsifiable, in the form: **"We are first to ___."** Then split it:
+
+| Layer | Example | Who can take it |
+|---|---|---|
+| **Construction** | "compile prose rules into executable checks" | anyone who built it first, *regardless of quality* |
+| **Measurement** | "measure how often stated rules are enforced in real repos" | anyone with the same corpus study |
+| **Guarantee** | "abstain unless the synthesized checker survives a blind gold set" | anyone with the same decision procedure |
+
+🔴 **These are lost independently.** Losing the construction does not lose the guarantee. Write all three
+down *now* — otherwise a single hit feels like total loss and you rewrite more than you must.
+
+## Step 2 — sweep, from multiple angles
+
+Do not run one query. Run **at least five angles**, because a neighbor that uses different vocabulary is
+exactly the one you will miss:
+
+1. **Your own terms** — the phrasing you use in the claim.
+2. **Their likely terms** — what would a group from a different subfield call this? (Same idea travels as
+   "policy", "constraint", "specification", "guardrail", "contract", "config".)
+3. **By artifact** — the thing you built, not the idea (tool names, file formats, benchmark names).
+4. **By venue** — recent proceedings of the venues you'd submit to, and their workshops.
+5. **By citation graph** — who cites the 2–3 works you consider closest, and what those works cite.
+
+Sources, in order of reliability: **arXiv listings + full-text search · ACL Anthology · DBLP · Semantic
+Scholar · venue proceedings pages · OpenReview**. Blogs and social posts count as leads, never as
+findings.
+
+**Parallelize.** One subagent per angle, each returning candidates with title, authors, venue, date, and
+two sentences on what it does. Deduplicate afterwards in plain code, not by another agent.
+
+## Step 3 — date everything against YOUR submission date
+
+For each candidate record **v1 date**, latest revision, and acceptance status.
+
+| Gap to your submission | Status | What you may write |
+|---|---|---|
+| Published **before** by more than ~3 months | **prior work** | Cite it. You may not call it concurrent. |
+| Within roughly ±3 months | **concurrent** | "independently and concurrently" is defensible — say so explicitly |
+| After your submission | not your problem | ignore for this cycle; note for the extension |
+
+🔴 **Five months is prior work, not concurrent.** Wanting it to be concurrent does not make it so, and a
+reviewer checks the arXiv date in one click. Also record **acceptance**: a preprint and a paper accepted
+at a real venue carry different weight, and describing an *accepted* work incorrectly costs more.
+
+## Step 4 — triage against the three layers
+
+For each candidate, mark which layer it threatens:
+
+| Verdict | Meaning | Action |
+|---|---|---|
+| 🔴 **SCOOPED** | takes a layer outright | that layer is gone — reshape the claim **now**, while it's cheap |
+| 🟠 **OVERLAP** | same territory, different question or method | must be read in full and positioned precisely |
+| 🟡 **ADJACENT** | cited for context, threatens nothing | one accurate sentence in related work |
+| ⚪ **IRRELEVANT** | surfaced by the sweep, doesn't apply | list it anyway, so the next sweep doesn't re-litigate |
+
+## Step 5 — deep-read everything 🔴 and 🟠 — hand off to \`analyze-sibling-paper\`
+
+**Never triage a close paper from its abstract.** Two abstracts in the real case above were actively
+misleading:
+
+- one made a *constructive* system read as a measurement tool (the word its title implies appears **zero
+  times** in its body);
+- another **omitted its matched-pair design**, so a check based on the abstract concluded "no present/absent
+  control" when the full text has one, with real effect sizes in a table.
+
+Both errors pointed the same way: **toward believing we were more novel than we were, or that a rival was
+weaker than it was.** Read the paper.
+
+**Formulate the read as refutation:** *"try to show this scoops us."* A clean negative is a valid result;
+a confirmation you did not try to break is not.
+
+## Step 6 — the output that matters: what you can still claim
+
+Do not stop at a list of papers. The deliverable is a **verdict on the claim**:
+
+- ✅ **HOLDS** — the sentence from Step 1 survives as written.
+- ⚠️ **HOLDS NARROWED** — give the exact replacement sentence, ready to paste.
+- 🔴 **DOES NOT HOLD** — say which layer is gone and what remains. If nothing remains, say that: killing
+  an idea at sweep stage costs days, killing it at review stage costs a cycle.
+
+Plus a **related-work skeleton**: for each 🔴/🟠, two to four sentences in English, correct about *them*
+first and about your delta second. Correctness about the rival is the load-bearing half — a reviewer who
+knows the work reads a wrong description as a stretch, and that contaminates trust in your measurements.
+
+## Step 7 — save the map, not a summary
+
+Per \`../../CLAUDE.md\` (research is recorded verbatim, in detail):
+
+\`\`\`
+<papers-root>/<paper>/siblings/
+├── README.md                      # index: table of every candidate + verdict + what's unread
+├── <date>-<name>.md               # one file per deep-read (analyze-sibling-paper's output)
+└── <date>-sweep.md                # the sweep itself: queries run, sources hit, candidates
+                                   # dropped and WHY, coverage gaps stated honestly
+\`\`\`
+
+**Record what you did NOT find and could not reach** — a paywalled venue, a dead repo link, a search that
+returned nothing. The next sweep starts from that, and "nothing found" is only useful if it says where
+you looked.
+
+---
+
+## Step 8 — record the verdict
+
+🔴 LAST step, once the deliverable exists:
+
+\`\`\`
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record map-prior-work <paper-dir> FINDING <count> <report-path>
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record map-prior-work <paper-dir> ABSTAINED <reason> "<one line>"
+\`\`\`
+
+**FINDING** — \`<count>\` is the number of rivals triaged 🔴 or 🟠 (they threaten the claim),
+\`<report-path>\` is the sweep file. Add \`--blocking\` when a rival did the contribution first and the
+claim has to change.
+**ABSTAINED** — \`no-witness\`: swept, and nothing found threatens what you claim. \`blocked\`: the
+paper has no stated contribution yet, so there is nothing to sweep against.
+
+That blocking finding is the outcome this skill was written from, discovered at T−10 days by
+accident. Recorded here it is a dated fact about the field rather than a memory of a bad night.
+
+🔴 **There is no PASS**, and this skill is where the reason is easiest to see. "Nothing threatens
+the claim" is a statement about everything that exists, made by a sweep that read a bounded list —
+so it can never be witnessed, only ever failed to be refuted. \`no-witness\` says that in one word,
+and the sweep's own coverage-gaps section says how far the reading actually went.
+
+## Rules
+
+- **Mark evidence level on every claim:** \`[A]\` full text · \`[B]\` abstract/metadata · \`[C]\` your
+  inference. The distinction between "I read this" and "I concluded this" must survive being retold —
+  it is precisely what erodes when a finding is summarized twice.
+- **Dates are facts, not judgment calls.** Record them; do not characterize a five-month-old paper as
+  concurrent because it reads better.
+- **A rival being weak does not restore your precedence.** Their evidence quality and who was first are
+  independent questions. "Second with better evidence" is an honest, publishable position; "first" when
+  you are second is what gets caught and taints the rest of the paper.
+- **Their weaknesses are your motivation, quotable from their own text.** A gap in a rival's validation
+  that you can quote justifies your section far better than any adjective.
+- **Do not delegate the claim decision.** A subagent maps; you decide what the paper claims.`,
+});

package/skills/map-prior-work/map-prior-work.eval.mjs

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

package/skills/map-prior-work/map-prior-work.harness.mjs

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

package/skills/osf-artifact-upload/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: osf-artifact-upload
+description: Upload or replace a paper's reproduction artifact file on an OSF project via the OSF API — for anonymized/view-only artifacts hosted for peer review (AISec/AgenticDev etc.). Use when a paper's OSF-hosted artifact needs a file added or a new version pushed (e.g. after fixing the artifact README or regenerating artifact.zip), and the OSF web UI is inconvenient. Composes with submit-paper / submit-paper-<venue>.
+allowed-tools: [Read, Write, Grep, Glob, Bash]
+---
+
+<!-- vigiles:sha256:334c907233abc97c compiled from skills/osf-artifact-upload/SKILL.md.spec.ts -->
+
+# osf-artifact-upload — push/replace a file on an OSF project via API
+
+Verified working 2026-07-18 (replaced `artifact.zip` on the node of a real submission's artifact).
+
+## Prereq — an OSF personal access token
+- Create at **osf.io/settings/tokens** → scope **`osf.full_write`** (read-only cannot write). Shown once.
+- Put it in the env as `OSF_TOKEN` for the session, OR the user pastes it. **NEVER commit it, never echo it,
+  never write it into a file or the skill.** Remind the user to **revoke it** after the upload.
+- ⚠️ Note: a token stored as a gzipped/base64 blob in some other env var may be **blocked from decoding by
+  the auto-mode classifier** (correctly). Don't fight it — ask for a fresh `osf.full_write` token instead.
+
+## Gotchas learned (bake these in)
+- **curl globbing:** OSF API URLs with `[ ]` (e.g. `?page[size]=50`) make curl fail silently (empty body,
+  no status). Always use **`curl -g`** (disable globbing) or drop the bracketed param.
+- **Flaky proxy:** calls intermittently return 0 bytes / empty. **Retry** (loop until valid JSON;
+  `--retry 3`). Verify by API metadata, not only by the waterbutler download (download-back flakes most).
+- **CA bundle:** in this env, add `--cacert /root/.ccr/ca-bundle.crt` to every curl.
+- **Node GUID:** the `osf.io/<guid>` in the paper's Availability (a five-character guid, e.g. `ab12c`) IS the node id; the
+  `?view_only=…` is a separate anonymized link. With the owner token you address the node by its guid.
+- **`set +x`** and keep the token only in a shell variable — never in printed output.
+
+## Recipe (all curl; `$T`=token, `$CA`=/root/.ccr/ca-bundle.crt, `$NODE`=guid, `$ZIP`=local file)
+```bash
+set +x; CA=/root/.ccr/ca-bundle.crt; T="$OSF_TOKEN"; AUTH="Authorization: Bearer $T"; NODE=<guid>   # the node from YOUR paper's Availability line
+# 1. verify auth (expect HTTP 200 + your name)
+curl -g -s --retry 3 --cacert $CA -H "$AUTH" https://api.osf.io/v2/users/me/ \
+  | python3 -c "import sys,json;d=json.load(sys.stdin);print('auth:',d['data']['attributes']['full_name'])"
+# 2. list osfstorage files → each file's links.upload is its waterbutler URL (for a NEW VERSION)
+curl -g -s --retry 3 --cacert $CA -H "$AUTH" "https://api.osf.io/v2/nodes/$NODE/files/osfstorage/" >/tmp/f.json
+#    parse: find the target file's attributes.name==X → f['links']['upload']  (call it $UP)
+#    to ADD a new file instead: use the folder's upload link from /v2/nodes/$NODE/files/ (osfstorage provider)
+# 3. push new version (PUT the bytes; append kind=file)
+curl -g -s --retry 3 --cacert $CA -H "$AUTH" -X PUT --data-binary @"$ZIP" "${UP}?kind=file" -o /tmp/up.json
+#    success = HTTP 200 + data.attributes.extra.version incremented + size matches
+# 4. VERIFY by API metadata: re-list files, confirm attributes.size and extra.hashes.md5 == md5sum of $ZIP
+```
+Verification that actually holds: **OSF-stored md5 == `md5sum $ZIP`**. The upload response also returns the
+md5; matching it to the local file is proof even when the download-back call flakes.
+
+## After
+- Confirm the paper's Availability `\url{}` still points at the same node (it does — same guid).
+- Tell the user to **revoke the token** (osf.io/settings/tokens → Delete).
+- If the artifact is stored unpacked (README.md, reproduce.py, data/…) rather than as a zip, replace each
+  stale file the same way (each has its own `links.upload`).

package/skills/osf-artifact-upload/SKILL.md.spec.ts

@@ -0,0 +1,59 @@
+// 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: "osf-artifact-upload",
+  description:
+    "Upload or replace a paper's reproduction artifact file on an OSF project via the OSF API — for anonymized/view-only artifacts hosted for peer review (AISec/AgenticDev etc.). Use when a paper's OSF-hosted artifact needs a file added or a new version pushed (e.g. after fixing the artifact README or regenerating artifact.zip), and the OSF web UI is inconvenient. Composes with submit-paper / submit-paper-<venue>.",
+  tools: ["Read", "Write", "Grep", "Glob", "Bash"],
+  body: `
+# osf-artifact-upload — push/replace a file on an OSF project via API
+
+Verified working 2026-07-18 (replaced \`artifact.zip\` on the node of a real submission's artifact).
+
+## Prereq — an OSF personal access token
+- Create at **osf.io/settings/tokens** → scope **\`osf.full_write\`** (read-only cannot write). Shown once.
+- Put it in the env as \`OSF_TOKEN\` for the session, OR the user pastes it. **NEVER commit it, never echo it,
+  never write it into a file or the skill.** Remind the user to **revoke it** after the upload.
+- ⚠️ Note: a token stored as a gzipped/base64 blob in some other env var may be **blocked from decoding by
+  the auto-mode classifier** (correctly). Don't fight it — ask for a fresh \`osf.full_write\` token instead.
+
+## Gotchas learned (bake these in)
+- **curl globbing:** OSF API URLs with \`[ ]\` (e.g. \`?page[size]=50\`) make curl fail silently (empty body,
+  no status). Always use **\`curl -g\`** (disable globbing) or drop the bracketed param.
+- **Flaky proxy:** calls intermittently return 0 bytes / empty. **Retry** (loop until valid JSON;
+  \`--retry 3\`). Verify by API metadata, not only by the waterbutler download (download-back flakes most).
+- **CA bundle:** in this env, add \`--cacert /root/.ccr/ca-bundle.crt\` to every curl.
+- **Node GUID:** the \`osf.io/<guid>\` in the paper's Availability (a five-character guid, e.g. \`ab12c\`) IS the node id; the
+  \`?view_only=…\` is a separate anonymized link. With the owner token you address the node by its guid.
+- **\`set +x\`** and keep the token only in a shell variable — never in printed output.
+
+## Recipe (all curl; \`$T\`=token, \`$CA\`=/root/.ccr/ca-bundle.crt, \`$NODE\`=guid, \`$ZIP\`=local file)
+\`\`\`bash
+set +x; CA=/root/.ccr/ca-bundle.crt; T="$OSF_TOKEN"; AUTH="Authorization: Bearer $T"; NODE=<guid>   # the node from YOUR paper's Availability line
+# 1. verify auth (expect HTTP 200 + your name)
+curl -g -s --retry 3 --cacert $CA -H "$AUTH" https://api.osf.io/v2/users/me/ \\
+  | python3 -c "import sys,json;d=json.load(sys.stdin);print('auth:',d['data']['attributes']['full_name'])"
+# 2. list osfstorage files → each file's links.upload is its waterbutler URL (for a NEW VERSION)
+curl -g -s --retry 3 --cacert $CA -H "$AUTH" "https://api.osf.io/v2/nodes/$NODE/files/osfstorage/" >/tmp/f.json
+#    parse: find the target file's attributes.name==X → f['links']['upload']  (call it $UP)
+#    to ADD a new file instead: use the folder's upload link from /v2/nodes/$NODE/files/ (osfstorage provider)
+# 3. push new version (PUT the bytes; append kind=file)
+curl -g -s --retry 3 --cacert $CA -H "$AUTH" -X PUT --data-binary @"$ZIP" "\${UP}?kind=file" -o /tmp/up.json
+#    success = HTTP 200 + data.attributes.extra.version incremented + size matches
+# 4. VERIFY by API metadata: re-list files, confirm attributes.size and extra.hashes.md5 == md5sum of $ZIP
+\`\`\`
+Verification that actually holds: **OSF-stored md5 == \`md5sum $ZIP\`**. The upload response also returns the
+md5; matching it to the local file is proof even when the download-back call flakes.
+
+## After
+- Confirm the paper's Availability \`\\url{}\` still points at the same node (it does — same guid).
+- Tell the user to **revoke the token** (osf.io/settings/tokens → Delete).
+- If the artifact is stored unpacked (README.md, reproduce.py, data/…) rather than as a zip, replace each
+  stale file the same way (each has its own \`links.upload\`).`,
+});

package/skills/osf-artifact-upload/osf-artifact-upload.eval.mjs

@@ -0,0 +1,22 @@
+/**
+ * osf-artifact-upload — 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 every case is
+ * 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.
+ *
+ * ⚠️ NEVER RUN. This case was written 2026-08-11 with the other two the coverage
+ * sweep surfaced; its rate is UNKNOWN, not assumed good.
+ *
+ * Costs money; not CI.
+ *   node .claude/skills/osf-artifact-upload/osf-artifact-upload.eval.mjs [trials]
+ */
+import { runSkillTriggerEval } from "../../lib/skill-eval-kit.mjs";
+
+await runSkillTriggerEval("osf-artifact-upload");