projectkeeper 0.0.0-stage → 1.0.0

package/src/keeper/organize/absence.ts

@@ -0,0 +1,266 @@
+/**
+ * Absence claims carry what was read, and a lane's Unsure stays unsure (CN, E152; Spec §2.12 没有痕迹，要读过才算, §3.3 抽查).
+ *
+ * The spot-check of the CM run found 3 wrong out of 29, all three absence or list claims written at the synthesis, none
+ * a fill error. Two notes stated as fact what a lane had marked Unsure: after the owner's D1 question 「底稿里未见后续回答」
+ * — the lane had not read the sessions after 09-30, and the fix shipped that evening. One cited a source that does not
+ * hold what it was cited for.
+ *
+ * - **An absence claim** is a note, or a six-things judgement of "dropped along the way" (3) or "let pass" (5), that says
+ *   something has no follow-up, was let pass, or was taken up by nobody (`ABSENCE_WORDS`: the kinds the spot-check checks
+ *   in full). It carries `looked`: where it was looked for, and up to when — the idea of `pk_record_looked` for
+ *   breakpoint candidates. The writers refuse the claim without it (tools.ts `pk_write_note`, clerk-tools.ts `pk_tag_six`).
+ * - **A look that does not reach the present says so in the claim's text.** The present is the ledger's: its newest
+ *   session message when sessions were read (`sessionsUpTo`), its newest commit otherwise (`upTo`). A claim whose look
+ *   stops earlier is stamped `As far as read — …` on the line everyone reads, so it reads "as far as … read", never a
+ *   bare "no follow-up" (`stampAsFarAs`).
+ * - **The lanes' Unsure items** are listed for the synthesis job (D103: in its task) and for the spot-check
+ *   (`laneUnsure`, `unsureBlock`): each is read to settle it, or written as unsure; never restated as fact.
+ *
+ * The program reads and compares; whether something was handled is the model's judgement.
+ */
+import { Ledger } from '../../ledger/index.ts';
+import type { AbsenceLooked, ClerkRound, RoundDoc } from '../../model/k-types.ts';
+
+export type { AbsenceLooked } from '../../model/k-types.ts';
+import type { ProjectStore } from '../../store/project-store.ts';
+
+// ───────────────────────── which text is an absence claim ─────────────────────────
+
+/**
+ * Words that say something has no follow-up, was let pass, or was taken up by nobody. Narrower than the claim words the
+ * program lists later mentions for (process/claim-check.ts `CLAIM_WORDS`): "still open" and "open items" state what a
+ * report says, not that nothing came after.
+ */
+export const ABSENCE_WORDS = new RegExp([
+  '[无没未][^。，,；;\\n]{0,4}(?:处置|处理|跟进|下文|后续|修复?|接手?|回应|回答|答复|落实)',
+  '无人|没人|没有人|放过去|放过了|被放过|不了了之|石沉大海',
+  '\\blet pass\\b|\\bnobody\\b|\\bno one\\b|\\bnot (?:handled|fixed|addressed|followed up|re-?checked|picked up|taken up|answered)\\b|\\bunhandled\\b|\\bunanswered\\b',
+  '\\b(?:no|without) (?:follow-?up|disposition|handling|successor|answer|reply|later (?:ticket|commit|record|answer))\\b|\\bnever (?:handled|fixed|followed up|picked up|addressed|answered|taken up)\\b',
+  '\\bdropped along the way\\b',
+].join('|'), 'i');
+
+/** The lines of a text that claim an absence. */
+export function absenceClaims(text: string): string[] {
+  return text.split(/\r?\n/).map((l) => l.trim()).filter((l) => l && ABSENCE_WORDS.test(l));
+}
+
+/** The six things whose judgement is an absence claim: dropped along the way (3), let pass (5). */
+export const ABSENCE_THINGS: readonly number[] = [3, 5];
+
+// ───────────────────────── what was read ─────────────────────────
+
+/** The newest session message and the newest commit the ledger holds (ISO times), or null where it holds none. */
+export interface LedgerPresent {
+  readonly sessions: string | null;
+  readonly commits: string | null;
+}
+
+export function ledgerPresent(ledger: Ledger | null): LedgerPresent {
+  if (!ledger) return { sessions: null, commits: null };
+  const one = (sql: string): string | null => { try { return ((ledger.db.prepare(sql).get() as { t: string | null } | undefined)?.t) ?? null; } catch { return null; } };
+  return {
+    sessions: one('SELECT max(coalesce(ended_at, started_at)) AS t FROM sessions WHERE missing = 0 AND messages > 0'),
+    commits: one('SELECT max(committer_at) AS t FROM commits'),
+  };
+}
+
+/** The ledger's present for a store; nothing when the project has no ledger yet. */
+export function presentOf(store: ProjectStore): LedgerPresent {
+  let ledger: Ledger | null = null;
+  try { ledger = Ledger.openDir(store.dir); } catch { ledger = null; }
+  try { return ledgerPresent(ledger); } finally { ledger?.close(); }
+}
+
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+/** A date or a date-time as milliseconds; a date alone reaches to the end of that day. Null when it is neither. */
+function reachMs(value: string): number | null {
+  const v = value.trim();
+  const ms = Date.parse(DATE_ONLY.test(v) ? `${v}T23:59:59.999Z` : v);
+  return Number.isNaN(ms) ? null : ms;
+}
+/** How much later the ledger's newest entry may be and the look still reaches it: the minute the reading took. */
+const REACH_SLACK_MS = 5 * 60_000;
+const short = (iso: string): string => (DATE_ONLY.test(iso.trim()) ? iso.trim() : new Date(iso).toISOString().slice(0, 16).replace('T', ' ') + 'Z');
+
+/** What lies beyond a look, in words, or null when it reaches the ledger's present. */
+export function behindOf(looked: Pick<AbsenceLooked, 'upTo' | 'sessionsUpTo'>, present: LedgerPresent): string | null {
+  const parts: string[] = [];
+  const check = (read: string | null | undefined, newest: string | null, what: string) => {
+    if (!read || !newest) return;
+    const a = reachMs(read), b = reachMs(newest);
+    if (a === null || b === null || a + REACH_SLACK_MS >= b) return;
+    parts.push(`${what} to ${short(read)}; the ledger has ${what} to ${short(newest)}`);
+  };
+  check(looked.sessionsUpTo, present.sessions, 'sessions');
+  check(looked.upTo, present.commits, 'commits');
+  return parts.length ? parts.join(' · ') : null;
+}
+
+/** `where` names sessions (a session id, the word) although no `sessionsUpTo` says how far they were read. */
+const NAMES_SESSIONS = /\bsessions?\b|会话|底稿|\bdrafts?\b|\btranscripts?\b/i;
+
+/**
+ * `looked` as a call gives it — `{ where, upTo, sessionsUpTo? }` — checked; a string says what is wrong with it.
+ */
+export function parseLooked(raw: unknown): { where: string[]; upTo: string; sessionsUpTo: string | null } | string {
+  const p = (raw ?? {}) as Record<string, unknown>;
+  const where = [...new Set((Array.isArray(p.where) ? p.where : []).filter((w): w is string => typeof w === 'string').map((w) => w.trim()).filter(Boolean))];
+  if (!where.length) return 'looked.where: each place you read for what came after (a file with its section or lines, a ledger query, a commit range, a session), so the spot-check can read it again.';
+  const upTo = typeof p.upTo === 'string' ? p.upTo.trim() : '';
+  if (!upTo || reachMs(upTo) === null) return 'looked.upTo: up to when your reading reaches — the date or time (2026-09-30, or 2026-09-30T19:53Z) of the newest commit, document version or report you read; a file read as it stands now reaches today.';
+  const sessionsUpTo = typeof p.sessionsUpTo === 'string' && p.sessionsUpTo.trim() ? p.sessionsUpTo.trim() : null;
+  if (sessionsUpTo && reachMs(sessionsUpTo) === null) return 'looked.sessionsUpTo: the time of the last session message you read (2026-09-30T19:53Z).';
+  if (!sessionsUpTo && where.some((w) => NAMES_SESSIONS.test(w))) return 'looked.where names sessions: give looked.sessionsUpTo, the time of the last session message you read, so the claim says how far the sessions were read.';
+  return { where, upTo, sessionsUpTo };
+}
+
+/** `looked` as it is kept: what the call gave, who looked and when, and what the ledger holds beyond it. */
+export function lookedRecord(given: { where: string[]; upTo: string; sessionsUpTo: string | null }, present: LedgerPresent, by: { readonly roundId: string | null; readonly jobId: string | null; readonly at: string }): AbsenceLooked {
+  return { where: given.where, upTo: given.upTo, ...(given.sessionsUpTo ? { sessionsUpTo: given.sessionsUpTo } : {}), roundId: by.roundId, jobId: by.jobId, at: by.at, behind: behindOf(given, present) };
+}
+
+/** The refusal of a writer given an absence claim with no `looked`. */
+export function absenceRefusal(what: string, claims: readonly string[]): string {
+  const quoted = claims.slice(0, 2).map((c) => `“${c.length > 120 ? `${c.slice(0, 119)}…` : c}”`).join(', ');
+  return `${what} says something has no follow-up, was let pass or was taken up by nobody${quoted ? ` (${quoted})` : ''}. Such a claim carries what was read: give looked: { where: [each place you read for what came after], upTo: the date or time your reading reaches, sessionsUpTo: the time of the last session message you read, when sessions were read }. A lane’s Unsure you did not settle by reading is written as unsure, not as a finding. Nothing was written.`;
+}
+
+// ───────────────────────── as far as read ─────────────────────────
+
+/** The words a claim opens with when its look does not reach the ledger's present. */
+export const AS_FAR_AS = 'As far as read';
+const STAMP = /^\[As far as read — [^\]]*\]\s*/;
+
+/**
+ * The claim's line with what its look leaves unread written in front — `[As far as read — sessions to …; the ledger has
+ * sessions to …] …` — or without it when the look reaches the present (an earlier stamp is taken off).
+ */
+export function stampAsFarAs(text: string, looked: Pick<AbsenceLooked, 'behind'> | null | undefined): string {
+  const bare = text.replace(STAMP, '');
+  return looked?.behind ? `[${AS_FAR_AS} — ${looked.behind}] ${bare}` : bare;
+}
+
+/** `looked` in one line, for the spot-check's list and a tool's answer. */
+export function lookedLine(l: AbsenceLooked): string {
+  return `looked in ${l.where.join('; ')} · up to ${short(l.upTo)}${l.sessionsUpTo ? ` · sessions to ${short(l.sessionsUpTo)}` : ''}${l.behind ? ` · does not reach the present (${l.behind})` : ''}`;
+}
+
+/**
+ * The absence claims this round wrote, each with what was read, for the spot-check (the list `pk_record_looked` gives it
+ * for breakpoint candidates): it reads past where each look stopped.
+ */
+export function absenceLookedBlock(store: ProjectStore, round: Pick<ClerkRound, 'id'>): string {
+  const lines: string[] = [];
+  for (const n of store.notes.filter((x) => x.looked?.roundId === round.id && x.status === 'Current')) lines.push(`- note ${n.id} “${n.versions[n.versions.length - 1]?.title ?? ''}”: ${lookedLine(n.looked!)}`);
+  for (const m of store.marks.filter((x) => x.looked?.roundId === round.id && !x.closed)) lines.push(`- mark ${m.id} (${m.kind} on ${m.targetId}): ${lookedLine(m.looked!)}`);
+  for (const s of store.sendbacks.filter((x) => x.looked?.roundId === round.id)) lines.push(`- send-back ${s.id} (to ${s.to}): ${lookedLine(s.looked!)}`);
+  const head = `=== Absence claims this round wrote, with what was read (${lines.length}): read past where each look stopped — the later sessions, commits and tickets — before you call one Right`;
+  return lines.length ? [head, ...lines].join('\n') : `${head}\nNone carries a look: a "no follow-up", "let pass" or "nobody took it up" in a document of this round has to be checked from the start.`;
+}
+
+// ───────────────────────── the lanes' Unsure ─────────────────────────
+
+export interface UnsureItem {
+  /** The lane whose report says it, and the report. */
+  readonly lane: string;
+  readonly reportId: string;
+  /** The line of the report it starts on. */
+  readonly line: number;
+  readonly text: string;
+}
+
+const UNSURE_WORD = /unsure|不确定|拿不准|没把握/i;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+/** Another part of a report named in the same heading or label: where the Unsure part ends. */
+const OTHER_PART = /looked for|not found|not read|proposed|找过|没找到|没读|未读|提议/i;
+/** A bold label at the start of a line or bullet: `**Unsure**：…`, `- **Looked for, not found**: …`. */
+const LABEL = /^\s*(?:[-*+]\s+)?\*\*\s*([^*]{1,60}?)\s*\*\*\s*[:：]?\s*(.*)$/;
+const ENUM = /[①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳]/;
+const NOTHING = /^(?:无|没有|none|nothing|n\/a|—|-)[。.\s]*$/i;
+const tidy = (s: string): string => s.replace(/^\s*(?:[-*+]|\d{1,2}[.)、])\s+/, '').replace(/\s+/g, ' ').trim();
+
+/** One run of an Unsure part into its items: by its circled numbers when it counts them, else as it stands. */
+function itemsOf(text: string): string[] {
+  const t = tidy(text);
+  if (!t || NOTHING.test(t)) return [];
+  // Counted ①②③: one item each. A lone circled number is a pointer to a section of the report, not a count.
+  if (!(t.includes('①') && t.includes('②'))) return [t];
+  return t.split(/(?=[①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳])/).map((x) => x.trim().replace(/[；;。]\s*$/, '')).filter((x) => ENUM.test(x.slice(0, 1)));
+}
+
+/**
+ * The Unsure items of a lane report (the skills' Report format ends with **Unsure**): what stands under a heading that
+ * says Unsure — the whole section when the heading names nothing else, the part labelled Unsure when it names other
+ * parts too (`## Unsure / Looked for, not found`) — and a bold `**Unsure**` label anywhere, with what follows it up to
+ * the next label, bullet of the same list, blank line or heading. A list counted ①②③ is one item each.
+ */
+export function unsureIn(markdown: string): { line: number; text: string }[] {
+  const lines = markdown.split(/\r?\n/);
+  const out: { line: number; text: string }[] = [];
+  const seen = new Set<number>();
+  const push = (line: number, text: string) => { for (const t of itemsOf(text)) out.push({ line, text: t }); };
+  /** A labelled part: from its label's line to the next label, heading or blank line. */
+  const labelled = (i: number, rest: string): number => {
+    const parts = [rest];
+    let j = i + 1;
+    for (; j < lines.length; j++) {
+      const l = lines[j]!;
+      if (!l.trim() || HEADING.test(l) || LABEL.test(l)) break;
+      parts.push(l);
+    }
+    for (let k = i; k < j; k++) seen.add(k);
+    // Bullets under the label are items of their own; a run of plain lines is one.
+    const bullets = parts.slice(1).filter((l) => /^\s*(?:[-*+]|\d{1,2}[.)、])\s+/.test(l));
+    if (bullets.length && bullets.length === parts.length - 1) { if (parts[0]!.trim()) push(i + 1, parts[0]!); bullets.forEach((b, k) => push(i + 2 + k, b)); } else push(i + 1, parts.join(' '));
+    return j;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const h = HEADING.exec(lines[i]!);
+    if (h && UNSURE_WORD.test(h[2]!)) {
+      const level = h[1]!.length;
+      let end = i + 1;
+      while (end < lines.length && !(HEADING.test(lines[end]!) && HEADING.exec(lines[end]!)![1]!.length <= level)) end++;
+      const mixed = OTHER_PART.test(h[2]!);
+      for (let j = i + 1; j < end; j++) {
+        const l = lines[j]!;
+        if (seen.has(j) || !l.trim()) continue;
+        const label = LABEL.exec(l);
+        if (label) { if (UNSURE_WORD.test(label[1]!)) j = labelled(j, label[2]!) - 1; else { seen.add(j); if (mixed) { let k = j + 1; while (k < end && lines[k]!.trim() && !LABEL.test(lines[k]!) && !HEADING.test(lines[k]!)) seen.add(k++); j = k - 1; } } continue; }
+        if (mixed) continue;   // a mixed section's unlabelled lines belong to no part the program can tell
+        seen.add(j);
+        // A bullet with its continuation lines is one item.
+        const parts = [l];
+        while (j + 1 < end && lines[j + 1]!.trim() && !/^\s*(?:[-*+]|\d{1,2}[.)、])\s+/.test(lines[j + 1]!) && !LABEL.test(lines[j + 1]!) && !HEADING.test(lines[j + 1]!)) { j++; seen.add(j); parts.push(lines[j]!); }
+        push(j - parts.length + 2, parts.join(' '));
+      }
+      i = end - 1;
+      continue;
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    if (seen.has(i)) continue;
+    const label = LABEL.exec(lines[i]!);
+    if (label && UNSURE_WORD.test(label[1]!)) i = labelled(i, label[2]!) - 1;
+  }
+  return out.sort((a, b) => a.line - b.line);
+}
+
+/** The Unsure items of this round's lane reports, by lane, in the order written. */
+export function laneUnsure(store: ProjectStore, round: Pick<ClerkRound, 'id'>): UnsureItem[] {
+  const reports: RoundDoc[] = store.roundDocs.filter((d) => d.roundId === round.id && d.kind === 'Report').sort((a, b) => a.at.localeCompare(b.at));
+  return reports.flatMap((d) => unsureIn(d.markdown).map((u) => ({ lane: d.path ?? d.title, reportId: d.id, line: u.line, text: u.text })));
+}
+
+const clip = (s: string, n: number): string => (s.length > n ? `${s.slice(0, n - 1)}…` : s);
+
+/** The block the synthesis job gets in its task (D103), and the spot-check with its targets. */
+export function unsureBlock(store: ProjectStore, round: Pick<ClerkRound, 'id'>, opts: { readonly forStep?: 'synthesis' | 'spot-check' } = {}): string {
+  const items = laneUnsure(store, round);
+  const head = `=== What the lanes marked Unsure (${items.length}): each is unsure until someone reads what settles it`;
+  if (!items.length) return `${head}\nNo lane report of this round has an Unsure item.`;
+  const rule = opts.forStep === 'spot-check'
+    ? 'A note, a send-back or the Result that states one of these as fact, without naming what was read to settle it, is Wrong as written: correct it to unsure, or settle it by reading.'
+    : 'Before you write one of these into a note, a send-back or the Result: read what settles it, and say what you read (looked) — or write it as unsure, with what was not read. Never restate it as a fact.';
+  return [head, rule, ...items.map((u) => `- ${u.lane} (${u.reportId}:${u.line}): ${clip(u.text, 320)}`)].join('\n');
+}

