paperlint 3.1.0 → 3.1.2

package/skills/paper-pipeline/scripts/status.test.mjs

@@ -0,0 +1,232 @@
+/**
+ * status.mjs — the paper's status view, derived from the ledger. Every section it can print is
+ * driven by rows written for the purpose: fresh and stale answers, open findings with and without
+ * a report path, retired-vocabulary rows (an acquittal and a counted one), an orphan check, a check
+ * that has run and never found anything, and the all-answered footer.
+ */
+import assert from "node:assert/strict";
+import { rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, test, vi } from "vitest";
+import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const root = useTempDir("status-");
+const consumer = join(root, "consumer");
+const LEDGER = join(root, "runs.jsonl");
+const paper = join(consumer, "papers", "p");
+writeTree(paper, { "paper.md": "# P\n\ntext\n" });
+Object.assign(process.env, {
+  CLAUDE_PROJECT_DIR: consumer,
+  PIPELINE_LEDGER: LEDGER,
+});
+const { inputHash } = await import("./ledger.mjs");
+const { EXPECTED_GATES, main, unlistedGates } = await import("./status.mjs");
+afterEach(() => rmSync(LEDGER, { force: true }));
+
+const NOW = inputHash(paper);
+const TS = "2026-09-01T10:30:00.000Z";
+/** A ledger row for `key` on paper p. No skill is installed here, so its current hash is null. */
+const row = (key, fields) => {
+  const [skill, check] = key.split("/");
+  return {
+    ts: TS,
+    skill,
+    check: check ?? skill,
+    paper: "p",
+    inputSha: NOW,
+    skillSha: null,
+    ...fields,
+  };
+};
+const NO_WITNESS = { kind: "ABSTAINED", reason: "no-witness", findings: 0 };
+
+function view(rows) {
+  writeFileSync(LEDGER, rows.map((r) => JSON.stringify(r)).join("\n") + "\n");
+  const lines = [];
+  const spy = vi
+    .spyOn(console, "log")
+    .mockImplementation((...a) => lines.push(a.join(" ")));
+  let code;
+  try {
+    code = main(["node", "status.mjs", paper]);
+  } finally {
+    spy.mockRestore();
+  }
+  return { code, text: lines.join("\n") };
+}
+/** The table line for one check, with its padding collapsed. */
+const tableLine = (text, key) =>
+  text
+    .split("\n")
+    .find((l) => l.includes(` ${key} `))
+    ?.trim()
+    .replace(/\s{2,}/g, " | ");
+/** A section: from the line that starts with `head` to the next blank line. */
+const section = (text, head) => {
+  const lines = text.split("\n");
+  const i = lines.findIndex((l) => l.trim().startsWith(head));
+  if (i < 0) return null;
+  const end = lines.findIndex((l, j) => j > i && l.trim() === "");
+  return lines.slice(i, end < 0 ? undefined : end).map((l) => l.trim());
+};
+
+const RAN = [
+  "research-ideate",
+  "find-venue",
+  "map-prior-work",
+  "sweep-design-space",
+  "plan-paper-timeline",
+  "build-benchmark",
+  "draft-paper",
+];
+
+test("every kind of row, and every section it triggers", () => {
+  const { code, text } = view([
+    row("research-ideate", NO_WITNESS),
+    row("find-venue", {
+      kind: "FINDING",
+      findings: 3,
+      blocking: true,
+      report: "r.md",
+    }),
+    row("map-prior-work", { kind: "FINDING", findings: 2, inputSha: "older" }),
+    row("sweep-design-space", { ...NO_WITNESS, skillSha: "a-different-skill" }),
+    row("plan-paper-timeline", { verdict: "PASS" }),
+    row("build-benchmark", { verdict: "FINDINGS", findings: 2 }),
+    row("draft-paper", { kind: "FINDING", findings: 0 }),
+    row("mystery-check", NO_WITNESS),
+    row("paper-status", NO_WITNESS),
+  ]);
+  assert.deepEqual(
+    {
+      code,
+      rows: [
+        "research-ideate",
+        "find-venue",
+        "map-prior-work",
+        "sweep-design-space",
+        "plan-paper-timeline",
+        "build-benchmark",
+        "draft-paper",
+        "camera-ready",
+      ].map((k) => tableLine(text, k)),
+      stale: text
+        .split("\n")
+        .filter((l) => /^\s+(🟠|🟡) [\w/-]+: /.test(l))
+        .map((l) => l.trim()),
+      never: section(text, "⬜ never run:"),
+      mute: section(text, "🔇"),
+      legacy: section(text, "🏷️"),
+      orphans: section(text, "❗"),
+      open: section(text, "📌"),
+      quiet: section(text, "🤍"),
+      footer: text.trim().split("\n").pop().trim(),
+    },
+    {
+      code: 0,
+      rows: [
+        "🟢 research-ideate | FRESH | abstained:no-witness | 1 | 2026-09-01 10:30",
+        "🟢 find-venue | FRESH | 🔴 3 found | 1 | 2026-09-01 10:30",
+        "🟠 map-prior-work | STALE-PAPER | • 2 found | 1 | 2026-09-01 10:30",
+        "🟡 sweep-design-space | STALE-SKILL | abstained:no-witness | 1 | 2026-09-01 10:30",
+        "🟢 plan-paper-timeline | FRESH | legacy:PASS | 1 | 2026-09-01 10:30",
+        "🟢 build-benchmark | FRESH | • 2 found | 1 | 2026-09-01 10:30",
+        "🟢 draft-paper | FRESH | no row | 1 | 2026-09-01 10:30",
+        "⬜ camera-ready | NEVER-RUN | — | 0 | —",
+      ],
+      stale: [
+        // In EXPECTED_GATES order.
+        "🟡 sweep-design-space: the check itself changed since it ran — that answer came from a different tool",
+        "🟠 map-prior-work: the paper changed since it ran — its answer is about a document that is gone",
+      ],
+      never: [
+        `⬜ never run: ${EXPECTED_GATES.filter((k) => !RAN.includes(k)).join(", ")}`,
+        "nobody has asked this question about this paper — an unasked question reads exactly like a clean one in prose.",
+      ],
+      mute: [
+        "🔇 has run and has NEVER recorded a finding: research-ideate, sweep-design-space, plan-paper-timeline",
+        "Borrowed from mutation testing: a test that kills no mutant is not a test. This is",
+        "not proof the check is broken — it is the reason to go plant a defect and watch.",
+        "Precedent here: a tightening pass returned KEEP on 80 of 81 sections and a",
+        'justification pass never once recommended a deletion. Both "ran".',
+      ],
+      legacy: [
+        "🏷️  answered in the RETIRED vocabulary: plan-paper-timeline=PASS, build-benchmark=FINDINGS",
+        "Rows written before 2026-08-10 are kept verbatim and are NOT translated into the",
+        "current constructors — a silent reinterpretation is the class of defect this",
+        "pipeline removed. A retired FINDINGS/FAIL row still shows its count above, because",
+        "it carries evidence and discarding evidence is the destructive direction.",
+        "plan-paper-timeline=PASS carry NOTHING forward:",
+        "they recorded that nothing was wrong, with no evidence attached, which is exactly",
+        "the value that was deleted. Re-run those checks for an answer in a live vocabulary.",
+      ],
+      // `paper-status` records too, but is the view itself, so it is never an orphan.
+      orphans: [
+        "❗ recording but NOT IN THE TABLE: mystery-check",
+        "These ran and said something, and this view showed you nothing. Add them to",
+        "EXPECTED_GATES — an invisible row is the failure this directory exists to end.",
+      ],
+      open: [
+        "📌 open findings: 7 across 3 check(s)",
+        "• map-prior-work: 2 (no report path recorded — the count is all there is)  [STALE-PAPER: this count describes an older text]",
+        "🔴 find-venue: 3 → r.md",
+        "• build-benchmark: 2 (no report path recorded — the count is all there is)",
+        "Nothing here proves anyone acted on these. The ledger records what a check SAID,",
+        "never what was done about it — that lives in the session, not in a file.",
+      ],
+      quiet: [
+        "🤍 ran against the current bytes and recorded nothing: 1 check(s)",
+        "research-ideate (no-witness)",
+        "Read this as the ABSENCE of a finding, which is what it is. `no-witness` means the",
+        "check ran and has no witness for the negative answer — unlike a certifying",
+        "algorithm (McConnell et al. 2011), which ships one for both answers. Our discipline",
+        "is strictly weaker than theirs and this line is where that shows.",
+        "no-witness: ran to completion, produced no finding — NOT a claim that nothing is wrong",
+      ],
+      footer: "🔴 29 check(s) not answering for the current text",
+    },
+  );
+});
+
+test("every expected check answered on the current bytes: the green footer, and nothing to flag", () => {
+  const { code, text } = view(
+    EXPECTED_GATES.map((k) =>
+      row(k, { kind: "FINDING", findings: 1, report: "r.md" }),
+    ),
+  );
+  assert.deepEqual(
+    {
+      code,
+      sections: ["🟠", "🟡", "⬜ never", "🔇", "🏷️", "❗", "🤍"].map((h) =>
+        section(text, h),
+      ),
+      footer: text.trim().split("\n").pop().trim(),
+    },
+    {
+      code: 0,
+      sections: [null, null, null, null, null, null, null],
+      footer: "🟢 every expected check answered for the current text",
+    },
+  );
+});
+
+test("unlistedGates names checks the table does not list, except the view's own rows", () => {
+  assert.deepEqual(
+    unlistedGates([
+      { skill: "find-venue", check: "find-venue" },
+      { skill: "x", check: "y" },
+      { skill: "paper-status", check: "paper-status" },
+    ]),
+    ["x/y"],
+  );
+});
+
+test("as a process, with no argument, it reads the current directory and exits 0", () => {
+  const r = runNode(join(HERE, "status.mjs"), [], {
+    cwd: paper,
+    env: { CLAUDE_PROJECT_DIR: consumer, PIPELINE_LEDGER: LEDGER },
+  });
+  assert.deepEqual([r.status, r.stdout.split("\n")[1]], [0, "  p"]);
+});

