paperlint 2.0.0

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

@@ -0,0 +1,103 @@
+/**
+ * osf-artifact-upload — the free, deterministic tier. No model, no network, no OSF.
+ *
+ * WHY THIS ONE IS NOT A `checkSkill()` ONE-LINER. It carries no
+ * `announce.mjs <self>` line, so by the pipeline's own membership contract it is
+ * not a stage — it is a utility `submit-paper` composes with, and the shared
+ * per-skill checks would (correctly) reject it.
+ *
+ * WHAT IT CHECKS: the two rules this skill states about its OWN commands, in its
+ * own §gotchas — that every `curl` carries `-g` (bracketed OSF params glob and
+ * the request fails SILENTLY: empty body, no status) and `--cacert` (this
+ * environment's proxy). The rule and its violation would live in the same file
+ * three paragraphs apart, with nothing comparing them. That is `prose isn't
+ * policy` at its smallest, applied to us.
+ *
+ * 🔴 THIS FILE WAS ~100 LINES ON 2026-08-11 AND IS NOW ~30. The difference is not
+ * cleverness, it is that the parsing moved into vigiles (`commandsIn` /
+ * `mustInclude`, shipped the same day for this reason). What remains is the rule
+ * itself. That is the whole test of "mechanism in vigiles, data here": the
+ * markdown parsing, the prose-vs-command distinction and the message formatting
+ * are the same for anyone; the flags are ours.
+ *
+ * What it does NOT prove: that an upload works. That needs a live OSF project
+ * and a real token, deliberately out of scope.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+// ⚠️ `commandsIn`/`mustInclude` shipped AFTER vigiles 15.0.2. A test that simply
+// threw on the import would read as "this skill is broken"; the honest state is
+// "the check exists and its library is not here yet", so it SKIPS with exit 77 —
+// the documented convention, which the runner surfaces as a loud ⊘ rather than a
+// silent ✓. The guard stays even though 16.0.1 ships all three: it is what turns a
+// future removal into a legible message instead of a stack trace.
+//
+// The subpath was `vigiles/testing` until v16 split the exports BY COST (#149) —
+// free deterministic testing is now the root barrel, and anything that spends money
+// lives in `vigiles/eval` behind a `paid_` prefix. These three are free.
+const testing = await import("vigiles");
+const { commandsIn, mustInclude, mustNotInclude, assertChecks, recordCheck } =
+  testing;
+if (typeof commandsIn !== "function") {
+  console.log(
+    "⊘ SKIP osf-artifact-upload: needs `commandsIn`/`mustInclude` from vigiles " +
+      "(newer than the installed 15.0.2). The rules below are the test; only the " +
+      "library that evaluates them is missing.",
+  );
+  process.exit(77);
+}
+
+const src = readFileSync(
+  join(dirname(fileURLToPath(import.meta.url)), "SKILL.md"),
+  "utf-8",
+);
+const curls = commandsIn(src, /(^|[|;&]\s*)curl\b/);
+
+assertChecks(curls, [
+  mustInclude(
+    "-g",
+    "the skill's own §gotchas: bracketed OSF params (?page[size]=50) glob and the " +
+      "request fails SILENTLY — empty body, no status code. Silent is why this is " +
+      "asserted rather than trusted.",
+  ),
+  mustInclude(
+    "--cacert",
+    "the skill's own §gotchas: this environment's proxy needs the CA bundle on every curl.",
+  ),
+  // Not stated in the file, and it should never need to be: this skill sends an
+  // OSF bearer token, so an example that disabled TLS verification would teach
+  // the agent to leak it on any hostile network.
+  mustNotInclude(
+    "-k",
+    "this skill sends a bearer token; -k/--insecure disables verification and hands it to any proxy.",
+  ),
+]);
+
+// The token check has no home in the command vocabulary — it is about the file's
+// prose, not its commands. The skill's own instruction is "NEVER commit it,
+// never echo it", and this file IS committed.
+const literal = /\b[0-9a-fA-F]{40,}\b/.exec(src);
+if (literal)
+  throw new Error(
+    `a literal credential-shaped string is present (${literal[0].slice(0, 12)}…). ` +
+      `This skill's own text says "NEVER commit it, never echo it".`,
+  );
+
+// 🔴 WITHOUT THIS THE RUNNER READS THIS FILE AS DOING NOTHING, and says so:
+// `∅ 0 CHECKS (it ran clean and verified nothing)` — and exits 1 on it, which is
+// the whole job red. Everything above DOES assert; it just asserts through
+// `assertChecks` and a thrown Error, neither of which increments the counter the
+// runner reads. So the file was simultaneously the strictest thing here (it is the
+// only guard standing between a bearer token and `-k`) and the reason CI was red.
+//
+// `recordCheck` exists for exactly this — its own doc says to call it "when you
+// assert some OTHER way … instead of leaving it to conclude the file did nothing".
+// Counted, not guessed: three command properties (-g, --cacert, no -k) across the
+// curls, plus the one credential check over the file.
+recordCheck(3 * curls.length + 1);
+
+console.log(
+  `✓ osf-artifact-upload: ${String(curls.length)} curl command(s) carry -g and --cacert, ` +
+    `none disable TLS, no pasted credential`,
+);

package/skills/paper-adversarial-review/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: paper-adversarial-review
+description: Use when asking "red-team this paper" / "what would Reviewer 2 attack?" / "find the weaknesses before I submit" — ONE fast hostile-but-fair review of a paper draft. Surfaces overclaims, methodology holes, missing baselines/citations, novelty concerns, threats to validity, and desk-reject risks, with concrete fixes, led by a multi-axis 1–5 scorecard whose card composes into a pc-panel-review panel. NOT the multi-reviewer accept/reject decision (pc-panel-review), a writing grade (grade-paper-writing — this skill consumes its stall inventory rather than re-grading prose), or the full pre-submit gate (harden-paper). Especially for security and agentic-coding measurement papers.
+context: fork
+allowed-tools: [Read, Write, Grep, Glob, Agent, Skill, Bash(node .claude/skills/paper-pipeline/scripts/announce.mjs:*), Bash(node .claude/skills/paper-pipeline/scripts/ledger.mjs:*)]
+---
+
+<!-- vigiles:sha256:2da081a03ae7fee3 compiled from skills/paper-adversarial-review/SKILL.md.spec.ts -->
+
+# paper-adversarial-review — be the reviewer who wants to reject it
+
+> **Which review skill?** `paper-adversarial-review` (you are here) = one hostile reviewer, fast defect
+> hunt. `pc-panel-review` = the whole PC (N independent lenses incl. an artifact-runner) + a chair
+> meta-review — the real pre-submission GATE, run LAST; its **venue-fit mode** is the one-reviewer
+> CFP-fit score (formerly `venue-review-sim`). Reach for an atom (this, or venue-fit mode) for a quick
+> spot-check; run the panel for the decision.
+
+## Run me
+
+🔴 FIRST, before any other step:
+
+```
+node .claude/skills/paper-pipeline/scripts/announce.mjs paper-adversarial-review <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.
+
+Purpose: catch what a real peer reviewer will hit, while it's still fixable. Peer review is
+**read, not run** — reviewers judge the *text, figures, and reported numbers*, rarely execute code.
+So the paper must be self-contained and airtight on its face. This skill simulates the skeptical
+reviewer and returns an actionable critique.
+
+## How to run it
+Prefer a **separate model as the reviewer** (e.g. Fable via a subagent) so it's not the author
+grading itself. Give the reviewer the full paper text (Read the `.tex`/`.md`/PDF) and the target
+venue + paper type (short/full/position/benchmark). Ask for the structured output below.
+
+## The review must cover (ranked by how often it kills a paper)
+
+1. **"So what / is this enough?" (contribution & novelty).** State the single contribution in one
+   sentence. Is it enough for *this venue and paper type*? Distinguish: a **methodology/benchmark**
+   contribution (a reusable way to measure X) vs a **result** ("tool Y is bad") — the former survives
+   review, the latter reads as a blog post. If the paper is really "X doesn't work," is the
+   *method/finding* generalizable beyond the one target? Name the weakest framing and the strongest
+   available reframing.
+2. **Overclaims.** Every sentence stronger than the evidence. Hunt for: absolutes, causal claims from
+   correlational data, "always/never," headline numbers not backed by the reported stats, a title that
+   promises more than the body delivers. For each hit, propose the fix by the **review-ratchet rule** —
+   tighten → cut → move to Threats → only then inline-hedge, and run `tighten-paper` after the round to
+   strip what it deposited. Full rule: `paper-pipeline/references/review-ratchet.md`.
+3. **Methodology holes a reviewer will poke.** Missing baseline, sample size / power, confounds,
+   cherry-picked tasks, unfair comparison, statistics misused (n, variance, multiple comparisons),
+   reproducibility gaps. For measurement papers: construct validity — are you measuring what you claim?
+4. **Threats to validity — are they honest and complete?** What did the authors *not* list that a
+   reviewer will? Adaptive attackers, generalization, single-model/single-dataset, convenience sample.
+5. **Related work gaps.** What obvious prior work is uncited? Would a reviewer say "this was already
+   done by ___"? Is the delta over the nearest neighbor explicit?
+6. **Presentation / desk-reject risks.** Over/under length, format (ACM/IEEE), anonymization for
+   double-blind (self-citations, repo links, "our tool X" naming that de-anonymizes), figures
+   unreadable, tables inconsistent with text, TMI/self-indulgent passages that waste a short paper's
+   space.
+6b. **Readability's implicit drag (the halo effect) — CONSUME the persona inventory, don't re-run the
+   pass.** A reviewer who finds the paper a slog loses confidence in the *science* and marks it down
+   overall, usually citing "methodology" rather than "writing." This skill's unique job here is to model
+   that drag on the OVERALL score — NOT to judge readability by its own read: a frontier reviewer knows
+   every term and cannot experience reader fatigue, so an inline cold-read (no persona, no per-section
+   chunking, no mechanical triggers, no hard caps) systematically under-fires — exactly the config that
+   once waved a bloated paper through. Take `grade-paper-writing`'s PERSONA stall inventory + scorecard
+   as the input — **if none exists for this draft, spawn `grade-paper-writing` first** — and state how
+   much the writing, per that inventory (stall density, walls, spec-sheet paragraphs), would drag a
+   real reviewer's overall score. Bad writing is a silent score-killer, not just a desk-reject flag.
+7. **Ethics / responsible-disclosure / tone** (security & measurement papers). Naming small hobbyist
+   projects as "insecure/broken" = punching down + disclosure risk → prefer aggregate stats + one
+   representative named example. Dunk on the *claim*, credit the *humans*. Flag any hater-tone.
+
+## Output format
+- **Scorecard (lead with this) — every axis, 1–5, one-line why each.** A graded card, not just prose, so
+  a weak axis is visible at a glance (e.g. "Readability 2/5 — abstract is a stat-wall, point arrives on
+  p.3"). Score all of: **Novelty/contribution · Technical rigor/methodology · Evidence strength** (stats,
+  sample size, baselines; for security: adaptive-attacker eval + threat model) **· Positioning/related
+  work** (delta over nearest neighbor) **· Readability/prose** (pull from `grade-paper-writing`'s rubric)
+  **· Reproducibility/artifact · Honesty/claim-scoping** (overclaim vs hedged) **· Presentation/desk-reject
+  risk**. End with an **Overall 1–5**. Keep the same 1–5 scale the other skills use so cards compose into a
+  `pc-panel-review` panel; the lowest 1–2 axes are the real story, not the average.
+- **Verdict leaning:** (strong accept / weak accept / borderline / weak reject / reject) + one-line why.
+- **The one contribution, in one sentence** (as a reviewer would paraphrase it — often less than the authors think).
+- **Top 5 weaknesses, ranked**, each: the attack (how a reviewer phrases it) → severity → concrete fix.
+- **Line/section-level nits** (overclaims, TMI, inconsistencies) as a checklist.
+- **Missing citations** (specific, real — do not invent).
+- **Strongest reframing** if the contribution is undersold or misframed.
+- **What to cut** (for length / TMI) and **what to add** (for soundness).
+
+## Record the verdict
+
+🔴 LAST step, once the deliverable exists:
+
+```
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record paper-adversarial-review <paper-dir> FINDING <count> <report-path>
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record paper-adversarial-review <paper-dir> ABSTAINED <reason> "<one line>"
+```
+
+**FINDING** — `<count>` is the number of ranked weaknesses, `<report-path>` the review with its
+scorecard. Add `--blocking` when the leaning is reject, or there is a live desk-reject risk.
+**ABSTAINED** — `no-witness`: the hostile read found nothing. `blocked`: there was no rendered
+draft to attack.
+
+🔴 **There is no PASS, and this skill is the reason the word was dangerous.** A hostile read that
+found nothing either met a very good paper or was not hostile, and the old vocabulary wrote the
+same word for both. `no-witness` says the true thing — this reader has no witness for the paper
+being sound — and leaves the second possibility standing where it belongs, in view.
+
+Record the weakness count, not the Overall 1–5. The average is exactly what this skill tells its own
+reviewer to distrust — the lowest one or two axes are the story.
+
+## Rules
+- Be adversarial but *fair* and *specific* — "weak" is useless; "the 65% claim in the abstract isn't
+  supported because the pooled bill is −1%, reword to X" is useful.
+- Do **not** fabricate citations or facts. If unsure a paper exists, say "verify."
+- Undersell nothing to spare feelings; the point is to fail it now, not at the venue.
+- If the paper is genuinely strong, say so — don't manufacture problems.
+
+## Compose with
+- `grade-paper-writing` — the Readability/prose axis of the scorecard defers to its 9-dim rubric; run it for the sentence-level fixes behind a low readability score.
+- `pc-panel-review` — this atom's scorecard is one reviewer's card; the panel aggregates N of them (same 1–5 scale) into the decision.
+- The venue CFP (fit/format). Prose QA for papers routes to `grade-paper-writing` + `paper-pipeline/references/writing-craft.md` — NOT the site repo's `writing-quality` / `audience-test` skills (those are for blog posts only; the paper suite's persona pass supersedes them here).

package/skills/paper-adversarial-review/SKILL.md.spec.ts

@@ -0,0 +1,142 @@
+// 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: "paper-adversarial-review",
+  description:
+    'Use when asking "red-team this paper" / "what would Reviewer 2 attack?" / "find the weaknesses before I submit" — ONE fast hostile-but-fair review of a paper draft. Surfaces overclaims, methodology holes, missing baselines/citations, novelty concerns, threats to validity, and desk-reject risks, with concrete fixes, led by a multi-axis 1–5 scorecard whose card composes into a pc-panel-review panel. NOT the multi-reviewer accept/reject decision (pc-panel-review), a writing grade (grade-paper-writing — this skill consumes its stall inventory rather than re-grading prose), or the full pre-submit gate (harden-paper). Especially for security and agentic-coding measurement papers.',
+  context: "fork",
+  tools: [
+    "Read",
+    "Write",
+    "Grep",
+    "Glob",
+    "Agent",
+    "Skill",
+    "Bash(node .claude/skills/paper-pipeline/scripts/announce.mjs:*)",
+    "Bash(node .claude/skills/paper-pipeline/scripts/ledger.mjs:*)",
+  ],
+  body: `
+# paper-adversarial-review — be the reviewer who wants to reject it
+
+> **Which review skill?** \`paper-adversarial-review\` (you are here) = one hostile reviewer, fast defect
+> hunt. \`pc-panel-review\` = the whole PC (N independent lenses incl. an artifact-runner) + a chair
+> meta-review — the real pre-submission GATE, run LAST; its **venue-fit mode** is the one-reviewer
+> CFP-fit score (formerly \`venue-review-sim\`). Reach for an atom (this, or venue-fit mode) for a quick
+> spot-check; run the panel for the decision.
+
+## Run me
+
+🔴 FIRST, before any other step:
+
+\`\`\`
+node .claude/skills/paper-pipeline/scripts/announce.mjs paper-adversarial-review <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.
+
+Purpose: catch what a real peer reviewer will hit, while it's still fixable. Peer review is
+**read, not run** — reviewers judge the *text, figures, and reported numbers*, rarely execute code.
+So the paper must be self-contained and airtight on its face. This skill simulates the skeptical
+reviewer and returns an actionable critique.
+
+## How to run it
+Prefer a **separate model as the reviewer** (e.g. Fable via a subagent) so it's not the author
+grading itself. Give the reviewer the full paper text (Read the \`.tex\`/\`.md\`/PDF) and the target
+venue + paper type (short/full/position/benchmark). Ask for the structured output below.
+
+## The review must cover (ranked by how often it kills a paper)
+
+1. **"So what / is this enough?" (contribution & novelty).** State the single contribution in one
+   sentence. Is it enough for *this venue and paper type*? Distinguish: a **methodology/benchmark**
+   contribution (a reusable way to measure X) vs a **result** ("tool Y is bad") — the former survives
+   review, the latter reads as a blog post. If the paper is really "X doesn't work," is the
+   *method/finding* generalizable beyond the one target? Name the weakest framing and the strongest
+   available reframing.
+2. **Overclaims.** Every sentence stronger than the evidence. Hunt for: absolutes, causal claims from
+   correlational data, "always/never," headline numbers not backed by the reported stats, a title that
+   promises more than the body delivers. For each hit, propose the fix by the **review-ratchet rule** —
+   tighten → cut → move to Threats → only then inline-hedge, and run \`tighten-paper\` after the round to
+   strip what it deposited. Full rule: \`paper-pipeline/references/review-ratchet.md\`.
+3. **Methodology holes a reviewer will poke.** Missing baseline, sample size / power, confounds,
+   cherry-picked tasks, unfair comparison, statistics misused (n, variance, multiple comparisons),
+   reproducibility gaps. For measurement papers: construct validity — are you measuring what you claim?
+4. **Threats to validity — are they honest and complete?** What did the authors *not* list that a
+   reviewer will? Adaptive attackers, generalization, single-model/single-dataset, convenience sample.
+5. **Related work gaps.** What obvious prior work is uncited? Would a reviewer say "this was already
+   done by ___"? Is the delta over the nearest neighbor explicit?
+6. **Presentation / desk-reject risks.** Over/under length, format (ACM/IEEE), anonymization for
+   double-blind (self-citations, repo links, "our tool X" naming that de-anonymizes), figures
+   unreadable, tables inconsistent with text, TMI/self-indulgent passages that waste a short paper's
+   space.
+6b. **Readability's implicit drag (the halo effect) — CONSUME the persona inventory, don't re-run the
+   pass.** A reviewer who finds the paper a slog loses confidence in the *science* and marks it down
+   overall, usually citing "methodology" rather than "writing." This skill's unique job here is to model
+   that drag on the OVERALL score — NOT to judge readability by its own read: a frontier reviewer knows
+   every term and cannot experience reader fatigue, so an inline cold-read (no persona, no per-section
+   chunking, no mechanical triggers, no hard caps) systematically under-fires — exactly the config that
+   once waved a bloated paper through. Take \`grade-paper-writing\`'s PERSONA stall inventory + scorecard
+   as the input — **if none exists for this draft, spawn \`grade-paper-writing\` first** — and state how
+   much the writing, per that inventory (stall density, walls, spec-sheet paragraphs), would drag a
+   real reviewer's overall score. Bad writing is a silent score-killer, not just a desk-reject flag.
+7. **Ethics / responsible-disclosure / tone** (security & measurement papers). Naming small hobbyist
+   projects as "insecure/broken" = punching down + disclosure risk → prefer aggregate stats + one
+   representative named example. Dunk on the *claim*, credit the *humans*. Flag any hater-tone.
+
+## Output format
+- **Scorecard (lead with this) — every axis, 1–5, one-line why each.** A graded card, not just prose, so
+  a weak axis is visible at a glance (e.g. "Readability 2/5 — abstract is a stat-wall, point arrives on
+  p.3"). Score all of: **Novelty/contribution · Technical rigor/methodology · Evidence strength** (stats,
+  sample size, baselines; for security: adaptive-attacker eval + threat model) **· Positioning/related
+  work** (delta over nearest neighbor) **· Readability/prose** (pull from \`grade-paper-writing\`'s rubric)
+  **· Reproducibility/artifact · Honesty/claim-scoping** (overclaim vs hedged) **· Presentation/desk-reject
+  risk**. End with an **Overall 1–5**. Keep the same 1–5 scale the other skills use so cards compose into a
+  \`pc-panel-review\` panel; the lowest 1–2 axes are the real story, not the average.
+- **Verdict leaning:** (strong accept / weak accept / borderline / weak reject / reject) + one-line why.
+- **The one contribution, in one sentence** (as a reviewer would paraphrase it — often less than the authors think).
+- **Top 5 weaknesses, ranked**, each: the attack (how a reviewer phrases it) → severity → concrete fix.
+- **Line/section-level nits** (overclaims, TMI, inconsistencies) as a checklist.
+- **Missing citations** (specific, real — do not invent).
+- **Strongest reframing** if the contribution is undersold or misframed.
+- **What to cut** (for length / TMI) and **what to add** (for soundness).
+
+## Record the verdict
+
+🔴 LAST step, once the deliverable exists:
+
+\`\`\`
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record paper-adversarial-review <paper-dir> FINDING <count> <report-path>
+node .claude/skills/paper-pipeline/scripts/ledger.mjs record paper-adversarial-review <paper-dir> ABSTAINED <reason> "<one line>"
+\`\`\`
+
+**FINDING** — \`<count>\` is the number of ranked weaknesses, \`<report-path>\` the review with its
+scorecard. Add \`--blocking\` when the leaning is reject, or there is a live desk-reject risk.
+**ABSTAINED** — \`no-witness\`: the hostile read found nothing. \`blocked\`: there was no rendered
+draft to attack.
+
+🔴 **There is no PASS, and this skill is the reason the word was dangerous.** A hostile read that
+found nothing either met a very good paper or was not hostile, and the old vocabulary wrote the
+same word for both. \`no-witness\` says the true thing — this reader has no witness for the paper
+being sound — and leaves the second possibility standing where it belongs, in view.
+
+Record the weakness count, not the Overall 1–5. The average is exactly what this skill tells its own
+reviewer to distrust — the lowest one or two axes are the story.
+
+## Rules
+- Be adversarial but *fair* and *specific* — "weak" is useless; "the 65% claim in the abstract isn't
+  supported because the pooled bill is −1%, reword to X" is useful.
+- Do **not** fabricate citations or facts. If unsure a paper exists, say "verify."
+- Undersell nothing to spare feelings; the point is to fail it now, not at the venue.
+- If the paper is genuinely strong, say so — don't manufacture problems.
+
+## Compose with
+- \`grade-paper-writing\` — the Readability/prose axis of the scorecard defers to its 9-dim rubric; run it for the sentence-level fixes behind a low readability score.
+- \`pc-panel-review\` — this atom's scorecard is one reviewer's card; the panel aggregates N of them (same 1–5 scale) into the decision.
+- The venue CFP (fit/format). Prose QA for papers routes to \`grade-paper-writing\` + \`paper-pipeline/references/writing-craft.md\` — NOT the site repo's \`writing-quality\` / \`audience-test\` skills (those are for blog posts only; the paper suite's persona pass supersedes them here).`,
+});

package/skills/paper-adversarial-review/paper-adversarial-review.eval.mjs

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

package/skills/paper-adversarial-review/paper-adversarial-review.harness.mjs

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