package/src/keeper/organize/carried-on.ts

@@ -0,0 +1,214 @@
+/**
+ * Carried on under the same number (CZ; Spec §2.12, D100 「上几代写去向、不标废弃」).
+ *
+ * An earlier generation lists the work it planned (`Generation.workIds`). Some of that work went on under its own number:
+ * the current plan lists the same contract, and the workbench holds one item for it. That item is current work in its
+ * current plan — the generation only shows it, with the destination "carried on". Everywhere else an item a generation
+ * lists is earlier work (the process engine lights nothing on it, its steps are history, the code it built is an
+ * earlier generation's), so every reader of `workIds` that means "earlier work" asks here: `earlierWork` leaves the
+ * carried-on items out.
+ *
+ * The rule is the item's state, not who wrote the membership (on the CQ run the main agent listed the 27 current
+ * contracts in the second generation by hand; from CZ the program lists them itself): the item is not Replaced,
+ * Abandoned or Removed, and it carries a number that a current document listing work has as a row, or that a current
+ * contract is named by. Which documents list work, and what a row is, are read here off the layer map, the documents'
+ * names and the ledger's definitions; generation-check.ts reads a candidate set's numbers with the same rules.
+ *
+ * Without a ledger nothing is known to be carried on, and every listed item is earlier work, as before.
+ */
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import { Ledger } from '../../ledger/index.ts';
+import { definitionsInPath, definitionsInText } from '../../ledger/numbering.ts';
+import type { LayerKind } from '../../model/k-types.ts';
+import type { ProjectStore } from '../../store/project-store.ts';
+import { entryDefinitions } from './entries.ts';
+
+export const slash = (p: string): string => p.replace(/\\/g, '/').replace(/\/+$/, '');
+
+/** A directory name under which projects keep what was superseded. */
+const ARCHIVAL = /^(?:archives?|archived|superseded.*|deprecated|obsolete|legacy|old|attic|history|_?deleted?|归档|旧版?本?|废弃|历史)$/i;
+
+/**
+ * The archived set a path belongs to, or null: the archival directory and the dated or named set under it
+ * (`design/archive/superseded-by-v0.4-20260916/…` is one set); a document directly in the archive belongs to the archive
+ * itself (`subagent/archive/plan.md`). `dir` says the path is a directory, so its last segment may be the set.
+ */
+export function archiveRootOf(path: string, dir = false): string | null {
+  const segs = slash(path).split('/');
+  const i = segs.findIndex((s) => ARCHIVAL.test(s));
+  if (i < 0) return null;
+  const hasSet = dir ? i + 1 < segs.length : i + 2 < segs.length;
+  return segs.slice(0, hasSet ? i + 2 : i + 1).join('/');
+}
+
+/** The layers whose documents list work as rows — a plan's tables, a task index, a contract set, an execution arrangement. */
+const ROW_LAYERS: ReadonlySet<LayerKind> = new Set<LayerKind>(['Plan', 'Task index', 'Task contract', 'Execution arrangement']);
+const SEP = String.raw`[\/_.\s-]`;
+/** A name holding one of the words as a word of its own (between separators), or one of the CJK words anywhere. */
+export const nameSays = (words: string, cjk: string): RegExp => new RegExp(`(?:^|${SEP})(?:${words})(?:${SEP}|$)|${cjk}`, 'i');
+/** A name that says the document lists work: a plan, a roadmap, an index, a set of contracts or tasks. */
+const ROW_NAME = nameSays('plans?|roadmap|backlog|milestones?|index|contracts?|tasks?|tickets?|issues?|todo', '计划|合同|任务|路线图|索引|清单');
+/** A name that says it is something else: a readme, requirements, a specification, modules, a design, decisions, a report. */
+const OTHER_NAME = nameSays('readme|prd|specs?|product|modules?|requirements?|designs?|decisions?|adrs?|notes?|reports?|reviews?|changelog', '需求|模块|决定|决策|设计|说明');
+
+/** The layer entry over a path: the file's own, else the longest directory above it. */
+export function layerEntryOver(store: ProjectStore, path: string) {
+  return store.layers.filter((l) => slash(l.path) === path || path.startsWith(`${slash(l.path)}/`)).sort((a, b) => slash(b.path).length - slash(a.path).length)[0] ?? null;
+}
+
+/**
+ * Whether a document lists work as its rows. The layer the orientation mapped the file itself to decides; else its
+ * name, then the names of the directories above it — inside its set when `root` is one, nearest first; else the layer of
+ * the directory the layer map names.
+ */
+export function listsWork(store: ProjectStore, root: string | null, path: string): boolean {
+  const own = store.layers.find((l) => slash(l.path) === path && /\.[A-Za-z0-9]{1,6}$/.test(path));
+  if (own) return ROW_LAYERS.has(own.layer);
+  const inside = root === null ? path.split('/') : path === root ? path.split('/').slice(-1) : path.slice(root.length + 1).split('/');
+  for (const seg of [...inside].reverse()) {
+    if (ROW_NAME.test(seg)) return true;
+    if (OTHER_NAME.test(seg)) return false;
+  }
+  const over = layerEntryOver(store, path);
+  return over ? ROW_LAYERS.has(over.layer) : false;
+}
+
+export interface DefRow { readonly num: string; readonly rule: string; readonly repo: string | null; readonly path: string; readonly position: string | null; readonly kind: string; readonly current: number }
+export interface LedgerDefs { readonly rows: readonly DefRow[]; readonly byNum: ReadonlyMap<string, readonly DefRow[]>; readonly repoPaths: ReadonlyMap<string, string>; readonly entries: Map<string, readonly { num: string; rule: string; position: string }[] | null> }
+/** Every definition the ledger holds in a document or a file name, read once per opened ledger (a few thousand rows). */
+const DEFS = new WeakMap<Ledger, LedgerDefs>();
+export function ledgerDefs(ledger: Ledger): LedgerDefs {
+  let d = DEFS.get(ledger);
+  if (!d) {
+    const rows = (ledger.db.prepare("SELECT DISTINCT num, rule, repo, path, position, kind, current FROM nums WHERE place = 'definition' AND kind IN ('doc', 'file-name') AND path IS NOT NULL").all() as unknown as DefRow[]);
+    const byNum = new Map<string, DefRow[]>();
+    for (const r of rows) byNum.set(r.num, [...(byNum.get(r.num) ?? []), r]);
+    d = { rows, byNum, repoPaths: new Map(ledger.repos().map((r) => [r.id, r.path])), entries: new Map() };
+    DEFS.set(ledger, d);
+  }
+  return d;
+}
+
+/**
+ * A document's own entries as it stands in the checkout — its definitions at entry positions, less the points of another
+ * numbered entry (entries.ts) — read from the text the ledger keeps; null when the ledger keeps no current text of it.
+ */
+export function currentEntries(ledger: Ledger, defs: LedgerDefs, repo: string | null, path: string): readonly { num: string; rule: string; position: string }[] | null {
+  const k = `${repo ?? ''}\u0000${path}`;
+  if (!defs.entries.has(k)) {
+    const text = repo ? ledger.currentText(`${defs.repoPaths.get(repo) ?? ''}/${path}`) : null;
+    defs.entries.set(k, text === null ? null : entryDefinitions(
+      definitionsInText(text).filter((d) => d.position === 'heading' || d.position === 'bold entry' || d.position === 'table first column').map((d) => ({ num: d.num, rule: d.family, position: d.position, line: d.line ?? 0 })),
+      text.split(/\r?\n/),
+    ));
+  }
+  return defs.entries.get(k)!;
+}
+
+/** The positions a row of a plan stands at: a heading, or the first cell of a table row (a bold line is a log's entry). */
+export const ROW_POSITIONS: ReadonlySet<string> = new Set(['heading', 'table first column']);
+
+export interface CurrentRows {
+  readonly defs: LedgerDefs;
+  /** A document that is not current: under an archive, mapped not current, or under one of the roots given. */
+  readonly setAside: (path: string) => boolean;
+  /** A document named by a number: that item's own document, whose rows are its points. */
+  readonly numberNamed: (path: string) => boolean;
+  /** A file-name definition that is the file's own name (not a directory above it). */
+  readonly namedByOwnNumber: (r: DefRow) => boolean;
+  /** The current documents that list a number as a row of their own. */
+  readonly currentRowsOf: (n: string) => DefRow[];
+  /**
+   * Carried on: a current document that lists work has the number as a row, or a current file among such documents is
+   * named by it (a contract in the contract set). A report that tabulates it, or one named after it, does not carry it on.
+   */
+  readonly isCurrent: (n: string) => boolean;
+}
+
+/** What the current documents list as rows, read off the ledger. `alsoAside` are roots to treat as set aside besides the archives. */
+export function currentRows(store: ProjectStore, ledger: Ledger, alsoAside: readonly string[] = []): CurrentRows {
+  const defs = ledgerDefs(ledger);
+  const aside = new Map<string, boolean>();
+  const setAside = (path: string): boolean => {
+    if (!aside.has(path)) aside.set(path, alsoAside.some((x) => path === x || path.startsWith(`${x}/`)) || archiveRootOf(path) !== null || layerEntryOver(store, path)?.current === false);
+    return aside.get(path)!;
+  };
+  const namedByOwnNumber = (r: DefRow): boolean => r.kind === 'file-name' && definitionsInPath(r.path.split('/').pop() ?? r.path).some((d) => d.num === r.num);
+  const numbered = new Map<string, boolean>();
+  const numberNamed = (path: string): boolean => {
+    if (!numbered.has(path)) numbered.set(path, definitionsInPath(path.split('/').pop() ?? path).some((d) => (defs.byNum.get(d.num) ?? []).some((r) => r.kind === 'file-name' && r.path === path)));
+    return numbered.get(path)!;
+  };
+  const currentRowsOf = (n: string): DefRow[] => (defs.byNum.get(n) ?? []).filter((d) => d.kind === 'doc' && d.current === 1 && !setAside(d.path) && ROW_POSITIONS.has(d.position ?? '')
+    && (currentEntries(ledger, defs, d.repo, d.path)?.some((e) => e.num === n && ROW_POSITIONS.has(e.position)) ?? true));
+  const listed = new Map<string, boolean>();
+  const isCurrent = (n: string): boolean => {
+    if (!listed.has(n)) listed.set(n, currentRowsOf(n).some((d) => !numberNamed(d.path) && listsWork(store, null, d.path))
+      || (defs.byNum.get(n) ?? []).some((d) => d.kind === 'file-name' && d.current === 1 && !setAside(d.path) && namedByOwnNumber(d) && listsWork(store, null, d.path)));
+    return listed.get(n)!;
+  };
+  return { defs, setAside, numberNamed, namedByOwnNumber, currentRowsOf, isCurrent };
+}
+
+const ENDED: ReadonlySet<string> = new Set(['Replaced', 'Abandoned', 'Removed']);
+
+/**
+ * The work items a generation lists that were carried on under the same number (see the module comment): current work,
+ * whatever generation lists them and whoever listed them. Empty without a ledger.
+ */
+export function carriedOnItems(store: ProjectStore, ledger: Ledger | null): Set<string> {
+  const out = new Set<string>();
+  const listed = new Set(store.generations.all().flatMap((g) => g.workIds));
+  if (!ledger || !listed.size) return out;
+  let rows: CurrentRows;
+  try { rows = currentRows(store, ledger); } catch { return out; }
+  for (const id of listed) {
+    const t = store.threads.get(id);
+    if (!t || ENDED.has(t.validity)) continue;
+    if (t.ids.some((i) => rows.isCurrent(i.trim().toUpperCase()) || rows.isCurrent(i.trim()))) out.add(id);
+  }
+  return out;
+}
+
+const CACHE = new WeakMap<ProjectStore, { mark: string; carried: Set<string> }>();
+const fileMark = (path: string): string => { try { const s = statSync(path); return `${s.size}:${Math.round(s.mtimeMs)}`; } catch { return '-'; } };
+
+/**
+ * `carriedOnItems` for a reader that has only the store: the project's ledger is opened here, and the answer is kept
+ * until the generations, their items, the layer map or the ledger change.
+ */
+export function carriedOn(store: ProjectStore): Set<string> {
+  const gens = store.generations.all();
+  if (!gens.some((g) => g.workIds.length)) return new Set();
+  const mark = [
+    fileMark(join(store.dir, 'ledger.sqlite')), fileMark(join(store.dir, 'ledger.sqlite-wal')),
+    gens.map((g) => `${g.id}:${g.workIds.map((id) => { const t = store.threads.get(id); return t ? `${id}/${t.validity}/${t.ids.join(',')}` : id; }).join(';')}`).join('|'),
+    store.layers.all().map((l) => `${l.path}/${l.layer}/${l.current ? 1 : 0}`).join('|'),
+  ].join('#');
+  const hit = CACHE.get(store);
+  if (hit && hit.mark === mark) return hit.carried;
+  let ledger: Ledger | null = null;
+  try { ledger = Ledger.openDir(store.dir); } catch { ledger = null; }
+  let carried = new Set<string>();
+  try { carried = carriedOnItems(store, ledger); } catch { carried = new Set(); } finally { ledger?.close(); }
+  CACHE.set(store, { mark, carried });
+  return carried;
+}
+
+/**
+ * The work of earlier generations: what the generations list, less what was carried on under the same number. This is
+ * what "in an earlier generation" means to every reader that treats such work as history.
+ */
+export function earlierWork(store: ProjectStore): Set<string> {
+  const listed = store.generations.all().flatMap((g) => g.workIds);
+  if (!listed.length) return new Set();
+  const carried = carriedOn(store);
+  return new Set(listed.filter((id) => !carried.has(id)));
+}
+
+/** The earlier generation a work item belongs to as earlier work, or undefined: a carried-on item belongs to none. */
+export function earlierGenerationOf(store: ProjectStore, workId: string) {
+  const g = store.generations.find((x) => x.workIds.includes(workId));
+  return g && !carriedOn(store).has(workId) ? g : undefined;
+}