@crouton-kit/crouter 0.3.33 → 0.3.34

package/dist/core/preview-registry.js

@@ -0,0 +1,2047 @@
+// Bundle-safe mirror of LeafHelp.preview metadata (see help.ts's PreviewMeta),
+// keyed by the leaf's full help name (e.g. "canvas snapshot", matching
+// LeafHelp.name exactly).
+//
+// This file has NO imports. The attach viewer is bundled as a separate
+// esbuild process from the one that runs a leaf, so it cannot read a leaf's
+// command-owned `preview` field directly — walking the live command tree
+// to find it would pull every subtree's module graph (including `surface`
+// -> the web client -> Tailwind's native oxide binary) into the attach
+// bundle. A flat, zero-dependency static map avoids that entirely.
+//
+// Source of truth: this Set must mirror every leaf that declares
+// `help.preview.suppressOutput: true` in its own command file (currently
+// canvas snapshot, node inspect snapshot, node inspect show, and sys
+// sysprompt). There is no automated sync — when you add or remove a leaf's
+// `preview.suppressOutput`, update this Set in the same commit.
+// `preview-registry-sync.test.ts` (which imports the real command tree — safe
+// in a test, never in the attach bundle) asserts the two stay identical.
+// Exported (not just consumed through the helpers below) so
+// preview-registry-sync.test.ts can diff it against the live command tree.
+export const SUPPRESS_OUTPUT_LEAVES = new Set([
+    'canvas snapshot',
+    'node inspect snapshot',
+    'node inspect show',
+    'sys sysprompt',
+]);
+/** True when the leaf at this full help-name path (e.g. "canvas snapshot")
+ *  declares `preview.suppressOutput: true`. */
+export function suppressOutputForLeaf(helpName) {
+    return SUPPRESS_OUTPUT_LEAVES.has(helpName);
+}
+/** Same lookup from argv tokens (e.g. ['node', 'inspect', 'snapshot', 'abc'])
+ *  instead of a pre-joined help name. Matches a registered leaf name against
+ *  a *prefix* of the tokens, not the whole joined tail, so a leaf's own
+ *  positional arguments (e.g. the snapshot id in `node inspect snapshot
+ *  abc`) don't prevent the match. */
+export function suppressOutputForPath(tokens) {
+    for (const leaf of SUPPRESS_OUTPUT_LEAVES) {
+        const words = leaf.split(' ');
+        if (words.length <= tokens.length && words.every((word, i) => tokens[i] === word))
+            return true;
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Icon registry (rule 12, inline-ui-placement: real Nerd Font glyphs, not the
+// generic ◆ diamond). Every leaf's glyph is looked up first in LEAF_ICON_CP
+// (longest-prefix match, same shape as SUPPRESS_OUTPUT_LEAVES); an unmapped
+// leaf falls back to its root family's glyph in FAMILY_ICON_CP.
+// ---------------------------------------------------------------------------
+/** question-circle — the header glyph for a `-h`/`--help` invocation,
+ *  regardless of which command's help was requested. */
+const HELP_ICON_CP = 0xf059;
+export const HELP_ICON = String.fromCodePoint(HELP_ICON_CP);
+/** One glyph per root subtree (`crtr <family> ...`) — the fallback for any
+ *  leaf not listed in LEAF_ICON_CP below. Codepoints are Nerd Font
+ *  private-use-area icons chosen per family concept (see command-icons.md). */
+const FAMILY_ICON_CP = {
+    canvas: 0xf0e8,
+    feed: 0xf09e,
+    human: 0xf007,
+    memory: 0xf02d,
+    node: 0xf192,
+    pkg: 0xf1b2,
+    push: 0xf0ee,
+    search: 0xf002,
+    surface: 0xf108,
+    sys: 0xf013,
+};
+/** Per-leaf overrides, keyed by full leaf help-name path (e.g. "memory
+ *  lint"), same shape as SUPPRESS_OUTPUT_LEAVES. */
+const LEAF_ICON_CP = {
+    'canvas dashboard': 0xf0e4,
+    'canvas snapshot': 0xf030,
+    'canvas browse': 0xf14e,
+    'canvas attention count': 0xf292,
+    'canvas attention list': 0xf03a,
+    'canvas attention map': 0xf279,
+    'canvas revive': 0xf021,
+    'canvas history search': 0xf002,
+    'canvas history read': 0xf02d,
+    'canvas history show': 0xf1da,
+    'canvas daemon start': 0xf04b,
+    'canvas daemon status': 0xf111,
+    'canvas daemon stop': 0xf04d,
+    'canvas chord': 0xf001,
+    'canvas tmux-spread': 0xf009,
+    'canvas issue new': 0xf188,
+    'canvas prune': 0xf0c4,
+    'canvas rebuild-index': 0xf0ad,
+    'feed read': 0xf02d,
+    'feed message': 0xf0e0,
+    'feed peek': 0xf06e,
+    'human ask': 0xf059,
+    'human review': 0xf044,
+    'human notify': 0xf0f3,
+    'human show': 0xf108,
+    'human cancel': 0xf00d,
+    'human inbox': 0xf01c,
+    'human list': 0xf03a,
+    'human deck': 0xf0db,
+    'human resolve': 0xf00c,
+    'memory list': 0xf03a,
+    'memory read': 0xf02d,
+    'memory find': 0xf002,
+    'memory write': 0xf040,
+    'memory origin': 0xf1bb,
+    'memory lint': 0xf14a,
+    'node new': 0xf067,
+    'node msg': 0xf0e0,
+    'node subscribe': 0xf0f3,
+    'node unsubscribe': 0xf1f6,
+    'node promote': 0xf102,
+    'node yield': 0xf28d,
+    'node focus': 0xf05b,
+    'node cycle': 0xf021,
+    'node inspect list': 0xf03a,
+    'node inspect show': 0xf06e,
+    'node inspect snapshot': 0xf030,
+    'node inspect context': 0xf07c,
+    'node lifecycle recycle': 0xf1b8,
+    'node lifecycle close': 0xf00d,
+    'node lifecycle demote': 0xf103,
+    'node config': 0xf013,
+    'node triggers list': 0xf017,
+    'node triggers cancel': 0xf05e,
+    'pkg plugin install': 0xf019,
+    'pkg plugin remove': 0xf014,
+    'pkg plugin enable': 0xf00c,
+    'pkg plugin disable': 0xf05e,
+    'pkg plugin update': 0xf021,
+    'pkg plugin list': 0xf03a,
+    'pkg plugin show': 0xf06e,
+    'pkg market add': 0xf067,
+    'pkg market remove': 0xf014,
+    'pkg market update': 0xf021,
+    'pkg market list': 0xf03a,
+    'pkg market browse': 0xf14e,
+    'push update': 0xf093,
+    'push urgent': 0xf0e7,
+    'push final': 0xf11e,
+    'search web': 0xf0ac,
+    'search answer': 0xf075,
+    'search contents': 0xf0f6,
+    'surface view list': 0xf03a,
+    'surface view run': 0xf04b,
+    'surface view cycle': 0xf021,
+    'surface view new': 0xf067,
+    'surface attach to': 0xf1e6,
+    'surface workspace enter': 0xf120,
+    'surface web serve': 0xf0ac,
+    'sys config get': 0xf019,
+    'sys config set': 0xf040,
+    'sys config path': 0xf07b,
+    'sys settings': 0xf1de,
+    'sys setup': 0xf0ad,
+    'sys doctor': 0xf0f1,
+    'sys sysprompt': 0xf15c,
+    'sys prompt-review': 0xf002,
+    'sys promptstudio': 0xf008,
+    'sys feedback': 0xf075,
+    'sys update': 0xf021,
+    'sys version': 0xf02b,
+    'sys sync': 0xf079,
+};
+/** Resolve the Nerd Font glyph for a command's argv tokens: the longest
+ *  matching LEAF_ICON_CP prefix, else the tokens[0] family glyph, else the
+ *  generic ◆ fallback for an unmapped family. */
+export function iconForPath(tokens) {
+    let best;
+    for (const [leaf, cp] of Object.entries(LEAF_ICON_CP)) {
+        const words = leaf.split(' ');
+        if (words.length <= tokens.length && words.every((word, i) => tokens[i] === word)) {
+            if (best === undefined || words.length > best.words)
+                best = { words: words.length, cp };
+        }
+    }
+    if (best !== undefined)
+        return String.fromCodePoint(best.cp);
+    const familyCp = tokens.length > 0 ? FAMILY_ICON_CP[tokens[0]] : undefined;
+    return familyCp !== undefined ? String.fromCodePoint(familyCp) : '◆';
+}
+const MEMORY_READ_CONTENT_LINES = 3;
+/** `crtr memory read <name>` prints a `- name:/- kind:/- scope:/- path:`
+ *  metadata block, then `**content:** <body>`, then a `**follow_up:**` hint.
+ *  The collapsed card is a tidy frontmatter glance (Silas, 2026-07-01,
+ *  option C): a `name · kind · scope` identity line (path is filesystem
+ *  noise, dropped; follow_up hint dropped) plus the first few lines of the
+ *  content as a teaser — the full body is what ctrl+o reveals. Returns null
+ *  when neither the metadata fields nor the `**content:**` marker are
+ *  present — an error result (missing/ambiguous doc name, etc.) has none of
+ *  this shape, and must fall back to the raw output rather than render a
+ *  blank collapsed card. */
+function summarizeMemoryRead(text) {
+    const field = (name) => new RegExp(`^-\\s+${name}:\\s*(.+)$`, 'm').exec(text)?.[1].trim() ?? '';
+    const header = [field('name'), field('kind'), field('scope')].filter((f) => f !== '').join(' · ');
+    // Content spans from `**content:**` to the `**follow_up:**` hint (or EOF).
+    const contentMatch = /\*\*content:\*\*\s*([\s\S]*?)(?:\n\s*\*\*follow_up:\*\*|$)/.exec(text);
+    if (header === '' && contentMatch === null)
+        return null;
+    const contentLines = (contentMatch?.[1] ?? '').replace(/^\s+/, '').replace(/\s+$/, '').split('\n');
+    const teaser = contentLines.slice(0, MEMORY_READ_CONTENT_LINES);
+    const hasMore = contentLines.slice(MEMORY_READ_CONTENT_LINES).some((l) => l.trim() !== '');
+    if (hasMore)
+        teaser.push('…');
+    const lines = [{ text: header }];
+    if (teaser.some((l) => l.trim() !== '')) {
+        lines.push({ text: '' });
+        for (const l of teaser)
+            lines.push({ text: l });
+    }
+    return lines;
+}
+/** Cap on individual finding rows in the `memory lint` findings-present
+ *  summary — the count line always shows the true total, this just bounds
+ *  how many per-finding detail lines get listed before falling back to a
+ *  muted "… N more" line. */
+const MEMORY_LINT_FINDINGS_CAP = 8;
+/** `crtr memory lint` has two real output shapes (verified against the live
+ *  command, not assumed):
+ *  - 0 findings (success return): `- checked: N`, `- corpora: {...}`, a
+ *    prose line, blank, then `0 findings.`
+ *  - >0 findings: the leaf THROWS instead of returning, so the CLI error path
+ *    renders `<error code="error">\nmemory lint: N finding(s) across M
+ *    files\nNext: ...\n</error>` on stdout, with one `crtr: memory lint:
+ *    <path>: <error>` line per finding on stderr (merged into the same tool
+ *    result text when the bash host merges the two streams). Both shapes are
+ *    parsed defensively; an output that matches neither falls through to the
+ *    generic truncation path (returns null). */
+function summarizeMemoryLint(text) {
+    const checkedMatch = /^- checked:\s*(\d+)\s*$/m.exec(text);
+    const successCountMatch = /(\d+)\s+findings\.\s*$/.exec(text.trimEnd());
+    if (checkedMatch && successCountMatch) {
+        const checked = checkedMatch[1];
+        const count = Number(successCountMatch[1]);
+        if (count === 0) {
+            return [
+                { text: 'PASS', tone: 'success' },
+                { text: `${checked} docs checked`, tone: 'muted' },
+            ];
+        }
+        return [
+            { text: `${count} findings`, tone: 'error' },
+            { text: `${checked} docs checked`, tone: 'muted' },
+        ];
+    }
+    const failureMatch = /(\d+)\s+finding\(s\)\s+across\s+(\d+)\s+files/.exec(text);
+    if (failureMatch) {
+        const count = Number(failureMatch[1]);
+        const checked = failureMatch[2];
+        const lines = [{ text: `${count} findings`, tone: 'error' }];
+        const findingLines = [...text.matchAll(/^crtr: memory lint: (.+)$/gm)].map((m) => m[1]);
+        for (const line of findingLines.slice(0, MEMORY_LINT_FINDINGS_CAP)) {
+            lines.push({ text: line, tone: 'warning' });
+        }
+        const remaining = findingLines.length - MEMORY_LINT_FINDINGS_CAP;
+        if (remaining > 0)
+            lines.push({ text: `… ${remaining} more`, tone: 'muted' });
+        lines.push({ text: `${checked} docs checked`, tone: 'muted' });
+        return lines;
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Shared table/count parsing helpers for the canvas/node/feed runtime cockpit
+// batch below. These parse the exact markdown shapes core/render.ts's generic
+// renderArray/renderResult produce (a `- field: N` bullet for a scalar count,
+// an `N <label>:` count lead-in followed by a GFM table for an array of
+// objects, or a bare `0 <label>.` line for an empty array) — strict recognition
+// of that one shape, never a second lenient fallback. Any deviation (missing
+// table, column-count mismatch, non-numeric field expected to be numeric)
+// returns null so the caller falls through to generic truncation.
+// ---------------------------------------------------------------------------
+/** Split one GFM table row into its cell strings, honoring `\|` as an escaped
+ *  literal pipe (the only escape core/render.ts's cellEsc introduces) rather
+ *  than a column separator. Returns null when the line isn't a `| ... |` row. */
+function splitTableRow(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('|') || !trimmed.endsWith('|'))
+        return null;
+    const body = trimmed.slice(1, -1);
+    const cells = [];
+    let current = '';
+    let i = 0;
+    while (i < body.length) {
+        const ch = body[i];
+        if (ch === '\\' && body[i + 1] === '|') {
+            current += '|';
+            i += 2;
+            continue;
+        }
+        if (ch === '|') {
+            cells.push(current.trim());
+            current = '';
+            i++;
+            continue;
+        }
+        current += ch;
+        i++;
+    }
+    cells.push(current.trim());
+    return cells;
+}
+/** Find the `N <headingLabel>:` + GFM table block renderArray emits for an
+ *  array-of-objects field named `headingLabel` (e.g. `28 rows:`, `63 nodes:`),
+ *  and parse every data row into a plain `{column: cellText}` record, using the
+ *  header row's own column names as keys — no positional/column-index
+ *  assumptions, so an unrelated extra column (e.g. `hanging`) is carried
+ *  along and simply ignored by callers that only read specific keys. A bare
+ *  `0 <headingLabel>.` line (renderArray's empty-array shape) parses as an
+ *  empty (not null) array. Returns null when the heading is missing, the
+ *  table shape doesn't match (header/separator/row column-count mismatch), or
+ *  trailing non-blank content follows the table — never a partial parse. */
+function parseTableRows(text, headingLabel) {
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed === `0 ${headingLabel}.`)
+            return [];
+        if (!/^\d+ /.test(trimmed) || !trimmed.endsWith(`${headingLabel}:`))
+            continue;
+        let j = i + 1;
+        while (j < lines.length && lines[j].trim() === '')
+            j++;
+        if (j + 1 >= lines.length)
+            return null;
+        const header = splitTableRow(lines[j]);
+        const separator = splitTableRow(lines[j + 1]);
+        if (header === null || separator === null || header.length === 0 || separator.length !== header.length)
+            return null;
+        if (separator.some((cell) => !/^-+$/.test(cell)))
+            return null;
+        const rows = [];
+        j += 2;
+        while (j < lines.length && lines[j].trim() !== '') {
+            const cells = splitTableRow(lines[j]);
+            if (cells === null || cells.length !== header.length)
+                return null;
+            const row = {};
+            for (let c = 0; c < header.length; c++)
+                row[header[c]] = cells[c];
+            rows.push(row);
+            j++;
+        }
+        while (j < lines.length && lines[j].trim() === '')
+            j++;
+        return j === lines.length ? rows : null;
+    }
+    return null;
+}
+/** Read a `- <field>: <integer>` scalar bullet (core/render.ts's scalar-bullet
+ *  shape). Returns null when the field isn't present as a plain integer. */
+function parseIntBullet(text, field) {
+    const match = new RegExp(`^-\\s+${field}:\\s*(\\d+)\\s*$`, 'm').exec(text);
+    return match === null ? null : Number(match[1]);
+}
+/** Compact a token count for a muted aside: 1000+ rounds to the nearest
+ *  thousand with a `k` suffix (`437000` → `437k`), matching the `ctx 365k`
+ *  shorthand the dashboard tree already uses elsewhere. */
+function compactThousands(value) {
+    return value >= 1000 ? `${Math.round(value / 1000)}k` : String(value);
+}
+/** The trailing path segment of a cwd, for a compact per-cwd label
+ *  (`/Users/.../cli/crouter` → `crouter`) — a full absolute path is filesystem
+ *  noise in a collapsed summary line. */
+function basename(path) {
+    const trimmed = path.replace(/[\\/]+$/, '');
+    const idx = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'));
+    return idx === -1 ? trimmed : trimmed.slice(idx + 1);
+}
+/** Render a `<count> <key>` digest across a fixed preferred key order (each
+ *  shown only when its count is > 0), then any other key present sorted
+ *  alphabetically — the `3 active · 24 done` shape both dashboard and node
+ *  list summaries share. */
+function summarizeOrderedCounts(counts, order) {
+    const inOrder = new Set(order);
+    const parts = [];
+    for (const key of order) {
+        const count = counts.get(key) ?? 0;
+        if (count > 0)
+            parts.push(`${count} ${key}`);
+    }
+    const extras = [...counts.entries()]
+        .filter(([key, count]) => count > 0 && !inOrder.has(key))
+        .sort(([a], [b]) => a.localeCompare(b));
+    for (const [key, count] of extras)
+        parts.push(`${count} ${key}`);
+    return parts.join(' · ');
+}
+/** Render the top `limit` entries of a name→count map, ranked by count
+ *  descending (name ascending to break ties), with a muted `… N more` tail
+ *  when entries were dropped — the `developer×2, advisor×1` kind-breakdown
+ *  shape. */
+function summarizeTopCounts(counts, limit, renderItem) {
+    const entries = [...counts.entries()]
+        .filter(([, count]) => count > 0)
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+    const shown = entries.slice(0, limit).map(([name, count]) => renderItem(name, count));
+    const remaining = entries.length - shown.length;
+    if (remaining > 0)
+        shown.push(`… ${remaining} more`);
+    return shown.join(', ');
+}
+/** `crtr canvas dashboard`'s object output carries a `rows` array (one entry
+ *  per node: {node_id,name,status,kind,mode,ctx_tokens,asks,...}) rendered by
+ *  renderArray as an `N rows:` table. The collapsed card is a status-count
+ *  digest (active/idle plain, done/dead/canceled muted by the ordering below),
+ *  the largest ctx_tokens across the view as a muted aside, and a warning line
+ *  only when any row carries a pending ask — Silas's 2026-07-01 reframe ("what
+ *  does a human want to know?"), not a re-rendering of the raw tree/table.
+ *  Returns null when the rows table isn't in the expected shape, or is empty
+ *  (an empty canvas has nothing to digest into a status line). */
+function summarizeCanvasDashboard(text) {
+    const rows = parseTableRows(text, 'rows');
+    if (rows === null || rows.length === 0)
+        return null;
+    const statuses = new Map();
+    let largestCtx = 0;
+    let asks = 0;
+    for (const row of rows) {
+        const status = row['status'];
+        const ctx = Number(row['ctx_tokens']);
+        const ask = Number(row['asks']);
+        if (status === undefined || status === '' || Number.isNaN(ctx) || Number.isNaN(ask))
+            return null;
+        statuses.set(status, (statuses.get(status) ?? 0) + 1);
+        largestCtx = Math.max(largestCtx, ctx);
+        asks += ask;
+    }
+    const digest = summarizeOrderedCounts(statuses, ['active', 'idle', 'done', 'dead', 'canceled']);
+    if (digest === '')
+        return null;
+    const lines = [{ text: digest }];
+    lines.push({ text: `largest ctx: ${compactThousands(largestCtx)} tokens`, tone: 'muted' });
+    if (asks > 0)
+        lines.push({ text: `${asks} pending asks`, tone: 'warning' });
+    return lines;
+}
+/** `crtr node inspect list`'s object output carries a `nodes` array (one entry
+ *  per node: {node_id,name,kind,mode,lifecycle,status,cwd,...}) rendered as an
+ *  `N nodes:` table. The collapsed card is a status-count digest (same order
+ *  as the dashboard summary) plus a muted kind breakdown (top 5 kinds by
+ *  count). Returns null when the table isn't in the expected shape or empty. */
+function summarizeNodeInspectList(text) {
+    const rows = parseTableRows(text, 'nodes');
+    if (rows === null || rows.length === 0)
+        return null;
+    const statuses = new Map();
+    const kinds = new Map();
+    for (const row of rows) {
+        const status = row['status'];
+        const kind = row['kind'];
+        if (status === undefined || status === '' || kind === undefined || kind === '')
+            return null;
+        statuses.set(status, (statuses.get(status) ?? 0) + 1);
+        kinds.set(kind, (kinds.get(kind) ?? 0) + 1);
+    }
+    const statusDigest = summarizeOrderedCounts(statuses, ['active', 'idle', 'done', 'dead', 'canceled']);
+    const kindDigest = summarizeTopCounts(kinds, 5, (kind, count) => `${kind}×${count}`);
+    if (statusDigest === '' || kindDigest === '')
+        return null;
+    return [
+        { text: statusDigest },
+        { text: `kinds: ${kindDigest}`, tone: 'muted' },
+    ];
+}
+/** `crtr canvas attention count`'s object output is a single `- count: N`
+ *  bullet. Silas's computed-status framing (2026-07-01): 0 pending asks is a
+ *  genuinely PASSing state worth a green line, not an empty card, and N > 0 is
+ *  worth an error-toned line naming the count — never suppress this leaf down
+ *  to nothing regardless of which way the count falls. Returns null only when
+ *  `count` isn't present as a plain integer (an unrecognized/error shape). */
+function summarizeCanvasAttentionCount(text) {
+    const count = parseIntBullet(text, 'count');
+    if (count === null)
+        return null;
+    if (count === 0)
+        return [{ text: 'PASS · no pending asks', tone: 'success' }];
+    return [{ text: `${count} pending asks`, tone: 'error' }];
+}
+/** `crtr canvas attention list`'s object output is a `- total: N` bullet
+ *  followed by an `M items:` table ({node_id,name,cwd,count}). The collapsed
+ *  card leads with `total · cwd count`, calls out the hottest single cwd in
+ *  warning tone (the one place a human should look first), then a muted
+ *  digest of the remaining cwd basenames (paths are filesystem noise here).
+ *  Zero pending asks reads as the same PASS line attention count uses —
+ *  consistent health framing across both leaves, never an empty card. Returns
+ *  null when the total/items shape doesn't match, or when any item is missing
+ *  its cwd/count (an unrecognized row shape). */
+function summarizeCanvasAttentionList(text) {
+    const total = parseIntBullet(text, 'total');
+    const items = parseTableRows(text, 'items');
+    if (total === null || items === null)
+        return null;
+    if (total === 0 || items.length === 0)
+        return [{ text: 'PASS · no pending asks', tone: 'success' }];
+    const entries = [];
+    for (const row of items) {
+        const cwd = row['cwd'];
+        const count = Number(row['count']);
+        if (cwd === undefined || cwd === '' || Number.isNaN(count))
+            return null;
+        entries.push({ cwd, count });
+    }
+    const sorted = entries
+        .slice()
+        .sort((a, b) => b.count - a.count || basename(a.cwd).localeCompare(basename(b.cwd)) || a.cwd.localeCompare(b.cwd));
+    const hottest = sorted[0];
+    const restBasenames = sorted.slice(1).map((item) => basename(item.cwd));
+    const lines = [
+        { text: `${total} total · ${items.length} cwds` },
+        { text: `hottest: ${basename(hottest.cwd)} (${hottest.count})`, tone: 'warning' },
+    ];
+    if (restBasenames.length > 0) {
+        const shown = restBasenames.slice(0, 4);
+        const remaining = restBasenames.length - shown.length;
+        const digest = remaining > 0 ? `${shown.join(', ')}, … ${remaining} more` : shown.join(', ');
+        lines.push({ text: `other cwds: ${digest}`, tone: 'muted' });
+    }
+    return lines;
+}
+/** `crtr canvas attention map` (src/commands/attention.ts:227) has no custom
+ *  `render`; its `counts` field is a nested plain object (node_id → ask
+ *  count), not an array, so the generic renderer's `renderResult` emits it
+ *  as ONE scalar bullet via `scalarStr`'s compact-JSON branch: `- counts:
+ *  {"id1":0,"id2":3,...}` (output schema at attention.ts:190). No node names
+ *  are available in this output (only ids), so the collapsed card names the
+ *  hottest id, not a name. The real shape is `Record<string, number>` — a
+ *  mixed object (any non-numeric value) is a shape mismatch, not a partial
+ *  total, so it's rejected wholesale rather than filtered down. Returns
+ *  null when `counts` isn't parseable JSON, is empty, or has any
+ *  non-numeric entry. */
+function summarizeCanvasAttentionMap(text) {
+    const m = /^- counts:\s*(\{.*\})\s*$/m.exec(text);
+    if (m === null)
+        return null;
+    let counts;
+    try {
+        counts = JSON.parse(m[1]);
+    }
+    catch {
+        return null;
+    }
+    if (counts === null || typeof counts !== 'object')
+        return null;
+    const rawEntries = Object.entries(counts);
+    if (rawEntries.length === 0)
+        return null;
+    if (rawEntries.some(([, v]) => typeof v !== 'number'))
+        return null;
+    const entries = rawEntries;
+    const total = entries.reduce((s, [, v]) => s + v, 0);
+    if (total === 0)
+        return [{ text: 'PASS · no pending asks', tone: 'success' }];
+    const withAsks = entries.filter(([, v]) => v > 0);
+    const sorted = withAsks.slice().sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+    const hottest = sorted[0];
+    return [
+        { text: `${total} asks across ${withAsks.length} node${withAsks.length === 1 ? '' : 's'}` },
+        { text: `hottest: ${hottest[0]} (${hottest[1]})`, tone: 'warning' },
+    ];
+}
+/** Find the first argv token after `skipWords` that isn't a boolean flag
+ *  (`--foo`) — recovers a leaf's own positional id when its render() output
+ *  carries no id of its own (see summarizeCanvasRevive below). Safe here
+ *  specifically because every `canvas revive` flag is a boolean with no
+ *  separate value token, so a naive forward scan can't mistake a flag's
+ *  value for the positional. */
+function firstPositionalAfter(tokens, skipWords) {
+    for (let i = skipWords; i < tokens.length; i++) {
+        if (!tokens[i].startsWith('--'))
+            return tokens[i];
+    }
+    return undefined;
+}
+/** `crtr canvas revive` (src/commands/revive.ts) has no custom `render`, so
+ *  its object output falls through to generic renderResult. Four shapes
+ *  depending on flags:
+ *  - `--all` (preview or executed) carries a `- mode: preview|revived`
+ *    bullet — skipped (null): `candidates`/`revived`/`failed` are
+ *    prose-or-bullet depending on whether they contain a newline (multi- vs
+ *    single-id), which core/render.ts's `isProse` makes genuinely ambiguous
+ *    to parse strictly, and this is a rare admin path.
+ *  - `--now` kick: the only shape with `- kicked: true` (revive.ts:192).
+ *  - plain single-node revive: the only shape with `- resumed: true|false`.
+ *    `window` (revive.ts:83) is documented "Always null", so it's never
+ *    bulleted — and there is no node id anywhere in the output, so it's
+ *    recovered from argv (the leaf's own positional) via
+ *    firstPositionalAfter.
+ *  Returns null on any other/unrecognized shape. */
+function summarizeCanvasRevive(text, tokens) {
+    if (/^- mode:\s*\S+\s*$/m.test(text))
+        return null;
+    if (/^- kicked:\s*true\s*$/m.test(text)) {
+        return [{ text: 'kicked — daemon resumes in ~20s', tone: 'warning' }];
+    }
+    const resumedMatch = /^- resumed:\s*(true|false)\s*$/m.exec(text);
+    if (resumedMatch === null)
+        return null;
+    const id = firstPositionalAfter(tokens, 2); // 'canvas','revive' = 2 words
+    const lines = [{ text: id !== undefined ? `revived ${id}` : 'revived', tone: 'success' }];
+    const readyMatch = /^- ready:\s*(true|false)\s*$/m.exec(text);
+    if (readyMatch !== null && readyMatch[1] === 'false') {
+        lines.push({ text: 'not yet attachable (socket not ready)', tone: 'warning' });
+    }
+    return lines;
+}
+/** `crtr canvas history search` (renderSearch, src/commands/canvas-history/
+ *  search.ts:246) has three shapes: `0 hits.`; `--full` (### heading blocks
+ *  per hit, not tabular — skipped, returns null); or the normal `N of M
+ *  hits:` lead-in plus a GFM table (columns `{ref,node,kind,source,ts,
+ *  score?,snippet}`, or `{ref,node,ts,line,text}` under `--grep`, no
+ *  `kind`). Reuses this file's own `splitTableRow` helper rather than
+ *  `parseTableRows` (whose `N <label>:` lead-in must end in a literal colon
+ *  immediately before the table — `N of M hits:` is a close but different
+ *  shape). Returns null on `--full` or any other shape mismatch: a
+ *  non-`---` separator cell, or a missing `node`/`ts` column (`kind` is
+ *  read only when present, never required — `--grep` mode legitimately
+ *  lacks it), or a parsed row count that doesn't match the leading `N of M
+ *  hits:` displayed count `N` (the actual page size — pagination can make
+ *  it less than `M`, the grand total). */
+function summarizeCanvasHistorySearch(text) {
+    if (/^0 hits\.$/m.test(text))
+        return [{ text: '0 hits', tone: 'muted' }];
+    const lead = /^(\d+) of (\d+) hits:$/m.exec(text);
+    if (lead === null)
+        return null;
+    const displayed = Number(lead[1]);
+    const total = Number(lead[2]);
+    const lines = text.split('\n');
+    const headerIdx = lines.findIndex((l) => l.trim().startsWith('| ref |'));
+    if (headerIdx === -1)
+        return null;
+    const header = splitTableRow(lines[headerIdx]);
+    const separator = splitTableRow(lines[headerIdx + 1]);
+    if (header === null || separator === null || header.length !== separator.length)
+        return null;
+    if (separator.some((cell) => !/^-+$/.test(cell)))
+        return null;
+    if (!header.includes('node') || !header.includes('ts'))
+        return null;
+    const rows = [];
+    let j = headerIdx + 2;
+    while (j < lines.length && lines[j].trim().startsWith('|')) {
+        const cells = splitTableRow(lines[j]);
+        if (cells === null || cells.length !== header.length)
+            return null;
+        const row = {};
+        header.forEach((h, i) => { row[h] = cells[i]; });
+        rows.push(row);
+        j++;
+    }
+    if (rows.length !== displayed)
+        return null;
+    const top = rows.slice(0, 3).map((r) => 'kind' in r ? `${r['node']} · ${r['kind']} · ${r['ts']}` : `${r['node']} · ${r['ts']}`);
+    const out = [{ text: `${total} hit${total === 1 ? '' : 's'}` }];
+    for (const t of top)
+        out.push({ text: t, tone: 'muted' });
+    const remaining = rows.length - top.length;
+    if (remaining > 0)
+        out.push({ text: `… ${remaining} more shown`, tone: 'muted' });
+    return out;
+}
+/** `crtr canvas history read` (src/commands/canvas-history/read.ts:61):
+ *  `${node}  |  source: ${source}  |  ts: ${ts}  |  ref: ${ref}\n\n${content}`
+ *  — note the DOUBLE SPACES around each `|`. Mirrors summarizeMemoryRead's
+ *  identity+teaser pattern (reusing MEMORY_READ_CONTENT_LINES). Returns null
+ *  when the head line doesn't match this exact shape. */
+function summarizeCanvasHistoryRead(text) {
+    const first = text.split('\n')[0] ?? '';
+    const head = /^(.+?)  \|  source: (.+?)  \|  ts: (.+?)  \|  ref: (.+)$/.exec(first);
+    if (head === null)
+        return null;
+    const [, node, source, ts] = head;
+    const rest = text.split('\n').slice(1);
+    let idx = 0;
+    while (idx < rest.length && rest[idx].trim() === '')
+        idx++;
+    const contentLines = rest.slice(idx);
+    const teaser = contentLines.slice(0, MEMORY_READ_CONTENT_LINES);
+    const hasMore = contentLines.slice(MEMORY_READ_CONTENT_LINES).some((l) => l.trim() !== '');
+    if (hasMore)
+        teaser.push('…');
+    const lines = [{ text: `${node} · ${source} · ${ts}` }];
+    if (teaser.some((l) => l.trim() !== '')) {
+        lines.push({ text: '' });
+        for (const l of teaser)
+            lines.push({ text: l });
+    }
+    return lines;
+}
+/** `crtr canvas history show` (src/commands/canvas-history/show.ts:66):
+ *  `node: <name (id)>\n\n0 artifacts. | N artifacts:\n\n<table
+ *  cols=ref,source,ts,detail>\n\n<follow_up>`. `source` values are
+ *  colon-prefixed types (`report:final`, `report:update`, `doc`,
+ *  `roadmap`). Reuses this file's `summarizeTopCounts` for the type
+ *  breakdown. Returns null when the `node:` line, the table shape (a
+ *  non-`---` separator cell), or a missing `source` column doesn't
+ *  match — or when the parsed row count doesn't match the leading `N
+ *  artifacts:` count (this render has no pagination, so the two must
+ *  agree exactly). */
+function summarizeCanvasHistoryShow(text) {
+    const nodeMatch = /^node: (.+)$/m.exec(text);
+    if (nodeMatch === null)
+        return null;
+    if (/^0 artifacts\.$/m.test(text))
+        return [{ text: `${nodeMatch[1]} · 0 artifacts`, tone: 'muted' }];
+    const countMatch = /^(\d+) artifacts:$/m.exec(text);
+    if (countMatch === null)
+        return null;
+    const lines = text.split('\n');
+    const headerIdx = lines.findIndex((l) => l.trim().startsWith('| ref |'));
+    if (headerIdx === -1)
+        return null;
+    const header = splitTableRow(lines[headerIdx]);
+    const separator = splitTableRow(lines[headerIdx + 1]);
+    if (header === null || separator === null || header.length !== separator.length)
+        return null;
+    if (separator.some((cell) => !/^-+$/.test(cell)))
+        return null;
+    const sourceIdx = header.indexOf('source');
+    if (sourceIdx === -1)
+        return null;
+    const typeCounts = new Map();
+    let rowCount = 0;
+    let j = headerIdx + 2;
+    while (j < lines.length && lines[j].trim().startsWith('|')) {
+        const cells = splitTableRow(lines[j]);
+        if (cells === null || cells.length !== header.length)
+            return null;
+        const type = (cells[sourceIdx] ?? '').split(':')[0];
+        typeCounts.set(type, (typeCounts.get(type) ?? 0) + 1);
+        rowCount++;
+        j++;
+    }
+    if (rowCount !== Number(countMatch[1]))
+        return null;
+    const digest = summarizeTopCounts(typeCounts, 5, (name, count) => `${name}s×${count}`);
+    return [{ text: `${countMatch[1]} artifacts` }, { text: digest, tone: 'muted' }];
+}
+/** `crtr canvas daemon start` (src/commands/daemon.ts:40, `spawnDaemon()` in
+ *  src/daemon/manage.ts:89) has no custom `render`; the generic renderer
+ *  bullets `{started:true,pid}` or `{started:false,existing_pid}`. `pid` is
+ *  unconditionally set alongside `started:true` (manage.ts:125) — a
+ *  true-with-no-pid shape is unrecognized, so it returns null rather than a
+ *  pid-less success line. `existing_pid` genuinely can be absent on the
+ *  false branch (a `readPidfile() ?? undefined` race), so that one stays
+ *  optional. Returns null when `started` isn't a plain boolean bullet, or
+ *  is `true` without a `pid` bullet. */
+function summarizeCanvasDaemonStart(text) {
+    const m = /^- started:\s*(true|false)\s*$/m.exec(text);
+    if (m === null)
+        return null;
+    if (m[1] === 'true') {
+        const pid = /^- pid:\s*(\d+)\s*$/m.exec(text)?.[1];
+        if (pid === undefined)
+            return null;
+        return [{ text: `started · pid ${pid}`, tone: 'success' }];
+    }
+    const pid = /^- existing_pid:\s*(\d+)\s*$/m.exec(text)?.[1];
+    return [{ text: `already running${pid !== undefined ? ` · pid ${pid}` : ''}`, tone: 'muted' }];
+}
+/** `crtr canvas daemon status` (src/commands/daemon.ts:65) has no custom
+ *  `render`; the generic renderer bullets `{running:true,pid}` or
+ *  `{running:false}`. `pid` is unconditionally set alongside `running:true`
+ *  (daemon.ts:70 — the true branch only fires once `readPidfile()` already
+ *  returned a pid), so a true-with-no-pid shape is unrecognized. Returns
+ *  null when `running` isn't a plain boolean bullet, or is `true` without a
+ *  `pid` bullet. */
+function summarizeCanvasDaemonStatus(text) {
+    const m = /^- running:\s*(true|false)\s*$/m.exec(text);
+    if (m === null)
+        return null;
+    if (m[1] === 'true') {
+        const pid = /^- pid:\s*(\d+)\s*$/m.exec(text)?.[1];
+        if (pid === undefined)
+            return null;
+        return [{ text: `running · pid ${pid}`, tone: 'success' }];
+    }
+    return [{ text: 'not running', tone: 'error' }];
+}
+/** `crtr canvas daemon stop` (src/commands/daemon.ts:93) has no custom
+ *  `render`; the generic renderer bullets `{stopped:true,pid}` or
+ *  `{stopped:false}`. `pid` is unconditionally set alongside `stopped:true`
+ *  (daemon.ts:98 — the signaled pid is echoed back in the same return), so a
+ *  true-with-no-pid shape is unrecognized. Returns null when `stopped` isn't
+ *  a plain boolean bullet, or is `true` without a `pid` bullet. */
+function summarizeCanvasDaemonStop(text) {
+    const m = /^- stopped:\s*(true|false)\s*$/m.exec(text);
+    if (m === null)
+        return null;
+    if (m[1] === 'true') {
+        const pid = /^- pid:\s*(\d+)\s*$/m.exec(text)?.[1];
+        if (pid === undefined)
+            return null;
+        return [{ text: `stopped · pid ${pid}` }];
+    }
+    return [{ text: 'was not running', tone: 'muted' }];
+}
+/** `crtr canvas issue new` (src/commands/canvas-issue.ts) has no custom
+ *  `render`; the generic renderer bullets `{created:false}` (empty note,
+ *  line 125), `{created:true,target:'github',type,title,url}` (line 137),
+ *  or `{created:true,target:'file',type,title,path}` (line 159). `url` is
+ *  unconditionally set on every `target:'github'` return, and `path` on
+ *  every `target:'file'` return — so either missing (e.g. a >80-char
+ *  value core/render.ts's `isProse` rule pushed to prose form instead of a
+ *  bullet) is an unrecognized shape, not a success to report without the
+ *  field. Returns null when `created` isn't a plain boolean bullet, or the
+ *  target's required companion field isn't present as a bullet. */
+function summarizeCanvasIssueNew(text) {
+    const createdMatch = /^- created:\s*(true|false)\s*$/m.exec(text);
+    if (createdMatch === null)
+        return null;
+    if (createdMatch[1] === 'false')
+        return [{ text: 'nothing captured', tone: 'muted' }];
+    const target = /^- target:\s*(\S+)\s*$/m.exec(text)?.[1];
+    if (target === 'github') {
+        const url = /^- url:\s*(\S+)\s*$/m.exec(text)?.[1];
+        if (url === undefined)
+            return null;
+        const num = /\/issues\/(\d+)$/.exec(url)?.[1];
+        return [
+            { text: num !== undefined ? `issue #${num}` : 'issue filed', tone: 'success' },
+            { text: url, tone: 'muted' },
+        ];
+    }
+    if (target === 'file') {
+        const path = /^- path:\s*(\S+)\s*$/m.exec(text)?.[1];
+        if (path === undefined)
+            return null;
+        return [
+            { text: 'note saved', tone: 'success' },
+            { text: basename(path), tone: 'muted' },
+        ];
+    }
+    return null;
+}
+/** `crtr node new` (nodeNew.render, src/commands/node.ts:318) has two
+ *  shapes: a spawn (`Spawned "${name}" (${id}) — ${status}${win}.`, with no
+ *  `kind`/`mode` anywhere in the output) or an armed deferred spawn (`Armed
+ *  deferred spawn ${id} — a ${kind} node, ${when}.`, one shared template
+ *  covering --at/--every/--when alike). Returns null when neither template
+ *  matches. */
+function summarizeNodeNew(text) {
+    const spawned = /^Spawned "([^"]*)" \((\S+)\) — (\w+)/.exec(text);
+    if (spawned !== null) {
+        const [, name, id, status] = spawned;
+        return [{ text: `spawned ${name} (${id}) · ${status}`, tone: 'success' }];
+    }
+    const armed = /^Armed deferred spawn (\S+) — a (\S+) node, (.+?)\.$/m.exec(text.split('\n')[0] ?? '');
+    if (armed !== null) {
+        const [, id, kind, detail] = armed;
+        const fires = /fires ([^\s,]+)/.exec(detail); // stop before a trailing `, recurs …` suffix
+        return [
+            { text: fires !== null ? `trigger armed · fires ${fires[1]}` : `trigger armed · ${detail}`, tone: 'accent' },
+            { text: `${kind} · ${id}`, tone: 'muted' },
+        ];
+    }
+    return null;
+}
+/** `crtr node msg` (nodeMsg.render, src/commands/node.ts:1284) has two
+ *  shapes: armed (covers --at/--every/--when/--until — one shared template
+ *  `Armed ${mode} trigger ${id} (${type}) — ${when}, target ${target}.`) or
+ *  immediate, whose render is JUST `${guidance}` — one of a small fixed set
+ *  of strings from the code (not user text): `"Delivered."`, `"Delivered —
+ *  the dormant target was revived to receive it."`, or `Fresh-revived <id>
+ *  now…`. Anything else returns null (deadline/predicate guidance is long
+ *  prose, but those cases are armed=true and already handled above). */
+function summarizeNodeMsg(text) {
+    const armed = /^Armed (\S+) trigger (\S+) \((\S+)\) — (.+?), target (\S+)\.$/m.exec(text.split('\n')[0] ?? '');
+    if (armed !== null) {
+        const [, mode, id, triggerType, when, target] = armed;
+        const fires = /fires ([^\s,]+)/.exec(when); // stop before a trailing `, recurs …` suffix
+        return [
+            { text: fires !== null ? `trigger armed · fires ${fires[1]}` : `trigger armed · ${when}`, tone: 'accent' },
+            { text: `${mode} · ${triggerType} · → ${target} · ${id}`, tone: 'muted' },
+        ];
+    }
+    if (/^Delivered\.$/.test(text))
+        return [{ text: 'delivered', tone: 'success' }];
+    if (/^Delivered — the dormant target was revived to receive it\.$/.test(text)) {
+        return [{ text: 'delivered · revived', tone: 'success' }];
+    }
+    const fresh = /^Fresh-revived (\S+) now/.exec(text);
+    if (fresh !== null)
+        return [{ text: `fresh-revived ${fresh[1]}`, tone: 'success' }];
+    return null;
+}
+/** `crtr node yield` (src/commands/node.ts:1513) has no custom `render`;
+ *  the generic renderer bullets `{node_id, promoted, model?, will_refresh}`
+ *  — none of these names are PROSE_FIELDS. `will_refresh` is documented
+ *  "Always true" (the command has no path that returns false), so
+ *  `- will_refresh: false` is itself an unrecognized/error shape, not an
+ *  alternate success to report armed. Returns null unless `will_refresh` is
+ *  exactly `true`, or `node_id` isn't present as a plain bullet. */
+function summarizeNodeYield(text) {
+    if (!/^- will_refresh:\s*true\s*$/m.test(text))
+        return null;
+    const nodeId = /^- node_id:\s*(\S+)\s*$/m.exec(text);
+    if (nodeId === null)
+        return null;
+    const promoted = /^- promoted:\s*true\s*$/m.test(text);
+    const model = /^- model:\s*(\S+)\s*$/m.exec(text)?.[1];
+    const extras = [];
+    if (promoted)
+        extras.push('promoted → orchestrator');
+    if (model !== undefined)
+        extras.push(`model: ${model}`);
+    const lines = [{ text: 'yield armed — refreshes on next wake', tone: 'accent' }];
+    if (extras.length > 0)
+        lines.push({ text: extras.join(' · '), tone: 'muted' });
+    return lines;
+}
+/** `crtr node lifecycle close` (nodeClose.render, src/commands/node.ts:650):
+ *  `Closed ${id} and its exclusive subtree — ${count} node(s)
+ *  closed${spared>0 ? ", ${spared} spared..." : ''}.` on success, or a
+ *  short failure line — left as null there, the generic fallback is fine for
+ *  a one-liner. */
+function summarizeNodeLifecycleClose(text) {
+    const m = /^Closed (\S+) and its exclusive subtree — (\d+) node\(s\) closed(?:, (\d+) spared)?/.exec(text);
+    if (m === null)
+        return null;
+    const [, id, countStr, sparedStr] = m;
+    const count = Number(countStr);
+    const descendants = count - 1;
+    const lines = [{ text: `closed ${id}`, tone: 'success' }];
+    if (descendants > 0)
+        lines.push({ text: `${descendants} descendant${descendants === 1 ? '' : 's'} canceled`, tone: 'warning' });
+    if (sparedStr !== undefined)
+        lines.push({ text: `${sparedStr} spared (managed elsewhere)`, tone: 'muted' });
+    return lines;
+}
+/** `crtr node triggers list` (nodeTriggersList.render, src/commands/
+ *  node.ts:1633): `No pending triggers in scope ${scope}.` (empty) or `${N}
+ *  pending trigger(s) in scope ${scope}.` plus a 15-column table
+ *  (`id|owner|target|action|mode|type|next|recur|timeout|label|eval_state|
+ *  last_eval_at|last_exit|last_stderr|created` — the trigger-kind column is
+ *  literally named `type`, not `trigger_type`). Returns null on any shape
+ *  mismatch: a non-`---` separator cell, a missing `type`/`next`/`target`
+ *  column, or a row-count/table mismatch (a sanity cross-check against the
+ *  leading `N pending` count). */
+function summarizeNodeTriggersList(text) {
+    if (/^No pending triggers in scope .+\.$/m.test(text.split('\n')[0] ?? '')) {
+        return [{ text: 'none pending', tone: 'muted' }];
+    }
+    const head = /^(\d+) pending trigger\(s\) in scope (.+)\.$/.exec(text.split('\n')[0] ?? '');
+    if (head === null)
+        return null;
+    const n = Number(head[1]);
+    const lines = text.split('\n');
+    const headerIdx = lines.findIndex((l) => l.trim().startsWith('| id |'));
+    if (headerIdx === -1)
+        return null;
+    const header = splitTableRow(lines[headerIdx]);
+    const separator = splitTableRow(lines[headerIdx + 1]);
+    if (header === null || separator === null || header.length !== separator.length)
+        return null;
+    if (separator.some((cell) => !/^-+$/.test(cell)))
+        return null;
+    if (!header.includes('type') || !header.includes('next') || !header.includes('target'))
+        return null;
+    const rows = [];
+    let j = headerIdx + 2;
+    while (j < lines.length && lines[j].trim().startsWith('|')) {
+        const cells = splitTableRow(lines[j]);
+        if (cells === null || cells.length !== header.length)
+            return null;
+        const row = {};
+        header.forEach((h, i) => { row[h] = cells[i]; });
+        rows.push(row);
+        j++;
+    }
+    if (rows.length !== n)
+        return null;
+    const cap = 5;
+    const shown = rows.slice(0, cap).map((r) => `${r['type']} · next ${r['next']} · ${r['target']}`);
+    const out = [{ text: `${n} pending` }];
+    for (const s of shown)
+        out.push({ text: s, tone: 'muted' });
+    const remaining = rows.length - shown.length;
+    if (remaining > 0)
+        out.push({ text: `… ${remaining} more`, tone: 'muted' });
+    return out;
+}
+/** `crtr feed read` (src/commands/push.ts:209) has two shapes: drained
+ *  (`${n} unread pointer(s) drained from ${node_id}'s inbox.\n\n${digest}`,
+ *  where the digest — `coalesce()`, src/core/feed/inbox.ts:225 — groups by
+ *  sender as `From ${sender} — ${N} update(s):` sections) or empty (`No
+ *  unread pointers for ${node_id} (unread=0).\n\n${explanation}`).
+ *  `coalesce()` always groups drained entries under at least one
+ *  From-section, so a positive drained count with zero parsed senders is a
+ *  shape mismatch, not a 0-sender success. Returns null on any other
+ *  shape. */
+function summarizeFeedRead(text) {
+    const lines = text.split('\n');
+    const first = lines[0] ?? '';
+    const drained = /^(\d+) unread pointers? drained from (.+)'s inbox\.$/.exec(first);
+    if (drained !== null) {
+        const n = Number(drained[1]);
+        const senders = [...new Set([...text.matchAll(/^From (.+?) — \d+ update/gm)].map((m) => m[1]))];
+        if (n > 0 && senders.length === 0)
+            return null;
+        const out = [{ text: `${n} pointer${n === 1 ? '' : 's'} drained from ${senders.length} node${senders.length === 1 ? '' : 's'}` }];
+        if (senders.length > 0) {
+            const shown = senders.slice(0, 5);
+            const remaining = senders.length - shown.length;
+            out.push({ text: remaining > 0 ? `${shown.join(', ')}, … ${remaining} more` : shown.join(', '), tone: 'muted' });
+        }
+        return out;
+    }
+    if (/^No unread pointers for .+ \(unread=0\)\.$/.test(first)) {
+        return [{ text: 'nothing unread', tone: 'muted' }];
+    }
+    return null;
+}
+/** Teaser cap for `feed message`'s body preview — mirrors
+ *  MEMORY_READ_CONTENT_LINES's role for a different leaf. */
+const FEED_MESSAGE_TEASER_LINES = 3;
+/** `crtr feed message` (src/commands/push.ts:264) has two shapes: found
+ *  (`Full message ${id} (from ${from}):\n\n${body}`) or not-found (a short
+ *  line — left as null, the generic fallback is fine for one line). */
+function summarizeFeedMessage(text) {
+    const lines = text.split('\n');
+    const head = /^Full message (\S+) \(from (.+)\):$/.exec(lines[0] ?? '');
+    if (head === null)
+        return null;
+    const [, id, from] = head;
+    const bodyLines = lines.slice(1);
+    let idx = 0;
+    while (idx < bodyLines.length && bodyLines[idx].trim() === '')
+        idx++;
+    const content = bodyLines.slice(idx);
+    const teaser = content.slice(0, FEED_MESSAGE_TEASER_LINES);
+    const hasMore = content.slice(FEED_MESSAGE_TEASER_LINES).some((l) => l.trim() !== '');
+    if (hasMore)
+        teaser.push('…');
+    const out = [{ text: `${id} · from ${from}` }];
+    if (teaser.some((l) => l.trim() !== '')) {
+        out.push({ text: '' });
+        for (const l of teaser)
+            out.push({ text: l });
+    }
+    return out;
+}
+/** `crtr feed peek` (src/commands/push.ts:351) has two shapes: zero-kids
+ *  (`No nodes below you (0 subscriptions, ${unread} unread). ${tail}` — the
+ *  "0" is a hardcoded literal, not a variable) or nonzero (`${verdictLine}
+ *  \n\n${N} node(s) below you — ${working} working, ${done} done, ${dead}
+ *  dead, ${unread} unread:\n${rows}`). Returns null on any other shape. */
+function summarizeFeedPeek(text) {
+    const zero = /^No nodes below you \(0 subscriptions, (\d+) unread\)\./.exec(text.split('\n')[0] ?? '');
+    if (zero !== null) {
+        const unread = Number(zero[1]);
+        return unread > 0
+            ? [{ text: `0 below · ${unread} unread`, tone: 'warning' }]
+            : [{ text: 'PASS · nothing below', tone: 'success' }];
+    }
+    const m = /(\d+) nodes? below you — (\d+) working, (\d+) done, (\d+) dead, (\d+) unread:/.exec(text);
+    if (m === null)
+        return null;
+    const [, , workingStr, doneStr, deadStr, unreadStr] = m;
+    const working = Number(workingStr);
+    const done = Number(doneStr);
+    const dead = Number(deadStr);
+    const unread = Number(unreadStr);
+    const parts = [`${working} working`, `${done} done`];
+    if (dead > 0)
+        parts.push(`${dead} dead`);
+    const lines = [{ text: parts.join(' · ') }];
+    if (dead > 0)
+        lines.push({ text: `${dead} dead — will not wake you`, tone: 'warning' });
+    else if (unread > 0)
+        lines.push({ text: `${unread} unread`, tone: 'warning' });
+    return lines;
+}
+/** `crtr push final` (makeTierLeaf's shared render, src/commands/push.ts:161)
+ *  leads with a fixed sentence ('Result recorded — node finished; ...')
+ *  followed unconditionally by `\n\n- report: ${report_path}` (`report_path`
+ *  is a required output field, push.ts:94). Returns null when that lead
+ *  sentence isn't present, or the `- report:` line is missing (an
+ *  unrecognized/error shape either way). */
+function summarizePushFinal(text) {
+    if (!/^Result recorded — node finished/.test(text))
+        return null;
+    const report = /^- report: (.+)$/m.exec(text)?.[1];
+    if (report === undefined)
+        return null;
+    return [
+        { text: 'final pushed · node done', tone: 'success' },
+        { text: basename(report.trim()), tone: 'muted' },
+    ];
+}
+/** `crtr push urgent` (makeTierLeaf's shared render, src/commands/push.ts:161):
+ *  `Urgent report fanned to ${n} subscriber(s) — they are force-woken.\n\n-
+ *  report: ${report_path}`, with the same unconditional `- report:` line as
+ *  push final. Returns null when the lead sentence doesn't match, or the
+ *  `- report:` line is missing. */
+function summarizePushUrgent(text) {
+    const m = /^Urgent report fanned to (\d+) subscriber/.exec(text);
+    if (m === null)
+        return null;
+    if (/^- report: (.+)$/m.exec(text) === null)
+        return null;
+    return [{ text: `urgent → ${m[1]} subscribers woken`, tone: 'warning' }];
+}
+// ---------------------------------------------------------------------------
+// Batch C — human/memory/pkg. Shared helpers for the two output shapes
+// renderResult (core/render.ts) can give the SAME logical field depending on
+// string length/newlines (isProse): a short value is a `- field: value`
+// bullet; a long/multiline one is prose — labeled `**field:** text` when 2+
+// prose fields are present, or a bare unlabeled paragraph when it's the SOLE
+// prose field (renderResult only labels when there's more than one). Several
+// leaves below carry a field (a path, typically) that crosses this threshold
+// depending on the user's home directory length, so both forms are handled
+// rather than assumed.
+// ---------------------------------------------------------------------------
+/** Read a `- field: value` bullet or a `**field:** text` labeled-prose block
+ *  for the same logical field — the two shapes renderResult can produce once
+ *  2+ prose fields are present (see block comment above). Does NOT recognize
+ *  a bare unlabeled solo-prose paragraph (see soloProseAfterBullets for
+ *  that); a leaf with exactly one long field needs that instead. */
+function readFieldFlexible(text, field) {
+    const bullet = new RegExp(`^-\\s+${field}:\\s*(.+)$`, 'm').exec(text);
+    if (bullet !== null)
+        return bullet[1].trim();
+    const labeled = new RegExp(`^\\*\\*${field}:\\*\\*\\s*([\\s\\S]*?)(?=\\n\\n|$)`, 'm').exec(text);
+    return labeled !== null ? labeled[1].trim() : undefined;
+}
+/** Recover the SOLE prose field's text when it renders as a bare, unlabeled
+ *  paragraph after the bullets block — renderResult's shape for exactly one
+ *  long/multiline field among otherwise-short scalars (see block comment
+ *  above). Requires at least one bullet line above it (otherwise this isn't
+ *  the bullets-then-solo-paragraph shape at all) and bails if what follows
+ *  looks like a labeled prose block or an array heading instead of a bare
+ *  paragraph — never misparse a different shape as this one. */
+function soloProseAfterBullets(text) {
+    const lines = text.split('\n');
+    let i = 0;
+    while (i < lines.length && /^- /.test(lines[i]))
+        i++;
+    if (i === 0)
+        return undefined;
+    while (i < lines.length && lines[i].trim() === '')
+        i++;
+    if (i >= lines.length)
+        return undefined;
+    if (/^\*\*\w+:\*\*/.test(lines[i]) || /^\d+ \S+:$/.test(lines[i]) || /^0 \S+\.$/.test(lines[i]))
+        return undefined;
+    const para = [];
+    while (i < lines.length && lines[i].trim() !== '') {
+        para.push(lines[i]);
+        i++;
+    }
+    const text2 = para.join(' ').trim();
+    return text2 === '' ? undefined : text2;
+}
+/** Find the first argv token after `skip` that isn't a flag, skipping the
+ *  value token that follows any flag listed in `valueFlags` (a boolean flag
+ *  with no separate value is skipped on its own via the `startsWith('--')`
+ *  check). Generalizes firstPositionalAfter (above) for leaves that mix
+ *  boolean and value-taking flags ahead of their positional. */
+function firstPositionalArg(tokens, skip, valueFlags) {
+    for (let i = skip; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t.startsWith('--')) {
+            if (valueFlags.has(t))
+                i++;
+            continue;
+        }
+        return t;
+    }
+    return undefined;
+}
+/** Truncate a single line of text to `max` chars for a muted-aside teaser,
+ *  appending an ellipsis when it was cut. */
+function truncateLine(line, max) {
+    return line.length > max ? `${line.slice(0, max).trimEnd()}…` : line;
+}
+const ASK_TEASER_CHARS = 160;
+/** `crtr human ask` (humanAsk.run, src/commands/human/prompts.ts:97) returns
+ *  `{job_id, dir, follow_up}` — `job_id` is always short (a node id) so it
+ *  always bullets; `dir`/`follow_up` cross the prose threshold depending on
+ *  path length, so the shape is recognized by `job_id` plus one of the two
+ *  FIXED follow_up sentences (followUpResult/followUpDrain, shared.ts) being
+ *  present anywhere in the text — never by assuming dir/follow_up's bullet
+ *  vs. prose form. The question text isn't in the output at all (only the
+ *  bare-question invocation echoes it), so it's recovered from argv: the
+ *  first non-flag token after `human ask`, skipping `--context-file`'s value
+ *  — absent for a `--context-file` deck invocation, which still gets the
+ *  road-sign line with no question teaser. Returns null when neither
+ *  follow_up sentence is present (an error/unrecognized shape). */
+function summarizeHumanAsk(text, tokens) {
+    const jobId = /^- job_id:\s*(\S+)\s*$/m.exec(text)?.[1];
+    if (jobId === undefined)
+        return null;
+    const drained = text.includes('Not in tmux: a human must drain it');
+    const delivered = text.includes('no need to poll');
+    if (!drained && !delivered)
+        return null;
+    const lines = drained
+        ? [{ text: 'ask posted — drain via `human inbox`', tone: 'warning' }]
+        : [{ text: 'ask posted → waiting on human', tone: 'accent' }];
+    const question = firstPositionalArg(tokens, 2, new Set(['--context-file']));
+    if (question !== undefined) {
+        const firstLine = truncateLine(question.split('\n')[0].trim(), ASK_TEASER_CHARS);
+        if (firstLine !== '')
+            lines.push({ text: firstLine, tone: 'muted' });
+    }
+    return lines;
+}
+/** `crtr human review` (humanReview.run, src/commands/human/prompts.ts:169)
+ *  returns `{job_id, dir, output, follow_up}` — same recognition strategy as
+ *  summarizeHumanAsk (job_id bullet + one of the two fixed follow_up
+ *  sentences, this time followUpReview/followUpDrain). The reviewed file
+ *  isn't in the output either, so its basename is recovered from argv (the
+ *  file positional, skipping `--output`'s value). Returns null when neither
+ *  follow_up sentence is present. */
+function summarizeHumanReview(text, tokens) {
+    const jobId = /^- job_id:\s*(\S+)\s*$/m.exec(text)?.[1];
+    if (jobId === undefined)
+        return null;
+    const drained = text.includes('Not in tmux: a human must drain it');
+    const live = text.includes("live on the human's screen for anchored, line-by-line review");
+    if (!drained && !live)
+        return null;
+    const file = firstPositionalArg(tokens, 2, new Set(['--output']));
+    const label = file !== undefined ? `review posted: ${basename(file)}` : 'review posted';
+    return drained
+        ? [{ text: `${label} — drain via \`human inbox\``, tone: 'warning' }]
+        : [{ text: `${label} → waiting on human`, tone: 'accent' }];
+}
+/** `crtr human list` (humanList.run, src/commands/human/queue.ts:283) has no
+ *  custom `render`; the generic renderer bullets `- total: N` then an
+ *  `N items:` table (or `0 items.`), columns including `kind` (the deck's
+ *  own interaction kind — `decision`/`question`/etc, often empty for a plain
+ *  freeform ask; NOT whether it was posed via `ask` vs `review`). Returns
+ *  null when the total/items shape doesn't match, or when `total` is
+ *  nonzero but the returned page is empty (exhausted pagination, not a
+ *  true zero total — collapsing that to "none pending" would misreport). */
+function summarizeHumanList(text) {
+    const total = parseIntBullet(text, 'total');
+    const rows = parseTableRows(text, 'items');
+    if (total === null || rows === null)
+        return null;
+    if (total === 0)
+        return [{ text: 'none pending', tone: 'success' }];
+    if (rows.length === 0)
+        return null;
+    const kinds = new Map();
+    for (const row of rows) {
+        const kind = row['kind'];
+        if (kind !== undefined && kind !== '')
+            kinds.set(kind, (kinds.get(kind) ?? 0) + 1);
+    }
+    const lines = [{ text: `${total} pending` }];
+    const kindDigest = summarizeTopCounts(kinds, 5, (k, c) => `${k}×${c}`);
+    if (kindDigest !== '')
+        lines.push({ text: kindDigest, tone: 'muted' });
+    return lines;
+}
+const DECK_PROMPT_TEASER_CHARS = 160;
+/** `crtr human deck` (humanDeck.run, src/commands/human/queue.ts:319) bullets
+ *  `id`/`interaction_count` (always short) then an `N interactions:` table
+ *  (columns `id,kind,prompt,options,allow_freetext`). `options` is a
+ *  cellEsc'd array of JSON-stringified `{id,label,...}` objects joined by
+ *  `, ` (core/render.ts's scalarStr for an array of objects) — counted via
+ *  the `"id":` occurrences each option object carries, not by splitting on
+ *  `, ` (a label/description could itself contain a comma). Only the FIRST
+ *  interaction is teased — decks built by `ask`/`review` always have exactly
+ *  one; a multi-interaction context-file deck gets an `interaction_count`
+ *  aside instead of every prompt. Returns null when the `id`/
+ *  `interaction_count` bullets or the interactions table don't match, or
+ *  when `allow_freetext` isn't exactly `true`/`false` (a malformed/
+ *  truncated row must not silently default to "no freetext"). */
+function summarizeHumanDeck(text) {
+    const id = /^- id:\s*(\S+)\s*$/m.exec(text)?.[1];
+    const interactionCount = parseIntBullet(text, 'interaction_count');
+    if (id === undefined || interactionCount === null)
+        return null;
+    const rows = parseTableRows(text, 'interactions');
+    if (rows === null || rows.length === 0)
+        return null;
+    const first = rows[0];
+    const prompt = first['prompt'];
+    if (prompt === undefined || prompt === '')
+        return null;
+    const optionCount = (first['options'] ?? '').match(/"id":/g)?.length ?? 0;
+    const allowFreetextRaw = first['allow_freetext'];
+    if (allowFreetextRaw !== 'true' && allowFreetextRaw !== 'false')
+        return null;
+    const allowFreetext = allowFreetextRaw === 'true';
+    const lines = [{ text: truncateLine(prompt, DECK_PROMPT_TEASER_CHARS) }];
+    const parts = [];
+    if (optionCount > 0)
+        parts.push(`${optionCount} option${optionCount === 1 ? '' : 's'}`);
+    if (allowFreetext)
+        parts.push('freetext');
+    if (interactionCount > 1)
+        parts.push(`${interactionCount} interactions`);
+    if (parts.length > 0)
+        lines.push({ text: parts.join(' · '), tone: 'muted' });
+    return lines;
+}
+/** `crtr memory list` (listLeaf.run, src/commands/memory/list.ts:65) has no
+ *  custom `render`; the generic renderer prints the `follow_up` prose then
+ *  an `N items:` table (columns `name,title,short_form,kind,scope,path,
+ *  is_dir`). No pagination on this leaf — `rows.length` IS the true total.
+ *  Returns null when the items table doesn't match, or is empty (an
+ *  empty corpus has nothing to digest into a breakdown). */
+function summarizeMemoryList(text) {
+    const rows = parseTableRows(text, 'items');
+    if (rows === null || rows.length === 0)
+        return null;
+    const kinds = new Map();
+    const scopes = new Map();
+    for (const row of rows) {
+        const kind = row['kind'];
+        const scope = row['scope'];
+        if (kind === undefined || kind === '' || scope === undefined || scope === '')
+            return null;
+        kinds.set(kind, (kinds.get(kind) ?? 0) + 1);
+        scopes.set(scope, (scopes.get(scope) ?? 0) + 1);
+    }
+    const kindDigest = summarizeTopCounts(kinds, 5, (k, c) => `${k}×${c}`);
+    const scopeDigest = summarizeTopCounts(scopes, 5, (s, c) => `${s}×${c}`);
+    if (kindDigest === '' || scopeDigest === '')
+        return null;
+    return [
+        { text: `${rows.length} docs` },
+        { text: `${kindDigest} / ${scopeDigest}`, tone: 'muted' },
+    ];
+}
+const MEMORY_FIND_NAME_CAP = 5;
+/** `crtr memory find` (findLeaf.run, src/commands/memory/find.ts:141) always
+ *  bullets `- query: <query>` then prose follow_up, then either `0 hits.` or
+ *  an `N hits:` table. Ranked mode's table has a `name` column; `--grep`
+ *  mode's does not (`path,line,text` instead) — recognized and rejected
+ *  (null, generic fallback) rather than digested, since a grep hit has no
+ *  document identity to name. Returns null when the query bullet or the
+ *  hits table (in ranked-mode shape) don't match. */
+function summarizeMemoryFind(text) {
+    const query = /^- query:\s*(.+)$/m.exec(text)?.[1]?.trim();
+    if (query === undefined)
+        return null;
+    if (/^0 hits\.$/m.test(text))
+        return [{ text: `0 hits for "${query}"`, tone: 'muted' }];
+    const rows = parseTableRows(text, 'hits');
+    if (rows === null || rows.length === 0)
+        return null;
+    const names = rows.map((r) => r['name']);
+    if (names.some((n) => n === undefined || n === ''))
+        return null;
+    const shown = names.slice(0, MEMORY_FIND_NAME_CAP);
+    const remaining = names.length - shown.length;
+    const namesLine = remaining > 0 ? `${shown.join(', ')}, … ${remaining} more` : shown.join(', ');
+    return [
+        { text: `${rows.length} hit${rows.length === 1 ? '' : 's'} for "${query}"` },
+        { text: namesLine, tone: 'muted' },
+    ];
+}
+/** `crtr memory write` (writeLeaf.run, src/commands/memory/write.ts:123)
+ *  bullets `name`/`kind`/`scope`/`created` (always short); `path` and
+ *  `follow_up` are always long, so they render as the two labeled prose
+ *  blocks (`**path:**`/`**follow_up:**`) — read via readFieldFlexible.
+ *  Returns null when `name` or `created` (a plain boolean) isn't present as
+ *  a bullet — an error/unrecognized shape. */
+function summarizeMemoryWrite(text) {
+    const name = /^- name:\s*(\S+)\s*$/m.exec(text)?.[1];
+    const createdMatch = /^- created:\s*(true|false)\s*$/m.exec(text);
+    if (name === undefined || createdMatch === null)
+        return null;
+    const created = createdMatch[1] === 'true';
+    const lines = [{ text: `${created ? 'wrote' : 'updated'} ${name}`, tone: 'success' }];
+    const path = readFieldFlexible(text, 'path');
+    if (path !== undefined)
+        lines.push({ text: path, tone: 'muted' });
+    return lines;
+}
+/** `crtr pkg plugin install` (pluginInstall.run, src/commands/pkg/
+ *  plugin-manage.ts:280) has no custom `render`; the generic renderer
+ *  bullets `name`/`scope` (always short) then `path` — almost always long
+ *  enough to cross the prose threshold, and since it's the SOLE prose field
+ *  it renders as a bare unlabeled paragraph (see soloProseAfterBullets),
+ *  not a labeled one. Falls back to a `- path:` bullet for the rare
+ *  short-path case. Returns null when `name`/`scope` aren't present as
+ *  bullets — an error/unrecognized shape (path is a muted aside, not
+ *  required for a recognized digest). */
+function summarizePkgPluginInstall(text) {
+    const name = /^- name:\s*(\S+)\s*$/m.exec(text)?.[1];
+    const scope = /^- scope:\s*(\S+)\s*$/m.exec(text)?.[1];
+    if (name === undefined || scope === undefined)
+        return null;
+    const path = readFieldFlexible(text, 'path') ?? soloProseAfterBullets(text);
+    return [
+        { text: `installed ${name}`, tone: 'success' },
+        { text: path !== undefined ? `${scope} · ${path}` : scope, tone: 'muted' },
+    ];
+}
+/** `crtr pkg plugin update` (pluginUpdate.run, src/commands/pkg/
+ *  plugin-manage.ts:349) has no custom `render`; the generic renderer emits
+ *  an `N updated:` table (columns `name,updated,sha`) — one row when
+ *  `--name` targets a single plugin, one row per installed plugin
+ *  otherwise. There is no version field anywhere in this output (unlike
+ *  command-icons.md's hypothetical version-delta wording) — `sha` (short,
+ *  7 chars) is the only content available to show. Returns null when the
+ *  table doesn't match this shape, or when any row's `updated` cell isn't
+ *  exactly `true`/`false` (the multi-row loop mirrors the single-row
+ *  validation above — a malformed cell must not be silently counted as
+ *  "already current"). */
+function summarizePkgPluginUpdate(text) {
+    const rows = parseTableRows(text, 'updated');
+    if (rows === null)
+        return null;
+    if (rows.length === 0)
+        return [{ text: 'nothing to update', tone: 'muted' }];
+    if (rows.length === 1) {
+        const row = rows[0];
+        const name = row['name'];
+        const updated = row['updated'];
+        if (name === undefined || (updated !== 'true' && updated !== 'false'))
+            return null;
+        const sha = (row['sha'] ?? '').slice(0, 7);
+        const lines = [
+            updated === 'true' ? { text: `updated ${name}`, tone: 'success' } : { text: `${name} already current`, tone: 'muted' },
+        ];
+        if (sha !== '')
+            lines.push({ text: sha, tone: 'muted' });
+        return lines;
+    }
+    let updatedCount = 0;
+    for (const row of rows) {
+        const updated = row['updated'];
+        if (updated !== 'true' && updated !== 'false')
+            return null;
+        if (updated === 'true')
+            updatedCount++;
+    }
+    const current = rows.length - updatedCount;
+    return [{ text: `${updatedCount} updated · ${current} already current` }];
+}
+const PKG_LIST_NAME_CAP = 8;
+/** `crtr pkg plugin list` (pluginList.run, src/commands/pkg/
+ *  plugin-inspect.ts:12) bullets `- total: N` then an `N items:` table
+ *  (columns `name,scope,version,enabled,source_marketplace,path`).
+ *  `enabled`/name counts are read from the RETURNED page only — with the
+ *  default 50-per-page limit this matches `total` in practice, but a
+ *  narrower `--limit` would undercount enabled/shown names against the
+ *  true total (the same page-vs-total caveat other paginated summaries in
+ *  this file carry). Returns null when the total/items shape doesn't
+ *  match, or when `total` is nonzero but the returned page is empty
+ *  (exhausted pagination, not a true zero total). */
+function summarizePkgPluginList(text) {
+    const total = parseIntBullet(text, 'total');
+    const rows = parseTableRows(text, 'items');
+    if (total === null || rows === null)
+        return null;
+    if (total === 0)
+        return [{ text: '0 plugins', tone: 'muted' }];
+    if (rows.length === 0)
+        return null;
+    let enabledCount = 0;
+    const names = [];
+    for (const row of rows) {
+        const name = row['name'];
+        const enabled = row['enabled'];
+        if (name === undefined || name === '' || (enabled !== 'true' && enabled !== 'false'))
+            return null;
+        if (enabled === 'true')
+            enabledCount++;
+        names.push(name);
+    }
+    const shown = names.slice(0, PKG_LIST_NAME_CAP);
+    const remaining = names.length - shown.length;
+    const namesLine = remaining > 0 ? `${shown.join(', ')}, … ${remaining} more` : shown.join(', ');
+    return [
+        { text: `${total} plugins · ${enabledCount} enabled` },
+        { text: namesLine, tone: 'muted' },
+    ];
+}
+/** `crtr pkg plugin show` (pluginShow.run, src/commands/pkg/
+ *  plugin-inspect.ts:76) bullets `name`/`scope`/`path`/`enabled` (path is
+ *  usually short here — a plugin dir, not a nested interaction path — so
+ *  stays a bullet) then `manifest` — an OBJECT, so core/render.ts's
+ *  scalarStr always JSON.stringifies it to a bullet regardless of length
+ *  (isProse only ever triggers for strings) — then an `N docs:` table (or
+ *  `0 docs.`). `version` is read from the parsed manifest JSON, not a
+ *  top-level field. Returns null when `name`/`enabled`/`manifest` don't
+ *  match, `manifest` isn't valid JSON, or the docs count line is missing. */
+function summarizePkgPluginShow(text) {
+    const name = /^- name:\s*(\S+)\s*$/m.exec(text)?.[1];
+    const enabledMatch = /^- enabled:\s*(true|false)\s*$/m.exec(text);
+    const manifestMatch = /^- manifest:\s*(\{.*\})\s*$/m.exec(text);
+    if (name === undefined || enabledMatch === null || manifestMatch === null)
+        return null;
+    let manifest;
+    try {
+        manifest = JSON.parse(manifestMatch[1]);
+    }
+    catch {
+        return null;
+    }
+    const version = manifest !== null && typeof manifest === 'object' && 'version' in manifest && typeof manifest.version === 'string'
+        ? manifest.version
+        : undefined;
+    const docsCount = /^0 docs\.$/m.test(text) ? 0 : Number(/^(\d+) docs:$/m.exec(text)?.[1] ?? NaN);
+    if (Number.isNaN(docsCount))
+        return null;
+    const enabled = enabledMatch[1] === 'true';
+    return [
+        { text: `${name}${version !== undefined ? `@${version}` : ''} · ${enabled ? 'enabled' : 'disabled'}`, tone: enabled ? 'success' : 'muted' },
+        { text: `${docsCount} substrate doc${docsCount === 1 ? '' : 's'}`, tone: 'muted' },
+    ];
+}
+/** `crtr pkg market list` (marketList.run, src/commands/pkg/
+ *  market-inspect.ts:14) bullets `- total: N` then an `N items:` table
+ *  (columns `name,scope,url,ref,path`). Returns null when the total/items
+ *  shape doesn't match, or when `total` is nonzero but the returned page
+ *  is empty (exhausted pagination, not a true zero total). */
+function summarizePkgMarketList(text) {
+    const total = parseIntBullet(text, 'total');
+    const rows = parseTableRows(text, 'items');
+    if (total === null || rows === null)
+        return null;
+    if (total === 0)
+        return [{ text: '0 marketplaces', tone: 'muted' }];
+    if (rows.length === 0)
+        return null;
+    const names = rows.map((r) => r['name']);
+    if (names.some((n) => n === undefined || n === ''))
+        return null;
+    return [
+        { text: `${total} marketplaces` },
+        { text: names.join(', '), tone: 'muted' },
+    ];
+}
+const MARKET_BROWSE_NAME_CAP = 8;
+/** `crtr pkg market browse` (marketBrowse.run, src/commands/pkg/
+ *  market-inspect.ts:77) bullets `marketplace`/`total` then an `N items:`
+ *  table (columns include `name,ref,source,version,description,keywords,
+ *  installed,installed_scope`). Returns null when the marketplace/total
+ *  bullets or the items table don't match, or when `total` is nonzero but
+ *  the returned page is empty (exhausted pagination, not a true zero
+ *  total). */
+function summarizePkgMarketBrowse(text) {
+    const market = /^- marketplace:\s*(\S+)\s*$/m.exec(text)?.[1];
+    const total = parseIntBullet(text, 'total');
+    const rows = parseTableRows(text, 'items');
+    if (market === undefined || total === null || rows === null)
+        return null;
+    if (total === 0)
+        return [{ text: `0 plugins in ${market}`, tone: 'muted' }];
+    if (rows.length === 0)
+        return null;
+    const names = rows.map((r) => r['name']);
+    if (names.some((n) => n === undefined || n === ''))
+        return null;
+    const shown = names.slice(0, MARKET_BROWSE_NAME_CAP);
+    const remaining = names.length - shown.length;
+    const namesLine = remaining > 0 ? `${shown.join(', ')}, … ${remaining} more` : shown.join(', ');
+    return [
+        { text: `${total} plugins in ${market}` },
+        { text: namesLine, tone: 'muted' },
+    ];
+}
+// ---------------------------------------------------------------------------
+// Batch D — search/sys/surface. search's three leaves share a rendering
+// convention (a numbered `### i. title` heading per item, an optional meta
+// line, then highlight bullets or a text blockquote — see exa.ts's
+// renderResult) and a fixed, unconditional follow_up sentence per leaf that
+// doubles as a shape boundary; sys/surface leaves have no shared shape and
+// are handled independently below.
+// ---------------------------------------------------------------------------
+const SEARCH_RESULT_CAP = 3;
+/** Pull a bare host out of a search result's meta line (renderResult,
+ *  src/commands/search/exa.ts:150 — `url · date · author · via source`, url
+ *  first when present) for a compact `title — domain` digest row. Returns
+ *  undefined when the line isn't a `https?://` url — a highlight bullet with
+ *  no meta line at all, or a meta line that leads with the date/author
+ *  because url was absent. */
+function extractDomain(metaLine) {
+    const first = (metaLine.split(' · ')[0] ?? '').trim();
+    const m = /^https?:\/\/(?:www\.)?([^/\s]+)/.exec(first);
+    return m?.[1];
+}
+/** `search web`'s follow_up (src/commands/search/web.ts:56–57) is a FIXED
+ *  string every call appends after the results (or `No results…`) line —
+ *  its presence is required below so a corrupted/foreign document that
+ *  happens to start with a matching lead line still can't be mistaken for
+ *  this leaf's real output. */
+const SEARCH_WEB_FOLLOWUP_MARKER = 'Fetch full content for selected result URLs with the contents leaf after checking its schema.';
+/** `crtr search web` (webLeaf.render, src/commands/search/web.ts:70) has two
+ *  shapes: `No results for "<query>".` (zero hits) or `${N} results for
+ *  "${query}":` followed by one `### i. title` heading per result (each
+ *  optionally followed by a meta line — see extractDomain) then highlight
+ *  bullets or a text blockquote, blank-line separated, then the fixed
+ *  follow_up road sign (see SEARCH_WEB_FOLLOWUP_MARKER). Returns null when
+ *  the follow_up marker is absent, the lead line matches neither shape, or
+ *  the parsed heading count doesn't equal the declared total (a pi
+ *  bash-tool truncation mid-list, or an unrecognized layout). */
+function summarizeSearchWeb(text) {
+    if (!text.includes(SEARCH_WEB_FOLLOWUP_MARKER))
+        return null;
+    const firstLine = text.split('\n')[0] ?? '';
+    const noResults = /^No results for "(.+)"\.$/.exec(firstLine);
+    if (noResults !== null)
+        return [{ text: `0 results for "${noResults[1]}"`, tone: 'muted' }];
+    const head = /^(\d+) results for ".+":$/.exec(firstLine);
+    if (head === null)
+        return null;
+    const count = Number(head[1]);
+    const lines = text.split('\n');
+    const items = [];
+    for (let i = 0; i < lines.length; i++) {
+        const h = /^### \d+\. (.+)$/.exec(lines[i]);
+        if (h === null)
+            continue;
+        items.push({ title: h[1], domain: extractDomain(lines[i + 1] ?? '') });
+    }
+    if (items.length !== count)
+        return null;
+    const top = items.slice(0, SEARCH_RESULT_CAP).map((it) => (it.domain !== undefined ? `${it.title} — ${it.domain}` : it.title));
+    const out = [{ text: `${count} result${count === 1 ? '' : 's'}` }];
+    for (const t of top)
+        out.push({ text: t, tone: 'muted' });
+    const remaining = items.length - top.length;
+    if (remaining > 0)
+        out.push({ text: `… ${remaining} more`, tone: 'muted' });
+    return out;
+}
+/** Fixed lead sentence of `search answer`'s follow_up (src/commands/search/
+ *  answer.ts:39) — the SAME string on every call (no branching), so its
+ *  presence marks where the answer body ends and the follow_up road sign
+ *  begins, regardless of whether citations are present. */
+const SEARCH_ANSWER_FOLLOWUP_MARKER = 'Read any cited source in full with the contents leaf';
+/** `crtr search answer` (answerLeaf.render, src/commands/search/answer.ts:52)
+ *  has two shapes: `No answer was returned.` (empty) or `${answer}\n\n` then,
+ *  when citations exist, `Sources (${N}):` plus one numbered line per
+ *  citation and a blank line, then unconditionally the fixed follow_up
+ *  sentence. Citations are optional; the follow_up marker is not, so it
+ *  locates the answer/Sources boundary either way. Mirrors
+ *  summarizeMemoryRead's teaser+ellipsis shape for the answer body. Returns
+ *  null when the follow_up marker is absent (unrecognized shape) or the
+ *  recovered answer text is empty. */
+function summarizeSearchAnswer(text) {
+    const followUpIdx = text.indexOf(SEARCH_ANSWER_FOLLOWUP_MARKER);
+    if (followUpIdx === -1)
+        return null;
+    if (/^No answer was returned\.$/.test(text.split('\n')[0] ?? '')) {
+        return [{ text: 'no answer returned', tone: 'muted' }];
+    }
+    const sourcesMatch = /^Sources \((\d+)\):$/m.exec(text);
+    const bodyEnd = sourcesMatch !== null ? text.indexOf(sourcesMatch[0]) : followUpIdx;
+    if (bodyEnd <= 0)
+        return null;
+    const answer = text.slice(0, bodyEnd).trim();
+    if (answer === '')
+        return null;
+    let citationCount = 0;
+    if (sourcesMatch !== null) {
+        citationCount = Number(sourcesMatch[1]);
+        const citationsBlock = text.slice(text.indexOf(sourcesMatch[0]) + sourcesMatch[0].length, followUpIdx);
+        const numberedLines = [...citationsBlock.matchAll(/^\d+\. .+$/gm)];
+        if (numberedLines.length !== citationCount)
+            return null;
+    }
+    const answerLines = answer.split('\n').filter((l) => l.trim() !== '');
+    const teaser = answerLines.slice(0, MEMORY_READ_CONTENT_LINES);
+    const hasMore = answerLines.length > MEMORY_READ_CONTENT_LINES;
+    const lines = teaser.map((l) => ({ text: l }));
+    if (hasMore)
+        lines.push({ text: '…', tone: 'muted' });
+    lines.push({ text: `${citationCount} citation${citationCount === 1 ? '' : 's'}`, tone: 'muted' });
+    return lines;
+}
+/** Fixed lead sentence of `search contents`'s follow_up (src/commands/
+ *  search/contents.ts:71) — always this exact string, used to bound the
+ *  last result block below (its true end would otherwise swallow a trailing
+ *  `Failed (…):` block and the follow_up text into the char count). */
+const SEARCH_CONTENTS_FOLLOWUP_MARKER = 'Stale or empty content? Re-run with --max-age-hours 0';
+const SEARCH_CONTENTS_NAME_CAP = 5;
+/** `crtr search contents` (contentsLeaf.render, src/commands/search/
+ *  contents.ts:87): `No content extracted.` (0 results) or `Extracted ${N}
+ *  URL(s):` plus one `### i. title` block per result (heading, optional
+ *  meta line, then highlight bullets or a text blockquote); either way, an
+ *  optional `Failed (${M}):` bullet list follows, then unconditionally the
+ *  fixed follow_up sentence. Per-URL `chars` is the length of that result's
+ *  own rendered content block (title/meta lines excluded) — the visible
+ *  extracted text, not Exa's own byte count. Returns null when the
+ *  follow_up marker is absent, the heading count doesn't match `N`, or (in
+ *  the 0-results case) there were no failures either — that combination
+ *  isn't a real shape this leaf produces. */
+function summarizeSearchContents(text) {
+    const followUpIdx = text.indexOf(SEARCH_CONTENTS_FOLLOWUP_MARKER);
+    if (followUpIdx === -1)
+        return null;
+    const failedMatch = /^Failed \((\d+)\):$/m.exec(text);
+    const failedCount = failedMatch !== null ? Number(failedMatch[1]) : 0;
+    const firstLine = text.split('\n')[0] ?? '';
+    if (/^No content extracted\.$/.test(firstLine)) {
+        if (failedCount === 0)
+            return [{ text: 'no content extracted', tone: 'muted' }];
+        return [{ text: `0 extracted · ${failedCount} failed`, tone: 'error' }];
+    }
+    const head = /^Extracted (\d+) URLs?:$/.exec(firstLine);
+    if (head === null)
+        return null;
+    const count = Number(head[1]);
+    const lines = text.split('\n');
+    const headingIdxs = [];
+    for (let i = 0; i < lines.length; i++)
+        if (/^### \d+\. /.test(lines[i]))
+            headingIdxs.push(i);
+    if (headingIdxs.length !== count)
+        return null;
+    const contentEndOffset = failedMatch !== null ? text.indexOf(failedMatch[0]) : followUpIdx;
+    const contentEndLine = text.slice(0, contentEndOffset).split('\n').length - 1;
+    const items = [];
+    for (let k = 0; k < headingIdxs.length; k++) {
+        const start = headingIdxs[k];
+        const end = k + 1 < headingIdxs.length ? headingIdxs[k + 1] : contentEndLine;
+        const heading = /^### \d+\. (.+)$/.exec(lines[start]);
+        if (heading === null)
+            return null;
+        const body = lines.slice(start + 1, end);
+        // renderResult (exa.ts:184–189) puts the meta line — url first when
+        // present — immediately after the heading; drop it so `chars` reflects
+        // only the extracted content, not the URL/date/author line.
+        const contentLines = body.length > 0 && /^https?:\/\//.test(body[0]) ? body.slice(1) : body;
+        items.push({ title: heading[1], chars: contentLines.join('\n').trim().length });
+    }
+    const shown = items.slice(0, SEARCH_CONTENTS_NAME_CAP).map((it) => `${it.title} · ${it.chars} chars`);
+    const out = [{ text: `extracted ${count} URL${count === 1 ? '' : 's'}` }];
+    for (const s of shown)
+        out.push({ text: s, tone: 'muted' });
+    const remaining = items.length - shown.length;
+    if (remaining > 0)
+        out.push({ text: `… ${remaining} more`, tone: 'muted' });
+    if (failedCount > 0)
+        out.push({ text: `${failedCount} failed`, tone: 'warning' });
+    return out;
+}
+/** `crtr sys setup` opens a pi-tui wizard when stdout is a TTY (its `render`
+ *  is always `''` — the wizard writes directly via process.stdout, and its
+ *  raw ANSI curses frames never match any marker below, so this summarizer
+ *  safely returns null in that case). In the headless/agent path
+ *  (src/commands/sys/setup.ts's `!process.stdout.isTTY` branch,
+ *  `buildSetupStaticInstructions` in setup-core.ts:328 — the shape every
+ *  bash-tool call to this leaf actually produces) it instead prints a
+ *  static inventory: the headline `crtr sys setup (non-interactive)`, a
+ *  `Packages:` section (`- <name> — <description> (installed|not
+ *  installed)`), a `System deps:` section (`- <tool>: ✓ installed` or `-
+ *  <tool>: <command/hint>`), then an `- Exa key: …` bullet and a footer line
+ *  — verified against the live command, 2026-07-01. Returns null when the
+ *  headline, both section headers, or the Exa-key marker bounding the
+ *  System deps section are missing, or any row's shape doesn't match — a
+ *  partial/truncated dump must not report a false step count. */
+function summarizeSysSetup(text) {
+    if ((text.split('\n')[0] ?? '') !== 'crtr sys setup (non-interactive)')
+        return null;
+    const lines = text.split('\n');
+    const pkgIdx = lines.indexOf('Packages:');
+    const sysIdx = lines.indexOf('System deps:');
+    if (pkgIdx === -1 || sysIdx === -1 || sysIdx <= pkgIdx)
+        return null;
+    const exaIdx = lines.findIndex((l, i) => i > sysIdx && /^- Exa key:/.test(l));
+    if (exaIdx === -1)
+        return null;
+    const pkgLines = lines.slice(pkgIdx + 1, sysIdx).filter((l) => l.trim() !== '');
+    const sysLines = lines.slice(sysIdx + 1, exaIdx).filter((l) => l.trim() !== '');
+    if (pkgLines.length === 0 && sysLines.length === 0)
+        return null;
+    let ok = 0;
+    const pending = [];
+    for (const l of pkgLines) {
+        const m = /^- (.+?) — .+\((installed|not installed)\)$/.exec(l);
+        if (m === null)
+            return null;
+        if (m[2] === 'installed')
+            ok++;
+        else
+            pending.push(m[1]);
+    }
+    for (const l of sysLines) {
+        const m = /^- (\S+): (.+)$/.exec(l);
+        if (m === null)
+            return null;
+        if (m[2] === '✓ installed')
+            ok++;
+        else
+            pending.push(m[1]);
+    }
+    if (pending.length === 0)
+        return [{ text: `${ok} steps ok`, tone: 'success' }];
+    return [
+        { text: `${ok} ok · ${pending.length} pending`, tone: 'warning' },
+        { text: pending.join(', '), tone: 'muted' },
+    ];
+}
+const SYS_DOCTOR_ISSUE_CAP = 5;
+/** `crtr sys doctor` (sysDoctorLeaf.run, src/commands/sys/doctor.ts:283) has
+ *  no custom `render`; the generic renderer bullets `ok`/`failed` then an `N
+ *  checks:` table (columns scope,name,status,message,remediation, plus a
+ *  `fixed` column ONLY when at least one row set it — renderArray's column
+ *  set is the union of keys across every row, src/core/render.ts:60).
+ *  `failed` counts only UNRESOLVED fails (status:fail with no `fixed:true`)
+ *  — mirroring doctor.ts's own `ok`/`failed` computation, which excludes
+ *  `fixed:true` rows. Returns null when the ok/failed bullets or the checks
+ *  table don't match this shape, or when the open-fail-row count found in
+ *  the table doesn't equal the declared `failed` bullet (a truncated table,
+ *  or a row missing name/message). */
+function summarizeSysDoctor(text) {
+    const okMatch = /^- ok:\s*(true|false)\s*$/m.exec(text);
+    const failedMatch = /^- failed:\s*(\d+)\s*$/m.exec(text);
+    if (okMatch === null || failedMatch === null)
+        return null;
+    const rows = parseTableRows(text, 'checks');
+    if (rows === null)
+        return null;
+    const failed = Number(failedMatch[1]);
+    const fixedCount = rows.filter((r) => r['status'] === 'fail' && r['fixed'] === 'true').length;
+    if (failed === 0) {
+        // A fail row with no `fixed:true` here would contradict the declared
+        // `failed: 0` — an inconsistent/foreign shape, not a real PASS.
+        if (rows.some((r) => r['status'] === 'fail' && r['fixed'] !== 'true'))
+            return null;
+        const lines = [{ text: `PASS · ${rows.length} checks`, tone: 'success' }];
+        if (fixedCount > 0)
+            lines.push({ text: `fixed ${fixedCount} automatically`, tone: 'muted' });
+        return lines;
+    }
+    const openIssues = rows.filter((r) => r['status'] === 'fail' && r['fixed'] !== 'true');
+    if (openIssues.length !== failed)
+        return null;
+    const shown = [];
+    for (const row of openIssues.slice(0, SYS_DOCTOR_ISSUE_CAP)) {
+        const name = row['name'];
+        const message = row['message'];
+        if (name === undefined || message === undefined)
+            return null;
+        shown.push(`${name}: ${message}`);
+    }
+    const lines = [{ text: `${failed} issue${failed === 1 ? '' : 's'}`, tone: 'error' }];
+    for (const s of shown)
+        lines.push({ text: s, tone: 'warning' });
+    const remaining = openIssues.length - shown.length;
+    if (remaining > 0)
+        lines.push({ text: `… ${remaining} more`, tone: 'muted' });
+    if (fixedCount > 0)
+        lines.push({ text: `fixed ${fixedCount} automatically`, tone: 'muted' });
+    return lines;
+}
+const SYS_UPDATE_OUTDATED_CAP = 5;
+/** `crtr sys update` (sysUpdateLeaf.run, src/commands/sys/update.ts:19) has
+ *  two shapes depending on `--check`: bounded check — a `- up_to_date:
+ *  true|false` bullet plus an `N updates:` table (columns name,kind,current,
+ *  latest,up_to_date,unreachable — no version field at the top level, so
+ *  command-icons.md's `vX.Y.Z` framing doesn't fit this leaf; that's `sys
+ *  version`'s shape, not this one); or apply — `- target: self|content|all`
+ *  + `- status: done|failed` + `- error: <msg>` (only on failure). Verified
+ *  against the live `--check` path, 2026-07-01; the apply path is read from
+ *  source only — running it mutates the install (spawns npm/git). Returns
+ *  null when neither shape's required bullets/table are present. */
+function summarizeSysUpdate(text) {
+    const upToDateMatch = /^- up_to_date:\s*(true|false)\s*$/m.exec(text);
+    if (upToDateMatch !== null) {
+        const rows = parseTableRows(text, 'updates');
+        if (rows === null)
+            return null;
+        if (upToDateMatch[1] === 'true') {
+            // sys update's own computation is `up_to_date = updates.every(u =>
+            // u.up_to_date || u.unreachable)` (update.ts:104) — a row that
+            // disagrees (reachable and NOT up to date) contradicts the bullet.
+            if (!rows.every((r) => r['up_to_date'] === 'true' || r['unreachable'] === 'true'))
+                return null;
+            return [{ text: `PASS · ${rows.length} up to date`, tone: 'success' }];
+        }
+        const outdated = [];
+        let unreachable = 0;
+        for (const row of rows) {
+            const name = row['name'];
+            const current = row['current'];
+            const latest = row['latest'];
+            const isUpToDate = row['up_to_date'];
+            const isUnreachable = row['unreachable'];
+            if (name === undefined || isUpToDate === undefined || isUnreachable === undefined)
+                return null;
+            if (isUnreachable === 'true') {
+                unreachable++;
+                continue;
+            }
+            if (isUpToDate === 'false')
+                outdated.push(`${name}: ${current} → ${latest}`);
+        }
+        const lines = [{ text: `${outdated.length} outdated · ${rows.length} checked`, tone: 'warning' }];
+        const shown = outdated.slice(0, SYS_UPDATE_OUTDATED_CAP);
+        for (const s of shown)
+            lines.push({ text: s, tone: 'muted' });
+        const remaining = outdated.length - shown.length;
+        if (remaining > 0)
+            lines.push({ text: `… ${remaining} more`, tone: 'muted' });
+        if (unreachable > 0)
+            lines.push({ text: `${unreachable} unreachable`, tone: 'muted' });
+        return lines;
+    }
+    const statusMatch = /^- status:\s*(done|failed)\s*$/m.exec(text);
+    if (statusMatch === null)
+        return null;
+    const target = /^- target:\s*(\S+)\s*$/m.exec(text)?.[1];
+    if (target === undefined)
+        return null;
+    if (statusMatch[1] === 'done')
+        return [{ text: `updated · ${target}`, tone: 'success' }];
+    const error = /^- error:\s*(.+)$/m.exec(text)?.[1];
+    const lines = [{ text: `update failed · ${target}`, tone: 'error' }];
+    if (error !== undefined)
+        lines.push({ text: error, tone: 'muted' });
+    return lines;
+}
+/** `crtr sys feedback` (sysFeedbackLeaf.run, src/commands/sys/feedback.ts:
+ *  187) has no custom `render`; the generic renderer bullets `status`
+ *  (always short) then either `url` (filed shape — a short GitHub issue
+ *  link) or `path`+`error` (saved-locally shape; `path` is usually short but
+ *  can cross the prose threshold with a long home dir, and `error` is a
+ *  free-form spawn/gh message that often does — read via
+ *  readFieldFlexible/soloProseAfterBullets, the same two-shape pattern
+ *  Batch C's human/memory summarizers use for a field whose bullet-vs-prose
+ *  form depends on string length). Read from source only — running it files
+ *  a real GitHub issue or writes a local report, so it was not invoked
+ *  live. Returns null when `status` isn't `filed`/`saved-locally`, or the
+ *  shape's required companion field is missing. */
+function summarizeSysFeedback(text) {
+    const statusMatch = /^- status:\s*(filed|saved-locally)\s*$/m.exec(text);
+    if (statusMatch === null)
+        return null;
+    if (statusMatch[1] === 'filed') {
+        const url = readFieldFlexible(text, 'url') ?? soloProseAfterBullets(text);
+        if (url === undefined)
+            return null;
+        return [
+            { text: 'issue filed', tone: 'success' },
+            { text: url, tone: 'muted' },
+        ];
+    }
+    const path = readFieldFlexible(text, 'path') ?? soloProseAfterBullets(text);
+    if (path === undefined)
+        return null;
+    // The reason (gh missing, unauthenticated, or the API call itself
+    // failing — feedback.ts:188–195) is prose the digest doesn't try to
+    // classify; "not filed" states the fact without guessing the cause.
+    return [
+        { text: 'saved locally — not filed', tone: 'warning' },
+        { text: basename(path), tone: 'muted' },
+    ];
+}
+const SURFACE_VIEW_LIST_ID_CAP = 8;
+/** `crtr surface view list` (viewListLeaf.render, src/commands/view-list.ts:
+ *  59) has a custom render, NOT the generic renderResult: one padded plain
+ *  line per view, `<id padded>  <title padded>  [<scope>]<optional
+ *  desc/error>` (verified live, 2026-07-01) — no GFM table markup at all, so
+ *  this file's shared parseTableRows/splitTableRow helpers don't apply.
+ *  Real ids/titles never contain a run of 2+ spaces, so each real field
+ *  boundary (the column padding plus the literal `  ` separator together
+ *  always total 2+ spaces) is recoverable by anchoring on the `[scope]`
+ *  bracket. Returns null when the roster is empty (`No views found…`, a
+ *  single plain line the generic path already renders fine) or any line
+ *  fails to match this row shape — including the pi truncation marker,
+ *  which never contains a `[scope]` bracket or a 2+-space run. */
+function summarizeSurfaceViewList(text) {
+    const lines = text.split('\n').filter((l) => l.trim() !== '');
+    if (lines.length === 0)
+        return null;
+    const ids = [];
+    for (const line of lines) {
+        const m = /^(\S+)\s{2,}.+?\s{2,}\[\w[\w-]*\](?:\s{2,}.*)?$/.exec(line);
+        if (m === null)
+            return null;
+        ids.push(m[1]);
+    }
+    const shown = ids.slice(0, SURFACE_VIEW_LIST_ID_CAP);
+    const remaining = ids.length - shown.length;
+    const idsLine = remaining > 0 ? `${shown.join(', ')}, … ${remaining} more` : shown.join(', ');
+    return [
+        { text: `${ids.length} views` },
+        { text: idsLine, tone: 'muted' },
+    ];
+}
+const SUMMARIZERS = [
+    { path: 'memory read', run: summarizeMemoryRead },
+    { path: 'memory lint', run: summarizeMemoryLint },
+    { path: 'canvas dashboard', run: summarizeCanvasDashboard },
+    { path: 'node inspect list', run: summarizeNodeInspectList },
+    { path: 'canvas attention count', run: summarizeCanvasAttentionCount },
+    { path: 'canvas attention list', run: summarizeCanvasAttentionList },
+    { path: 'canvas attention map', run: summarizeCanvasAttentionMap },
+    { path: 'canvas revive', run: summarizeCanvasRevive },
+    { path: 'canvas history search', run: summarizeCanvasHistorySearch },
+    { path: 'canvas history read', run: summarizeCanvasHistoryRead },
+    { path: 'canvas history show', run: summarizeCanvasHistoryShow },
+    { path: 'canvas daemon start', run: summarizeCanvasDaemonStart },
+    { path: 'canvas daemon status', run: summarizeCanvasDaemonStatus },
+    { path: 'canvas daemon stop', run: summarizeCanvasDaemonStop },
+    { path: 'canvas issue new', run: summarizeCanvasIssueNew },
+    { path: 'node new', run: summarizeNodeNew },
+    { path: 'node msg', run: summarizeNodeMsg },
+    { path: 'node yield', run: summarizeNodeYield },
+    { path: 'node lifecycle close', run: summarizeNodeLifecycleClose },
+    { path: 'node triggers list', run: summarizeNodeTriggersList },
+    { path: 'feed read', run: summarizeFeedRead },
+    { path: 'feed message', run: summarizeFeedMessage },
+    { path: 'feed peek', run: summarizeFeedPeek },
+    { path: 'push urgent', run: summarizePushUrgent },
+    { path: 'push final', run: summarizePushFinal },
+    { path: 'human ask', run: summarizeHumanAsk },
+    { path: 'human review', run: summarizeHumanReview },
+    { path: 'human list', run: summarizeHumanList },
+    { path: 'human deck', run: summarizeHumanDeck },
+    { path: 'memory list', run: summarizeMemoryList },
+    { path: 'memory find', run: summarizeMemoryFind },
+    { path: 'memory write', run: summarizeMemoryWrite },
+    { path: 'pkg plugin install', run: summarizePkgPluginInstall },
+    { path: 'pkg plugin update', run: summarizePkgPluginUpdate },
+    { path: 'pkg plugin list', run: summarizePkgPluginList },
+    { path: 'pkg plugin show', run: summarizePkgPluginShow },
+    { path: 'pkg market list', run: summarizePkgMarketList },
+    { path: 'pkg market browse', run: summarizePkgMarketBrowse },
+    { path: 'search web', run: summarizeSearchWeb },
+    { path: 'search answer', run: summarizeSearchAnswer },
+    { path: 'search contents', run: summarizeSearchContents },
+    { path: 'sys setup', run: summarizeSysSetup },
+    { path: 'sys doctor', run: summarizeSysDoctor },
+    { path: 'sys update', run: summarizeSysUpdate },
+    { path: 'sys feedback', run: summarizeSysFeedback },
+    { path: 'surface view list', run: summarizeSurfaceViewList },
+];
+/** Dispatch a command's argv tokens + its raw result text to the summarizer
+ *  that owns that leaf path (longest-registered-prefix match, same shape as
+ *  suppressOutputForPath), or null when no command owns a summary — the
+ *  caller falls through to generic truncation in that case. */
+export function summarizePath(tokens, rawText) {
+    for (const { path, run } of SUMMARIZERS) {
+        const words = path.split(' ');
+        if (words.length <= tokens.length && words.every((word, i) => tokens[i] === word)) {
+            return run(rawText, tokens);
+        }
+    }
+    return null;
+}