paperlint 13.2.0 → 13.3.0

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

@@ -0,0 +1,136 @@
+"""Candidate neighbours: works a refutation or a search surfaced, waiting for the author to decide on each one.
+
+Why Python, not TypeScript (a TypeScript rewrite is paperlint#339): check_novelty.py,
+which is Python, imports this module, and the gate must be the same code the page builder asks. The builder
+(candidate_page.ts) calls this file's `shape` command instead of keeping a second copy of the rules.
+
+A candidate is one file, <paper-dir>/siblings/candidates/<id>.json:
+
+    {"id": "smith16",                        # = the file name; becomes the neighbour id on "add"
+     "title": "...", "authors": "...", "venue": "...", "year": 2016,
+     "url": "https://...",                       # the work's landing page
+     "pdf_url": "https://...",                   # optional: the PDF itself
+     "text": "siblings/data/<id>.txt",           # the full text, as for a neighbour
+     "found_by": [{"claim": "C3", "file": "siblings/...-refutation-C3.md"} | {"source": "paper.tex ref86"}],
+     "summary": "what the work does, in plain words",
+     "abstract": {"page": 1, "text": "the abstract, verbatim"},
+     "conclusion": {"page": 10, "text": "the conclusion section, verbatim"},
+     "passages": [{"claim": "C3", "page": 4, "quote": "verbatim, at least 8 words",
+                   "crop": "siblings/data/crops/<id>-1.png", "meaning": "what it means for the claim"}],
+     "suggestion": "add" | "cite" | "skip", "suggestion_why": "...",
+     "decision": {"choice": "add" | "cite" | "skip", "reason": "...", "at": "ISO time",
+                  "source": "page" | "chat"}}        # absent until the author decides
+
+The abstract and the conclusion are what the authors say about their own work, at the top of the page, so the
+author judges the passages against them (the author asked for the abstract and the
+conclusions to be shown at every stage, if possible at the top). Every quoted text must be found in the saved text.
+
+The author decides on a page (candidate_page.ts builds it); nobody else writes `decision`. "add" makes the work
+a neighbour, read in full by sibling-read; "cite" keeps it out of the novelty table but the paper should cite
+it; "skip" needs a reason. check_novelty.py fails while a candidate is undecided or added but not yet read.
+
+    python3 -I novelty_candidates.py shape <paper-dir>   # each shape problem on its own line; exit 1 if any
+"""
+import json
+import os
+import sys
+
+CHOICES = ("add", "cite", "skip")
+SOURCES = ("page", "chat")
+QUOTE_WORDS_MIN = 8
+REQUIRED = ("id", "title", "url", "text", "found_by", "summary", "abstract", "conclusion", "passages", "suggestion")
+OWN_WORDS = ("abstract", "conclusion")
+
+
+def load(paper):
+    """[(relative path, parsed file)] for every siblings/candidates/*.json, sorted by name."""
+    folder = os.path.join(paper, "siblings", "candidates")
+    if not os.path.isdir(folder):
+        return []
+    names = sorted(n for n in os.listdir(folder) if n.endswith(".json"))
+    return [(f"siblings/candidates/{n}", json.load(open(os.path.join(folder, n), encoding="utf-8"))) for n in names]
+
+
+def shape(path, c):
+    missing = [k for k in REQUIRED if c.get(k) in (None, "", [], {})]
+    if missing:
+        return [f"{path}: missing {', '.join(missing)}"]
+    errs = []
+    if os.path.basename(path) != f"{c['id']}.json":
+        errs.append(f"{path}: id {c['id']!r} does not match the file name")
+    if c["suggestion"] not in CHOICES:
+        errs.append(f"{path}: suggestion {c['suggestion']!r} is not one of {', '.join(CHOICES)}")
+    errs += [f"{path}: found_by[{i}] names neither a claim with its file nor a source"
+             for i, f in enumerate(c["found_by"]) if not ((f.get("claim") and f.get("file")) or f.get("source"))]
+    errs += [f"{path}: {k} needs page and text" for k in OWN_WORDS
+             if not (isinstance(c[k], dict) and c[k].get("page") and (c[k].get("text") or "").strip())]
+    for i, p in enumerate(c["passages"]):
+        gaps = [k for k in ("quote", "page", "crop", "meaning") if not p.get(k)]
+        errs += [f"{path}: passages[{i}] missing {', '.join(gaps)}"] if gaps else []
+        if p.get("quote") and len(p["quote"].split()) < QUOTE_WORDS_MIN:
+            errs.append(f"{path}: passages[{i}] quote has {len(p['quote'].split())} words; at least {QUOTE_WORDS_MIN}")
+    return errs
+
+
+def _decision(path, c):
+    d = c.get("decision")
+    if d is None:
+        return []
+    errs = [f"{path}: decision.choice {d.get('choice')!r} is not one of {', '.join(CHOICES)}"
+            ] if d.get("choice") not in CHOICES else []
+    if d.get("source") not in SOURCES:
+        errs.append(f"{path}: decision.source {d.get('source')!r} is not one of {', '.join(SOURCES)}")
+    if not d.get("at"):
+        errs.append(f"{path}: decision has no time (at)")
+    if d.get("choice") == "skip" and not (d.get("reason") or "").strip():
+        errs.append(f"{path}: skip without a reason")
+    return errs
+
+
+def errors(paper, data, files, found, texts_of):
+    """Every problem with the candidates of one paper.
+
+    data: the novelty table; found(quote, text) -> bool, the same presence check the cells use;
+    texts_of(path) -> the saved text at a paper-relative path, or None when there is no such file.
+    """
+    neighbours = {n["id"]: n for n in data.get("neighbours", [])}
+    out = []
+    for path, c in files:
+        problems = shape(path, c)
+        if problems:
+            out += problems
+            continue
+        text = texts_of(c["text"])
+        if text is None:
+            out.append(f"{path}: no text at {c['text']}")
+        else:
+            out += [f"{path}: {k} not found in {c['text']}: {c[k]['text'][:80]!r}"
+                    for k in OWN_WORDS if not found(c[k]["text"], text)]
+            out += [f"{path}: passages[{i}] quote not found in {c['text']}: {p['quote'][:80]!r}"
+                    for i, p in enumerate(c["passages"]) if not found(p["quote"], text)]
+        out += [f"{path}: passages[{i}] crop {p['crop']} does not exist"
+                for i, p in enumerate(c["passages"]) if not os.path.isfile(os.path.join(paper, p["crop"]))]
+        out += _decision(path, c)
+        choice = (c.get("decision") or {}).get("choice")
+        n = neighbours.get(c["id"])
+        if choice is None:
+            out.append(f"{c['id']}: candidate waiting for the author's decision (candidate_page.ts build)")
+        elif choice == "add" and (n is None or n.get("read") != "full"):
+            out.append(f"{c['id']}: approved as a neighbour but not read in full yet "
+                       f"(sibling-read with only: [{c['id']!r}])")
+        elif choice != "add" and n is not None:
+            out.append(f"{c['id']}: is a neighbour in novelty.json, but the author's decision was {choice!r}")
+    return out
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3 or sys.argv[1] != "shape":
+        print(__doc__, file=sys.stderr)
+        sys.exit(2)
+    paper = sys.argv[2]
+    problems = [e for path, c in load(paper) for e in shape(path, c)]
+    problems += [f"{path}: passages[{i}] crop {p['crop']} does not exist" for path, c in load(paper)
+                 for i, p in enumerate(c.get("passages") or []) if p.get("crop")
+                 and not os.path.isfile(os.path.join(paper, p["crop"]))]
+    print("\n".join(problems))
+    sys.exit(1 if problems else 0)

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

