@sabaiway/agent-workflow-kit 11.2.0 → 12.1.0

package/tools/queue-audit-rows.mjs

@@ -23,6 +23,8 @@
 //
 // Pure string functions. No IO, no argv, no side effects on import. Dependency-free, Node >= 22.
 
+import { nameOf } from './queue-row-name.mjs';
+
 // 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.
@@ -37,7 +39,9 @@ export const FROZEN_MARKERS = ['PARKED', 'STOPPED'];
 // 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.
+// Not work: a counter and an ordering note. Read by POSITION like every other status — the head of
+// the title, or the head of a ` — `-separated segment, and everywhere but the title head the marker
+// owes a DATE adjacent to it, the form the counter is always written in.
 export const RECORD_PREFIXES = ['TALLY', 'SEQUENCING'];
 
 export const CLASSES = ['live', 'terminal', 'parked', 'record', 'ambiguous'];
@@ -97,7 +101,9 @@ export const titleOf = (blockLines, gaps = new Set()) => {
   // 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 };
+  const text = flatten(display.raw).replace(/`/g, '');
+  const { name, id } = nameOf(nameSource(text));
+  return { text, name, id, judged: flatten(judged.raw), endLine: display.endLine };
 };
 
 // A word-boundary match that survives punctuation the corpus writes (`— CLOSED 2026-08-21 ·`), and
@@ -126,9 +132,11 @@ export const titleOf = (blockLines, gaps = new Set()) => {
 export const UNREAD_ITEM = /^(?:[*+](?:\s+\S|\s*$)|-\s*$)/;
 
 const IDENT = '[A-Za-z0-9_-]';
+const wordMatches = (text, marker, { anyCase = false } = {}) =>
+  Array.from(String(text).matchAll(new RegExp(`(?<!${IDENT})${marker}(?!${IDENT})`, anyCase ? 'giu' : 'gu')));
 const carries = (text, marker, { anyCase = false } = {}) =>
   /^[A-Za-z]+$/.test(marker)
-    ? new RegExp(`(?<!${IDENT})${marker}(?!${IDENT})`, anyCase ? 'i' : '').test(text)
+    ? wordMatches(text, marker, { anyCase }).length > 0
     : text.includes(marker);
 
 const markersIn = (text, list, options) => list.filter((marker) => carries(text, marker, options));
@@ -189,14 +197,17 @@ const DATED_STATUS = /^(?:\s*\+\s*[A-Z][A-Z-]*)*\s*\d{4}-\d{2}-\d{2}/;
 // `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 } = {}) => {
+export const leadMarkers = (span, list = TERMINAL_MARKERS, { requireDate = true, anyCase = false } = {}) => {
   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]) : [];
