paperlint 9.0.1 → 10.0.0

package/eslint-rules/prereg-coverage.ts

@@ -0,0 +1,419 @@
+/**
+ * `study/declare-sample` — a study's pre-registration says which population the paper's claim is
+ * about, what the screens between that population and the sample removed, what share of it the
+ * sample can represent, and that the author looked at the drawn units before the run.
+ *
+ * ── THE FAILURE IT PREVENTS ──────────────────────────────────────────────────────
+ * A measurement study of how language models read coding rules drew its rules from three pools,
+ * kept only the rules "judgeable from one code excerpt of at most 40 lines", restricted one pool to a
+ * classifier's "enforceable" lane, and let a model pick short excerpts. Each screen was reasonable
+ * alone; together they left a sample of crisp rules. The labeller found 93 % of the items designed as
+ * borderline clear-cut, and the rules looked nothing like the ones met in practice. A spot-check of
+ * ten items flagged it (seven of ten clear-cut) and the run went ahead: nothing in the design made
+ * anyone state what share of the population the sample covered, or which screens removed which kinds
+ * of rules. The four fields below are those statements, and this rule makes them part of the record.
+ *
+ * ── WHERE IT LOOKS ───────────────────────────────────────────────────────────────
+ * A study lives in a folder at the top of the paper's `repro/` (`repro/allowed-files-only` names the
+ * layout); `tools/` and `data/` beside them are shared, not studies. Every study folder that holds a
+ * `prereg.json` is judged; a study without one owes nothing here. The findings are reported on the paper's `PIPELINE-STATUS.md`, first line, as the other rules
+ * about a paper's folders are: `prereg.json` is not a file paperlint lints, and every paper has a
+ * status file.
+ *
+ * ── THE FIELDS ───────────────────────────────────────────────────────────────────
+ *   population    { about, source, size }            what the claim is about, where it comes from, how many
+ *   strata        { by, values }                     the one stratification the screens are counted by
+ *   screens       [{ name, removed: {value: n} }]    each screen, and what it removed per stratum value
+ *   coverage      { share, reason?, unreachable }    0–1, or null with a reason; strata it cannot reach
+ *   author_check  { who, when, units_seen, units_drawn, verdict, decision? }
+ *
+ * A pre-registration holds much more (hypotheses, arms, models, budget); every other key is the
+ * author's and is not read. The shape is `PREREG` below — a zod schema whose every field carries the
+ * text a finding gives for it — and the relations between fields that a schema of one field cannot
+ * see (`removed` keyed by the declared strata, a null share with a reason, a doubtful verdict with a
+ * decision) are `crossProblems`.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { z } from "zod";
+import type { RuleContext } from "./rule-context.ts";
+
+/**
+ * The folder of a paper that holds its studies, the folders in it that are shared rather than a
+ * study's, and the file a study pre-registers in. The first two are `repro/allowed-files-only`'s
+ * (`src/domain/repro-layout.ts`, `REPRO_DIR` and `REPRO_DIRS`), copied because a module here is
+ * compiled before `src/`; the test beside this file holds the copies equal.
+ */
+export const REPRO_DIR = "repro";
+export const SHARED_DIRS: readonly string[] = ["tools", "data"];
+export const PREREG_FILE = "prereg.json";
+const STATUS_FILE = "PIPELINE-STATUS.md";
+const PAGE =
+  "https://github.com/zernie/paperlint/blob/main/docs/rules/study/declare-sample.md";
+
+/** The one sentence every finding ends with: why the fields exist. */
+export const WHY =
+  "Why: a study once screened its sample down to rules that are easy to judge — its labeller found 93 % of the items designed as borderline clear-cut — and nothing in its design made anyone state what share of the real population the sample covered or which screens removed which kinds of units.";
+
+/** A zod error option: `what` is the text a finding gives for the field, missing or malformed. */
+const field = (
+  what: string,
+): { readonly error: (iss: { readonly input?: unknown }) => string } => ({
+  error: (iss) =>
+    iss.input === undefined
+      ? `is missing — add ${what}`
+      : `is not valid — it must be ${what}`,
+});
+
+/** Text that says something: a string with more than white space in it. */
+const text = (what: string) =>
+  z
+    .string(field(what))
+    .trim()
+    .min(1, { error: `is empty — write ${what}` });
+
+/** A whole number above 0. */
+const positive = (what: string) =>
+  z.number(field(what)).int(field(what)).positive(field(what));
+
+const POPULATION = z.object(
+  {
+    about: text(
+      "what the paper's claim is about, in the paper's own words (e.g. the rules written in agent instruction files of public repositories)",
+    ),
+    source: text(
+      "where the population's units come from — the census, crawl or registry, with its date",
+    ),
+    size: positive(
+      "the number of units in the population, a whole number above 0 (an estimate is fine; say how it was made in `source`)",
+    ),
+  },
+  field(
+    "`population`: what the paper's claim is about (`about`), where its units come from (`source`) and how many there are (`size`)",
+  ),
+);
+
+const STRATA = z.object(
+  {
+    by: text("the property the units are stratified by, e.g. rule type"),
+    values: z
+      .array(
+        text("a value of the stratum"),
+        field("the stratum's values, a list of names"),
+      )
+      .min(1, {
+        error: "is empty — list the stratum's values, at least one",
+      }),
+  },
+  field(
+    "`strata`: the property the screens are counted by (`by`, e.g. rule type) and its values (`values`)",
+  ),
+);
+
+const REMOVED_WHAT =
+  "the number of candidates the screen removed in each declared stratum value, an object {<value>: <count>} with 0 where it removed none";
+
+const SCREEN = z.object(
+  {
+    name: text(
+      "what the screen keeps, as it was applied (e.g. judgeable from one code excerpt of at most 40 lines)",
+    ),
+    removed: z.record(
+      z.string(),
+      z
+        .number(field("a count, a whole number from 0"))
+        .int(field("a count, a whole number from 0"))
+        .nonnegative(field("a count, a whole number from 0")),
+      field(REMOVED_WHAT),
+    ),
+  },
+  field("a screen: `name` and `removed`"),
+);
+
+const SCREENS = z.array(
+  SCREEN,
+  field(
+    "`screens`: one entry per screen applied between the population and the sample, each with `name` and `removed` — [] when none was",
+  ),
+);
+
+const SHARE_WHAT =
+  "the share of the population the sample can represent, a number from 0 to 1, or null with a `reason`";
+
+const COVERAGE = z.object(
+  {
+    share: z
+      .number(field(SHARE_WHAT))
+      .min(0, field(SHARE_WHAT))
+      .max(1, field(SHARE_WHAT))
+      .nullable(),
+    reason: text("why the share cannot be stated").optional(),
+    unreachable: z.array(
+      text("a stratum or kind of unit"),
+      field(
+        "the strata (or kinds of units) the sample cannot reach, a list of names — [] only when it reaches them all",
+      ),
+    ),
+  },
+  field(
+    "`coverage`: the share of the population the sample can represent (`share`, 0 to 1, or null with a `reason`) and the strata it cannot reach (`unreachable`)",
+  ),
+);
+
+/** The answers to "is this what you meet in practice?"; any but the first needs a decision. */
+export const VERDICTS = ["representative", "partly", "not-representative"];
+
+const DECISION = z.object(
+  {
+    proceed: z.boolean(
+      field("whether the study runs on this sample, true or false"),
+    ),
+    by: text("who decided"),
+    why: text("why, in a sentence"),
+  },
+  field(
+    "the decision taken after the verdict: `proceed` (true or false), `by` whom, and `why`",
+  ),
+);
+
+const AUTHOR_CHECK = z.object(
+  {
+    who: text("who looked at the drawn units (a name or a role)"),
+    when: z.iso.date(field("the date of the check, YYYY-MM-DD")),
+    units_seen: positive(
+      "how many of the drawn units — the rules or cases drawn, not the items made from them — the author looked at, a whole number above 0",
+    ),
+    units_drawn: positive("how many units the sample drew"),
+    verdict: z.enum(
+      VERDICTS,
+      field(
+        `the author's answer to "is this what you meet in practice?" — one of ${VERDICTS.join(", ")}`,
+      ),
+    ),
+    decision: DECISION.optional(),
+  },
+  field(
+    "`author_check`: who looked at the drawn units before the run (`who`), when (`when`), how many of how many (`units_seen`, `units_drawn`), and what they said (`verdict`)",
+  ),
+);
+
+/** The declaration a `prereg.json` must carry. Every other key of the file is the author's. */
+export const PREREG = z.object(
+  {
+    population: POPULATION,
+    strata: STRATA,
+    screens: SCREENS,
+    coverage: COVERAGE,
+    author_check: AUTHOR_CHECK,
+  },
+  field(
+    "a JSON object holding `population`, `strata`, `screens`, `coverage` and `author_check`",
+  ),
+);
+
+export type Prereg = z.infer<typeof PREREG>;
+
+/** A zod path as it is written in the file: `screens[0].removed.vague`. */
+export const pathText = (path: readonly PropertyKey[]): string =>
+  path
+    .map((k) => (typeof k === "number" ? `[${String(k)}]` : `.${String(k)}`))
+    .join("")
+    .replace(/^\./u, "");
+
+/** One problem: the field it is about, and what is wrong with it. */
+export interface Problem {
+  readonly at: string;
+  readonly text: string;
+}
+
+/** The values that occur more than once in `values`, each once. */
+const repeated = (values: readonly string[]): readonly string[] => [
+  ...new Set(values.filter((v, i) => values.indexOf(v) !== i)),
+];
+
+/** What one screen's `removed` lacks and holds beyond the declared strata. */
+const removedProblems = (
+  removed: Readonly<Record<string, number>>,
+  i: number,
+  values: readonly string[],
+): readonly Problem[] => [
+  ...values
+    .filter((v) => !Object.hasOwn(removed, v))
+    .map((v) => ({
+      at: `screens[${String(i)}].removed.${v}`,
+      text: `is missing — every screen states how many candidates it removed in each declared stratum value (${values.join(", ")}), 0 where it removed none`,
+    })),
+  ...Object.keys(removed)
+    .filter((k) => !values.includes(k))
+    .map((k) => ({
+      at: `screens[${String(i)}].removed.${k}`,
+      text: `is not a declared stratum value — \`strata.values\` declares ${values.join(", ")}; add it there or count it under one of them`,
+    })),
+];
+
+/** A problem when `when` holds, else none. */
+const problemIf = (
+  when: boolean,
+  at: string,
+  text: string,
+): readonly Problem[] => (when ? [{ at, text }] : []);
+
+/** The author's check against itself: no more units seen than drawn, a doubtful verdict decided. */
+const checkProblems = (
+  check: Readonly<Prereg["author_check"]>,
+): readonly Problem[] => [
+  ...problemIf(
+    check.units_seen > check.units_drawn,
+    "author_check.units_seen",
+    `is ${String(check.units_seen)}, more than the ${String(check.units_drawn)} units drawn (\`units_drawn\`)`,
+  ),
+  ...problemIf(
+    check.verdict !== "representative" && check.decision === undefined,
+    "author_check.decision",
+    `is missing — the verdict is «${check.verdict}», and a doubtful verdict with no recorded decision is how a sample the author doubted gets run anyway: add \`proceed\` (true or false), \`by\` whom and \`why\``,
+  ),
+];
+
+/** What a schema of one field cannot see: how the fields of a parsed declaration relate. */
+export function crossProblems(p: Readonly<Prereg>): readonly Problem[] {
+  const values = p.strata.values;
+  return [
+    ...repeated(values).map((v) => ({
+      at: "strata.values",
+      text: `names «${v}» more than once — each stratum value once`,
+    })),
+    ...p.screens.flatMap((s, i) => removedProblems(s.removed, i, values)),
+    ...problemIf(
+      p.coverage.share === null && p.coverage.reason === undefined,
+      "coverage.reason",
+      "is missing — `share` is null, so say why the share cannot be stated",
+    ),
+    ...problemIf(
+      p.coverage.share === 1 && p.coverage.unreachable.length > 0,
+      "coverage.unreachable",
+      `contradicts \`share\` 1 — a sample that cannot reach ${p.coverage.unreachable.map((u) => `«${u}»`).join(", ")} does not represent the whole population: lower \`share\`, or empty the list`,
+    ),
+    ...checkProblems(p.author_check),
+  ];
+}
+
+/** Everything wrong with the parsed JSON of one `prereg.json`, in the file's field order. */
+export function judgePrereg(data: unknown): readonly Problem[] {
+  const parsed = PREREG.safeParse(data);
+  return parsed.success
+    ? crossProblems(parsed.data)
+    : parsed.error.issues.map((i) => ({
+        at: pathText(i.path),
+        text: i.message,
+      }));
+}
+
+/** What `JSON.parse` says about the text it refused. */
+const Thrown = z
+  .object({ message: z.string() })
+  .catch({ message: "unparseable" });
+
+/** The problems of one `prereg.json` whose text is `source`: a parse failure, or the judgement. */
+export function preregProblems(source: string): readonly Problem[] {
+  const parsed = ((): { readonly data: unknown } | { readonly why: string } => {
+    try {
+      const data: unknown = JSON.parse(source);
+      return { data };
+    } catch (e) {
+      return { why: Thrown.parse(e).message };
+    }
+  })();
+  return "why" in parsed
+    ? [
+        {
+          at: "",
+          text: `does not parse as JSON (${parsed.why}) — there is no declaration to read`,
+        },
+      ]
+    : judgePrereg(parsed.data);
+}
+
+/** The one text a problem in the file `file` (relative to the paper) is reported with. */
+export const problemMessage = (file: string, p: Problem): string =>
+  [
+    p.at === ""
+      ? `\`${file}\` ${p.text}.`
+      : `\`${file}\`: \`${p.at}\` ${p.text}.`,
+    WHY,
+    `Rule study/declare-sample: ${PAGE}`,
+  ].join(" ");
+
+/**
+ * The `prereg.json` of every study folder at the top of `<paperDir>/repro/`, relative to the paper:
+ * every folder there but the shared ones, whatever its name — a study folder misnamed is
+ * `repro/allowed-files-only`'s finding, and its pre-registration is still judged here.
+ */
+export function preregFiles(paperDir: string): readonly string[] {
+  const repro = join(paperDir, REPRO_DIR);
+  return existsSync(repro) && statSync(repro).isDirectory()
+    ? readdirSync(repro, { withFileTypes: true })
+        // stat, not the entry's own type: a study folder linked into repro/ is a folder to
+        // repro/allowed-files-only too, and must not escape the check by being a link
+        .filter(
+          (e) =>
+            !SHARED_DIRS.includes(e.name) &&
+            (statSync(join(repro, e.name), {
+              throwIfNoEntry: false,
+            })?.isDirectory() ??
+              false),
+        )
+        .map((e) => `${REPRO_DIR}/${e.name}/${PREREG_FILE}`)
+        .filter((rel) => existsSync(join(paperDir, rel)))
+        .sort()
+    : [];
+}
+
+/** A `prereg.json` that is not a regular file (a folder, a socket): reading it would abort the run. */
+const NOT_A_FILE: readonly Problem[] = [
+  {
+    at: "",
+    text: "is not a file — the declaration is one JSON file; move what the folder holds elsewhere",
+  },
+];
+
+/** Every finding for the paper folder `paperDir`, one text each. */
+export const paperFindings = (paperDir: string): readonly string[] =>
+  preregFiles(paperDir).flatMap((rel) => {
+    const path = join(paperDir, rel);
+    const problems = statSync(path).isFile()
+      ? preregProblems(readFileSync(path, "utf8"))
+      : NOT_A_FILE;
+    return problems.map((p) => problemMessage(rel, p));
+  });
+
+export default {
+  rules: {
+    "declare-sample": {
+      meta: {
+        type: "problem" as const,
+        docs: {
+          description:
+            "every study's prereg.json declares its population, the screens and what each removed per stratum, the sample's coverage, and the author's check of the drawn units",
+          url: PAGE,
+        },
+        schema: [],
+        messages: { coverage: "{{text}}" },
+      },
+      create(context: RuleContext) {
+        if (basename(context.filename) !== STATUS_FILE) return {};
+        return {
+          root() {
+            const at = context.sourceCode.getLocFromIndex(0);
+            paperFindings(dirname(context.filename)).forEach((t) => {
+              context.report({
+                loc: { start: at, end: at },
+                messageId: "coverage",
+                data: { text: t },
+              });
+            });
+          },
+        };
+      },
+    },
+  },
+};