@@ -0,0 +1,222 @@
+/**
+ * check_novelty.py, candidates: a work a refutation surfaced waits for the author's add / cite / skip, and an
+ * "add" is not settled until sibling-read has read it in full. Execution tier: the novelty fixture, no model.
+ * Run: npx vitest run skills/assess-novelty/scripts/novelty_candidates.test.ts
+ *
+ * Why: the refutation pass found four works and the agent added all four as neighbours itself; the author wants each
+ * one put to them first, with the passages in front of them. The gate is that an undecided work fails the check.
+ * Each case copies the fixture and writes ONE candidate; every failing class has a clean twin that passes.
+ */
+import {
+  cpSync,
+  mkdirSync,
+  mkdtempSync,
+  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";
+
+test("novelty_candidates", () => {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const FIXTURE = join(here, "fixtures", "novelty");
+  const CHECKER = join(here, "check_novelty.py");
+  const SENTENCE =
+    "We ran Checkstyle before and after applying the initial patch and the final patch.";
+  const ABSTRACT =
+    "We study whether code review removes the coding convention violations a linter reports.";
+  const CONCLUSION =
+    "Review removes some violations, and most of the rest stay in the code after the merge.";
+
+  const candidate = (over: Record<string, unknown> = {}) => ({
+    id: "roe20",
+    title: "Does code review really remove style violations?",
+    url: "https://example.org/roe20",
+    text: "siblings/data/roe20.txt",
+    found_by: [{ claim: "P5-1", file: "siblings/refutation.md" }],
+    summary: "Runs a linter on review patches before and after review.",
+    abstract: { page: 1, text: ABSTRACT },
+    conclusion: { page: 9, text: CONCLUSION },
+    passages: [
+      {
+        claim: "P5-1",
+        page: 4,
+        quote: SENTENCE,
+        crop: "siblings/data/crops/roe20-1.png",
+        meaning: "The before/after linter run is an established instrument.",
+      },
+    ],
+    suggestion: "cite",
+    suggestion_why: "Same instrument, not the same object.",
+    ...over,
+  });
+  const decided = (choice: string, reason = "the instrument only") => ({
+    decision: {
+      choice,
+      reason,
+      at: "2026-10-29T16:00:00+05:00",
+      source: "page",
+    },
+  });
+
+  // Copy the fixture, write one candidate (or none) plus its text and crop, run the checker.
+  const run = (
+    c: Record<string, unknown> | null,
+    { crop = true, text = `${ABSTRACT}\n${SENTENCE}\n${CONCLUSION}` } = {},
+  ) => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), "novelty-cand-")));
+    try {
+      cpSync(FIXTURE, dir, { recursive: true });
+      if (c) {
+        mkdirSync(join(dir, "siblings", "candidates"), { recursive: true });
+        mkdirSync(join(dir, "siblings", "data", "crops"), { recursive: true });
+        writeFileSync(
+          join(dir, "siblings", "candidates", `${c.id}.json`),
+          JSON.stringify(c, null, 2),
+        );
+        writeFileSync(
+          join(dir, "siblings", "data", "roe20.txt"),
+          `Section 3.\n${text}\n`,
+        );
+        if (crop)
+          writeFileSync(
+            join(dir, "siblings", "data", "crops", "roe20-1.png"),
+            "png",
+          );
+      }
+      const r = spawnSync("python3", ["-I", CHECKER, dir], {
+        encoding: "utf8",
+      });
+      return { code: r.status, out: `${r.stdout}\n${r.stderr}` };
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  };
+  const passes = (
+    c: Record<string, unknown> | null,
+    what: string,
+    opts = {},
+  ) => {
+    const r = run(c, opts);
+    assert.equal(r.code, 0, `must pass: ${what}\n${r.out}`);
+    assert.doesNotMatch(
+      r.out,
+      /candidate/,
+      `silent about candidates: ${what}\n${r.out}`,
+    );
+  };
+  const fails = (
+    c: Record<string, unknown>,
+    re: RegExp,
+    what: string,
+    opts = {},
+  ) => {
+    const r = run(c, opts);
+    assert.equal(r.code, 1, `must fail: ${what}\n${r.out}`);
+    assert.match(r.out, re, `wrong reason for: ${what}\n${r.out}`);
+  };
+
+  // ── clean: no candidates folder at all; a decided "cite" with its passage in the text ──
+  passes(null, "no candidates");
+  passes(
+    candidate(decided("cite")),
+    "a cite decision, quote in the text, crop on disk",
+  );
+
+  // ── 1. undecided: the author has not answered ──
+  fails(
+    candidate(),
+    /roe20: candidate waiting for the author's decision/,
+    "no decision",
+  );
+
+  // ── 2. "add" is only settled once the work is a neighbour read in full ──
+  fails(
+    candidate(decided("add")),
+    /roe20: approved as a neighbour but not read in full yet/,
+    "add, not read",
+  );
+  passes(
+    candidate({ id: "doe26", ...decided("add") }),
+    "add of a work that is now a neighbour read in full",
+  );
+
+  // ── 3. a neighbour the author did not approve ──
+  fails(
+    candidate({ id: "doe26", ...decided("skip") }),
+    /doe26: is a neighbour in novelty.json, but the author's decision was 'skip'/,
+    "skipped yet a neighbour",
+  );
+
+  // ── 4. skip needs its reason ──
+  fails(
+    candidate(decided("skip", " ")),
+    /skip without a reason/,
+    "skip with a blank reason",
+  );
+  passes(
+    candidate(
+      decided("skip", "different object: code review, not rules files"),
+    ),
+    "skip with a reason",
+  );
+
+  // ── 5. what the page shows must be real: the quote in the saved text, the crop on disk ──
+  fails(
+    candidate(decided("cite")),
+    /passages\[0\] quote not found in siblings\/data\/roe20.txt/,
+    "quote missing from the text",
+    { text: "Something else entirely, said in nine whole words here." },
+  );
+  fails(
+    candidate(decided("cite")),
+    /passages\[0\] crop siblings\/data\/crops\/roe20-1.png does not exist/,
+    "crop not rendered",
+    { crop: false },
+  );
+
+  // ── 6. shape: a field the page needs, a short quote, a choice outside the three ──
+  fails(
+    candidate({ summary: "", ...decided("cite") }),
+    /roe20.json: missing summary/,
+    "no summary",
+  );
+
+  // ── 7. the authors' own words open every tab: abstract and conclusion, each with its page, each in the text ──
+  fails(
+    candidate({ abstract: undefined, ...decided("cite") }),
+    /roe20.json: missing abstract/,
+    "no abstract",
+  );
+  fails(
+    candidate({ conclusion: { text: CONCLUSION }, ...decided("cite") }),
+    /conclusion needs page and text/,
+    "a conclusion without its page",
+  );
+  fails(
+    candidate(decided("cite")),
+    /roe20.json: abstract not found in siblings\/data\/roe20.txt/,
+    "an abstract the saved text does not hold",
+    { text: `${SENTENCE}\n${CONCLUSION}` },
+  );
+  fails(
+    candidate({
+      passages: [{ ...candidate().passages[0], quote: "before and after" }],
+      ...decided("cite"),
+    }),
+    /passages\[0\] quote has 3 words; at least 8/,
+    "a three-word quote",
+  );
+  fails(
+    candidate({
+      decision: { choice: "maybe", at: "2026-10-29", source: "page" },
+    }),
+    /decision.choice 'maybe' is not one of add, cite, skip/,
+    "an unknown choice",
+  );
+}, 300_000);

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

