@sabaiway/agent-workflow-kit 9.0.0 → 10.1.0

package/tools/fold-scope.mjs

@@ -44,25 +44,52 @@ const contains = (haystack, needle) => normalize(haystack).toLowerCase().include
 // AND a boundary: it closes the block it interrupts, so text past a fence can never join the bullet
 // before it (which would let a far-side literal satisfy a near-side claim). A `-` plus any whitespace
 // run opens a block; a blank or indented line continues it; any other unindented line closes it.
-// Blocks are returned RAW (their own lines) — the queue reader needs the field lines inside them.
-const bulletBlocks = (lines, fencedLines, from, to) => {
+// Blocks are returned RAW (their own lines) — the queue reader needs the field lines inside them —
+// each carrying the body index it OPENS at, because a second reader (queue-audit.mjs) reports rows by
+// file line and a scan that dropped the index would have to re-derive it against a different grammar.
+//
+// `fenceContinues` is the SECOND reader's question, and it is a different one. A deferral row asks
+// what a bullet CLAIMS, so a fence must cut it. A queue row asks what a bullet COSTS and whether it
+// is still work, and there the fence-as-boundary is a hole: measured, a row carrying a code block
+// reported ONE line and its `**DONE 2026-01-01:**` two lines further down was invisible, so the
+// per-row cap could be walked straight past and a closure went unseen.
+//
+// Under the option only a NESTED fence continues an open block — one whose opening line is indented,
+// which is what makes it part of the list item at all. A fence opening at column 0 is a
+// DOCUMENT-level block and still closes the row, exactly as an unindented line does; absorbing it
+// charged a one-line row for six. The run is decided ONCE, at its opening line, so a content line
+// inside it cannot re-decide the question.
+//
+// The absorbed lines never enter `lines` — a marker inside a quotation is not a status — so the
+// block records where they were: `span` is the row's PHYSICAL extent, and `gaps` holds the `lines`
+// indices a fence run follows, so a reader assembling a multi-line span cannot join text from both
+// sides of a code block into one claim.
+export const bulletBlocks = (lines, fencedLines, from, to, { fenceContinues = false } = {}) => {
   const blocks = [];
   let current = null;
+  let absorbing = null;
   const close = () => {
     if (current) blocks.push(current);
     current = null;
   };
   for (let index = from; index < to; index += 1) {
     if (fencedLines.has(index)) {
-      close();
+      if (absorbing === null) absorbing = Boolean(fenceContinues && current && /^\s+\S/.test(lines[index]));
+      if (!absorbing) close();
+      else {
+        current.span += 1;
+        current.gaps.add(current.lines.length - 1);
+      }
       continue;
     }
+    absorbing = null;
     const line = lines[index];
     if (BULLET.test(line)) {
       close();
-      current = [line];
+      current = { start: index, lines: [line], span: 1, gaps: new Set() };
     } else if (current && (line.trim() === '' || /^\s+\S/.test(line))) {
-      current.push(line);
+      current.lines.push(line);
+      current.span += 1;
     } else {
       close();
     }
@@ -83,7 +110,7 @@ export const extractAcceptance = (planText) => {
   if (!open) return [];
   const next = headings.find((heading) => heading.index > open.index && heading.level <= 2);
   return bulletBlocks(lines, fencedLines, open.index + 1, next ? next.index : lines.length)
-    .map((block) => normalize(block.join('\n').replace(/^-\s+/, '')))
+    .map((block) => normalize(block.lines.join('\n').replace(/^-\s+/, '')))
     .filter(Boolean);
 };
 
@@ -134,7 +161,7 @@ const exposureOf = (value) => {
 
 const topLevelRows = (queueText) => {
   const { lines, fencedLines } = tokenizeMarkdown(String(queueText ?? ''), 'the queue');
-  return bulletBlocks(lines, fencedLines, 0, lines.length).map((block) => block.join('\n'));
+  return bulletBlocks(lines, fencedLines, 0, lines.length).map((block) => block.lines.join('\n'));
 };
 
 const EMPTY_ROW = () => ({ found: false, matches: 0, fields: {}, missing: [...ROW_FIELDS], duplicates: [], exposure: null, closed: null, claimInInvariant: false });

package/tools/queue-audit-cli.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+// The CLI half of the queue auditor: argv and fs, no rule (the rule is queue-audit.mjs).
+//
+// Split for the same reason fold-scope is split — a module you can hold whole is the unit of review,
+// and the rules file had reached the source-size cap. Read-only: it reads the file it is pointed at
+// and writes nothing. Dependency-free, Node >= 22.
+//
+// Exit codes: 0 accept; 1 refuse (a terminal/record row still listed, or a cap breach); 2 usage —
+// a missing/unknown flag, a flag with no value, an unreadable path, or a section that is not there.
+
+import { readFileSync } from 'node:fs';
+import { fail } from '../references/scripts/markdown-blocks.mjs';
+import { isDirectRun } from './direct-run.mjs';
+import { CLASSES, DEFAULTS, auditQueue, checkQueue, formatReport } from './queue-audit.mjs';
+
+const HELP = `queue-audit — classify the backlog queue's rows (agent-workflow family).
+
+Usage:
+  node queue-audit-cli.mjs --report <queue-file> [--section "## Pending / backlog (newest)"]
+  node queue-audit-cli.mjs --check  <queue-file> [--section "…"] [--max-rows N] [--max-row-lines N]
+
+--report  one tab-separated line per row: file line, class, row length, title, the literal evidence.
+          Deterministic — this is the manifest a deletion is driven by, never a regex guess.
+--check   refuses when a terminal or record row is still listed, when a row over the per-row line cap
+          carries work (live, parked and ambiguous alike), or when more rows than the row cap carry
+          work. Ambiguous rows are reported and never refuse on their own: a row that contradicts
+          itself, or names a status word outside a status position, is settled by a human.
+
+Classes: ${CLASSES.join(' · ')}. Defaults: --max-rows ${DEFAULTS.maxRows}, --max-row-lines ${DEFAULTS.maxRowLines}.
+
+Exit codes: 0 accept; 1 refuse; 2 usage (missing/unknown flag, unreadable path, bad section).`;
+
+// A flag whose value is MISSING refuses. `--section` with nothing after it used to fall through to
+// `null`, which means "audit the whole document" — silently widening the domain of a report a
+// deletion is driven by, in exactly the direction that costs live rows.
+const valueOf = (argv, index, flag) => {
+  const value = argv[index + 1];
+  if (value === undefined || value === '' || value.startsWith('--')) throw fail(2, `${flag} takes a value`);
+  return value;
+};
+
+const parseArgv = (argv) => {
+  // `--help` is answered ONLY when it is the whole invocation. A help flag that wins from anywhere
+  // makes `--check <dirty-file> --help` exit 0 — the gate's refusal replaced by a help page, which
+  // is the same bypass a second mode flag would be, reached by a flag nobody reads as dangerous.
+  if (argv.length === 1 && (argv[0] === '--help' || argv[0] === '-h')) return { mode: 'help' };
+  const options = { mode: null, path: null, section: null };
+  // Every option here is a SINGLETON. A repeat used to win silently: a second `--section` moved the
+  // domain the report covers and a softer `--max-rows` moved the ratchet, both without a word — and
+  // both in the direction that lets a queue keep rows a check would have refused.
+  const seen = new Set();
+  const once = (flag) => {
+    if (seen.has(flag)) throw fail(2, `${flag} was given twice — each option is named exactly once`);
+    seen.add(flag);
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--help' || arg === '-h') throw fail(2, '--help is answered only when it is the whole invocation — it never rides another mode');
+    else if (arg === '--report' || arg === '--check') {
+      // The mode is set ONCE. A later flag overwriting an earlier one would let `--check <f>
+      // --report <f>` answer a refusal question with an exit-0 report — the gate's verdict replaced
+      // by a listing, silently. Repetition is as wrong as conflict: both mean the caller asked two
+      // questions and only one was answered.
+      if (options.mode) throw fail(2, `--${options.mode} was already given — name exactly one of --report or --check`);
+      options.mode = arg.slice(2);
+      options.path = valueOf(argv, index, arg);
+      index += 1;
+    } else if (arg === '--section') {
+      once(arg);
+      options.section = valueOf(argv, index, arg);
+      index += 1;
+    } else if (arg === '--max-rows' || arg === '--max-row-lines') {
+      once(arg);
+      const value = Number(valueOf(argv, index, arg));
+      if (!Number.isInteger(value) || value <= 0) throw fail(2, `${arg} takes a positive integer, got "${argv[index + 1]}"`);
+      options[arg === '--max-rows' ? 'maxRows' : 'maxRowLines'] = value;
+      index += 1;
+    } else throw fail(2, `unknown argument "${arg}" — run with --help`);
+  }
+  if (!options.mode) throw fail(2, 'one of --report or --check is required — run with --help');
+  if (!options.path) throw fail(2, `${`--${options.mode}`} takes a queue file path`);
+  // A cap named beside `--report` used to be accepted and then ignored, and the run still exited 0 —
+  // so an operator who meant to ask a question about the caps was told nothing and read the silence
+  // as an answer. The caps belong to `--check`; naming one here is a usage error, not a no-op.
+  const capsInReport = ['--max-rows', '--max-row-lines'].filter((flag) => seen.has(flag));
+  if (options.mode === 'report' && capsInReport.length) {
+    throw fail(2, `${capsInReport.join(' and ')} ${capsInReport.length > 1 ? 'are' : 'is'} a --check option — --report lists every row and judges no cap`);
+  }
+  return options;
+};
+
+export const main = (argv, { log = console.log, error = console.error } = {}) => {
+  let options;
+  try {
+    options = parseArgv(argv);
+  } catch (err) {
+    error(err.message);
+    return err.exitCode ?? 2;
+  }
+  if (options.mode === 'help') {
+    log(HELP);
+    return 0;
+  }
+
+  let text;
+  try {
+    text = readFileSync(options.path, 'utf8');
+  } catch (err) {
+    error(`cannot read ${options.path}: ${err.message}`);
+    return 2;
+  }
+
+  try {
+    if (options.mode === 'report') {
+      log(formatReport(auditQueue(text, { section: options.section, label: options.path }), { label: options.path }));
+      return 0;
+    }
+    const result = checkQueue(text, { ...options, label: options.path });
+    for (const note of result.notes) log(note);
+    for (const problem of result.problems) error(problem);
+    log(
+      `${options.path}: ${result.total} rows — ` +
+        CLASSES.map((klass) => `${result.counts[klass]} ${klass}`).join(' · '),
+    );
+    return result.ok ? 0 : 1;
+  } catch (err) {
+    error(err.message);
+    return err.exitCode ?? 1;
+  }
+};
+
+// `process.exitCode`, never `process.exit()`: stdout is a PIPE under a gate runner, and an immediate
+// exit drops whatever of a large `--report` has not been flushed yet. A truncated manifest is worse
+// than none — it is the document a deletion is driven by, and a short one reads as a complete one.
+if (isDirectRun(import.meta.url)) process.exitCode = main(process.argv.slice(2));

package/tools/queue-audit-rows.mjs

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+// The STATUS GRAMMAR of a queue row: what one row says about its own state, and the literal evidence
+// for saying it. The DOCUMENT pass — which rows exist, which section they live in, what the caps say
+// — is queue-audit.mjs, and the argv/fs half is queue-audit-cli.mjs. Split at the seam the source-size
+// practice asks for: a module you can hold whole is the unit of review.
+//
+// Five classes, and the boundaries between them are deliberately conservative, because the consumer
+// of a `terminal` verdict is a DELETION:
+//
+//   live       no status marker decides otherwise — the default, and what a queue should hold.
+//   terminal   the row is DEAD — done, closed, superseded, moot, declined: a marker in the TITLE, or
+//              a marker OPENING a bold status line in the body (`**CLOSED 2026-07-20 …**`). The body
+//              decides when the title is silent — the real shape of a row that was closed in place.
+//   parked     the row is FROZEN, not dead: `PARKED` / `STOPPED` carry a stated resume condition, so
+//              deleting one loses work that is only waiting. Reported, never deleted, never a refusal.
+//   record     the row is not work at all: a TALLY counter or a SEQUENCING note.
+//   ambiguous  the row declares two states, or names a status word outside a status position.
+//              REPORTED, never auto-deleted.
+//
+// A terminal WORD in ordinary prose is NOT a status: rows routinely cite a sibling that was CLOSED or
+// explain why something was CUT, and reading that as the row's own state would delete live work. Only
+// the title and a bold status line are status positions.
+//
+// Pure string functions. No IO, no argv, no side effects on import. Dependency-free, Node >= 22.
+
+// The closed list the queue actually uses. `DONE` and `CLOSED` are the two fold-scope already knows
+// (its CLOSED_MARKERS); the rest are the states this corpus grew on its own. The check mark is a
+// marker in its own right because the file's DONE-entry convention leads with it.
+export const TERMINAL_MARKERS = ['✅', 'DONE', 'CLOSED', 'RESOLVED', 'DECIDED', 'SUPERSEDED', 'MOOT', 'DECLINED'];
+
+// FROZEN, not dead: each of these carries a stated condition under which the work resumes (measured:
+// "costs nothing until one is adopted again", "do NOT open tranche 4", "do NOT schedule without
+// recurring incidents"). They are classified apart precisely so a deletion pass cannot take them.
+export const FROZEN_MARKERS = ['PARKED', 'STOPPED'];
+
+// A title marker that declares the row still OPEN. Only these two: they are the ones the corpus
+// writes deliberately, and a wider list would turn ordinary words into status.
+export const LIVE_MARKERS = ['QUEUED', 'PENDING'];
+
+// Not work: a counter and an ordering note. Matched at the START of the title only.
+export const RECORD_PREFIXES = ['TALLY', 'SEQUENCING'];
+
+export const CLASSES = ['live', 'terminal', 'parked', 'record', 'ambiguous'];
+
+// The classes that still carry work, and therefore still cost a reader attention: both caps judge
+// exactly these.
+export const CARRY_WORK = new Set(['live', 'parked', 'ambiguous']);
+
+export const DEFAULTS = { maxRows: 60, maxRowLines: 12 };
+
+// A row is judged on the text it DECLARES, never on the text it QUOTES, and this is the ONE place
+// that distinction is made. Every quotation this grammar can recognise is removed before any marker
+// is looked for, and each is replaced by a SPACE so the tokens around it never become neighbours:
+//
+//   inline code  `` `DONE 2026-01-01` is parser input `` names a literal. Stripping the backticks and
+//                keeping the text turned a row ABOUT the parser into a closed row — a deletion.
+//   indented     a body line indented past the row's own continuation (2 spaces here, plus Markdown's
+//   code block   4) is a code block, so `      **DONE 2026-02-01:** sample` is sample output, not this
+//                row's status.
+//
+// A fenced region is handled one level up, by the block scan, and reaches here as a `gaps` boundary.
+// What remains is deliberately NOT exhaustive: this is a hand-written reader over a corpus, so the
+// residue is stated in the contract rather than guessed at, and the classes it can still misread are
+// reported (`ambiguous`), never deleted.
+const INLINE_CODE = /`[^`\n]*`/g;
+const CODE_INDENT = /^\s{6,}\S/;
+const quoteFree = (line) => String(line ?? '').replace(/\r/g, '').replace(INLINE_CODE, ' ');
+const judgeable = (line) => (CODE_INDENT.test(String(line ?? '')) ? '' : quoteFree(line));
+
+// The TITLE is the row's first bold span — `- **… — queued 2026-08-26.** prose` — and it ENDS where
+// that span closes, even when it wraps over several lines. Both halves matter: taking the whole first
+// line would read a sibling named in the prose after the title (`Its sibling was CLOSED …`) as this
+// row's own status, and taking only the first line would lose the marker of a title that wraps — the
+// common shape here, since a named row puts its id and `queued <date>` on the second line. A row with
+// no bold span falls back to its first line.
+export const titleOf = (blockLines, gaps = new Set()) => {
+  // A title never closes ACROSS a code block: the fenced lines a row absorbs are elided from its
+  // lines, so without this bound an opener above a fence and a `:**` below it become adjacent and a
+  // title assembles itself out of two halves the document never joined.
+  const upTo = [...gaps].filter((at) => at >= 0).sort((a, b) => a - b)[0];
+  const reach = upTo === undefined ? blockLines.length : upTo + 1;
+  const span = (render) => {
+    const first = render(String(blockLines[0] ?? ''));
+    const joined = blockLines.slice(0, reach).map(render).join('\n');
+    const open = first.indexOf('**');
+    const close = open === -1 ? -1 : joined.indexOf('**', open + 2);
+    return {
+      raw: close === -1 ? first : joined.slice(open + 2, close),
+      endLine: close === -1 ? 0 : joined.slice(0, close).split('\n').length - 1,
+    };
+  };
+  const flatten = (raw) => raw.replace(/^\s*[-*]\s+/, '').replace(/[*_]/g, '').replace(/\s+/g, ' ').trim();
+  // TWO renderings of one title, and the split is the point. `text` is what a HUMAN reads in the
+  // manifest, so it keeps every word the row wrote — eliding quoted code there turned readable titles
+  // into gaps ("codex and") in the very document a deletion is driven by. `judged` is what the
+  // MARKERS are looked for in, with quotations removed, so a row that names a literal is never
+  // mistaken for a row that declares a state.
+  const display = span((line) => String(line ?? '').replace(/\r/g, ''));
+  const judged = span(quoteFree);
+  return { text: flatten(display.raw).replace(/`/g, ''), judged: flatten(judged.raw), endLine: display.endLine };
+};
+
+// A word-boundary match that survives punctuation the corpus writes (`— CLOSED 2026-08-21 ·`), and
+// that never fires inside a longer word (`UNDECIDED`, `PARKED-ish`). The HYPHEN is a boundary that
+// does NOT count: every row id here is a kebab slug, so `IS-A-CLOSED-LIST` carries the word CLOSED as
+// part of a NAME, and reading that as the row's own status would delete live work (measured — it was
+// the only false positive in the 272-row corpus). The check mark is not a word character, so it is
+// matched literally.
+//
+// CASE is asymmetric, and the asymmetry is measured, not stylistic. A real status here is SHOUTED
+// (`QUEUED` · `DONE` · `CLOSED` · `PARKED`), while the same words in lower case are ordinary prose:
+// matching terminal markers case-insensitively flipped EIGHT live rows to terminal in one pass —
+// "(decided 2026-07-22)", "…is DEFERRED until resolved", "the class gets asked for … done" — every
+// one a false positive, every one a deletion. Live markers are the opposite: the corpus writes
+// `queued 2026-08-26` in lower case, so a case-sensitive live marker never fires and the
+// contradiction arm that PROTECTS a row goes dead. So: terminal and frozen are case-sensitive, live
+// is not. The cost of the split is a non-standard lower-case dead row staying `live` — visible, and
+// far cheaper than deleting work.
+// ONE identifier-aware boundary, used by every marker test here: a marker glued to any identifier
+// character — letter, DIGIT, underscore or hyphen — belongs to a NAME, not to a status. Measured
+// misses when it was letters-and-hyphen only: `DONE2-STATE-IS-UNREACHABLE` and
+// `CLOSED_LOOP-DESIGN-IS-UNDOCUMENTED` are live rows named after the thing they fix.
+// A TOP-LEVEL list item the row grammar does not take: a `*` or `+` bullet — with content or EMPTY,
+// since an empty one still opens a list whose indented content the audit would then never judge — or
+// a `-` with nothing after it. Indented items are nested content of a row and are read as its body.
+export const UNREAD_ITEM = /^(?:[*+](?:\s+\S|\s*$)|-\s*$)/;
+
+const IDENT = '[A-Za-z0-9_-]';
+const carries = (text, marker, { anyCase = false } = {}) =>
+  /^[A-Za-z]+$/.test(marker)
+    ? new RegExp(`(?<!${IDENT})${marker}(?!${IDENT})`, anyCase ? 'i' : '').test(text)
+    : text.includes(marker);
+
+const markersIn = (text, list, options) => list.filter((marker) => carries(text, marker, options));
+
+// A BOLD status line: `**CLOSED 2026-07-20 (…):** the story`. Anchored at the start of the line
+// (indent allowed) so a bold phrase mid-sentence is never a status, and requiring the marker to open
+// the bold span so `**Fix (small canon change):**` cannot become one.
+// A bold status may WRAP: the opener sits on one line and the `:**` on the next — two rows of the
+// live corpus are written that way, and a per-line matcher called both of them live, which is a
+// false GREEN from the gate that authorises deletions. So the span is read across continuation
+// lines, bounded so a `**` that never closes cannot swallow the rest of the row.
+const BOLD_OPEN = /^\s*\*\*\s*(.*)$/;
+const BOLD_SPAN_LINES = 4;
+
+// A span never reaches ACROSS a code block. The fenced lines a row absorbs are elided from its
+// lines, so without the gap set an opener above a fence and a `:**` below it become adjacent and
+// assemble into one claim that the document never made.
+const boldSpanAt = (blockLines, index, gaps = new Set()) => {
+  const first = BOLD_OPEN.exec(judgeable(blockLines[index]));
+  if (!first) return null;
+  let span = first[1];
+  for (let step = 0; step < BOLD_SPAN_LINES; step += 1) {
+    const close = span.indexOf('**');
+    if (close !== -1) return span.slice(0, close).replace(/:\s*$/, '');
+    const next = blockLines[index + step + 1];
+    if (next === undefined || gaps.has(index + step)) return null;
+    span += ` ${judgeable(next).trim()}`;
+  }
+  return null;
+};
+// The marker must OPEN the bold span, as a WHOLE token. A QUALIFIED closure closes a PART of the row,
+// not the row: `**PART (2) IS CLOSED …**`, `**SECOND FACE CLOSED …**`, `**+ bare-lane DECIDED …**`,
+// `**DISPOSITION DECIDED …**` all leave work behind, and five of the six body-decided rows in the live
+// corpus were exactly that shape. The token boundary matters too — `**CLOSED-loop design:**` is a
+// subheading about a loop, not a closure. A bare check mark with no word after it (`**✅ 2026-08-20:**`)
+// IS a status: the corpus leads its done entries with it.
+const LEAD_WORD = new RegExp(`^([A-Za-z]+)(?!${IDENT})`);
+const DATE = /^\d{4}-\d{2}-\d{2}/;
+// A real status carries its DATE, and that is measured, not stylistic: across the 272-row corpus the
+// status forms are `DONE 2026-08-21 ·`, `CLOSED 2026-07-20 (…)`, `SUPERSEDED 2026-08-21 by the row
+// above`, `PARKED 2026-08-21 by AD-105`, `RESOLVED 2026-08-25 —`; the same words in prose never do —
+// `STOPPED. That is`, `PARKED rather than`, `RESOLVED; the npm-pack`, `SUPERSEDED by a`. Requiring
+// the date is what keeps a row NAMED after the machinery it fixes (`CLOSED STATUS PARSER DROPS ROWS`,
+// `**DONE criteria:**`) out of the deletion set. A marker without one is not ignored — it makes the
+// row `ambiguous`, for a human.
+// The date is ADJACENT to the marker. A 40-character window of arbitrary text between the two was
+// measured wrong: `**DONE criteria due 2026-09-01:**` — a live row stating when its criteria are due
+// — read as a closure, and this verdict authorises a DELETION. The only gap the corpus actually
+// writes is a SECOND shouted status word introduced by `+`: `DONE + SHIPPED 2026-07-09`,
+// `DONE + PUBLISHED 2026-08-25` (measured — those three rows and nothing else in 6900 lines). So the
+// gap is exactly that, never prose: a `+` must introduce every extra word, which is what keeps
+// `DONE criteria due <date>` and `DONE CRITERIA <date>` out of the deletion set.
+const DATED_STATUS = /^(?:\s*\+\s*[A-Z][A-Z-]*)*\s*\d{4}-\d{2}-\d{2}/;
+
+// The markers OPENING a span, as whole tokens. A leading check mark alone declares NOTHING: the
+// corpus writes `**✅ ENTRY GATE OPEN:**` for a live gate, so the mark must be followed by a terminal
+// word or by a date — the form its done entries actually use (`**✅ 2026-08-20 (AD-100):**`).
+// `requireDate: false` answers the WEAKER question — does this span OPEN with a status word at all —
+// which is what separates "no status here" from "a status word with no date beside it". The second
+// is not silence: it is a row a human has to settle.
+export const leadMarkers = (span, list = TERMINAL_MARKERS, { requireDate = true } = {}) => {
+  let rest = String(span).replace(/\r/g, '').trimStart();
+  const tick = rest.startsWith('✅');
+  if (tick) rest = rest.slice(1).trimStart();
+  const word = LEAD_WORD.exec(rest);
+  const named = word ? list.filter((m) => m === word[1]) : [];
+  if (named.length && (!requireDate || DATED_STATUS.test(rest.slice(word[1].length)))) {
+    return tick ? ['✅', ...named] : named;
+  }
+  // A BARE check mark declares nothing on its own — the corpus writes `**✅ ENTRY GATE OPEN …**` for
+  // a LIVE gate — so it counts only in its DATED form, and the weaker question never takes it.
+  // Measured: dropping that guard turned three live rows into ambiguous, this one among them.
+  if (!named.length && tick && list.includes('✅') && requireDate && DATE.test(rest)) return ['✅'];
+  return [];
+};
+
+// A STATUS sits at the head of the title or at the head of one of its segments — `✅ DONE 2026-…`,
+// `A-ROW — ✅ CLOSED 2026-…`, `SUPERSEDED 2026-… by the row above`. A marker anywhere else is a
+// MENTION: `THE CLOSED state drops live work` is a defect report about closed state, not a closed
+// row, and deleting it would take live work. ONLY the documented separators split a segment — the
+// spaced dash family the corpus writes its status after. A bare hyphen would cut every kebab id into
+// pieces; a bracket or a colon would make `(CLOSED is an input)` and `note: DONE is a token` into
+// status heads, which is a row ABOUT status words being deleted for containing them.
+const SEGMENT_SPLIT = /\s+[—–]\s+/;
+const statusMarkersIn = (title, list) => [
+  ...new Set(
+    String(title)
+      .split(SEGMENT_SPLIT)
+      .flatMap((segment) => leadMarkers(segment, list)),
+  ),
+];
+
+const boldStatusMarkers = (blockLines, from, { list = TERMINAL_MARKERS, gaps, ...options } = {}) => {
+  for (let offset = from + 1; offset < blockLines.length; offset += 1) {
+    const span = boldSpanAt(blockLines, offset, gaps);
+    if (span === null) continue;
+    const found = leadMarkers(span, list, options);
+    if (found.length) return { markers: found, offset };
+  }
+  return null;
+};
+
+const evidenceOf = (parts) => parts.filter(Boolean).join(' + ');
+
+// classifyRow(blockLines) -> { klass, evidence }. The order of the arms IS the rule: a record is
+// judged before any status, a contradiction before the state it contradicts, and `live` is what
+// survives when nothing else decided.
+export const classifyRow = (blockLines, gaps) => {
+  const { judged: title, endLine } = titleOf(blockLines, gaps);
+  // The prefix must be a whole token: `TALLYING-FAILURES-HAS-NO-RUNG` and `SEQUENCING-BUG-IN-THE-
+  // DISPATCHER` are work, and a bare `startsWith` would have the checker demand their deletion.
+  const record = RECORD_PREFIXES.find((prefix) => new RegExp(`^${prefix}(?!${IDENT})`).test(title));
+  if (record) return { klass: 'record', evidence: `title opens with ${record}` };
+
+  // EVERY status of every class is gathered BEFORE anything is decided. Deciding as they were found
+  // made two states unreachable: a frozen title returned before the contradiction arms could see a
+  // live marker beside it, so `PARKED … — QUEUED …` read as simply parked, and the body was scanned
+  // for terminal markers only, so a dated `**PARKED 2026-08-21 …**` closing a row in place was not a
+  // state at all.
+  const titleFrozen = statusMarkersIn(title, FROZEN_MARKERS);
+  const titleTerminal = statusMarkersIn(title, TERMINAL_MARKERS);
+  const titleLive = markersIn(title, LIVE_MARKERS, { anyCase: true });
+  const bodyTerminal = boldStatusMarkers(blockLines, endLine, { gaps });
+  const bodyFrozen = boldStatusMarkers(blockLines, endLine, { gaps, list: FROZEN_MARKERS });
+  // The body declares LIVE too, and leaving it out of the table was the dangerous half: a row whose
+  // body said `**QUEUED 2026-08-20:**` and then `**CLOSED 2026-01-01:**` was read as simply closed —
+  // a contradiction handed to a deletion as a verdict. A live marker never needs its date here (the
+  // corpus writes `queued` in lower case, and the arm that reads it PROTECTS the row).
+  const bodyLive = boldStatusMarkers(blockLines, endLine, { gaps, list: LIVE_MARKERS, requireDate: false });
+  // A marker the title carries somewhere OTHER than a status head. It cannot decide the row, and it
+  // cannot be ignored either — a human settles it. The check mark STAYS in this path, and the
+  // asymmetry with the body side is measured, not an oversight: in a TITLE the corpus writes
+  // `✅ Plan 3 / 3 — …` as a done marker (ten such rows), so dropping it turned ten reported rows
+  // silent; in a BOLD BODY span it writes `**✅ ENTRY GATE OPEN …**` for a gate that OPENED. Same
+  // glyph, two positions, two meanings — and the position is what this module already reads.
+  const mentioned = markersIn(title, [...TERMINAL_MARKERS, ...FROZEN_MARKERS]).filter(
+    (marker) => !titleTerminal.includes(marker) && !titleFrozen.includes(marker),
+  );
+  if (!titleTerminal.length && !titleFrozen.length && mentioned.length) {
+    return { klass: 'ambiguous', evidence: `title mentions ${mentioned.join(', ')} outside a status position` };
+  }
+  // A row that declares two states declares none: it is REPORTED, and a human settles it. The title
+  // and the body are read into ONE table and reduced by CLASS, never by position — an earlier version
+  // let the title's own state hide the body's, so a terminal title above a `**PARKED <date>:**` body
+  // stayed terminal and kept authorising a deletion while the row declared two things. Two sightings
+  // of the SAME class are one state (a title and a body that agree do not contradict).
+  const sightings = [
+    titleTerminal.length && { klass: 'terminal', evidence: `title: ${titleTerminal.join(', ')}` },
+    titleFrozen.length && { klass: 'parked', evidence: `title: ${titleFrozen.join(', ')}` },
+    titleLive.length && { klass: 'live', evidence: `title: ${titleLive.join(', ')}` },
+    bodyTerminal && { klass: 'terminal', evidence: `body +${bodyTerminal.offset}: ${bodyTerminal.markers.join(', ')}` },
+    bodyFrozen && { klass: 'parked', evidence: `body +${bodyFrozen.offset}: ${bodyFrozen.markers.join(', ')}` },
+    bodyLive && { klass: 'live', evidence: `body +${bodyLive.offset}: ${bodyLive.markers.join(', ')}` },
+  ].filter(Boolean);
+  const declared = [...new Set(sightings.map((s) => s.klass))];
+  if (declared.length > 1) return { klass: 'ambiguous', evidence: evidenceOf(sightings.map((s) => s.evidence)) };
+  if (declared.length === 1 && declared[0] !== 'live') {
+    return { klass: declared[0], evidence: evidenceOf(sightings.map((s) => s.evidence)) };
+  }
+
+  // A bold body span that OPENS with a status word but carries no date beside it is the residue of
+  // the date rule, and silence is the wrong answer for it: `**DONE criteria due 2026-09-01:**` used
+  // to be read as a closure, and the fix must not turn it into "nothing to see". It is REPORTED as
+  // ambiguous — visible to a human, never deletable by a machine. Measured: with the bare-check-mark
+  // guard in place, zero rows in the live 314-row corpus and zero in the 62-row purge archive take
+  // this arm, so it closes a door without moving a single existing verdict.
+  const undated = boldStatusMarkers(blockLines, endLine, { gaps, requireDate: false })
+    ?? boldStatusMarkers(blockLines, endLine, { gaps, list: FROZEN_MARKERS, requireDate: false });
+  if (undated) {
+    return {
+      klass: 'ambiguous',
+      evidence: `body +${undated.offset}: ${undated.markers.join(', ')} with no date beside it`,
+    };
+  }
+
+  return { klass: 'live', evidence: 'no status marker' };
+};
+
+// The `[from, to)` body-line window a `--section` names: it opens after that heading and closes at