+  // The tick joins the answer only when the LIST being asked about carries it. Prepending it to a
+  // frozen, live or RECORD answer named the wrong marker in the evidence a deletion is read from.
+  const named = word ? list.filter((m) => anyCase ? m.toLowerCase() === word[1].toLowerCase() : m === word[1]) : [];
+  const withTick = (found) => (tick && list.includes('✅') ? ['✅', ...found] : found);
   if (named.length && (!requireDate || DATED_STATUS.test(rest.slice(word[1].length)))) {
-    return tick ? ['✅', ...named] : named;
+    return withTick(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.
@@ -213,14 +224,54 @@ export const leadMarkers = (span, list = TERMINAL_MARKERS, { requireDate = true
 // 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) => [
+const statusMarkersIn = (title, list, options) => [
   ...new Set(
     String(title)
       .split(SEGMENT_SPLIT)
-      .flatMap((segment) => leadMarkers(segment, list)),
+      .flatMap((segment) => leadMarkers(segment, list, options)),
   ),
 ];
 
+// The NAME is what remains after the row's own STATUS declarations, and this is where the two
+// grammars meet: the readability judge owns the sentence, this module owns the status vocabulary, so
+// the drop happens HERE rather than by restating four marker lists in a second home. Every LEADING
+// ` — `-segment that OPENS with a status word is removed before the name is cut — measured on the
+// live corpus, `PARKED 2026-08-21 by AD-105 (…) — QUEUED 2026-08-20 — B — A-PLAN-REVIEW-…` was
+// passing the readability bar with its own PARKED declaration as the row's "name", which is the
+// exact class of unreadable row the bar exists for. The date is not required here: the question is
+// only whether a human reading the head of that segment meets a status word instead of a name.
+// Stated residual: the segments are judged on the DISPLAY text, so a QUOTED status word opening a
+// segment drops it too — a stricter name, never a missed one.
+// The CASE asymmetry is the classifier's own and it holds here too: terminal, frozen and record
+// words are SHOUTED, live words are not. Reading all four case-insensitively deleted the name of a
+// row that opens with an ordinary verb — `Tally the remaining broken gates — ROW-A` lost its whole
+// name to a `TALLY` that was never there. And the remainder is returned as a SLICE of the display
+// title, never re-joined from the split parts: re-joining rewrote every en dash the row wrote into
+// an em dash, so the "name" stopped being the bytes a human is shown.
+const SHOUTED_STATUS = [...TERMINAL_MARKERS, ...FROZEN_MARKERS, ...RECORD_PREFIXES];
+const opensWithStatus = (segment) =>
+  leadMarkers(segment, SHOUTED_STATUS, { requireDate: false }).length > 0
+  // The DATED bare tick is a status the weaker question cannot see — that arm is guarded by
+  // `requireDate` — and it was the one form of status this drop still left inside a name:
+  // `✅ 2026-08-20 — PARKED 2026-08-21 by AD-105 — A-ROW` was named by its own status text and
+  // passed the bar with no finding at all, which is the blocker this drop exists to close.
+  || leadMarkers(segment, TERMINAL_MARKERS).length > 0
+  || leadMarkers(segment, LIVE_MARKERS, { requireDate: false, anyCase: true }).length > 0;
+const nameSource = (title) => {
+  const text = String(title);
+  let at = 0;
+  for (const segment of text.split(SEGMENT_SPLIT)) {
+    const start = text.indexOf(segment, at);
+    if (!opensWithStatus(segment)) return text.slice(start);
+    at = start + segment.length;
+  }
+  return '';
+};
+
+const datedMarkersIn = (title, list, options) => list.filter((marker) =>
+  wordMatches(title, marker, options).some((match) => DATED_STATUS.test(String(title).slice(match.index + match[0].length))),
+);
+
 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);
@@ -233,15 +284,20 @@ const boldStatusMarkers = (blockLines, from, { list = TERMINAL_MARKERS, gaps, ..
 
 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.
+// classifyRow(blockLines) -> { klass, evidence }. The order of the arms IS the rule: a
+// contradiction is judged before the state it contradicts, and `live` is what survives when nothing
+// else decided. A RECORD is a state like any other and is reduced with the rest: returning it early
+// made `QUEUED 2026-09-04 — TALLY 2026-09-04 — A-ROW` a deletable `record` while the row said it was
+// open, and hid a `DONE …` beside a `TALLY …` behind a single verdict.
 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}` };
+  const records = String(title)
+    .split(SEGMENT_SPLIT)
+    .flatMap((segment, index) => leadMarkers(segment, RECORD_PREFIXES, { requireDate: index !== 0 })
+      .map((prefix) => ({ prefix, index, tick: segment.trimStart().startsWith('✅') })));
+  const [record] = records;
 
   // 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
@@ -250,8 +306,20 @@ export const classifyRow = (blockLines, gaps) => {
   // 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 bodyTerminalAt = boldStatusMarkers(blockLines, endLine, { gaps });
+  // Narrowing the live reading to a status POSITION may never move a row INTO a deletable class.
+  // The narrow reading is what lets `Rows still pending a rename — A-ROW — PARKED 2026-09-04` be
+  // parked instead of ambiguous; applied to the same name beside a dated `DONE`, it deleted the
+  // contradiction and handed the row to a purge. So wherever the row already declares a TERMINAL or
+  // a RECORD state, the wide reading — a live word anywhere in the title, in any case — is added
+  // back: there it can only ever ADD ambiguity, and this grammar errs toward keeping a row.
+  const deletable = Boolean(titleTerminal.length || record || bodyTerminalAt);
+  const titleLive = [...new Set([
+    ...statusMarkersIn(title, LIVE_MARKERS, { anyCase: true, requireDate: false }),
+    ...datedMarkersIn(title, LIVE_MARKERS, { anyCase: true }),
+    ...(deletable ? markersIn(title, LIVE_MARKERS, { anyCase: true }) : []),
+  ])];
+  const bodyTerminal = bodyTerminalAt;
   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 —
@@ -264,8 +332,18 @@ export const classifyRow = (blockLines, gaps) => {
   // `✅ 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.
+  // A tick OPENING the record's own segment is consumed by that status exactly as a terminal status
+  // consumes its own: without this, `A-ROW — ✅ TALLY 2026-09-04` took the mention arm and became
+  // `ambiguous`, dropping the record refusal the row had always earned. It consumes THAT tick and no
+  // other, counted rather than assumed: suppressing every tick in the title made
+  // `✅ Plan 3 / 3 — a readable name — ✅ TALLY 2026-09-04` a DELETABLE record while one of its two
+  // done markers had nothing to do with the counter. Counting the ticks EVERY record segment
+  // consumes is what keeps `✅ TALLY 2026-09-04 — ✅ SEQUENCING 2026-09-04` the record it is.
+  const ticks = (String(title).match(/✅/gu) ?? []).length;
+  const consumed = records.filter((sighting) => sighting.tick).length;
   const mentioned = markersIn(title, [...TERMINAL_MARKERS, ...FROZEN_MARKERS]).filter(
-    (marker) => !titleTerminal.includes(marker) && !titleFrozen.includes(marker),
+    (marker) => !titleTerminal.includes(marker) && !titleFrozen.includes(marker)
+      && !(marker === '✅' && consumed > 0 && ticks <= consumed),
   );
   if (!titleTerminal.length && !titleFrozen.length && mentioned.length) {
     return { klass: 'ambiguous', evidence: `title mentions ${mentioned.join(', ')} outside a status position` };
@@ -276,6 +354,10 @@ export const classifyRow = (blockLines, gaps) => {
   // 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 = [
+    record && {
+      klass: 'record',
+      evidence: `${record.index === 0 ? 'title' : `title segment ${record.index + 1}`} opens with ${record.prefix}`,
+    },
     titleTerminal.length && { klass: 'terminal', evidence: `title: ${titleTerminal.join(', ')}` },
     titleFrozen.length && { klass: 'parked', evidence: `title: ${titleFrozen.join(', ')}` },
     titleLive.length && { klass: 'live', evidence: `title: ${titleLive.join(', ')}` },
@@ -306,5 +388,3 @@ export const classifyRow = (blockLines, gaps) => {
 
   return { klass: 'live', evidence: 'no status marker' };
 };
-
-// The `[from, to)` body-line window a `--section` names: it opens after that heading and closes at

package/tools/queue-audit.mjs

@@ -8,7 +8,7 @@
 // This module is the half prose cannot do — it says, per row and with the literal evidence, whether
 // the row is still WORK.
 //
-// Four classes, and the boundaries between them are deliberately conservative, because the consumer
+// 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.
@@ -37,10 +37,12 @@
 import { tokenizeMarkdown, fail } from '../references/scripts/markdown-blocks.mjs';
 import { bulletBlocks } from './fold-scope.mjs';
 import { CARRY_WORK, CLASSES, DEFAULTS, UNREAD_ITEM, classifyRow, titleOf } from './queue-audit-rows.mjs';
+import { nameFindings } from './queue-row-name.mjs';
 
 // The row grammar is re-exported so one import names the whole reader: the CLI, the tests and any
 // consumer ask this module, and the split into a rules half stays an implementation detail.
-export { CLASSES, DEFAULTS, TERMINAL_MARKERS, FROZEN_MARKERS, LIVE_MARKERS, RECORD_PREFIXES, classifyRow, leadMarkers } from './queue-audit-rows.mjs';
+export { CLASSES, DEFAULTS, TERMINAL_MARKERS, FROZEN_MARKERS, LIVE_MARKERS, RECORD_PREFIXES, classifyRow, leadMarkers, titleOf } from './queue-audit-rows.mjs';
+export { nameOf, nameFindings } from './queue-row-name.mjs';
 
 // The `[from, to)` body-line window a `--section` names: it opens after that heading and closes at
 // the next heading of the SAME level or higher, so a level-3 subheading stays inside. An absent
@@ -52,7 +54,7 @@ export { CLASSES, DEFAULTS, TERMINAL_MARKERS, FROZEN_MARKERS, LIVE_MARKERS, RECO
 // ATX allows an optional CLOSING run of `#`, so `## Pending ##` and `## Pending` are the SAME
 // heading. Comparing raw text made them two: the audit took one, and every row under the other left
 // the domain silently — a section full of dead rows reported as zero rows and exit 0.
-const canonicalHeading = (text) =>
+export const canonicalHeading = (text) =>
   String(text ?? '')
     .replace(/\r/g, '')
     .replace(/\s+#+\s*$/, '')
@@ -77,10 +79,34 @@ const sectionWindow = (headings, lines, section, frontLines = 0) => {
 };
 
 // auditQueue(text, { section, label }) -> { rows, counts }. Each row carries its 1-based FILE line
-// (frontmatter included), the title as written, its class and the literal evidence for that class.
+// (frontmatter included), the title as written, its class and the literal evidence for that class —
+// and beside them the fields a RENDERER reads: the row's plain `name`, the `id` the one parse cut
+// at, the `nameFindings` that name is judged by, and the line-numbered heading `buckets` it sits
+// under. They are computed here, once, so no consumer becomes a second grammar over this document.
 export const auditQueue = (text, { section = null, label = 'the queue' } = {}) => {
   const { lines, headings, fencedLines, frontLines } = tokenizeMarkdown(String(text ?? ''), label);
-  const { from, to } = sectionWindow(headings, lines, section, frontLines);
+  // ONE heading set answers BOTH questions this module asks of a heading — where a `--section` ends,
+  // and which bucket a row sits in — so the rows of the whole document are scanned FIRST and a
+  // heading a row SWALLOWS is refused. The tokenizer reads a 1-3-space indented ATX line as a
+  // heading (deliberately: a consumer's unit grammar is refused rather than guessed at) while the
+  // bullet scan reads the same line as a row CONTINUATION, and DECIDING between them silently was
+  // tried twice and was wrong twice: read raw, a `  ## Details` in a row's body ended the section
+  // early and every row after it went unjudged, and a `  ### Details` became an ancestor bucket of
+  // every following row; dropped, a `## Heading` one space under a `- ` row — where the document
+  // ends the list item and this scan does not — let the section run past a real heading into the
+  // next one. The column that would tell them apart is not knowable here either: a TAB after the
+  // bullet puts the row's body at a tab stop this hand-written reader does not compute.
+  // So the arithmetic is gone and the disposition is the one this file already gives an unread list
+  // item: a token this document reads two ways is corrected by hand. The corpus writes none — zero
+  // indented ATX headings in the 850 KB queue and in every plan and reference doc — and the
+  // correction is one keystroke in either direction, which the refusal names.
+  const documentBlocks = bulletBlocks(lines, fencedLines, 0, lines.length, { fenceContinues: true });
+  const insideARow = (index) => documentBlocks.some((block) => index > block.start && index < block.start + block.span);
+  const documentHeadings = headings.filter(({ index }) => {
+    if (!insideARow(index)) return true;
+    throw fail(2, `line ${frontLines + index + 1} is a heading this document and its row scan read differently ("${lines[index].trim().slice(0, 40)}") — the row above swallows it as body while the document opens a section there, and judging around it would report a domain that was never looked at. Indent it past three spaces to make it body, or to column 0 to make it a heading.`);
+  });
+  const { from, to } = sectionWindow(documentHeadings, lines, section, frontLines);
   // A fence CONTINUES a queue row rather than ending it, and the cap judges the row's PHYSICAL span.
   // Both halves are the same defect: a row carrying a code block reported one line and hid whatever
   // followed the fence — its length from the cap, and a closure from the classifier.
@@ -92,14 +118,28 @@ export const auditQueue = (text, { section = null, label = 'the queue' } = {}) =
     if (fencedLines.has(index) || !UNREAD_ITEM.test(lines[index])) continue;
     throw fail(2, `line ${frontLines + index + 1} opens a list item this audit does not read ("${lines[index].trim().slice(0, 40)}") — a queue row is a "- " bullet, and judging around this one would report a domain that was never looked at.`);
   }
-  const rows = bulletBlocks(lines, fencedLines, from, to, { fenceContinues: true }).map((block) => {
+  const blocks = bulletBlocks(lines, fencedLines, from, to, { fenceContinues: true });
+  const bucketsByStart = new Map();
+  const positionedHeadings = documentHeadings.map(({ index, level, text: headingText }) => ({
+    index, level, text: headingText, line: frontLines + index + 1,
+  }));
+  const events = [
+    ...positionedHeadings.map((heading) => ({ kind: 'heading', index: heading.index, heading })),
+    ...blocks.map((block) => ({ kind: 'row', index: block.start, block })),
+  ].sort((left, right) => left.index - right.index);
+  events.reduce((stack, event) => {
+    if (event.kind === 'heading') return [...stack.filter(({ level }) => level < event.heading.level), event.heading];
+    bucketsByStart.set(event.block.start, stack.map(({ level, text: headingText, line }) => ({ level, text: headingText, line })));
+    return stack;
+  }, []);
+  const rows = blocks.map((block) => {
     const { klass, evidence } = classifyRow(block.lines, block.gaps);
+    const { text: title, name, id } = titleOf(block.lines, block.gaps);
     return {
-      line: frontLines + block.start + 1,
-      lines: block.span,
-      title: titleOf(block.lines, block.gaps).text,
-      klass,
-      evidence,
+      title, name, id,
+      nameFindings: CARRY_WORK.has(klass) ? nameFindings(name, id) : [],
+      klass, line: frontLines + block.start + 1, lines: block.span,
+      buckets: bucketsByStart.get(block.start), evidence,
     };
   });
   const counts = Object.fromEntries(CLASSES.map((klass) => [klass, rows.filter((row) => row.klass === klass).length]));
@@ -109,7 +149,9 @@ export const auditQueue = (text, { section = null, label = 'the queue' } = {}) =
 // checkQueue(text, options) -> { ok, problems, notes }. A problem is a REFUSAL and every one of them
 // names a location: the family's bar is locations, never counts. An ambiguous row is a NOTE — it is
 // exactly the case a human must settle, and failing on it would make the cap unpassable by anyone
-// who did not already know the answer.
+// who did not already know the answer. A NAME finding is the same shape with an opt-in: a note by
+// default, so a gate line written before this contract keeps its verdict byte for byte, and a
+// problem under `requireNames`, which a project adds once its rows are named.
 export const checkQueue = (text, options = {}) => {
   const { maxRows = DEFAULTS.maxRows, maxRowLines = DEFAULTS.maxRowLines, label = 'the queue' } = options;
   const { rows, counts, total } = auditQueue(text, { section: options.section ?? null, label });
@@ -129,6 +171,10 @@ export const checkQueue = (text, options = {}) => {
     if (row.klass === 'parked') {
       notes.push(`${label}:${row.line}: parked (${row.evidence}) — frozen, not dead: ${row.title.slice(0, 80)}`);
     }
+    const nameResults = options.requireNames ? problems : notes;
+    for (const finding of row.nameFindings) {
+      nameResults.push(`${label}:${row.line}: name ${JSON.stringify(row.name)} (${finding.cause}) — ${finding.message}`);
+    }
     if (CARRY_WORK.has(row.klass) && row.lines > maxRowLines) {
       problems.push(
         `${label}:${row.line}: the row is ${row.lines} lines, over the ${maxRowLines}-line cap — a row names the ` +

package/tools/queue-row-name.mjs

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+// The READABILITY judge of a backlog row: can the person who owns the queue read what the work is?
+// The sibling question — is this row still WORK? — is queue-audit-rows.mjs, and the two never mix:
+// this module classifies nothing and writes nothing. Governing contract:
+// docs/ai/specs/kit/queue-row-name.md.
+//
+// Measured 2026-09-04 on this repo's own `## Pending / backlog`: 165 of 247 work-carrying rows
+// failed this bar and 121 of those opened with the id itself, so every status answer named the work
+// by machine ids the maintainer could not read. The fix is a rung, never a rule an agent remembers
+// — the remembered rule is the discipline that already failed.
+//
+// Pure string functions. No IO, no argv, no side effects on import. Dependency-free, Node >= 22.
+
+import { ROW_ID } from './feedback-record.mjs';
+
+const IDENT = '[A-Za-z0-9_-]';
+const PART = '[A-Z0-9]+';
+const LETTERED = '(?=[A-Z0-9]*[A-Z])[A-Z0-9]+';
+
+// AN ID IS A RUN THE ROW PRESENTS AS ONE — that is the whole rule, and it replaced "the first
+// shouted kebab run anywhere", which was walked around from both sides at once: it cut a SENTENCE at
+// its first shouted compound adjective (`… never a HAND-APPLY \`rm\` …` reported HAND-APPLY as the
+// row's cross-reference key), and it matched NOTHING on the real ids this corpus writes, because one
+// all-digit part killed the run — `UPGRADE-RUN-FEEDBACK-2026-08-18`, `FLOW-CHECK-64-HAS-NO-VALVE-…`
+// and `AMEND-REACHES-FOR---NO-VERIFY` each handed the WHOLE title back as its "name", id included.
+//
+// TWO grammars, and the difference is who VOUCHES for the id:
+//
+//   MARKED   `id <ID>` — the row says so, so the id is exactly what a checked record may hand over:
+//            feedback-record.mjs's ROW_ID, imported rather than restated. `FOO`, `TASK-123` and
+//            `1-TASK` are ids here, and the kit's own row writer marks its ids for this reason.
+//   UNMARKED a heuristic over a display title nobody validated, so it stays narrow: parts of
+//            upper-case letters and digits joined by one or more hyphens (the corpus writes `---`),
+//            the FIRST TWO parts each carrying a letter, the rest unconstrained. That is what keeps
+//            `AD-133` a cross-reference inside a name rather than an id. A run SPANNING its whole
+//            segment needs only its first part lettered — nothing precedes it that it could eat.
+//
+// And the POSITION is where a row PRESENTS an id: the head of a ` — `-separated segment, or before a
+// colon with nothing but WHITESPACE AND PUNCTUATION ahead of it in that segment. Both guards are
+// measured: an id read mid-sentence took a claim's own words (`Preserve id TASK-123 in output — id
+// ROW-A` answered TASK-123 rather than the row's id), and a prefix that admitted digits cut
+// `123 ROW-A: the claim remains readable` down to the name `123`. What survives is why
+// `See also FIRST-TIME-CORRECTNESS: …` keeps its name while `[ ] ROW-A: the claim` still names `[ ]`.
+const RUN = `${LETTERED}(?:-+${LETTERED})(?:-+${PART})*`;
+const SPANNING = `${LETTERED}(?:-+${PART})+`;
+const MARKED = `id(?![A-Za-z0-9_])\\s+(${ROW_ID})(?!${IDENT})`;
+const SEGMENT_SPLIT = /\s+[—–]\s+/u;
+
+// Each form says where the NAME is cut: at the segment's own start for a presented head, at the
+// `id` word for a marked id mid-sentence, and at the RUN itself for the label form — a cut at the
+// match start there would swallow the `[ ]` the checkbox row is named by.
+const FORMS = [
+  { re: new RegExp(`^(?:${MARKED}|(${SPANNING}))$`, 'du'), cut: () => 0 },
+  { re: new RegExp(`^(?:${MARKED}|(${RUN})(?!${IDENT}))`, 'du'), cut: () => 0 },
+  { re: new RegExp(`^[\\s\\p{P}\\p{S}]*?(?<!${IDENT})(${RUN})(?=:)`, 'du'), cut: (match) => match.indices[1][0] },
+];
+
+const CASED = /\p{Cased}/u;
+const LOWERCASE = /\p{Lowercase}/u;
+const LETTER = /\p{L}/u;
+const HYPHENS = /^-+$/u;
+const normalize = (value) => String(value).replace(/-/gu, ' ').replace(/\s+/gu, ' ').trim().toLowerCase();
+
+// nameOf(title) -> { name, id }. The title handed in is the DISPLAY text queue-audit already
+// renders — every word the row wrote, its backticks stripped — with its leading STATUS segments
+// already removed by the parser that owns the status vocabulary. Never the judged text, whose
+// elided quotations would leave a HOLE where a quoted word stood and report an absent name for a
+// row that reads perfectly. The boundary is stated POSITIVELY, by the id: ` — ` is the STATUS
+// grammar's segment separator, not a name boundary, so a name that carries one keeps it whole, and
+// a title that puts its id outside the bold span is named by that span entire.
+export const nameOf = (title) => {
+  const display = String(title ?? '').trim();
+  let at = 0;
+  for (const text of display.split(SEGMENT_SPLIT)) {
+    const start = display.indexOf(text, at);
+    at = start + text.length;
+    for (const form of FORMS) {
+      const match = form.re.exec(text);
+      if (!match) continue;
+      const name = display.slice(0, start + form.cut(match)).trimEnd().replace(/(?:\s*[—–-]+)+$/u, '').trimEnd();
+      return { name, id: match[1] ?? match[2] };
+    }
+  }
+  return { name: display, id: null };
+};
+
+// ONE word list, and every clause below reads it. A hyphen-joined RUN is one word — `row-is-unreadable`
+// is a slug, `fix---the---bug` is the same slug, and `2026-08-21` is one date rather than three
+// numbers — while punctuation is no word at all, so the `[ ]` the kit's own row writer renders no
+// longer supplies two of the three words the bar asks for. Word segmentation is the platform's
+// (`Intl.Segmenter`, a JS built-in — this module stays dependency-free).
+const WORDS = new Intl.Segmenter(undefined, { granularity: 'word' });
+export const wordsOf = (text) => {
+  const parts = [...WORDS.segment(String(text))];
+  const words = [];
+  for (let index = 0; index < parts.length; index += 1) {
+    if (!parts[index].isWordLike) continue;
+    let back = index - 1;
+    while (back >= 0 && HYPHENS.test(parts[back].segment)) back -= 1;
+    if (back >= 0 && back < index - 1 && parts[back].isWordLike && words.length) {
+      words[words.length - 1] += parts.slice(back + 1, index + 1).map((part) => part.segment).join('');
+      continue;
+    }
+    words.push(parts[index].segment);
+  }
+  return words;
+};
+
+// A name is a SENTENCE, and that ONE invariant is the whole bar — never a table of shapes, because
+// a table is walked around, and each earlier draft was: the slug written back in lower case walked
+// around all four shapes the first draft enumerated; a dated parenthetical walked around a clause
+// that asked the whole name for one lower-case letter anywhere; and "no cased character" as the
+// signal for a caseless SCRIPT let a name of pure punctuation, digits or emoji (`[ ]`, `123`,
+// `2026-09-04`) through as a sentence. So:
+//
+//   a name CARRIES A LETTER — asked of every name, and the one clause a caseless script also meets;
+//   a name that carries CASE is three or more words, one of its first three CASED words carrying a
+//   lower-case letter.
+//
+// Binding the two counting clauses to case is what makes the verdict DETERMINISTIC rather than a
+// function of the host's word-segmentation data: a caseless writing system writes no spaces to
+// count and has no case to shout with, so neither is asked of it. Reading the SHOUTED clause off the
+// first three CASED words (not the first three words) is what lets a Japanese sentence carry an
+// English acronym without being called shouted.
+export const nameFindings = (name, id) => {
+  const text = String(name ?? '').trim();
+  if (text === '') return [{ cause: 'absent', message: 'The row has no name before its id.' }];
+  const findings = [];
+  const words = wordsOf(text);
+  if (!words.some((word) => LETTER.test(word))) {
+    findings.push({ cause: 'no-letter', message: 'The name carries no letter, so it names nothing.' });
+  }
+  if (CASED.test(text) && words.length < 3) {
+    findings.push({ cause: 'too-few-words', message: 'The name is fewer than three words.' });
+  }
+  // The acronym exemption is for a MIXED-SCRIPT name — a caseless sentence carrying an English
+  // acronym — so it is spent only where caseless letter words actually exist. Skipping the clause
+  // on "fewer than three cased words" alone let `API 123 456` and `API GATE 2` through as sentences.
+  const cased = words.filter((word) => CASED.test(word));
+  const caseless = words.filter((word) => LETTER.test(word) && !CASED.test(word));
+  const exempt = caseless.length > 0 && cased.length < 3;
+  if (cased.length > 0 && !exempt && !cased.slice(0, 3).some((word) => LOWERCASE.test(word))) {
+    findings.push({ cause: 'shouted', message: 'None of the name\'s leading cased words carries a lower-case letter.' });
+  }
+  if (id !== null && normalize(text) === normalize(id)) {
+    findings.push({ cause: 'restates-the-id', message: 'The name only restates its id.' });
+  }
+  return findings;
+};

package/tools/script-priors.mjs

@@ -34,6 +34,8 @@ export const SCRIPT_PRIORS = Object.freeze([
   prior('spec-schema.mjs', '4.7.0', '4.7.0', '40b5b038d5ec5ed53c327c6d269d22fe5fa2bed99ae711fbf84306ad047be452'),
   prior('spec-schema.test.mjs', '4.7.0', '4.7.0', 'fde896419924223e54cfcabfdb1ef5807df5386fac700ed7c1463b6e7f81501b'),
   prior('check-docs-size.mjs', '4.6.0', '6.0.0', '22d020c3668cdbfb4cbc1f67a8a85b2baa2d0c4956808a50626d37409e81ab38'),
+  prior('spec-schema.mjs', '5.0.0', '7.2.1', '6a7d1e836c158baab5a412a1ad76d34891934dc28c88486c264a4b5d46f5892a'),
+  prior('spec-schema.test.mjs', '5.0.0', '7.2.1', '698564d7283281be1826019d214df475bb876687915de086818d8f5ece0e0336'),
 ]);
 
 export const digestOf = (bytes) => createHash('sha256').update(bytes).digest('hex');