paperlint 13.6.0 → 14.0.0

package/dist/skills/build-label-page/scripts/label-page-core.d.ts

@@ -1,4 +1,4 @@
-import { type RuleRef } from "./rule-descriptions.ts";
+import { type Described as RuleText, type RuleRef } from "./rule-descriptions.ts";
 export declare class Refusal extends Error {
     readonly exitCode: number;
     constructor(exitCode: number, message: string);
@@ -13,8 +13,8 @@ type Json = null | boolean | number | string | readonly Json[] | {
 type JsonObject = {
     readonly [key: string]: Json;
 };
-declare const PAGE_FIELDS: readonly ["group", "title", "body", "code", "context"];
-type SchemaNode = {
+declare const PAGE_FIELDS: readonly ["group", "title", "body", "code", "context", "file"];
+type SchemaNode = ({
     kind: "string";
     required: boolean;
     pattern?: string;
@@ -40,7 +40,16 @@ type SchemaNode = {
     required: boolean;
     closed: boolean;
     fields: Readonly<Record<string, SchemaNode>>;
+}) & {
+    why?: string;
 };
+/**
+ * THE PAGE KINDS, and the card fields each requires on every item and practice card (#373). A fix to
+ * a card is a field; a kind that needs it makes it required, so a page built without it fails the
+ * schema with the field named instead of shipping the old card.
+ */
+type Kind = "approval" | "witness" | "labels";
+/** The declared schema (`schema` prints it): every field, those a kind requires left optional. */
 export declare const CONFIG_SCHEMA: SchemaNode;
 interface Option {
     readonly value: string;
@@ -58,28 +67,33 @@ interface Question {
 interface Unit {
     readonly id: string;
     readonly text: string;
+    readonly mark: string;
     readonly part: number;
     readonly of: number;
 }
-type Item = {
+/** What a card shows, on an item and on a practice item alike. */
+type Card = {
     readonly [F in (typeof PAGE_FIELDS)[number]]?: string;
 } & {
-    readonly source_id: string;
-    readonly group: string;
     readonly body: string;
     readonly rules?: readonly RuleRef[];
     readonly unit?: Unit;
+    readonly readings?: {
+        readonly a: string;
+        readonly b: string;
+    };
 };
-interface Practice {
-    readonly title?: string;
-    readonly body: string;
-    readonly code?: string;
-    readonly context?: string;
+type Item = Card & {
+    readonly source_id: string;
+    readonly group: string;
+};
+type Practice = Card & {
     readonly expected: Readonly<Record<string, string>>;
     readonly why: string;
-}
+};
 interface Config {
     readonly study: string;
+    readonly kind: Kind;
     readonly title: string;
     readonly intro?: string;
     readonly seed: number;
@@ -97,8 +111,8 @@ interface KeyEntry {
     readonly group: string;
     readonly on_page: boolean;
 }
-/** Rule → the linter's description, for every rule an item on the page names. */
-type Described = ReadonlyMap<string, string>;
+/** Rule → the linter's description (and a ruff rule's family), for every rule a card names. */
+type Described = ReadonlyMap<string, RuleText>;
 /** Only what the labeller can answer goes on the page, and only that gets an id, in id order. */
 declare function itemsOnPage(cfg: Config, keyPath: string): {
     items: Item[];
@@ -123,8 +137,21 @@ declare function payloadOf(cfg: Config, page: ReturnType<typeof itemsOnPage>, de
     questions: readonly Question[];
     practice: {
         round: number;
-        items: readonly (Practice & {
-            readonly id: string;
+        items: ({
+            rules?: never;
+            id: string;
+            expected: Readonly<Record<string, string>>;
+            why: string;
+        } | {
+            rules: {
+                description?: string;
+                family?: string;
+                linter: "eslint" | "ruff";
+                id: string;
+            }[];
+            id: string;
+            expected: Readonly<Record<string, string>>;
+            why: string;
         })[];
     };
     items: ({
@@ -132,9 +159,10 @@ declare function payloadOf(cfg: Config, page: ReturnType<typeof itemsOnPage>, de
         id: string;
     } | {
         rules: {
+            description?: string;
+            family?: string;
             linter: "eslint" | "ruff";
             id: string;
-            description: string;
         }[];
         id: string;
     })[];
@@ -162,8 +190,21 @@ export declare function prepareBuild(configPath: string, outDir: string): {
         questions: readonly Question[];
         practice: {
             round: number;
-            items: readonly (Practice & {
-                readonly id: string;
+            items: ({
+                rules?: never;
+                id: string;
+                expected: Readonly<Record<string, string>>;
+                why: string;
+            } | {
+                rules: {
+                    description?: string;
+                    family?: string;
+                    linter: "eslint" | "ruff";
+                    id: string;
+                }[];
+                id: string;
+                expected: Readonly<Record<string, string>>;
+                why: string;
             })[];
         };
         items: ({
@@ -171,9 +212,10 @@ export declare function prepareBuild(configPath: string, outDir: string): {
             id: string;
         } | {
             rules: {
+                description?: string;
+                family?: string;
                 linter: "eslint" | "ruff";
                 id: string;
-                description: string;
             }[];
             id: string;
         })[];

package/dist/skills/build-label-page/scripts/rule-descriptions.d.ts

@@ -2,6 +2,11 @@ export interface RuleRef {
     readonly linter: "eslint" | "ruff";
     readonly id: string;
 }
+/** What the linter says a rule does; a ruff rule also names the family it comes from. */
+export interface Described {
+    readonly description: string;
+    readonly family?: string;
+}
 /** A process run to its end: the exit status and what it printed. */
 export type RunProcess = (cmd: string, args: readonly string[]) => {
     readonly status: number | null;
@@ -9,4 +14,4 @@ export type RunProcess = (cmd: string, args: readonly string[]) => {
 };
 export declare const runProcess: RunProcess;
 /** The linter's own one-line description of `ref`, or undefined when it has none. */
-export declare function describeRule(ref: RuleRef, fromDir: string, run?: RunProcess): string | undefined;
+export declare function describeRule(ref: RuleRef, fromDir: string, run?: RunProcess): Described | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paperlint",
-  "version": "13.6.0",
+  "version": "14.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/skills/assess-novelty/scripts/check_novelty.py

@@ -10,7 +10,9 @@ The verdict is computed from the cells, never stored, over neighbours read in fu
   result · ⚪ a piece nobody has excluded yet could still complete a neighbour (an unread cell, or an
   abstract-only read).
 Errors: a 'yes' cell without a quote or with a quote not in the text · a 'no' cell on an abstract-only
-neighbour · a missing search source · a priority sentence in paper.tex (first / none of the studies /
+neighbour · a missing search source · a 🟢 claim that some source has no search covering (a `searched`
+entry covers the claims its "claims" names, or, without "claims", the claims "added" on or before its date:
+novelty_search.py) · a priority sentence in paper.tex (first / none of the studies /
 to our knowledge / ...) not mapped to a 🟢 claim · CLAIMS.md disagreeing with the computed verdict ·
 a 🟢 claim without a refutation file · a claim without a known type or an objection_answer · a saved text
 with more than 30 % glued lines (two page columns merged by `pdftotext -layout`).
@@ -32,11 +34,12 @@ from quote_match import found, letters, norm  # noqa: E402
 from novelty_coverage import coverage_errors  # noqa: E402
 import novelty_candidates  # noqa: E402
 import novelty_cells  # noqa: E402
+import novelty_search  # noqa: E402
+from novelty_search import SOURCES  # noqa: E402
 
 # Boldness of a ledger status; ⚪ is not on the scale (unchecked is neither more nor less cautious).
 BOLDNESS = {"🟢": 2, "🟡": 1, "🔴": 0}
 FILE_NAME = re.compile(r"[\w./-]+\.(?:md|txt|json|tex|tsv|csv|py|ts|mjs)\b")
-SOURCES = ("venue-pc", "prev-edition", "arxiv-recent")
 TYPES = {"new-object", "transfer", "installed-base", "instrument", "refutation", "replication"}
 # The result itself: what is examined and what number comes out. A neighbour with both already reported the
 # result, so the claim's delta over it is setting (population, comparator, instrument): 🟡 at best, never 🟢,
@@ -158,6 +161,7 @@ def main():
 
     have = {s.get("source") for s in data.get("searched", []) if (s.get("how") or "").strip()}
     errors += [f"searched: no '{s}' search recorded (source + how)" for s in SOURCES if s not in have]
+    errors += novelty_search.entry_errors(data.get("searched", []))
 
     neighbours = data.get("neighbours", [])
     texts = {}
@@ -228,6 +232,7 @@ def main():
                 errors.append(f"{cid}: 🟢 without a refutation pass (refutation.file)")
             elif not os.path.isfile(os.path.join(paper, ref["file"])):
                 errors.append(f"{cid}: refutation file {ref['file']} does not exist")
+        errors += novelty_search.claim_errors(c, data.get("searched", []), v)
         print(f"{cid}  {v}  {why}")
         print(table(c, neighbours))
 

package/skills/assess-novelty/scripts/check_novelty_search.test.ts

@@ -0,0 +1,279 @@
+/**
+ * check_novelty.py, the search behind a 🟢: for each of the three sources (venue-pc, prev-edition, arxiv-recent) a
+ * free verdict needs a `searched` entry that covers THAT claim. Execution tier: the novelty fixture on disk, no
+ * model, no network. Run: npx vitest run skills/assess-novelty/scripts/check_novelty_search.test.ts
+ *
+ * Why (paperlint#367): three planned claims added to a table on 2026-11-04, whose searches were dated 2026-10-27
+ * and 2026-11-03, came out 🟢 against 30 neighbours collected for other claims; four works the consumer's own
+ * ledger names for one of them were not neighbours at all. `searched` was one list for the whole table, and the
+ * checker asked only for a refutation file.
+ *
+ * An entry covers a claim when its "claims" names it; an entry without "claims" (a table-wide search, as every
+ * table had before) covers a claim whose "added" date is on or before the entry's date.
+ * Each case copies the fixture and makes ONE change; every failing class has a clean twin that passes.
+ */
+import {
+  cpSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { spawnSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import assert from "node:assert/strict";
+import { test } from "vitest";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const FIXTURE = join(here, "fixtures", "novelty");
+const CHECKER = join(here, "check_novelty.py");
+const SOURCES = ["venue-pc", "prev-edition", "arxiv-recent"];
+
+// Copy the fixture, let `change` edit the novelty table, run the checker: the exit code, the printed verdict
+// lines and every ERROR line, so a case can compare the whole list of errors.
+const run = (change: (json: any) => void) => {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "novelty-search-")));
+  try {
+    cpSync(FIXTURE, dir, { recursive: true });
+    const path = join(dir, "siblings", "novelty.json");
+    const json = JSON.parse(readFileSync(path, "utf8"));
+    change(json);
+    writeFileSync(path, JSON.stringify(json, null, 2));
+    const r = spawnSync("python3", ["-I", CHECKER, dir], { encoding: "utf8" });
+    const errors = r.stderr
+      .split("\n")
+      .filter((l) => l.startsWith("ERROR "))
+      .map((l) => l.slice("ERROR ".length));
+    return { code: r.status, out: r.stdout, errors };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+};
+const claim = (j: any, id: string) => j.claims.find((c: any) => c.id === id);
+const entry = (source: string, date: string, claims?: string[]) => ({
+  source,
+  how: `${source}: the search, as run`,
+  date,
+  ...(claims ? { claims } : {}),
+});
+// The searches as every table had them before: one list, no "claims"; the issue's two dates.
+const legacy = (j: any) => {
+  j.searched = [
+    entry("venue-pc", "2026-10-27"),
+    entry("prev-edition", "2026-10-27"),
+    entry("arxiv-recent", "2026-11-03"),
+  ];
+};
+// A design-stage claim added after the last search, with P5-1's cells (🟢) and a refutation file.
+const addC8 = (j: any, added?: string) => {
+  const c8 = { ...structuredClone(claim(j, "P5-1")), id: "C8", planned: true };
+  delete c8.ledger;
+  delete c8.added;
+  j.claims.push(added ? { ...c8, added } : c8);
+};
+const missingC8 = (sources: string, hint: string) =>
+  `C8: 🟢 but no search covers it in ${sources}: search for C8 there and record it with "claims": ["C8"]${hint}`;
+const AFTER = (added: string) =>
+  ` (a search without "claims" covers only the claims added on or before its date; C8 was added ${added})`;
+const NO_ADDED =
+  ' (or set "added" to the day C8 entered the table: a search without "claims" covers only the claims added on or before its date)';
+
+test("check_novelty_search: a claim added after the table's searches", () => {
+  // fires: the issue's case — a claim added 2026-11-04, searches of 2026-10-27 and 2026-11-03, no "claims"
+  {
+    const r = run((j) => {
+      legacy(j);
+      for (const c of j.claims) c.added = "2026-10-08";
+      addC8(j, "2026-11-04");
+    });
+    // Guards: C8 computes 🟢 (the table prints it), yet the run fails, naming C8, all three sources and the fix.
+    assert.match(r.out, /C8\s+🟢/);
+    assert.deepEqual(
+      { code: r.code, errors: r.errors },
+      {
+        code: 1,
+        errors: [missingC8(SOURCES.join(", "), AFTER("2026-11-04"))],
+      },
+    );
+  }
+  // fires: the same claim with no "added" at all — the error names both fixes
+  {
+    const r = run((j) => {
+      legacy(j);
+      for (const c of j.claims) c.added = "2026-10-08";
+      addC8(j);
+    });
+    // Guards: a claim with no date is not assumed to predate the searches.
+    assert.deepEqual(
+      { code: r.code, errors: r.errors },
+      { code: 1, errors: [missingC8(SOURCES.join(", "), NO_ADDED)] },
+    );
+  }
+  // silent: the delta search recorded for C8 in each source
+  {
+    const r = run((j) => {
+      legacy(j);
+      for (const c of j.claims) c.added = "2026-10-08";
+      addC8(j, "2026-11-04");
+      j.searched.push(...SOURCES.map((s) => entry(s, "2026-11-04", ["C8"])));
+    });
+    // Guards: the per-claim search is what lets a 🟢 through.
+    assert.deepEqual(
+      { code: r.code, errors: r.errors },
+      { code: 0, errors: [] },
+    );
+  }
+}, 120_000);
+
+test("check_novelty_search: one source short, and searches without claims", () => {
+  // fires: the delta search ran in two sources only (the third entry says nothing of how) — the error names it
+  {
+    const r = run((j) => {
+      legacy(j);
+      for (const c of j.claims) c.added = "2026-10-08";
+      addC8(j, "2026-11-04");
+      j.searched.push(entry("venue-pc", "2026-11-04", ["C8"]));
+      j.searched.push(entry("prev-edition", "2026-11-04", ["C8"]));
+      j.searched.push({
+        ...entry("arxiv-recent", "2026-11-04", ["C8"]),
+        how: " ",
+      });
+    });
+    // Guards: coverage is counted per source, not "some search names C8"; an entry without a "how" is no search.
+    assert.deepEqual(
+      { code: r.code, errors: r.errors },
+      { code: 1, errors: [missingC8("arxiv-recent", AFTER("2026-11-04"))] },
+    );
+  }
+  // silent: a search without "claims" dated on or after the claim's added date covers it (same day counts)
+  {
+    const r = run((j) => {
+      legacy(j);
+      for (const c of j.claims) c.added = "2026-10-08";
+      addC8(j, "2026-10-27");
+      j.searched.push(entry("arxiv-recent", "2026-10-27"));
+    });
+    // Guards: a table-wide search still counts for every claim the table had on its date.
+    assert.deepEqual(
+      { code: r.code, errors: r.errors },
+      { code: 0, errors: [] },
+    );
+  }
+  // fires: a search that names other claims does not cover C8, whatever its date
+  {
+    const r = run((j) => {
+      addC8(j, "2026-10-01");
+      // the fixture's searches name R1 and P5-1, dated 2026-10-08, after C8's added date
+    });
+    // Guards: an entry with "claims" covers only the claims it names; no hint, since no entry lacks "claims".
+    assert.deepEqual(
+      { code: r.code, errors: r.errors },
+      { code: 1, errors: [missingC8(SOURCES.join(", "), "")] },
+    );
+  }
+}, 120_000);
+
+test("check_novelty_search: migrating a table, and claims that are not free", () => {
+  // fires: an old table as it was (no "claims", no "added") whose 🟢 claim must now say when it entered
+  {
+    const r = run((j) => {
+      for (const s of j.searched) delete s.claims;
+    });
+    // Guards: the migration is named in the error itself; R1 is 🔴 and needs no search to stay 🔴.
+    assert.deepEqual(
+      { code: r.code, errors: r.errors },
+      {
+        code: 1,
+        errors: [
+          `P5-1: 🟢 but no search covers it in ${SOURCES.join(", ")}: search for P5-1 there and record it with "claims": ["P5-1"] (or set "added" to the day P5-1 entered the table: a search without "claims" covers only the claims added on or before its date)`,
+        ],
+      },
+    );
+  }
+  // silent: the same table migrated by dating its claims
+  {
+    const r = run((j) => {
+      for (const s of j.searched) delete s.claims;
+      for (const c of j.claims) c.added = "2026-10-08";
+    });
+    // Guards: "added" on or before the searches' date is the whole migration for a table searched once.
+    assert.deepEqual(
+      { code: r.code, errors: r.errors },
+      { code: 0, errors: [] },
+    );
+  }
+  // silent: a 🔴 claim that no search covers
+  {
+    const r = run((j) => {
+      for (const s of j.searched) s.claims = ["P5-1"];
+    });
+    // Guards: only a 🟢 rests on the search having covered the claim.
+    assert.deepEqual(
+      { code: r.code, errors: r.errors },
+      { code: 0, errors: [] },
+    );
+  }
+}, 120_000);
+
+test("check_novelty_search: an explicit null scope is malformed, not a table-wide search", () => {
+  const r = run((j) => {
+    for (const e of j.searched) e.claims = null;
+    for (const c of j.claims) c.added = "2026-10-08";
+  });
+  // Guards: "claims": null is not the same as no "claims". A null scope in every source must not authorize 🟢 for
+  // every claim added before the searches (Codex review on #370); it is named and covers nothing.
+  assert.equal(r.code, 1);
+  assert.deepEqual(
+    r.errors.filter((e) => e.startsWith("searched[")),
+    nullScopeErrors(3),
+  );
+  assert.ok(
+    r.errors.some((e) =>
+      e.startsWith(
+        "P5-1: 🟢 but no search covers it in venue-pc, prev-edition, arxiv-recent",
+      ),
+    ),
+    r.errors.join("\n"),
+  );
+}, 120_000);
+const nullScopeErrors = (n: number) =>
+  Array.from(
+    { length: n },
+    (_, i) =>
+      `searched[${i}]: "claims" must be a non-empty list of claim ids, got None`,
+  );
+
+test("check_novelty_search: malformed claims, added and dates", () => {
+  const r = run((j) => {
+    j.searched[0].claims = ["R1", "P5-1", "C9"];
+    j.searched[1].claims = [];
+    j.searched[2].claims = "P5-1";
+    claim(j, "R1").added = "4 Nov 2026";
+    j.searched.push({
+      source: "venue-pc",
+      how: "a later sweep",
+      date: "2026-13-01",
+    });
+    j.searched.push({ source: "venue-pc", how: "a sweep with no date" });
+  });
+  // Guards: each malformed field is named with its fix, and a malformed entry covers nothing (P5-1 is short of
+  // prev-edition and arxiv-recent, whose only entries are malformed). C9, no claim of the table, is no error: the
+  // entry records what was searched that day, and a claim dropped later does not make the record wrong.
+  assert.deepEqual(
+    { code: r.code, errors: r.errors },
+    {
+      code: 1,
+      errors: [
+        'searched[1]: "claims" must be a non-empty list of claim ids, got []',
+        "searched[2]: \"claims\" must be a non-empty list of claim ids, got 'P5-1'",
+        "searched[3]: date '2026-13-01' is not YYYY-MM-DD; a search without \"claims\" covers the claims added on or before its date",
+        'searched[4]: date None is not YYYY-MM-DD; a search without "claims" covers the claims added on or before its date',
+        "R1: \"added\" '4 Nov 2026' is not a date (YYYY-MM-DD)",
+        'P5-1: 🟢 but no search covers it in prev-edition, arxiv-recent: search for P5-1 there and record it with "claims": ["P5-1"]',
+      ],
+    },
+  );
+}, 120_000);

package/skills/assess-novelty/scripts/fixtures/novelty/siblings/novelty.json

@@ -1,9 +1,12 @@
 {
   "paper": "paper.tex",
   "searched": [
-    {"source": "venue-pc", "how": "venue PC list, DBLP 2024-2026 of each member", "date": "2026-10-08"},
-    {"source": "prev-edition", "how": "previous edition accepted papers, titles and abstracts", "date": "2026-10-08"},
-    {"source": "arxiv-recent", "how": "arXiv cs.SE since 2026-01: AGENTS.md, rules files", "date": "2026-10-08"}
+    {"source": "venue-pc", "how": "venue PC list, DBLP 2024-2026 of each member", "date": "2026-10-08",
+     "claims": ["R1", "P5-1"]},
+    {"source": "prev-edition", "how": "previous edition accepted papers, titles and abstracts", "date": "2026-10-08",
+     "claims": ["R1", "P5-1"]},
+    {"source": "arxiv-recent", "how": "arXiv cs.SE since 2026-01: AGENTS.md, rules files", "date": "2026-10-08",
+     "claims": ["R1", "P5-1"]}
   ],
   "neighbours": [
     {"id": "doe26", "cite": "doe2026rules", "source": "arxiv-recent", "read": "full",

package/skills/assess-novelty/scripts/novelty_search.py

@@ -0,0 +1,87 @@
+"""Which searches covered which claim: a 🟢 needs, in each of the three sources, a search that covered THAT claim.
+
+A `searched` entry is {"source", "how", "date", "claims"?}. With "claims" (a non-empty list of claim ids) it covers
+exactly the claims it names. Without it, it is a search of the whole table as it stood on its date: it covers the
+claims whose "added" (YYYY-MM-DD, the day the claim entered the table) is on or before that date, and no claim
+without "added". Why: a claim added a week after the last search inherited that search as if it had covered it, and
+came out 🟢 against neighbours collected for other claims (paperlint#367). An entry counts only with a "how".
+
+Migrating a table written before this: give each claim the day it entered the table as "added" (the searches
+without "claims" dated on or after it then count for it), or name the claims in each entry's "claims".
+"""
+import datetime
+import re
+
+SOURCES = ("venue-pc", "prev-edition", "arxiv-recent")
+DAY = re.compile(r"\d{4}-\d{2}-\d{2}")
+SCOPE = 'a search without "claims" covers only the claims added on or before its date'
+
+
+def day(value):
+    """The date a YYYY-MM-DD string names, or None."""
+    if not isinstance(value, str) or not DAY.fullmatch(value):
+        return None
+    try:
+        return datetime.date.fromisoformat(value)
+    except ValueError:
+        return None
+
+
+TABLE_WIDE = object()  # an entry without "claims"; an explicit "claims": null is malformed, not this
+
+
+def named(entry):
+    """The claim ids an entry names, or TABLE_WIDE for an entry without "claims" (a search of the whole table)."""
+    return entry["claims"] if "claims" in entry else TABLE_WIDE
+
+
+def well_formed(entry):
+    ids = named(entry)
+    return ids is TABLE_WIDE or (isinstance(ids, list) and bool(ids) and all(isinstance(i, str) for i in ids))
+
+
+def covers(entry, claim):
+    """Did this search cover this claim? A malformed entry covers nothing."""
+    if not (entry.get("how") or "").strip() or not well_formed(entry):
+        return False
+    ids = named(entry)
+    if ids is not TABLE_WIDE:
+        return claim.get("id") in ids
+    searched_on, added = day(entry.get("date")), day(claim.get("added"))
+    return searched_on is not None and added is not None and added <= searched_on
+
+
+def entry_errors(searched):
+    """A malformed "claims", and an entry without "claims" whose date is not a date: either covers nothing.
+
+    An id in "claims" that is no longer a claim is not an error: the entry records what was searched that day, and
+    a claim dropped from the table later does not make the record wrong (a misspelt id leaves its claim uncovered,
+    which claim_errors names).
+    """
+    def one(i, e):
+        ids = named(e)
+        if ids is TABLE_WIDE:
+            return ([] if day(e.get("date")) else
+                    [f"searched[{i}]: date {e.get('date')!r} is not YYYY-MM-DD; a search without \"claims\" covers"
+                     " the claims added on or before its date"])
+        return [] if well_formed(e) else [f'searched[{i}]: "claims" must be a non-empty list of claim ids, got {ids!r}']
+    return [err for i, e in enumerate(searched) for err in one(i, e)]
+
+
+def claim_errors(claim, searched, verdict):
+    """A malformed "added"; and, for a 🟢, the sources with no search that covered the claim, with the fix."""
+    cid = claim.get("id")
+    bad_added = (["%s: \"added\" %r is not a date (YYYY-MM-DD)" % (cid, claim["added"])]
+                 if "added" in claim and day(claim["added"]) is None else [])
+    if verdict != "🟢":
+        return bad_added
+    missing = [s for s in SOURCES if not any(e.get("source") == s and covers(e, claim) for e in searched)]
+    if not missing:
+        return bad_added
+    table_wide = any(e.get("source") in missing and named(e) is TABLE_WIDE and (e.get("how") or "").strip()
+                     for e in searched)
+    hint = ("" if not table_wide else
+            f' (or set "added" to the day {cid} entered the table: {SCOPE})' if day(claim.get("added")) is None else
+            f" ({SCOPE}; {cid} was added {claim['added']})")
+    return bad_added + [f"{cid}: 🟢 but no search covers it in {', '.join(missing)}: search for {cid} there and"
+                        f' record it with "claims": ["{cid}"]{hint}']

package/skills/build-label-page/SKILL.md

@@ -4,7 +4,7 @@ description: Build a phone labelling page published as a claude.ai Artifact with
 allowed-tools: [Read, Write, Edit, Grep, Glob, Bash, Artifact, ArtifactData]
 ---
 
-<!-- vigiles:sha256:bd616b2694831fa1 compiled from skills/build-label-page/SKILL.md.spec.ts -->
+<!-- vigiles:sha256:6e828827dc6fcfc1 compiled from skills/build-label-page/SKILL.md.spec.ts -->
 
 # build-label-page — a page the person labels on a phone, and the labels back in the repo
 
@@ -63,8 +63,8 @@ building. In one line each:
    source labels on the page. The generator refuses to build when an item carries a field outside an
    allow-list; a page written by hand checks its items against the same list.
 5. **Ask only what the labeller can answer.** Only the languages and tools they know; one "how well do
-   you know it" question per group, used later as an analysis filter (off on an approval page,
-   `"familiarity": false`: the author has not seen those repositories); "clear-cut or real boundary"
+   you know it" question per group when the study filters on it (`"familiarity": true`; left
+   out, none is asked, as on an approval page, whose author has not seen those repositories); "clear-cut or real boundary"
    is the labeller's judgement, not the designer's.
 6. **Export into the repository right away**, one JSON per page into the study's `data/` with the
    export date, commit it, and record answers given in chat with `source: "chat"`. If the page fails,
@@ -104,7 +104,8 @@ building. In one line each:
    ```
 
    It writes `label-page/page.html` and `label-page/key.json` (the only link from `G001` to the
-   source id; it never goes on the page). Written by hand, the page meets the requirements above.
+   source id; it never goes on the page). `kind` (`approval`, `witness`, `labels`) is required,
+   and each kind requires its card fields on every item and practice card. Written by hand, the page meets the requirements above.
 4. **Read it as the labeller, then look at it.** Read the page text once as a person who knows
    nothing about the source: if anything on it tells the answer, take it out. Read each question as
    someone who did not design the study: can they tell what each answer means from the question, its

package/skills/build-label-page/SKILL.md.spec.ts

@@ -74,8 +74,8 @@ building. In one line each:
    source labels on the page. The generator refuses to build when an item carries a field outside an
    allow-list; a page written by hand checks its items against the same list.
 5. **Ask only what the labeller can answer.** Only the languages and tools they know; one "how well do
-   you know it" question per group, used later as an analysis filter (off on an approval page,
-   \`"familiarity": false\`: the author has not seen those repositories); "clear-cut or real boundary"
+   you know it" question per group when the study filters on it (\`"familiarity": true\`; left
+   out, none is asked, as on an approval page, whose author has not seen those repositories); "clear-cut or real boundary"
    is the labeller's judgement, not the designer's.
 6. **Export into the repository right away**, one JSON per page into the study's \`data/\` with the
    export date, commit it, and record answers given in chat with \`source: "chat"\`. If the page fails,
@@ -115,7 +115,8 @@ building. In one line each:
    \`\`\`
 
    It writes \`label-page/page.html\` and \`label-page/key.json\` (the only link from \`G001\` to the
-   source id; it never goes on the page). Written by hand, the page meets the requirements above.
+   source id; it never goes on the page). \`kind\` (\`approval\`, \`witness\`, \`labels\`) is required,
+   and each kind requires its card fields on every item and practice card. Written by hand, the page meets the requirements above.
 4. **Read it as the labeller, then look at it.** Read the page text once as a person who knows
    nothing about the source: if anything on it tells the answer, take it out. Read each question as
    someone who did not design the study: can they tell what each answer means from the question, its