package/skills/plan-paper-timeline/plan-paper-timeline.effects.harness.mjs

@@ -343,8 +343,8 @@ try {
     // matters more than it looks. The first version of this guard keyed on `evt_fake_`,
     // a string the stand-in prints only on SUCCESS — so a perfectly correct schema
     // REJECTION arrived with no marker and was reported as "something else served this
-    // tool". The guard meant to protect the verdict was hiding it, and it took a
-    // mutation run to notice (2026-08-17). The log is written on both paths, so a
+    // tool". The guard meant to protect the verdict was hiding it, and that went
+    // unnoticed until 2026-08-17. The log is written on both paths, so a
     // non-empty log means our server handled the call, whatever it decided.
     const logged = existsSync(callLog)
       ? readFileSync(callLog, "utf8")

package/skills/render-paper/checkers-requirements.txt

@@ -8,25 +8,26 @@
 
 jinja2>=3.0                  # {{macro}} substitution in paper_numbers.py
 
-# 🔴 THIS PIN IS LOAD-BEARING, not cosmetic. aclpubcheck pulls in bibtexparser; the 2.x branch is
-# beta (2.0.0b9) with a different API, and the 1.4.x branch's sdist does not build under
-# setuptools 68+. 1.3.0 has a prebuilt WHEEL (bibtexparser-1.3.0-py3-none-any.whl), so `<2`
-# resolves to it and there's nothing to build. Verified 2026-09-04 in a clean venv: install exits
-# 0, `python -m aclpubcheck.formatchecker --help` runs.
-bibtexparser<2
+# bibtexparser is pulled in by rebiber (below), not by aclpubcheck: aclpubcheck's own code never
+# imports it. rebiber 1.4 moved to bibtexparser 2 (`bibtexparser>=2,<3` in its pyproject), and
+# 2.0.1 is a stable release with a prebuilt wheel. The old pin `bibtexparser<2` existed only
+# for rebiber 1.1.3; it would now make the file unsatisfiable, so it is gone.
 
-# 🔴 aclpubcheck IS INSTALLED SEPARATELY, WITH `--no-deps`, AND IT IS DELIBERATELY NOT LISTED HERE.
-# Measured 2026-09-17: it declares `tsv>=1.2,<2.0`, which has NO PREBUILT WHEEL AT ALL
-# (`pip download --only-binary :all: tsv` → "from versions: none"), and its source does not build
+# 🔴 aclpubcheck IS INSTALLED SEPARATELY, WITH `--no-deps`, BY ensure-checkers.sh, AND IT IS
+# DELIBERATELY NOT LISTED HERE (a requirements file cannot say `--no-deps` for one line).
+# It comes from its GitHub source pinned to a commit, not from PyPI: upstream says to install "from
+# the GitHub repository (DIFFERENT from `pypi`)", and PyPI's 0.2.0 is a snapshot of 2022-10-10. The
+# pin is 237bee3 of 2026-09-11, whose own setup.py pins rebiber to the SAME commit as below —
+# measured 2026-09-27: both resolve together, `pip check` names no rebiber conflict.
+# Why `--no-deps`: it still declares `tsv`, which has NO PREBUILT WHEEL AT ALL
+# (`pip download --only-binary :all: tsv` → "from versions: none"), and whose source does not build
 # under a modern setuptools:
 #     AttributeError: install_layout. Did you mean: 'install_platlib'?
-# That one line alone made installing the WHOLE file fail, and that's why the paper went a month
+# That one line alone once made installing the WHOLE file fail, and that's why a paper went a month
 # without an official format check.
-# Verified, not assumed: `tsv` is imported NOWHERE in aclpubcheck's source (grep for
-# `import tsv|from tsv` — 0 hits), and without it
-# `python3 -m aclpubcheck.formatchecker --help` prints usage and exits zero.
-# So what follows is aclpubcheck's OWN dependencies, taken verbatim from the package's metadata,
-# minus tsv. A list, rather than `aclpubcheck` on one line, so the next unrepresentable dependency
+# Verified, not assumed, on the pinned commit: `tsv` is imported NOWHERE in aclpubcheck's source,
+# and neither is `setuptools`, which it also declares.
+# So what follows is aclpubcheck's OWN dependencies, from its setup.py, minus tsv and setuptools. A list, rather than `aclpubcheck` on one line, so the next unrepresentable dependency
 # reads as a missing line rather than an unverified assumption.
 # 🔴 THE UPPER BOUNDS ARE REMOVED, AND THAT IS A MEASUREMENT, NOT CARELESSNESS. The first edition
 # of this list copied aclpubcheck's bounds verbatim — and turned red on CI, where Python is newer:
@@ -48,8 +49,18 @@ pylatexenc>=2.10
 termcolor>=2.0.1
 tqdm>=4.64.1
 
-rebiber>=1.1.3               # an aclpubcheck dependency AND our own tool
+# 🔴 rebiber FROM ITS GITHUB SOURCE, PINNED TO A COMMIT — NOT FROM PyPI. The upstream README says
+# so itself: "Install from GitHub only. We do not publish or support PyPI (`pip install rebiber` is
+# a 2021 1.1.3 release)." The `rebiber>=1.1.3` that stood here installed exactly that 2021 release
+# (#114). The pin is 1.4.0, commit b917e36 of 2026-09-08 ("Support bibtexparser 2 parsing and
+# writing APIs"); upstream has no 1.4 tag, so a commit is the only fixed name.
+# Measured 2026-09-27 in a clean Python 3.11 venv, under this file's `--only-binary :all:`: installs
+# in 36 s (pip builds it from source with hatchling, the one allowed build), `rebiber -v` runs,
+# and a `--dry-run` over a three-entry .bib leaves the file untouched. It carries 409 MB of venue
+# data. aclpubcheck declares `rebiber>=1.1.3,<2`, which 1.4.0 satisfies.
+rebiber @ git+https://github.com/yuchenlin/rebiber@b917e36ec94084a84025eb06781b5aac96d1cedd
 
-# ⚠️ Call ONLY as `python3 -m aclpubcheck.formatchecker`. The package has no __main__.py, and the
-# form `python3 -m aclpubcheck` fails with "cannot be directly executed" — that's exactly how this
-# step once lived its whole life without ever running.
+# Since the pinned commit the package has a `__main__.py`, so `python3 -m aclpubcheck <pdf>` runs
+# the format checker (measured 2026-09-27 on its example PDF: 10 errors, 0 warnings, exit 0). The
+# PyPI 0.2.0 that stood here had none, and `python3 -m aclpubcheck` failed with "cannot be directly
+# executed"; `python3 -m aclpubcheck.formatchecker` works on both.

package/skills/render-paper/ensure-checkers.sh

@@ -27,8 +27,10 @@ echo "== python dependencies =="
 # bibtexparser looked like the guilty one.
 pip install -q --only-binary :all: -r "$HERE/checkers-requirements.txt"
 # The checker itself — WITHOUT its dependencies: they are listed in requirements.txt by name, minus
-# the unbuildable `tsv`, which it does not import. The reason is in the header of requirements.txt.
-pip install -q --no-deps aclpubcheck
+# the unbuildable `tsv`, which it does not import. From its GitHub source at a fixed commit, not
+# PyPI — both reasons are in the header of requirements.txt.
+ACLPUBCHECK="aclpubcheck @ git+https://github.com/acl-org/aclpubcheck@237bee3a554f2d2fcda69cd0cf1edf4168e3d339"
+pip install -q --no-deps "$ACLPUBCHECK"
 
 echo "== TeXtidote (a jar, not a pip package) =="
 if [ -f "$JAR" ]; then
@@ -55,10 +57,24 @@ fail=0
 # "numpy.dtype size changed"). That is, the acceptance check that stood here let through exactly
 # the failure it was written for. `import aclpubcheck.formatchecker` pulls in numpy and pandas on
 # lines 15 and 20 of the checker itself and therefore fails honestly.
+# And the entry point, which the PyPI release did not have: `python3 -m aclpubcheck` must answer.
 python3 -c "import aclpubcheck.formatchecker" >/dev/null 2>&1 \
+  && python3 -m aclpubcheck --help >/dev/null 2>&1 \
   && echo "   ✅ aclpubcheck" || { echo "   ❌ aclpubcheck is installed, but does not run"; fail=1; }
-python3 -c "import rebiber" >/dev/null 2>&1 \
-  && echo "   ✅ rebiber" || { echo "   ❌ rebiber does not import"; fail=1; }
+# 🔴 RUN IT, NOT IMPORT IT. rebiber is used as a command, and an import proves neither the entry
+# point, nor that it loads its bundled venue data, nor that it parses a .bib (bibtexparser 2 since
+# 1.4). So it is given the arXiv entry of a paper its data knows (NeurIPS 2017) with --dry-run
+# (nothing is written) and must report that entry CONVERTED to the official record — measured
+# 2026-09-27 on the pinned commit: `converted (official): 1`, no network.
+reb_tmp="$(mktemp -d)"
+printf '@article{vaswani2017attention,\n  title = {Attention Is All You Need},\n  author = {Vaswani, Ashish and Shazeer, Noam and Parmar, Niki and Uszkoreit, Jakob and Jones, Llion and Gomez, Aidan N. and Kaiser, Lukasz and Polosukhin, Illia},\n  journal = {arXiv preprint arXiv:1706.03762},\n  year = {2017}\n}\n' > "$reb_tmp/in.bib"
+reb_out="$(rebiber -i "$reb_tmp/in.bib" --dry-run 2>&1 || true)"
+if grep -q "converted (official): 1" <<<"$reb_out"; then
+  echo "   ✅ rebiber $(rebiber -v 2>/dev/null)"
+else
+  echo "   ❌ rebiber does not convert a known entry"; fail=1
+fi
+rm -rf "$reb_tmp"
 python3 -c "import jinja2" >/dev/null 2>&1 \
   && echo "   ✅ jinja2" || { echo "   ❌ jinja2 does not import"; fail=1; }
 java -jar "$JAR" --version >/dev/null 2>&1 \

package/skills/render-paper/extract-pdf-facts.harness.mjs

@@ -10,7 +10,6 @@
  *
  * The shim imports the compiled package (`dist/`), so `npm run build` runs before this.
  */
-import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
 import {
   cpSync,
@@ -25,16 +24,13 @@ import {
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createChecker } from "../../lib/check.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const SHIM = join(HERE, "extract-pdf-facts.mjs");
 const FIX = resolve(HERE, "..", "..", "fixtures", "pdf-facts");
 
-let n = 0;
-const check = (label, cond, detail = "") => {
-  assert.ok(cond, detail ? `${label} — ${detail}` : label);
-  n++;
-};
+const check = createChecker();
 
 const root = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-extract-")));
 /**
@@ -49,6 +45,16 @@ const shim = (args, env = {}) =>
       PATH: process.env.PATH,
       HOME: root,
       CLAUDE_PROJECT_DIR: root,
+      // Forwarded, not chosen: under `npm run coverage` these carry the coverage directory and the
+      // preload that resolves dist/ to src/. Dropping them measured the shim's dist/ imports as a
+      // second copy of each module (the function map remapped through source maps, with shifted
+      // columns), so every function it did not call counted as uncovered in src/.
+      ...(process.env.NODE_OPTIONS
+        ? { NODE_OPTIONS: process.env.NODE_OPTIONS }
+        : {}),
+      ...(process.env.NODE_V8_COVERAGE
+        ? { NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE }
+        : {}),
       ...env,
     },
   });
@@ -157,10 +163,53 @@ try {
     missing.status === 3 && /not built/.test(said(missing)),
     said(missing),
   );
+
+  // ── a PDF named directly, in a directory with no paperlint.json, no project dir set ──
+  const loose = join(root, "papers", "loose");
+  mkdirSync(loose, { recursive: true });
+  cpSync(join(FIX, "t3-mixed.pdf"), join(loose, "draft.pdf"));
+  const direct = shim([join(loose, "draft.pdf")], { CLAUDE_PROJECT_DIR: "" });
+  const looseFacts = join(loose, "_build", "paper.facts.json");
+  check(
+    "a PDF path: facts go to its directory's _build/, the path printed relative to the cwd",
+    direct.status === 0 &&
+      direct.stdout.startsWith(
+        "✅ draft.pdf → papers/loose/_build/paper.facts.json (",
+      ) &&
+      JSON.parse(readFileSync(looseFacts, "utf8")).venue === null,
+    said(direct),
+  );
+  // The project directory IS the facts file (nonsense, but an environment can say it): the
+  // relative path would be empty, so the absolute one is printed instead of nothing.
+  const same = shim([join(loose, "draft.pdf")], {
+    CLAUDE_PROJECT_DIR: looseFacts,
+  });
+  check(
+    "a project dir equal to the facts file prints the absolute path, never an empty one",
+    same.stdout.startsWith(`✅ draft.pdf → ${looseFacts} (`),
+    said(same),
+  );
+
+  // ── a file that is not a PDF: refused, strict or not, in the words for the mode ──
+  writeFileSync(join(loose, "broken.pdf"), "not a pdf at all\n");
+  const brokenStrict = shim([join(loose, "broken.pdf"), "--strict"]);
+  const brokenLocal = shim([join(loose, "broken.pdf")]);
+  check(
+    "an unreadable PDF: --strict exits 1 as an environment error; locally exit 0, saying THE PDF IS NOT CHECKED",
+    brokenStrict.status === 1 &&
+      /🛑 facts not taken: .* — in CI this is an environment error/.test(
+        brokenStrict.stderr,
+      ) &&
+      brokenLocal.status === 0 &&
+      /⏭️ {2}facts not taken: .*THE PDF IS NOT CHECKED/.test(
+        brokenLocal.stderr,
+      ),
+    `${said(brokenStrict)}\n---\n${said(brokenLocal)}`,
+  );
 } finally {
   rmSync(root, { recursive: true, force: true });
 }
 
 console.log(
-  `✓ ${String(n)} assertions passed — extract-pdf-facts: the exit-code contract, schema 2, and the no-no-yes font`,
+  `✓ ${String(check.count)} assertions passed — extract-pdf-facts: the exit-code contract, schema 2, and the no-no-yes font`,
 );

package/skills/tighten-paper/__snapshots__/structure.test.mjs.snap

@@ -0,0 +1,133 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`--section=1 keeps section 1 and its sub-sections, and nothing before it 1`] = `
+"
+=== full.md — outline, in order ===
+   own  total  share  section
+    10     16  53.3%  1 Introduction
+                     ↳ [7/10 KEEP] carries: the claim
+     4                    1.1 Detail
+                         ↳ carries: a sub-point
+     2                    1.2 Bare sub
+                         ↳ 🔴 no carries: note — nobody has said why this section is here
+
+body total 30 words across 4 sections
+
+=== outside the page limit ===
+    40               Limitations
+                     ↳ 🔴 no carries: note — and no page limit forcing the question
+     5                   Scope
+                         ↳ carries: why the scope note
+    30               Appendix A
+                     ↳ carries: the raw tables
+
+free total 75 words = 250% of the body
+🔴 The unbudgeted half is LARGER than the paper. Nothing prices these sections, which
+   is exactly why prose settles here. Ask of each: would a reviewer miss it?
+
+The rest is judgement and stays with the skill: is this the ORDER a stranger needs, does each
+heading name a thing, and does each section earn its place. Read the headings as a set — a
+stranger should be able to reconstruct the argument from them alone.
+"
+`;
+
+exports[`the inventory of body-only.md 1`] = `
+"
+=== body-only.md — outline, in order ===
+   own  total  share  section
+     8      8  66.7%  1 Intro
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+     4      4  33.3%  2 Rest
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+     0      0   0.0%  3 Empty
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+
+body total 12 words across 3 sections
+
+The rest is judgement and stays with the skill: is this the ORDER a stranger needs, does each
+heading name a thing, and does each section earn its place. Read the headings as a set — a
+stranger should be able to reconstruct the argument from them alone.
+"
+`;
+
+exports[`the inventory of full.md 1`] = `
+"
+=== full.md — outline, in order ===
+   own  total  share  section
+     3                    Orphan sub
+    10     16  53.3%  1 Introduction
+                     ↳ [7/10 KEEP] carries: the claim
+     4                    1.1 Detail
+                         ↳ carries: a sub-point
+     2                    1.2 Bare sub
+                         ↳ 🔴 no carries: note — nobody has said why this section is here
+     6      6  20.0%  2 Method
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+     5      5  16.7%  3 Results
+                     ↳ [?/10 CUT] carries: only a verdict
+     3      3  10.0%  Discussion
+                     ↳ [4/10 NO VERDICT] carries: score only
+
+body total 30 words across 4 sections
+
+=== outside the page limit ===
+    40               Limitations
+                     ↳ 🔴 no carries: note — and no page limit forcing the question
+     5                   Scope
+                         ↳ carries: why the scope note
+    30               Appendix A
+                     ↳ carries: the raw tables
+
+free total 75 words = 250% of the body
+🔴 The unbudgeted half is LARGER than the paper. Nothing prices these sections, which
+   is exactly why prose settles here. Ask of each: would a reviewer miss it?
+
+The rest is judgement and stays with the skill: is this the ORDER a stranger needs, does each
+heading name a thing, and does each section earn its place. Read the headings as a set — a
+stranger should be able to reconstruct the argument from them alone.
+"
+`;
+
+exports[`the inventory of no-appendix.md 1`] = `
+"
+=== no-appendix.md — outline, in order ===
+   own  total  share  section
+     8      8 100.0%  1 Intro
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+
+body total 8 words across 1 sections
+
+=== outside the page limit ===
+     3               Limitations
+                     ↳ 🔴 no carries: note — and no page limit forcing the question
+
+free total 3 words = 38% of the body
+
+The rest is judgement and stays with the skill: is this the ORDER a stranger needs, does each
+heading name a thing, and does each section earn its place. Read the headings as a set — a
+stranger should be able to reconstruct the argument from them alone.
+"
+`;
+
+exports[`the inventory of refs-first.md 1`] = `
+"
+=== refs-first.md — outline, in order ===
+   own  total  share  section
+     8      8 100.0%  1 Intro
+                     ↳ 🔴 no carries: note — nobody has said why this section is here
+
+body total 8 words across 1 sections
+
+=== outside the page limit ===
+     2               References
+                     ↳ 🔴 no carries: note — and no page limit forcing the question
+     2               Ethical note
+                     ↳ 🔴 no carries: note — and no page limit forcing the question
+
+free total 4 words = 50% of the body
+
+The rest is judgement and stays with the skill: is this the ORDER a stranger needs, does each
+heading name a thing, and does each section earn its place. Read the headings as a set — a
+stranger should be able to reconstruct the argument from them alone.
+"
+`;