package/lib/skill-trigger-cases.harness.mjs

@@ -21,7 +21,7 @@ import { mkdtempSync, writeFileSync, mkdirSync, realpathSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { recordCheck } from "vigiles";
+import { assertPromptDiversity, recordCheck } from "vigiles";
 import { CASES, BY_SKILL, irrelevantFor } from "./skill-trigger-cases.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -86,10 +86,9 @@ const LOCAL_ONE = `export const CASES = [{
 soft("I. every case is shaped and every collider resolves", () => {
   for (const c of CASES) {
     assert.equal(typeof c.skill, "string", `a case has no skill name`);
-    assert.equal(
-      c.prompts.length,
-      4,
-      `${c.skill}: ${c.prompts.length} prompts, expected 4`,
+    assert.ok(
+      c.prompts.length >= 4,
+      `${c.skill}: ${c.prompts.length} prompts, expected at least 4`,
     );
     for (const sib of c.collides)
       assert.ok(
@@ -112,6 +111,53 @@ soft("I. irrelevantFor still yields a full set for a one-collider case", () => {
   );
 });
 
+// A collider that contributes nothing to the irrelevant set is named in the table and never
+// measured: the case reads as "must not take X's requests" and no request of X's is ever sent.
+// `irrelevantFor` used to cut the set at four, so a case with more than four colliders silently
+// lost the rest — grade-paper-writing, which names seven, lost three (2026-10-13).
+soft(
+  "I. every collider of every case contributes to its irrelevant set",
+  () => {
+    for (const c of CASES) {
+      const got = new Set(irrelevantFor(c.skill));
+      const silent = c.collides.filter(
+        (sib) => !BY_SKILL.get(sib).prompts.some((p) => got.has(p)),
+      );
+      assert.deepEqual(silent, [], `${c.skill}: colliders never measured`);
+    }
+  },
+);
+
+// The paid tier refuses a set that is too small or near-duplicate (vigiles' diversity pre-flight,
+// run by `measureTriggerRate` on both sides) — but only when someone pays to run it. The same gate,
+// with the same options `lib/skill-eval-kit.mjs` passes, decided here for free on every push.
+soft(
+  "I. every case would pass the paid tier's prompt-diversity pre-flight",
+  () => {
+    for (const c of CASES) {
+      assertPromptDiversity(c.prompts, {
+        minPrompts: 4,
+        label: `${c.skill} prompts`,
+      });
+      assertPromptDiversity(irrelevantFor(c.skill), {
+        minPrompts: 4,
+        label: `${c.skill} irrelevantPrompts`,
+      });
+    }
+  },
+);
+
+// A prompt listed under two skills says it must fire both, and each case's precision run then
+// counts the other's correct answer as a false positive.
+soft("I. no prompt is claimed by two cases", () => {
+  const owners = new Map();
+  for (const c of CASES)
+    for (const p of c.prompts)
+      owners.set(p, [...(owners.get(p) ?? []), c.skill]);
+  const shared = [...owners].filter(([, o]) => o.length > 1);
+  assert.deepEqual(shared, []);
+});
+
 // ── II. The carrier, all four states ─────────────────────────────────────────
 soft(
   "II. undeclared and absent is SILENT — a consumer with no skills of its own",

package/lib/skill-trigger-cases.mjs

@@ -12,11 +12,11 @@
  *
  *   skill     the skill under test
  *   why       the territory it owns, in one line — the thing a sibling must NOT take
- *   prompts   should-fire. FOUR each, deliberately mixed (below)
+ *   prompts   should-fire. At least FOUR, deliberately mixed (below)
  *   collides  siblings whose own should-fire prompts become this case's
- *             irrelevantPrompts. That is how "the WRONG skill must not fire" is
- *             asserted, and it is symmetric: each side of a collision is measured
- *             from both directions.
+ *             irrelevantPrompts — at least one from EVERY collider. That is how
+ *             "the WRONG skill must not fire" is asserted, and it is symmetric:
+ *             each side of a collision is measured from both directions.
  *
  * 🔴 THE PROMPTS ARE MIXED ON PURPOSE, AND THE MIX DECIDES THE NUMBER.
  * `framing-vs-vocabulary.eval.mjs` measured the same skills two ways: prompts that
@@ -55,13 +55,36 @@ const PACKAGE_CASES = [
   {
     skill: "grade-paper-writing",
     why: "prose craft — the sentence is the unit, NOT the section",
+    // The first four are HARVESTED and measured; they stay first and unchanged, so the rate on
+    // them stays comparable with pipeline-firing.eval.mjs and the siblings that collide with this
+    // case keep receiving the same irrelevant prompts. The last four were added 2026-10-13 with
+    // the rewritten description and have never been run — rates UNKNOWN. Eight, not four, because
+    // this skill's firing was measured at 12%, then 50–54%, on the same prompts: four prompts
+    // cannot tell those apart.
     prompts: [
       "оцени как написано — читается как стена жаргона",
       "is the writing any good or does it read like shit",
       "abstract звучит криво хотя по смыслу всё на месте, дай оценку прозе",
       "grade the craft: title, abstract, sentence clarity, hedge stacking",
+      "прочитай черновик и скажи честно, нормально ли он читается",
+      "the reviewer says our paper reads like a blog post — is he right about the prose",
+      "каждое предложение по отдельности понятно, а абзацы всё равно сливаются в сплошную простыню",
+      "grade the prose in section 3 and give me the sentences to rewrite",
+    ],
+    // Every sibling the description sends a request to. Each is a different wrong answer to "is
+    // this paper any good?": cut it, re-read one edit, attack the science, predict the committee,
+    // gate the submission, study the venue. Of the five added 2026-10-13, only cold-read-diff
+    // already named this case; the other four do not name it back, because that would change the
+    // irrelevant sets their own rates are measured on.
+    collides: [
+      "tighten-paper",
+      "argument-arc",
+      "cold-read-diff",
+      "paper-adversarial-review",
+      "pc-panel-review",
+      "harden-paper",
+      "study-accepted-papers",
     ],
-    collides: ["tighten-paper", "argument-arc"],
   },
   {
     skill: "argument-arc",
@@ -153,6 +176,17 @@ const PACKAGE_CASES = [
     ],
     collides: ["research-ideate", "draft-paper"],
   },
+  {
+    skill: "build-label-page",
+    why: "a PERSON labels items on a phone page with a shared store, and the answers are exported into the study",
+    prompts: [
+      "сделай мне страницу, где я разметил бы эти примеры с телефона",
+      "build a gold-labelling page for these 40 items so I can answer on my phone",
+      "нужна слепая страница для ревью ответов модели, чтобы я не видел, какой из них чей",
+      "make me a page to label these, and put the answers back into the study folder",
+    ],
+    collides: ["build-benchmark", "draft-paper"],
+  },
   {
     skill: "camera-ready",
     why: "AFTER accept — de-anonymize, archive, disclose",
@@ -248,7 +282,7 @@ const PACKAGE_CASES = [
       "посмотри что принимали на этой площадке и чем те статьи сильны",
       "хочу дотянуть с accept до strong accept — что для этого нужно именно там",
       "read a dozen accepted papers from this venue and diff our draft against them",
-      "какие приёмы у них заходят — артефакты, threat model, запоминающееся название",
+      "before we design the study: what does this venue actually reward? look at its award winners",
     ],
     collides: ["find-venue", "harden-paper"],
   },
@@ -436,14 +470,18 @@ export function irrelevantFor(skill, want = 4) {
   // verify-citations — seven of twenty-one, exactly the set with `collides.length
   // === 1`. Two-collider cases are unaffected (ceil(4/2) === 2), so numbers
   // measured before the fix stay comparable.
+  //
+  // `want` is a FLOOR, not a cap (2026-10-13). The set used to be cut at `want`,
+  // so a case with more than four colliders silently dropped the rest: the table
+  // said "must not take X's requests" and no request of X's was ever sent. Cases
+  // with one or two colliders get exactly what they got before (4); a case with
+  // three gets 6, with seven gets 7 — one from each.
   const per = Math.ceil(want / c.collides.length);
-  return c.collides
-    .flatMap((sib, i) => {
-      const s = BY_SKILL.get(sib);
-      if (!s) throw new Error(`${skill} collides with unknown skill "${sib}"`);
-      // Rotate by the collider's index so two cases sharing a collider do not
-      // receive byte-identical irrelevant sets.
-      return [...s.prompts.slice(i), ...s.prompts.slice(0, i)].slice(0, per);
-    })
-    .slice(0, want);
+  return c.collides.flatMap((sib, i) => {
+    const s = BY_SKILL.get(sib);
+    if (!s) throw new Error(`${skill} collides with unknown skill "${sib}"`);
+    // Rotate by the collider's index so two cases sharing a collider do not
+    // receive byte-identical irrelevant sets.
+    return [...s.prompts.slice(i), ...s.prompts.slice(0, i)].slice(0, per);
+  });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paperlint",
-  "version": "9.0.1",
+  "version": "10.0.0",
   "description": "A linter for scientific papers written in LaTeX: catches mistakes before you submit to a conference or journal.",
   "type": "module",
   "license": "MIT",

package/plugin/hooks/hooks.json

@@ -9,6 +9,15 @@
             "command": "node \"${CLAUDE_PROJECT_DIR}/node_modules/paperlint/bin/paperlint.mjs\" hook paper-edit-guard"
           }
         ]
+      },
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PROJECT_DIR}/node_modules/paperlint/bin/paperlint.mjs\" hook paper-folder-layout"
+          }
+        ]
       }
     ],
     "PostToolUse": [

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

@@ -5,7 +5,7 @@ context: fork
 allowed-tools: [WebSearch, WebFetch, Read, Write, Grep, Glob, Bash, Agent]
 ---
 
-<!-- vigiles:sha256:238796152df07749 compiled from skills/analyze-sibling-paper/SKILL.md.spec.ts -->
+<!-- vigiles:sha256:834f128ace92288a compiled from skills/analyze-sibling-paper/SKILL.md.spec.ts -->
 
 # analyze-sibling-paper — settle "isn't this just X?" before a reviewer does
 
@@ -115,7 +115,7 @@ again at rebuttal. **A close sibling with no file in `<paper-dir>/siblings/` is
 ## Compose with
 - `verify-citations` — surfaces the nearest-neighbor works; hand each genuine sibling to this skill.
 - `harden-paper` — its nearest-neighbor-scoop axis (axis 3) calls this for each close competitor.
-- `study-accepted-papers` — venue-corpus levers (different axis: the venue's bar, not a specific rival).
+- `study-accepted-papers` — venue-corpus levers (different axis: what the venue rewards, not a specific rival).
 - `extend-paper` — a scooped angle, or the un-scooped remainder, can become the next paper's pivot.
 
 ## Provenance

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

@@ -130,7 +130,7 @@ again at rebuttal. **A close sibling with no file in \`<paper-dir>/siblings/\` i
 ## Compose with
 - \`verify-citations\` — surfaces the nearest-neighbor works; hand each genuine sibling to this skill.
 - \`harden-paper\` — its nearest-neighbor-scoop axis (axis 3) calls this for each close competitor.
-- \`study-accepted-papers\` — venue-corpus levers (different axis: the venue's bar, not a specific rival).
+- \`study-accepted-papers\` — venue-corpus levers (different axis: what the venue rewards, not a specific rival).
 - \`extend-paper\` — a scooped angle, or the un-scooped remainder, can become the next paper's pivot.
 
 ## Provenance