@@ -0,0 +1,88 @@
+"""Merge the readers' per-neighbour files into a paper's novelty table.
+
+Usage: python3 -I novelty_cells.py <paper-dir>
+  reads <paper-dir>/siblings/cells/<id>.json, one per neighbour, each {"id", "read", "coverage", "cells":
+  {claim: {piece: cell}}}, and writes their read, coverage and cells into siblings/novelty.json; exit 1, writing
+  nothing, if a file names a neighbour, claim or piece the table does not have.
+
+One reader agent per neighbour writes its own file, so parallel readers never edit the same file; the files
+are the record of each read, and novelty.json is merged from them. check_novelty.py fails while novelty.json is
+behind any of them. The neighbour list, the claims and their pieces stay owned by novelty.json.
+"""
+import copy
+import json
+import os
+import sys
+
+OWNED = ("read", "coverage")  # neighbour fields a cells file owns; plus that neighbour's cells in every claim
+
+
+def load(paper):
+    """[(relative path, parsed file)] for every siblings/cells/*.json, sorted by name."""
+    folder = os.path.join(paper, "siblings", "cells")
+    if not os.path.isdir(folder):
+        return []
+    names = sorted(n for n in os.listdir(folder) if n.endswith(".json"))
+    return [(f"siblings/cells/{n}", json.load(open(os.path.join(folder, n), encoding="utf-8"))) for n in names]
+
+
+def merge(data, files):
+    """(novelty table with every file merged in, errors). Pure: `data` is not changed."""
+    out = copy.deepcopy(data)
+    by_id = {n["id"]: n for n in out.get("neighbours", [])}
+    claims = {c["id"]: c for c in out.get("claims", [])}
+    errors = []
+    for path, f in files:
+        nid = f.get("id")
+        if os.path.basename(path) != f"{nid}.json":
+            errors.append(f"{path}: id {nid!r} does not match the file name")
+            continue
+        if nid not in by_id:
+            errors.append(f"{path}: no neighbour {nid!r} in novelty.json (the neighbour list is novelty.json's)")
+            continue
+        for key in OWNED:
+            if key in f:
+                by_id[nid][key] = f[key]
+        # The file is the whole record of this neighbour: a claim it leaves out has no cells for it (unknown),
+        # never the cells of an earlier read, whose 'no' would still grant novelty.
+        given = f.get("cells") or {}
+        for cid in claims.keys() - given.keys():
+            claims[cid].get("cells", {}).pop(nid, None)
+        for cid, cells in given.items():
+            if cid not in claims:
+                errors.append(f"{path}: claim {cid!r} is not in novelty.json")
+                continue
+            unknown = [p for p in cells if p not in claims[cid].get("pieces", {})]
+            errors += [f"{path}: {cid} has no piece {p!r}" for p in unknown]
+            if not unknown:
+                claims[cid].setdefault("cells", {})[nid] = cells
+    return out, errors
+
+
+def behind(data, files):
+    """Paths of cells files whose content novelty.json does not hold yet."""
+    results = [(path, merge(data, [(path, f)])) for path, f in files]
+    return [path for path, (merged, errs) in results if not errs and merged != data]
+
+
+def main():
+    if len(sys.argv) != 2:
+        print(__doc__, file=sys.stderr)
+        sys.exit(2)
+    paper = sys.argv[1]
+    path = os.path.join(paper, "siblings", "novelty.json")
+    raw = open(path, encoding="utf-8").read()
+    files = load(paper)
+    merged, errors = merge(json.loads(raw), files)
+    for e in errors:
+        print("ERROR " + e, file=sys.stderr)
+    if errors:
+        sys.exit(1)
+    text = json.dumps(merged, indent=2, ensure_ascii=False) + ("\n" if raw.endswith("\n") else "")
+    if text != raw:
+        open(path, "w", encoding="utf-8").write(text)
+    print(f"merged {len(files)} cells file(s) into {os.path.relpath(path, paper)}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,159 @@
+/**
+ * novelty_cells.py: one reader per neighbour writes siblings/cells/<id>.json (its read, coverage and cells);
+ * the script merges them into novelty.json, and check_novelty.py fails when novelty.json is behind them.
+ * Execution tier: the novelty fixture on disk, no model, no network.
+ * Run: npx vitest run skills/assess-novelty/scripts/novelty_cells.test.ts
+ */
+import {
+  cpSync,
+  mkdirSync,
+  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";
+
+test("novelty_cells", () => {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const FIXTURE = join(here, "fixtures", "novelty");
+  const py = (script: string, dir: string) => {
+    const r = spawnSync("python3", ["-I", join(here, script), dir], {
+      encoding: "utf8",
+    });
+    return { code: r.status, out: `${r.stdout}\n${r.stderr}` };
+  };
+
+  // The fixture's own doe26 data, as a reader would return it, with P5-1's comparator flipped to 'yes'.
+  const READER = {
+    id: "doe26",
+    read: "full",
+    coverage: [
+      {
+        lines: [1, 63],
+        quote: "We measure this gap in 481 public AGENTS.md files.",
+      },
+    ],
+  };
+
+  // Copy the fixture, drop the given cells files, optionally merge, then check; returns both results.
+  const run = (cellFiles: Record<string, object>, { merge = true } = {}) => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), "novelty-cells-")));
+    try {
+      cpSync(FIXTURE, dir, { recursive: true });
+      const fixtureJson = JSON.parse(
+        readFileSync(join(dir, "siblings", "novelty.json"), "utf8"),
+      );
+      mkdirSync(join(dir, "siblings", "cells"));
+      for (const [name, body] of Object.entries(cellFiles)) {
+        const cells = Object.fromEntries(
+          fixtureJson.claims.map((c: any) => [c.id, c.cells.doe26]),
+        );
+        writeFileSync(
+          join(dir, "siblings", "cells", name),
+          JSON.stringify({ ...READER, cells, ...body }, null, 2),
+        );
+      }
+      const merged = merge
+        ? py("novelty_cells.py", dir)
+        : { code: null, out: "" };
+      const checked = py("check_novelty.py", dir);
+      const json = JSON.parse(
+        readFileSync(join(dir, "siblings", "novelty.json"), "utf8"),
+      );
+      return { merged, checked, json };
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  };
+
+  // ── clean: a reader's file equal to the fixture merges to the same table, checker green ──
+  {
+    const r = run({ "doe26.json": {} });
+    assert.equal(r.merged.code, 0, r.merged.out);
+    assert.equal(r.checked.code, 0, r.checked.out);
+  }
+
+  // ── the merge carries the reader's cells into novelty.json ─────────────────────
+  {
+    const r = run({ "doe26.json": { read: "abstract", coverage: [] } });
+    assert.equal(r.merged.code, 0, r.merged.out);
+    assert.equal(
+      r.json.neighbours[0].read,
+      "abstract",
+      "read comes from the reader's file",
+    );
+  }
+
+  // ── a claim the reader left out loses that neighbour's old cells: they turn unknown, never stay 'no' ──
+  // The file is the reader's whole record of the neighbour; old 'no' cells kept for an omitted claim would
+  // still grant novelty on evidence nobody re-read.
+  {
+    const r = run({ "doe26.json": { cells: {} } });
+    assert.equal(r.merged.code, 0, r.merged.out);
+    assert.deepEqual(
+      r.json.claims.map((c: any) => c.cells?.doe26),
+      [undefined, undefined],
+    );
+    const behind = run({ "doe26.json": { cells: {} } }, { merge: false });
+    assert.match(
+      behind.checked.out,
+      /novelty\.json is behind siblings\/cells\/doe26\.json/,
+    );
+  }
+
+  // ── novelty.json behind a cells file: the checker says so ──────────────────────
+  {
+    const r = run(
+      { "doe26.json": { read: "abstract", coverage: [] } },
+      { merge: false },
+    );
+    assert.equal(r.checked.code, 1, r.checked.out);
+    assert.match(
+      r.checked.out,
+      /novelty\.json is behind siblings\/cells\/doe26\.json: run novelty_cells\.py/,
+    );
+  }
+
+  // ── a file for a neighbour the table does not list ─────────────────────────────
+  {
+    const r = run({ "zhou26.json": { id: "zhou26" } });
+    assert.equal(r.merged.code, 1, r.merged.out);
+    assert.match(
+      r.merged.out,
+      /cells\/zhou26\.json: no neighbour 'zhou26' in novelty\.json/,
+    );
+  }
+
+  // ── the file name and its id disagree ──────────────────────────────────────────
+  {
+    const r = run({ "doe.json": {} });
+    assert.equal(r.merged.code, 1, r.merged.out);
+    assert.match(
+      r.merged.out,
+      /cells\/doe\.json: id 'doe26' does not match the file name/,
+    );
+  }
+
+  // ── a claim or piece the table does not have ───────────────────────────────────
+  {
+    const r = run({
+      "doe26.json": { cells: { R9: {}, "P5-1": { colour: { has: "no" } } } },
+    });
+    assert.equal(r.merged.code, 1, r.merged.out);
+    assert.match(
+      r.merged.out,
+      /cells\/doe26\.json: claim 'R9' is not in novelty\.json/,
+    );
+    assert.match(
+      r.merged.out,
+      /cells\/doe26\.json: P5-1 has no piece 'colour'/,
+    );
+  }
+}, 300_000);

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

@@ -0,0 +1,55 @@
+"""Proof that a neighbour marked read "full" was read in full: one verbatim sentence per chunk of its saved text.
+
+A neighbour's `coverage` is a list of {"lines": [first, last], "quote": "..."}: the chunks tile the text from
+line 1 to its last line with no gap, none is longer than CHUNK_LINES_MAX, and each quote is found inside its own
+chunk. Why: one Read returns at most 25,000 tokens (a 1,790-line text came back as lines 1-627), and a 'no' cell —
+the one that grants novelty — rests on the neighbour having been read to the end. 400 plain-pdftotext lines are
+about a third of that cap, so a chunk is one Read. A quote is a presence check, as for the cells.
+"""
+from quote_match import found, letters, norm
+
+CHUNK_LINES_MAX = 400
+QUOTE_WORDS_MIN = 8
+
+
+def coverage_gaps(last_line, ranges):
+    """Line spans in 1..last_line that no range covers, in order: [(first, last), ...]."""
+    gaps, nxt = [], 1
+    for first, last in sorted(ranges):
+        if first > nxt:
+            gaps.append((nxt, first - 1))
+        nxt = max(nxt, last + 1)
+    return gaps + ([(nxt, last_line)] if nxt <= last_line else [])
+
+
+def coverage_errors(nid, text, coverage):
+    """Why the coverage does not prove a full read of `text`; empty when it does."""
+    if not coverage:
+        return [f"{nid}: read 'full' not proven: no coverage (one quote per chunk of at most {CHUNK_LINES_MAX} lines)"]
+    # By "\n" only, as Read and wc -l number them: splitlines() also splits on the form feed pdftotext writes at
+    # every page break, and a 1,825-line text then counts 1,850 (sibling-read).
+    lines = text.removesuffix("\n").split("\n")
+    errors = []
+    ranges = []
+    for chunk in coverage:
+        span = chunk.get("lines")
+        if not (isinstance(span, list) and len(span) == 2 and all(isinstance(x, int) for x in span)
+                and 1 <= span[0] <= span[1] <= len(lines)):
+            errors.append(f"{nid}: coverage lines {span!r} are not [first, last] within 1-{len(lines)}")
+            continue
+        first, last = span
+        ranges.append((first, last))
+        where = f"{first}-{last}"
+        if last - first + 1 > CHUNK_LINES_MAX:
+            errors.append(f"{nid}: coverage chunk {where} is {last - first + 1} lines; at most {CHUNK_LINES_MAX}")
+        quote = chunk.get("quote") or ""
+        words = len(norm(quote).split())
+        if words < QUOTE_WORDS_MIN:
+            errors.append(f"{nid}: coverage quote for lines {where} has {words} words; at least {QUOTE_WORDS_MIN}")
+            continue
+        body = "\n".join(lines[first - 1:last])
+        if not found(quote, norm(body), letters(body)):
+            errors.append(f"{nid}: coverage quote for lines {where} not found in those lines: {quote[:80]!r}")
+    errors += [f"{nid}: read 'full' not proven: lines {a}-{b} have no coverage quote"
+               for a, b in coverage_gaps(len(lines), ranges)]
+    return errors