@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/clients/attach/__tests__/crtr-output-render.test.js

@@ -0,0 +1,2340 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { visibleWidth } from '@earendil-works/pi-tui';
+import { createCrtrBashToolDefinition, isCrtrBashCommand, isCrtrHelpInvocation, renderCrtrOutputText, } from '../crtr-output-render.js';
+import { HELP_ICON, iconForPath } from '../../../core/preview-registry.js';
+const theme = {
+    fg(name, text) { return `<${name}>${text}</${name}>`; },
+    bg(_name, text) { return text; },
+    bold(text) { return `<b>${text}</b>`; },
+};
+const plainTheme = {
+    fg(_name, text) { return text; },
+    bg(_name, text) { return text; },
+    bold(text) { return text; },
+};
+function stripAnsi(text) {
+    return text.replace(/\x1b\[[0-9;]*m/g, '');
+}
+test('detects crtr in bash command position, not heredoc body prose', () => {
+    assert.equal(isCrtrBashCommand('crtr node new -h'), true);
+    assert.equal(isCrtrBashCommand('crtr node inspect snapshot --node abc'), true);
+    assert.equal(isCrtrBashCommand('crtr canvas daemon status'), true);
+    assert.equal(isCrtrBashCommand('npm test && /usr/local/bin/crouter surface view run inbox'), true);
+    assert.equal(isCrtrBashCommand("cat <<'EOF'\nask about crtr node new\nEOF\necho done"), false);
+    assert.equal(isCrtrBashCommand('echo crtr node new'), false);
+});
+test('returns a viewer tool definition only for crtr bash commands', () => {
+    assert.equal(createCrtrBashToolDefinition({ command: 'echo hi' }), undefined);
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard' });
+    assert.equal(typeof def.renderCall, 'function');
+    const rendered = def.renderCall({ command: 'crtr canvas dashboard' }, theme).render(80).join('\n');
+    assert.equal(rendered.trimEnd().split('\n').length, 1);
+    assert.match(rendered, new RegExp(iconForPath(['canvas', 'dashboard'])));
+    assert.match(rendered, /crtr/);
+    assert.match(rendered, /canvas dashboard/);
+    assert.doesNotMatch(rendered, /◆/);
+    assert.match(def.renderResult({ content: [{ type: 'text', text: '<command name="canvas">' }], details: undefined }, { expanded: true }, theme, {}).render(80).join('\n'), /<accent><b><command/);
+});
+test('styles crtr structural output and status glyphs', () => {
+    const rendered = renderCrtrOutputText('<command name="node">\nInput\n● active\nCommand exited with code 1', theme);
+    assert.match(rendered, /<accent><b><command/);
+    assert.match(rendered, /<toolTitle><b>Input/);
+    assert.match(rendered, /<success>● active/);
+    assert.match(rendered, /<error>Command exited/);
+});
+// Help output is structural schema text, never a command result, so the
+// viewer detects it from the invocation itself and gives it help-specific
+// collapsed chrome rather than treating it as a normal result preview.
+test('detects a bare -h/--help token in a crtr invocation', () => {
+    assert.equal(isCrtrHelpInvocation('crtr node new -h'), true);
+    assert.equal(isCrtrHelpInvocation('crtr node inspect snapshot --node abc --help'), true);
+    assert.equal(isCrtrHelpInvocation('crtr canvas dashboard'), false);
+    assert.equal(isCrtrHelpInvocation('echo crtr node new -h'), false);
+});
+// Help-token detection is scoped to the extracted crtr segment's own tokens,
+// with quote boundaries respected, so unrelated shell siblings and quoted
+// prompt text do not affect the crtr preview.
+test('does not misclassify -h/--help outside the crtr invocation\'s own argv as help', () => {
+    assert.equal(isCrtrHelpInvocation('echo -h && crtr canvas snapshot'), false);
+    assert.equal(isCrtrHelpInvocation('crtr canvas snapshot && echo --help'), false);
+    assert.equal(isCrtrHelpInvocation('crtr node new "write about -h flags"'), false);
+    // Sanity: the real thing one token over still trips it.
+    assert.equal(isCrtrHelpInvocation('crtr node new -h'), true);
+    assert.equal(isCrtrHelpInvocation('crtr node new --help'), true);
+});
+// Realistic leaf schema (renderLeafArgv shape: `name: summary.` then an
+// Input-headed param block) — a stand-in for e.g. `crtr canvas dashboard -h`.
+const LEAF_SCHEMA = 'canvas dashboard: render the canvas as an ASCII subscription tree.\n\n' +
+    'Input\n' +
+    '  --root ROOT  string, optional. Node id to use as the tree root.\n\n' +
+    'Output (fields carried in the rendered result)\n' +
+    '  tree  string. Multi-line ASCII tree.\n\n' +
+    'Effects\n' +
+    '  Read-only: queries canvas.db.';
+// Realistic branch schema (renderBranch shape: one <command description=...>
+// card with self-closing <subcommand .../> rows) — a stand-in for e.g.
+// `crtr node inspect -h`.
+const BRANCH_SCHEMA = '<command name="node inspect" description="read the canvas graph">\n' +
+    '<subcommand name="list" description="list nodes on the canvas" whenToUse="a very long rubric that is not part of the preview at all"/>\n\n' +
+    '<subcommand name="show" description="show a node + its spine neighbors" whenToUse="another long rubric"/>\n' +
+    '</command>';
+test('collapsed help preview never parrots the call header or dumps the raw schema, and stays within the line cap', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard -h' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: LEAF_SCHEMA }] }, { expanded: false }, theme, {})
+        .render(80)
+        .join('\n');
+    // The call header already carries the help glyph header; the collapsed body is
+    // JUST the synthesized preview content, no repeated status/help label.
+    assert.doesNotMatch(collapsed, new RegExp(`${HELP_ICON} crtr help`));
+    assert.match(collapsed, /ctrl\+o to expand/);
+    assert.doesNotMatch(collapsed, /<success>✓ crtr done/);
+    // No raw schema dump leaking into the body.
+    assert.doesNotMatch(collapsed, /<command/);
+    // A useful synthesized slice IS present: the leaf's own summary line.
+    assert.match(collapsed, /render the canvas as an ASCII subscription/);
+    assert.match(collapsed, /Params: --root/);
+    assert.ok(collapsed.split('\n').length <= 20, `expected <=20 lines, got ${collapsed.split('\n').length}`);
+    // Full schema remains readable on demand.
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: LEAF_SCHEMA }] }, { expanded: true }, theme, {})
+        .render(80)
+        .join('\n');
+    assert.match(expanded, /Node id to use as the tree root/);
+    assert.match(expanded, /Read-only: queries canvas\.db/);
+});
+test('collapsed branch/root help synthesizes a subcommand/description preview, not the raw <subcommand> tags', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node inspect -h' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: BRANCH_SCHEMA }] }, { expanded: false }, theme, {})
+        .render(80)
+        .join('\n');
+    assert.doesNotMatch(collapsed, /<command/);
+    assert.doesNotMatch(collapsed, /<subcommand/);
+    assert.doesNotMatch(collapsed, /whenToUse/);
+    // Useful preview: branch description plus name — description subcommand rows.
+    assert.match(collapsed, /read the canvas graph/);
+    assert.match(collapsed, /list.*—.*list nodes on the canvas/s);
+    assert.match(collapsed, /show.*—.*show a node \+ its spine neighbors/s);
+    assert.ok(collapsed.split('\n').length <= 20, `expected <=20 lines, got ${collapsed.split('\n').length}`);
+});
+// Realistic root schema (renderRoot shape: a tagline, then one
+// `<command name="X">\n<concept>\nuse when ...` block per subtree, NO
+// description attribute on the tag) — a stand-in for `crtr -h`.
+const ROOT_SCHEMA = 'crtr: agentic runtime.\n\n' +
+    '<command name="memory">\n' +
+    'a memory document you read on demand\n' +
+    'use when a task matches stored knowledge or a preference\n' +
+    '</command>\n\n' +
+    '<command name="node">\n' +
+    'a unit of the agent runtime\n' +
+    'use when delegating work\n' +
+    '</command>\n\n' +
+    'Globals\n' +
+    '  -h  print help\n\n' +
+    'I/O contract: ...';
+test('collapsed root help synthesizes a tagline + name/concept preview, not the raw <command> blocks', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr -h' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: ROOT_SCHEMA }] }, { expanded: false }, theme, {})
+        .render(80)
+        .join('\n');
+    assert.doesNotMatch(collapsed, /<command/);
+    assert.match(collapsed, /crtr: agentic runtime/);
+    assert.match(collapsed, /memory.*—.*a memory document you read on demand/s);
+    assert.match(collapsed, /node.*—.*a unit of the agent runtime/s);
+    assert.ok(collapsed.split('\n').length <= 20, `expected <=20 lines, got ${collapsed.split('\n').length}`);
+});
+test('a branch help preview with more subcommands than the line cap truncates with an expand hint, never mid-tag', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node -h' });
+    const manySubs = Array.from({ length: 30 }, (_, i) => `<subcommand name="sub${i}" description="description for subcommand ${i}" whenToUse="long rubric ${i}"/>`).join('\n\n');
+    const bigBranchSchema = `<command name="node" description="spawn and navigate canvas nodes">\n${manySubs}\n</command>`;
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: bigBranchSchema }] }, { expanded: false }, theme, {})
+        .render(80)
+        .join('\n');
+    assert.doesNotMatch(collapsed, /<subcommand/);
+    assert.match(collapsed, /ctrl\+o to expand/);
+    assert.ok(collapsed.split('\n').length <= 20, `expected <=20 lines, got ${collapsed.split('\n').length}`);
+});
+// Contract: outer bash redirects are shell plumbing, not crtr argv, so the
+// displayed crtr path and help detection include only the command segment.
+test('a shell redirect on the outer bash call never leaks into the displayed crtr path or help detection', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr feed -h 2>&1' });
+    const rendered = def.renderCall({ command: 'crtr feed -h 2>&1' }, theme).render(80).join('\n');
+    assert.match(rendered, new RegExp(HELP_ICON));
+    assert.match(rendered, /crtr help/);
+    assert.match(rendered, /<b>feed<\/b>/);
+    assert.doesNotMatch(rendered, /2>/);
+    assert.doesNotMatch(rendered, />&1/);
+    assert.equal(isCrtrHelpInvocation('crtr feed -h 2>&1'), true);
+    // Other redirect shapes on the outer call, and mid-argv redirects, must
+    // never survive into the path either.
+    const other = createCrtrBashToolDefinition({ command: 'crtr node new --name foo > /tmp/log 2>&1' });
+    const otherRendered = other.renderCall({ command: 'crtr node new --name foo > /tmp/log 2>&1' }, theme).render(80).join('\n');
+    assert.match(otherRendered, /node new --name foo/);
+    assert.doesNotMatch(otherRendered, /tmp\/log/);
+    // Redirect operators glued to their target with NO space (`2>/tmp/out`,
+    // `>/tmp/log`) are still shell plumbing and never displayed as path text.
+    const noSpace = createCrtrBashToolDefinition({ command: 'crtr feed -h 2>/tmp/out' });
+    const noSpaceRendered = noSpace.renderCall({ command: 'crtr feed -h 2>/tmp/out' }, theme).render(80).join('\n');
+    assert.match(noSpaceRendered, /<b>feed<\/b>/);
+    assert.doesNotMatch(noSpaceRendered, /2>/);
+    assert.doesNotMatch(noSpaceRendered, /tmp\/out/);
+    const noSpaceMid = createCrtrBashToolDefinition({ command: 'crtr node new --name foo >/tmp/log' });
+    const noSpaceMidRendered = noSpaceMid.renderCall({ command: 'crtr node new --name foo >/tmp/log' }, theme).render(80).join('\n');
+    assert.match(noSpaceMidRendered, /node new --name foo/);
+    assert.doesNotMatch(noSpaceMidRendered, /tmp\/log/);
+});
+// Contract: the call header owns the help glyph label; the collapsed result
+// body contains only synthesized preview content, never a repeated header.
+test('a collapsed help card never shows the help label twice (header + body)', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard -h' });
+    const header = def.renderCall({ command: 'crtr canvas dashboard -h' }, theme).render(80).join('\n');
+    const body = def
+        .renderResult({ content: [{ type: 'text', text: LEAF_SCHEMA }] }, { expanded: false }, theme, {})
+        .render(80)
+        .join('\n');
+    const helpLabel = new RegExp(`${HELP_ICON} crtr help`, 'g');
+    const headerLabelCount = (header.match(helpLabel) ?? []).length;
+    const bodyLabelCount = (body.match(helpLabel) ?? []).length;
+    assert.equal(headerLabelCount, 1);
+    assert.equal(bodyLabelCount, 0);
+});
+// REQUIREMENT: expanded (ctrl+o) is raw truth — the exact invoked command
+// (redirects and all) plus the exact, unsummarized output, for both help and
+// normal commands.
+test('expanded view shows the original raw command (redirects included) plus the raw output', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr feed -h 2>&1' });
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: LEAF_SCHEMA }] }, { expanded: true }, theme, {})
+        .render(80)
+        .join('\n');
+    assert.match(expanded, /\$ crtr feed -h 2>&1/);
+    assert.match(expanded, /render the canvas as an ASCII subscription/);
+    assert.match(expanded, /Read-only: queries canvas\.db/);
+    // Normal (non-help) command: expanded still carries the raw invocation.
+    const normalDef = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard' });
+    const normalExpanded = normalDef
+        .renderResult({ content: [{ type: 'text', text: 'a normal-sized dashboard body' }] }, { expanded: true }, theme, {})
+        .render(80)
+        .join('\n');
+    assert.match(normalExpanded, /\$ crtr canvas dashboard/);
+    assert.match(normalExpanded, /a normal-sized dashboard body/);
+});
+test('a running or failed crtr -h invocation never gets the muted help status', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node new -h' });
+    const running = def
+        .renderResult({ content: [{ type: 'text', text: '' }] }, { expanded: false, isPartial: true }, theme, {})
+        .render(80)
+        .join('\n');
+    assert.match(running, /<warning>⟳ crtr running<\/warning>/);
+});
+// BUG regression (Silas, 2026-07-01): a SUCCESSFUL normal crtr call showed a
+// "✓ crtr done" body status line — pure noise, since the header already names
+// the command and the output is right there. Success (help or normal) carries
+// no body status; only running/failed do.
+test('a successful crtr call shows no "crtr done" body status line', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr feed' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: 'some feed output' }] }, { expanded: false }, theme, {})
+        .render(80)
+        .join('\n');
+    assert.doesNotMatch(collapsed, /crtr done/);
+    assert.match(collapsed, /some feed output/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: 'some feed output' }] }, { expanded: true }, theme, {})
+        .render(80)
+        .join('\n');
+    assert.doesNotMatch(expanded, /crtr done/);
+});
+// Command-owned preview: a leaf declares `help.preview.suppressOutput` next
+// to its own definition (e.g. canvas snapshot, node inspect snapshot —
+// machine-readable dumps, not agent glances). The viewer reads this
+// synchronously from the bundle-safe static registry (preview-registry.ts,
+// kept honest by preview-registry-sync.test.ts) keyed by the real leaf path.
+test('command-owned suppressOutput collapses a successful result, never on failure', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas snapshot' });
+    const component = def.renderResult({ content: [{ type: 'text', text: '{"nodes":[/* huge */]}' }] }, { expanded: false }, theme, {});
+    const collapsed = component.render(80).join('\n');
+    // A successful call shows no body status line at all (✓ crtr done is noise).
+    assert.doesNotMatch(collapsed, /crtr done/);
+    assert.doesNotMatch(collapsed, /huge/);
+    // A failed run is never collapsed, even when the leaf opts into suppressOutput.
+    const failedComponent = def.renderResult({ content: [{ type: 'text', text: 'huge dump on failure too' }] }, { expanded: false }, theme, { isError: true });
+    assert.match(failedComponent.render(80).join('\n'), /huge dump on failure too/);
+});
+test('command-owned suppressOutput matches the leaf name even with positional args after it', () => {
+    // node inspect snapshot takes a required positional id; the lookup must
+    // match the leaf-name prefix and ignore the argument that follows it.
+    const def = createCrtrBashToolDefinition({ command: 'crtr node inspect snapshot abc' });
+    const component = def.renderResult({ content: [{ type: 'text', text: '{"snapshot":{/* huge */}}' }] }, { expanded: false }, theme, {});
+    const collapsed = component.render(80).join('\n');
+    assert.doesNotMatch(collapsed, /crtr done/);
+    assert.doesNotMatch(collapsed, /huge/);
+});
+// Command-owned preview (Silas, 2026-07-01, option C): a `crtr memory read`
+// collapsed card is a tidy frontmatter glance — `name · kind · scope` identity
+// line (path dropped as noise, follow_up hint dropped) + a short content
+// teaser — not the full doc body, which ctrl+o reveals.
+const MEMORY_READ_OUTPUT = [
+    '- name: no-flag-and-defer',
+    '- kind: preference',
+    '- scope: user',
+    '- path: /Users/silasrhyneer/.crouter/memory/no-flag-and-defer.md',
+    '',
+    '**content:** Fix issues in the same pass you find them — never "flagged for later".',
+    '',
+    '',
+    '**follow_up:** Read the raw file at `path` to view the YAML frontmatter.',
+].join('\n');
+test('a crtr memory read card previews a tidy frontmatter glance, not the raw block or body dump', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr memory read no-flag-and-defer' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_READ_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    // Curated frontmatter identity line: name · kind · scope, path/follow_up gone.
+    assert.match(collapsed, /no-flag-and-defer · preference · user/);
+    assert.doesNotMatch(collapsed, /\/Users\//);
+    assert.doesNotMatch(collapsed, /follow_up/);
+    assert.doesNotMatch(collapsed, /Read the raw file/);
+    // A slice of the content is teased, and the raw `**content:**` marker is gone.
+    assert.match(collapsed, /Fix issues in the same pass/);
+    assert.doesNotMatch(collapsed, /\*\*content:\*\*/);
+    // No spurious success status line.
+    assert.doesNotMatch(collapsed, /crtr done/);
+    assert.match(collapsed, /ctrl\+o to expand/);
+    // A long doc body is teased, then clipped with an ellipsis — never dumped whole.
+    const longOutput = [
+        '- name: pi-frontmatter-rules',
+        '- kind: knowledge',
+        '- scope: user',
+        '- path: /x/pi-frontmatter-rules.md',
+        '',
+        '**content:** # Title',
+        'line one',
+        'line two',
+        'line three',
+        'line four',
+        'line five',
+    ].join('\n');
+    const longCollapsed = def
+        .renderResult({ content: [{ type: 'text', text: longOutput }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(longCollapsed, /pi-frontmatter-rules · knowledge · user/);
+    assert.match(longCollapsed, /…/);
+    assert.doesNotMatch(longCollapsed, /line five/);
+});
+// REQUIREMENT: the memory read summarizer must return null (not a blank
+// summary) when its expected metadata/content markers are absent — an error
+// result (missing/ambiguous doc name, etc.) has none of the `- name:`/
+// `**content:**` shape, so it must fall back to the raw output.
+test('a crtr memory read error output falls back to raw, never a blank summary card', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr memory read nonexistent-doc' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: 'crtr: memory read: no document found matching "nonexistent-doc"' }] }, { expanded: false }, theme, { isError: true })
+        .render(120)
+        .join('\n');
+    assert.match(collapsed, /no document found matching/);
+});
+test('an expanded crtr memory read shows the full raw output, not the frontmatter glance', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr memory read no-flag-and-defer' });
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_READ_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    // Raw truth: the path, the content marker, and the follow_up hint are all present.
+    assert.match(expanded, /\$ crtr memory read no-flag-and-defer/);
+    assert.match(expanded, /\.crouter\/memory\/no-flag-and-defer\.md/);
+    assert.match(expanded, /\*\*follow_up:\*\*/);
+});
+const MEMORY_LINT_CLEAN_OUTPUT = [
+    '- checked: 261',
+    '- corpora: {"memory_stores":261}',
+    '',
+    'Corpus green — zero invalid frontmatter docs.',
+    '',
+    '0 findings.',
+].join('\n');
+const MEMORY_LINT_FINDINGS_OUTPUT = [
+    'crtr: memory lint: /tmp/lint-test/.crouter/memory/bad-doc.md: invalid kind: "bogus" (expected knowledge|preference)',
+    'crtr: memory lint: /tmp/lint-test/.crouter/memory/bad-doc2.md: missing `when-and-why-to-read`: one read-routing line',
+    '<error code="error">',
+    'memory lint: 2 finding(s) across 229 files',
+    'Next: Fix each doc (quote YAML values containing `: `; use a valid kind/rung/gate), then re-run `crtr memory lint`.',
+    '</error>',
+].join('\n');
+test('a clean crtr memory lint collapses to PASS and docs checked, with semantic tones', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr memory lint' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_LINT_CLEAN_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(collapsed, /<success>PASS<\/success>/);
+    assert.match(collapsed, /<muted>261 docs checked<\/muted>/);
+    assert.doesNotMatch(collapsed, /- checked:/);
+    assert.doesNotMatch(collapsed, /- corpora:/);
+    assert.doesNotMatch(collapsed, /0 findings\./);
+    assert.match(collapsed, /ctrl\+o to expand/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_LINT_CLEAN_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(expanded, /checked: 261/);
+    assert.match(expanded, /corpora: \{"memory_stores":261\}/);
+    assert.match(expanded, /0 findings\./);
+});
+// REQUIREMENT: a real failed `crtr memory lint` (delivered to the renderer as
+// `{ isError: true }` — see chat-view.ts) must still collapse to the
+// command-owned findings summary, not fall through to the raw failed output;
+// only a command with no summarizer (or a shape neither summarizer branch
+// recognizes) stays raw on failure.
+test('a crtr memory lint with findings collapses to a findings count and warnings even on the real failed-command path', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr memory lint' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_LINT_FINDINGS_OUTPUT }] }, { expanded: false }, theme, { isError: true })
+        .render(120)
+        .join('\n');
+    assert.match(collapsed, /<error>2 findings<\/error>/);
+    assert.match(collapsed, /<warning>[^<]*invalid kind: "bogus"[^<]*<\/warning>/);
+    assert.match(collapsed, /<warning>[^<]*missing `when-and-why-to-read`[^<]*<\/warning>/);
+    assert.match(collapsed, /<muted>229 docs checked<\/muted>/);
+    assert.doesNotMatch(collapsed, /PASS/);
+    // No raw error block/XML leaks into the collapsed summary.
+    assert.doesNotMatch(collapsed, /code="error"/);
+    assert.doesNotMatch(collapsed, /Next: Fix each doc/);
+});
+// Help must look like help at the call header itself, not only once the
+// (possibly collapsed) result renders.
+test('renderCall shows a help-specific header for a -h/--help invocation, no bash chrome', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node config -h' });
+    const rendered = def.renderCall({ command: 'crtr node config -h' }, theme).render(80).join('\n');
+    assert.equal(rendered.trimEnd().split('\n').length, 1);
+    assert.match(rendered, new RegExp(HELP_ICON));
+    assert.match(rendered, /crtr help/);
+    assert.doesNotMatch(rendered, /via bash/);
+    assert.doesNotMatch(rendered, /\$ crtr/);
+    assert.doesNotMatch(rendered, /-h/);
+    assert.match(rendered, /node config/);
+});
+// Table-driven header coverage across every mapped root family (rule 12: real
+// Nerd Font glyphs, never the generic ◆) — includes `memory lint` (the
+// motivating case for the memory-lint summarizer above), not just `canvas`/
+// `node`.
+test('renderCall uses a mapped Nerd Font glyph and one line for every mapped root family, never the generic ◆', () => {
+    const cases = [
+        { command: 'crtr memory lint', iconTokens: ['memory', 'lint'], path: 'memory lint' },
+        { command: 'crtr canvas dashboard', iconTokens: ['canvas', 'dashboard'], path: 'canvas dashboard' },
+        { command: 'crtr feed read', iconTokens: ['feed', 'read'], path: 'feed read' },
+        { command: 'crtr human ask', iconTokens: ['human', 'ask'], path: 'human ask' },
+        { command: 'crtr node config set foo bar', iconTokens: ['node', 'config'], path: 'node config set foo bar' },
+        { command: 'crtr pkg plugin list', iconTokens: ['pkg', 'plugin', 'list'], path: 'pkg plugin list' },
+        { command: 'crtr push update', iconTokens: ['push', 'update'], path: 'push update' },
+        { command: 'crtr search web', iconTokens: ['search', 'web'], path: 'search web' },
+        { command: 'crtr surface view list', iconTokens: ['surface', 'view', 'list'], path: 'surface view list' },
+        { command: 'crtr sys doctor', iconTokens: ['sys', 'doctor'], path: 'sys doctor' },
+    ];
+    for (const { command, iconTokens, path } of cases) {
+        const def = createCrtrBashToolDefinition({ command });
+        // Width 200 (not 80): this test's fake theme wraps each styled span in
+        // literal `<tag>...</tag>` text (not real ANSI escapes the wrapper would
+        // strip for width purposes), so the visible-width accounting used by the
+        // real Text component's word-wrap counts that markup as content width —
+        // a generous width keeps every case here well clear of an unrelated wrap.
+        const rendered = def.renderCall({ command }, theme).render(200).join('\n');
+        assert.equal(rendered.trimEnd().split('\n').length, 1, `expected one line for ${command}`);
+        assert.match(rendered, new RegExp(iconForPath(iconTokens)), `expected the ${iconTokens.join(' ')} glyph in ${command}`);
+        assert.match(rendered, /crtr/, `expected "crtr" in ${command}`);
+        assert.match(rendered, new RegExp(path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')), `expected path "${path}" on the same line`);
+        assert.doesNotMatch(rendered, /◆/, `unexpected generic diamond for ${command}`);
+    }
+});
+test('renderCall for a normal invocation previews the crtr path, not a raw bash echo', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node config set foo bar' });
+    const rendered = def.renderCall({ command: 'crtr node config set foo bar' }, theme).render(200).join('\n');
+    assert.equal(rendered.trimEnd().split('\n').length, 1);
+    assert.match(rendered, new RegExp(iconForPath(['node', 'config'])));
+    assert.match(rendered, /crtr/);
+    assert.match(rendered, /node config set foo bar/);
+    assert.doesNotMatch(rendered, /◆/);
+    assert.doesNotMatch(rendered, /via bash/);
+    assert.doesNotMatch(rendered, /\$ crtr/);
+});
+test('a leaf that does not declare suppressOutput is never collapsed', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard' });
+    const component = def.renderResult({ content: [{ type: 'text', text: 'a normal-sized dashboard body' }] }, { expanded: false }, theme, {});
+    assert.match(component.render(80).join('\n'), /a normal-sized dashboard body/);
+});
+test('expanded crtr output clamps long single lines to the terminal width', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard' });
+    const longLine = 'x'.repeat(442);
+    const lines = def
+        .renderResult({ content: [{ type: 'text', text: longLine }] }, { expanded: true }, theme, {})
+        .render(70);
+    assert.ok(lines.length > 0);
+    for (const line of lines) {
+        assert.ok(visibleWidth(line) <= 70, `line exceeded width: ${visibleWidth(line)} > 70`);
+    }
+});
+test('collapsed crtr output clamps all rendered chrome to the terminal width', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard' });
+    const longLine = 'y'.repeat(442);
+    const lines = def
+        .renderResult({ content: [{ type: 'text', text: longLine }] }, { expanded: false }, theme, {})
+        .render(70);
+    assert.ok(lines.length > 0);
+    for (const line of lines) {
+        assert.ok(visibleWidth(line) <= 70, `line exceeded width: ${visibleWidth(line)} > 70`);
+    }
+});
+const WIDE_GENERIC_TABLE_OUTPUT = [
+    '24 plugins:',
+    '',
+    '| name | version | description | status |',
+    '| --- | --- | --- | --- |',
+    ...Array.from({ length: 24 }, (_, i) => `| plugin-${String(i).padStart(2, '0')} | 1.0.${i} | This is a deliberately over-wide description cell that used to wrap the collapsed card mid-cell for row ${i} | ${i % 2 === 0 ? 'enabled' : 'disabled'} |`),
+].join('\n');
+test('generic collapsed fallback renders wide GFM tables aligned, clipped, and row-capped instead of raw pipe rows', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr surface view run catalog' });
+    const rendered = def
+        .renderResult({ content: [{ type: 'text', text: WIDE_GENERIC_TABLE_OUTPUT }] }, { expanded: false }, plainTheme, {})
+        .render(58)
+        .join('\n');
+    assert.doesNotMatch(rendered, /\|/);
+    assert.match(rendered, /plugin-00\s+1\.0\.0\s+.*…/);
+    assert.match(rendered, /more lines/);
+    assert.doesNotMatch(rendered, /plugin-23/);
+    assert.ok(rendered.split('\n').length <= 20, `expected <=20 lines, got ${rendered.split('\n').length}`);
+    const row0 = rendered.split('\n').find((line) => line.includes('plugin-00')) ?? '';
+    const row1 = rendered.split('\n').find((line) => line.includes('plugin-01')) ?? '';
+    assert.notEqual(row0, '');
+    assert.notEqual(row1, '');
+    assert.equal(row0.indexOf('1.0.0'), row1.indexOf('1.0.1'));
+    for (const line of rendered.split('\n')) {
+        assert.ok(visibleWidth(line) <= 58, `line exceeded width: ${visibleWidth(line)} > 58: ${line}`);
+    }
+});
+const HEADERLESS_TABLE_TAIL_OUTPUT = [
+    '| mr2iy5tw-a1f5e1f0 | batch-a-implementation | /Users/silasrhyneer/Code/cli/crouter | active |',
+    '| mr147q9d-c7681b04 | initial-session-setup | /Users/silasrhyneer/Code/cli/crouter | idle |',
+    '| mr2ejzaw-6f70e858 | preview-roadmap | /Users/silasrhyneer/Code/cli/crouter | done |',
+].join('\n');
+test('generic collapsed fallback aligns a header-less truncated table tail by column count', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr surface view run catalog' });
+    const rendered = def
+        .renderResult({ content: [{ type: 'text', text: HEADERLESS_TABLE_TAIL_OUTPUT }] }, { expanded: false }, plainTheme, {})
+        .render(64)
+        .join('\n');
+    assert.doesNotMatch(rendered, /\|/);
+    assert.match(rendered, /batch-a-implemen/);
+    const rows = rendered.split('\n').filter((line) => line.includes('mr')).map(stripAnsi);
+    assert.equal(rows.length, 3);
+    assert.equal(rows[0].indexOf('/Users'), rows[1].indexOf('/Users'));
+    assert.equal(rows[1].indexOf('/Users'), rows[2].indexOf('/Users'));
+});
+test('generic collapsed fallback renders the pi truncation marker as one muted line', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr surface view run catalog' });
+    const marker = '[Showing lines 951-1000 of 1000 (50.0KB limit). Full output: /tmp/pi-bash-output.log]';
+    const rendered = def
+        .renderResult({ content: [{ type: 'text', text: `last retained line\n${marker}` }] }, { expanded: false }, theme, {})
+        .render(240)
+        .join('\n');
+    assert.match(rendered, /<muted>\[Showing lines 951-1000 of 1000 \(50\.0KB limit\)\. Full output: \/tmp\/pi-bash-output\.log\]<\/muted>/);
+    assert.equal((rendered.match(/Showing lines/g) ?? []).length, 1);
+});
+const NO_EDGE_PIPE_TABLE_OUTPUT = [
+    'name | version | status',
+    '--- | --- | ---',
+    'alpha | 1.0.0 | enabled',
+    'beta | 2.1.0 | disabled',
+].join('\n');
+test('generic collapsed fallback aligns a GFM table whose rows omit both outer pipes', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr surface view run catalog' });
+    const rendered = def
+        .renderResult({ content: [{ type: 'text', text: NO_EDGE_PIPE_TABLE_OUTPUT }] }, { expanded: false }, plainTheme, {})
+        .render(60)
+        .join('\n');
+    assert.doesNotMatch(rendered, /\|/);
+    assert.doesNotMatch(rendered, /---/);
+    const rows = rendered.split('\n').filter((line) => line.trim() !== '');
+    const alphaRow = rows.find((line) => line.includes('alpha')) ?? '';
+    const betaRow = rows.find((line) => line.includes('beta')) ?? '';
+    assert.notEqual(alphaRow, '');
+    assert.notEqual(betaRow, '');
+    assert.equal(alphaRow.indexOf('1.0.0'), betaRow.indexOf('2.1.0'));
+});
+test('a stray line containing a single literal pipe is not mistaken for a table row', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr surface view run catalog' });
+    const rendered = def
+        .renderResult({ content: [{ type: 'text', text: 'warning: use x | y instead' }] }, { expanded: false }, plainTheme, {})
+        .render(60)
+        .join('\n');
+    assert.match(rendered, /warning: use x \| y instead/);
+});
+test('icon lookup uses per-leaf glyphs before family glyphs, with help unchanged', () => {
+    assert.equal(iconForPath(['canvas', 'dashboard']), String.fromCodePoint(0xf0e4));
+    assert.notEqual(iconForPath(['canvas', 'dashboard']), iconForPath(['canvas']));
+    assert.equal(iconForPath(['node', 'inspect', 'list']), String.fromCodePoint(0xf03a));
+    assert.notEqual(iconForPath(['node', 'inspect', 'list']), iconForPath(['node']));
+    assert.equal(iconForPath(['sys', 'doctor']), String.fromCodePoint(0xf0f1));
+    assert.equal(HELP_ICON, String.fromCodePoint(0xf059));
+});
+// ---------------------------------------------------------------------------
+// canvas/node/feed runtime cockpit summaries (first non-memory batch, Silas's
+// 2026-07-01 reframe: collapsed cards are computed status digests, not
+// decorated stdout). Fixtures below are literal renderResult() output shapes
+// (core/render.ts: a `- field: N` scalar bullet, an `N <label>:` count
+// lead-in + GFM table for an array of objects) — not the live command tree,
+// so these stay independent of what actually runs on a real canvas.
+// ---------------------------------------------------------------------------
+const DASHBOARD_OUTPUT = [
+    '- nodes: 4',
+    '',
+    '● root-node [developer/orchestrator] ctx 5k',
+    '├─ ✓ child-a ...',
+    '└─ ○ child-b ...',
+    '',
+    '4 rows:',
+    '',
+    '| node_id | name | status | kind | mode | ctx_tokens | asks | cwd | created |',
+    '| --- | --- | --- | --- | --- | --- | --- | --- | --- |',
+    '| n1 | root-node | active | developer | orchestrator | 5000 | 0 | /Users/x/proj | 2026-01-01T00:00:00.000Z |',
+    '| n2 | child-a | active | developer | base | 12000 | 3 | /Users/x/proj | 2026-01-01T00:00:00.000Z |',
+    '| n3 | child-b | done | advisor | base | 8000 | 0 | /Users/x/proj | 2026-01-01T00:00:00.000Z |',
+    '| n4 | child-c | idle | reviewer | base | 3000 | 0 | /Users/x/proj | 2026-01-01T00:00:00.000Z |',
+].join('\n');
+test('a crtr canvas dashboard card collapses to a status-count digest, not the raw tree/table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: DASHBOARD_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(collapsed, /2 active/);
+    assert.match(collapsed, /1 idle/);
+    assert.match(collapsed, /1 done/);
+    assert.match(collapsed, /<muted>largest ctx: 12k tokens<\/muted>/);
+    assert.match(collapsed, /<warning>3 pending asks<\/warning>/);
+    assert.doesNotMatch(collapsed, /\| ---/);
+    assert.doesNotMatch(collapsed, /node_id/);
+    assert.doesNotMatch(collapsed, /crtr done/);
+    assert.match(collapsed, /ctrl\+o to expand/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: DASHBOARD_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(expanded, /\$ crtr canvas dashboard/);
+    assert.match(expanded, /\| node_id \| name \|/);
+    assert.match(expanded, /root-node \[developer\/orchestrator\]/);
+});
+const NODE_LIST_OUTPUT = [
+    '4 nodes:',
+    '',
+    '| node_id | name | status | kind | mode | lifecycle | cwd | created | hanging |',
+    '| --- | --- | --- | --- | --- | --- | --- | --- | --- |',
+    '| n1 | alpha | active | developer | orchestrator | terminal | /a | 2026-01-01T00:00:00.000Z | none |',
+    '| n2 | beta | active | developer | base | terminal | /a | 2026-01-01T00:00:00.000Z | none |',
+    '| n3 | gamma | done | advisor | base | terminal | /a | 2026-01-01T00:00:00.000Z | none |',
+    '| n4 | delta | idle | reviewer | base | resident | /a | 2026-01-01T00:00:00.000Z | none |',
+].join('\n');
+test('a crtr node inspect list card collapses to status + kind digests, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node inspect list' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: NODE_LIST_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(collapsed, /2 active/);
+    assert.match(collapsed, /1 idle/);
+    assert.match(collapsed, /1 done/);
+    assert.match(collapsed, /<muted>kinds: developer×2, advisor×1, reviewer×1<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| ---/);
+    assert.doesNotMatch(collapsed, /node_id/);
+    assert.doesNotMatch(collapsed, /crtr done/);
+    assert.match(collapsed, /ctrl\+o to expand/);
+});
+test('a crtr canvas attention count card renders a computed health tone, error when pending, success when clear', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas attention count' });
+    const pending = def
+        .renderResult({ content: [{ type: 'text', text: '- count: 14' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(pending, /<error>14 pending asks<\/error>/);
+    assert.match(pending, /ctrl\+o to expand/);
+    const clear = def
+        .renderResult({ content: [{ type: 'text', text: '- count: 0' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(clear, /<success>PASS · no pending asks<\/success>/);
+    assert.doesNotMatch(clear, /0 pending asks/);
+});
+const ATTENTION_LIST_OUTPUT = [
+    '- total: 14',
+    '',
+    '5 items:',
+    '',
+    '| node_id | name | cwd | count |',
+    '| --- | --- | --- | --- |',
+    '| mq3geac4-9b947921 | general | /Users/silasrhyneer/Code/alaria-map-site | 7 |',
+    '| mqa7c632-24f0e384 | general | /Users/silasrhyneer/Code/cli/crouter | 3 |',
+    '| mqa9w9qy-e1cafda1 | general | /Users/silasrhyneer/Code/godot/StarTheory2 | 2 |',
+    '| mqt6lz47-09daf181 | developer | /Users/silasrhyneer/Code/godot/StarTheory2-worktrees/escape-pod-selection | 1 |',
+    '| mr0v8vxi-580c7572 | general | /Users/silasrhyneer/Code/northlight | 1 |',
+].join('\n');
+test('a crtr canvas attention list card collapses to total/hottest/digest, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas attention list' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: ATTENTION_LIST_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(collapsed, /14 total · 5 cwds/);
+    assert.match(collapsed, /<warning>hottest: alaria-map-site \(7\)<\/warning>/);
+    assert.match(collapsed, /<muted>other cwds: [^<]*crouter[^<]*<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| ---/);
+    assert.doesNotMatch(collapsed, /node_id/);
+    assert.match(collapsed, /ctrl\+o to expand/);
+    const empty = def
+        .renderResult({ content: [{ type: 'text', text: ['- total: 0', '', '0 items.'].join('\n') }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(empty, /<success>PASS · no pending asks<\/success>/);
+});
+// Command-owned preview: `node inspect show` inlines a full node meta object
+// (system prompt + every telemetry field) with no useful human-glance slice —
+// same rationale as canvas snapshot / node inspect snapshot, mirrored in the
+// bundle-safe SUPPRESS_OUTPUT_LEAVES registry.
+test('node inspect show is command-owned suppressOutput, never on failure', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node inspect show abc' });
+    const collapsed = def.renderResult({ content: [{ type: 'text', text: '{"node":{/* huge */}}' }] }, { expanded: false }, theme, {});
+    const rendered = collapsed.render(80).join('\n');
+    assert.doesNotMatch(rendered, /crtr done/);
+    assert.doesNotMatch(rendered, /huge/);
+    assert.match(rendered, /suppressed — ctrl\+o to expand/);
+    const failed = def.renderResult({ content: [{ type: 'text', text: 'huge dump on failure too' }] }, { expanded: false }, theme, { isError: true });
+    assert.match(failed.render(80).join('\n'), /huge dump on failure too/);
+});
+// ---------------------------------------------------------------------------
+// Batch B: canvas/node/feed/push runtime cockpit summaries (Silas's
+// 2026-07-01 reframe continued). Fixtures below are literal render() output
+// shapes copied from the real command source (see preview-registry.ts's
+// per-summarizer doc comments for the exact file:line), not the live command
+// tree — these stay independent of what actually runs on a real canvas.
+// ---------------------------------------------------------------------------
+test('a crtr canvas attention map card collapses to a hottest-id digest, PASS when all zero', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas attention map --view mq1' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: '- counts: {"n1":0,"n2":3,"n3":5}' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(collapsed, /8 asks across 2 nodes/);
+    assert.match(collapsed, /<warning>hottest: n3 \(5\)<\/warning>/);
+    const zero = def
+        .renderResult({ content: [{ type: 'text', text: '- counts: {"n1":0,"n2":0}' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(zero, /<success>PASS · no pending asks<\/success>/);
+    const zeroExpanded = def
+        .renderResult({ content: [{ type: 'text', text: '- counts: {"n1":0,"n2":0}' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(zeroExpanded, /counts: \{"n1":0,"n2":0\}/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: '- counts: {"n1":0,"n2":3,"n3":5}' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(expanded, /counts: \{"n1":0,"n2":3,"n3":5\}/);
+});
+test('a crtr canvas revive card collapses to a kicked/revived status line, argv-recovered id', () => {
+    const kickedDef = createCrtrBashToolDefinition({ command: 'crtr canvas revive mq2jpqz5-87fa626e --now' });
+    const kicked = kickedDef
+        .renderResult({ content: [{ type: 'text', text: ['- session: mysession', '- kicked: true', '', 'Sent SIGTERM to worker-a (mq2jpqz5-87fa626e, pid 456).'].join('\n') }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(kicked, /<warning>kicked — daemon resumes in ~20s<\/warning>/);
+    const kickedExpanded = kickedDef
+        .renderResult({ content: [{ type: 'text', text: ['- session: mysession', '- kicked: true', '', 'Sent SIGTERM to worker-a (mq2jpqz5-87fa626e, pid 456).'].join('\n') }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(kickedExpanded, /Sent SIGTERM to worker-a \(mq2jpqz5-87fa626e, pid 456\)\./);
+    const revivedDef = createCrtrBashToolDefinition({ command: 'crtr canvas revive mq2jpqz5-87fa626e' });
+    const revived = revivedDef
+        .renderResult({ content: [{ type: 'text', text: ['- session: mysession', '- resumed: true', '- ready: true'].join('\n') }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(revived, /<success>revived mq2jpqz5-87fa626e<\/success>/);
+    assert.doesNotMatch(revived, /not yet attachable/);
+    const revivedExpanded = revivedDef
+        .renderResult({ content: [{ type: 'text', text: ['- session: mysession', '- resumed: true', '- ready: true'].join('\n') }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(revivedExpanded, /session: mysession/);
+    const notReady = revivedDef
+        .renderResult({ content: [{ type: 'text', text: ['- resumed: false', '- ready: false'].join('\n') }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(notReady, /<warning>not yet attachable \(socket not ready\)<\/warning>/);
+    const notReadyExpanded = revivedDef
+        .renderResult({ content: [{ type: 'text', text: ['- resumed: false', '- ready: false'].join('\n') }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(notReadyExpanded, /resumed: false/);
+    assert.match(notReadyExpanded, /ready: false/);
+    // `--all` carries a `- mode:` bullet and is deliberately skipped (null) —
+    // falls through to generic truncation, raw `mode` text survives.
+    const allPreview = revivedDef
+        .renderResult({ content: [{ type: 'text', text: '- mode: preview\n- candidates: mq1' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(allPreview, /mode: preview/);
+    const allPreviewExpanded = revivedDef
+        .renderResult({ content: [{ type: 'text', text: '- mode: preview\n- candidates: mq1' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(allPreviewExpanded, /candidates: mq1/);
+});
+const HISTORY_SEARCH_HITS_OUTPUT = [
+    '3 of 10 hits:',
+    '',
+    '| ref | node | kind | source | ts | snippet |',
+    '| --- | --- | --- | --- | --- | --- |',
+    '| n1:reports/a.md | alpha (n1) | developer | report:final | 2026-01-01T00:00:00.000Z | did a thing |',
+    '| n2:reports/b.md | beta (n2) | developer | doc | 2026-01-02T00:00:00.000Z | did another |',
+    '| n3:reports/c.md | gamma (n3) | advisor | report:update | 2026-01-03T00:00:00.000Z | did a third |',
+    '',
+    '- next_cursor: abc123',
+    '- total: 10',
+    '',
+    'Read a hit with `canvas history read <ref>`; narrow with `canvas history search -h`.',
+].join('\n');
+test('a crtr canvas history search card collapses to a hit count + top rows, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas history search foo' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: HISTORY_SEARCH_HITS_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /10 hits/);
+    assert.match(collapsed, /<muted>alpha \(n1\) · developer · 2026-01-01T00:00:00\.000Z<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| ref \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: HISTORY_SEARCH_HITS_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| ref \| node \| kind \| source \| ts \| snippet \|/);
+    assert.match(expanded, /did a thing/);
+    const zero = def
+        .renderResult({ content: [{ type: 'text', text: ['0 hits.', '', '- next_cursor: null\n- total: 0', 'Read a hit…'].join('\n\n') }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(zero, /<muted>0 hits<\/muted>/);
+    const zeroExpanded = def
+        .renderResult({ content: [{ type: 'text', text: ['0 hits.', '', '- next_cursor: null\n- total: 0', 'Read a hit…'].join('\n\n') }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(zeroExpanded, /total: 0/);
+    // --full mode shares the same `N of M hits:` lead-in but has no table —
+    // deliberately skipped (null), raw survives.
+    const full = def
+        .renderResult({ content: [{ type: 'text', text: '1 of 1 hits:\n\n### n1:reports/a.md\n- node: alpha (n1)  |  kind: developer  |  source: doc  |  ts: 2026-01-01\n\nfull body here' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(full, /full body here/);
+    const fullExpanded = def
+        .renderResult({ content: [{ type: 'text', text: '1 of 1 hits:\n\n### n1:reports/a.md\n- node: alpha (n1)  |  kind: developer  |  source: doc  |  ts: 2026-01-01\n\nfull body here' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(fullExpanded, /full body here/);
+    // Lead-in says 3 displayed hits, but the table only has 2 rows — a
+    // truncated/mismatched render is a shape mismatch, not a partial summary:
+    // skipped (null), raw survives even collapsed.
+    const truncated = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: [
+                    '3 of 10 hits:',
+                    '',
+                    '| ref | node | kind | source | ts | snippet |',
+                    '| --- | --- | --- | --- | --- | --- |',
+                    '| n1:reports/a.md | alpha (n1) | developer | report:final | 2026-01-01T00:00:00.000Z | did a thing |',
+                    '| n2:reports/b.md | beta (n2) | developer | doc | 2026-01-02T00:00:00.000Z | did another |',
+                    '',
+                    '- next_cursor: abc123',
+                    '- total: 10',
+                ].join('\n'),
+            },
+        ],
+    }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(truncated, /3 of 10 hits:/);
+    assert.doesNotMatch(truncated, /<muted>alpha \(n1\) · developer/);
+});
+const HISTORY_READ_OUTPUT = [
+    'alpha (n1)  |  source: report:final  |  ts: 2026-01-01T00:00:00.000Z  |  ref: n1:reports/a.md',
+    '',
+    'Line one of body.',
+    'Line two of body.',
+    'Line three of body.',
+    'Line four of body.',
+].join('\n');
+test('a crtr canvas history read card previews an identity line + content teaser', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas history read n1:reports/a.md' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: HISTORY_READ_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(collapsed, /alpha \(n1\) · report:final · 2026-01-01T00:00:00\.000Z/);
+    assert.match(collapsed, /Line one of body\./);
+    assert.match(collapsed, /…/);
+    assert.doesNotMatch(collapsed, /Line four of body\./);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: HISTORY_READ_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(expanded, /Line four of body\./);
+});
+const HISTORY_SHOW_OUTPUT = [
+    'node: alpha (n1)',
+    '',
+    '4 artifacts:',
+    '',
+    '| ref | source | ts | detail |',
+    '| --- | --- | --- | --- |',
+    '| n1:reports/a.md | report:final | 2026-01-01T00:00:00.000Z | Final report  (120B) |',
+    '| n1:reports/b.md | report:update | 2026-01-02T00:00:00.000Z | Update  (80B) |',
+    '| n1:docs/design.md | doc | 2026-01-03T00:00:00.000Z | Design doc |',
+    '| n1:roadmap.md | roadmap | 2026-01-04T00:00:00.000Z | Roadmap |',
+    '',
+    'Read one with `canvas history read <ref>`; reopen the node with `canvas revive n1`.',
+].join('\n');
+test('a crtr canvas history show card collapses to a node line + type-count digest, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas history show n1' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: HISTORY_SHOW_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(collapsed, /4 artifacts/);
+    assert.match(collapsed, /<muted>reports×2, docs×1, roadmaps×1<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| ref \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: HISTORY_SHOW_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(expanded, /\| ref \| source \| ts \| detail \|/);
+    assert.match(expanded, /Final report {2}\(120B\)/);
+    const empty = def
+        .renderResult({ content: [{ type: 'text', text: ['node: alpha (n1)', '', '0 artifacts.', '', 'Read one…'].join('\n\n') }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(empty, /<muted>alpha \(n1\) · 0 artifacts<\/muted>/);
+    // Lead-in says 4 artifacts, but the table only has 3 rows — a
+    // truncated/mismatched render is a shape mismatch, not a partial summary:
+    // skipped (null), raw survives even collapsed.
+    const truncated = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: [
+                    'node: alpha (n1)',
+                    '',
+                    '4 artifacts:',
+                    '',
+                    '| ref | source | ts | detail |',
+                    '| --- | --- | --- | --- |',
+                    '| n1:reports/a.md | report:final | 2026-01-01T00:00:00.000Z | Final report  (120B) |',
+                    '| n1:reports/b.md | report:update | 2026-01-02T00:00:00.000Z | Update  (80B) |',
+                    '| n1:docs/design.md | doc | 2026-01-03T00:00:00.000Z | Design doc |',
+                ].join('\n'),
+            },
+        ],
+    }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(truncated, /4 artifacts:/);
+    assert.doesNotMatch(truncated, /<muted>reports×/);
+    const emptyExpanded = def
+        .renderResult({ content: [{ type: 'text', text: ['node: alpha (n1)', '', '0 artifacts.', '', 'Read one…'].join('\n\n') }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(emptyExpanded, /0 artifacts\./);
+});
+test('crtr canvas daemon start/status/stop cards collapse to a one-line pid status', () => {
+    const start = createCrtrBashToolDefinition({ command: 'crtr canvas daemon start' });
+    assert.match(start.renderResult({ content: [{ type: 'text', text: '- started: true\n- pid: 4242' }] }, { expanded: false }, theme, {}).render(120).join('\n'), /<success>started · pid 4242<\/success>/);
+    assert.match(start.renderResult({ content: [{ type: 'text', text: '- started: false\n- existing_pid: 99' }] }, { expanded: false }, theme, {}).render(120).join('\n'), /<muted>already running · pid 99<\/muted>/);
+    assert.match(start.renderResult({ content: [{ type: 'text', text: '- started: false\n- existing_pid: 99' }] }, { expanded: true }, theme, {}).render(120).join('\n'), /existing_pid: 99/);
+    const startExpanded = start
+        .renderResult({ content: [{ type: 'text', text: '- started: true\n- pid: 4242' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(startExpanded, /started: true/);
+    assert.match(startExpanded, /pid: 4242/);
+    const status = createCrtrBashToolDefinition({ command: 'crtr canvas daemon status' });
+    assert.match(status.renderResult({ content: [{ type: 'text', text: '- running: true\n- pid: 4242' }] }, { expanded: false }, theme, {}).render(120).join('\n'), /<success>running · pid 4242<\/success>/);
+    assert.match(status.renderResult({ content: [{ type: 'text', text: '- running: false' }] }, { expanded: false }, theme, {}).render(120).join('\n'), /<error>not running<\/error>/);
+    assert.match(status.renderResult({ content: [{ type: 'text', text: '- running: false' }] }, { expanded: true }, theme, {}).render(120).join('\n'), /running: false/);
+    const statusExpanded = status
+        .renderResult({ content: [{ type: 'text', text: '- running: true\n- pid: 4242' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(statusExpanded, /running: true/);
+    assert.match(statusExpanded, /pid: 4242/);
+    const stop = createCrtrBashToolDefinition({ command: 'crtr canvas daemon stop' });
+    assert.match(stop.renderResult({ content: [{ type: 'text', text: '- stopped: true\n- pid: 4242' }] }, { expanded: false }, theme, {}).render(120).join('\n'), /stopped · pid 4242/);
+    assert.match(stop.renderResult({ content: [{ type: 'text', text: '- stopped: false' }] }, { expanded: false }, theme, {}).render(120).join('\n'), /<muted>was not running<\/muted>/);
+    assert.match(stop.renderResult({ content: [{ type: 'text', text: '- stopped: false' }] }, { expanded: true }, theme, {}).render(120).join('\n'), /stopped: false/);
+    const stopExpanded = stop
+        .renderResult({ content: [{ type: 'text', text: '- stopped: true\n- pid: 4242' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(stopExpanded, /stopped: true/);
+    assert.match(stopExpanded, /pid: 4242/);
+});
+test('a crtr canvas issue new card collapses to an issue/note confirmation, not the raw bullets', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas issue new --type bug' });
+    const github = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: '- created: true\n- target: github\n- type: bug\n- title: Fix the thing\n- url: https://github.com/acme/repo/issues/42',
+            },
+        ],
+    }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(github, /<success>issue #42<\/success>/);
+    assert.match(github, /<muted>https:\/\/github\.com\/acme\/repo\/issues\/42<\/muted>/);
+    const githubExpanded = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: '- created: true\n- target: github\n- type: bug\n- title: Fix the thing\n- url: https://github.com/acme/repo/issues/42',
+            },
+        ],
+    }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(githubExpanded, /url: https:\/\/github\.com\/acme\/repo\/issues\/42/);
+    const file = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: '- created: true\n- target: file\n- type: idea\n- title: Add the thing\n- path: /Users/x/proj/.todos/20260101-add-the-thing.md',
+            },
+        ],
+    }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(file, /<success>note saved<\/success>/);
+    assert.match(file, /<muted>20260101-add-the-thing\.md<\/muted>/);
+    const fileExpanded = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: '- created: true\n- target: file\n- type: idea\n- title: Add the thing\n- path: /Users/x/proj/.todos/20260101-add-the-thing.md',
+            },
+        ],
+    }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(fileExpanded, /path: \/Users\/x\/proj\/\.todos\/20260101-add-the-thing\.md/);
+    const empty = def
+        .renderResult({ content: [{ type: 'text', text: '- created: false' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(empty, /<muted>nothing captured<\/muted>/);
+    const emptyExpanded = def
+        .renderResult({ content: [{ type: 'text', text: '- created: false' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(emptyExpanded, /created: false/);
+});
+test('a crtr node new card collapses to a spawned-or-armed status line, not the raw follow_up prose', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node new --kind developer' });
+    const spawned = def
+        .renderResult({ content: [{ type: 'text', text: ['Spawned "worker-a" (mq2jpqz5-87fa626e) — active.', '', 'Independent root spawned — hand it off and move on.'].join('\n') }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(spawned, /<success>spawned worker-a \(mq2jpqz5-87fa626e\) · active<\/success>/);
+    const spawnedExpanded = def
+        .renderResult({ content: [{ type: 'text', text: ['Spawned "worker-a" (mq2jpqz5-87fa626e) — active.', '', 'Independent root spawned — hand it off and move on.'].join('\n') }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(spawnedExpanded, /Independent root spawned — hand it off and move on\./);
+    const armedClock = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: ['Armed deferred spawn tr-abc123 — a developer node, fires 2026-07-02T09:00:00.000Z.', '', 'No node exists yet.'].join('\n'),
+            },
+        ],
+    }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(armedClock, /<accent>trigger armed · fires 2026-07-02T09:00:00\.000Z<\/accent>/);
+    assert.match(armedClock, /<muted>developer · tr-abc123<\/muted>/);
+    const armedClockExpanded = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: ['Armed deferred spawn tr-abc123 — a developer node, fires 2026-07-02T09:00:00.000Z.', '', 'No node exists yet.'].join('\n'),
+            },
+        ],
+    }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(armedClockExpanded, /Armed deferred spawn tr-abc123 — a developer node, fires 2026-07-02T09:00:00\.000Z\./);
+    const armedWhen = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: ['Armed deferred spawn tr-xyz — a developer node, next eval 2026-07-01T00:00:00.000Z, timeout 2026-07-08T00:00:00.000Z.', '', 'No node exists yet.'].join('\n'),
+            },
+        ],
+    }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(armedWhen, /<accent>trigger armed · next eval 2026-07-01T00:00:00\.000Z, timeout 2026-07-08T00:00:00\.000Z<\/accent>/);
+    const armedWhenExpanded = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: ['Armed deferred spawn tr-xyz — a developer node, next eval 2026-07-01T00:00:00.000Z, timeout 2026-07-08T00:00:00.000Z.', '', 'No node exists yet.'].join('\n'),
+            },
+        ],
+    }, { expanded: true }, theme, {})
+        .render(200)
+        .join('\n');
+    assert.match(armedWhenExpanded, /Armed deferred spawn tr-xyz — a developer node, next eval 2026-07-01T00:00:00\.000Z, timeout 2026-07-08T00:00:00\.000Z\./);
+});
+test('a crtr node msg card collapses to an armed/delivered status line, not the raw guidance prose', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node msg --to mq123' });
+    const armed = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: [
+                    'Armed inbox_message trigger tr-1 (every) — fires 2026-07-02T09:00:00.000Z, recurs every 6h, target mq123.',
+                    '',
+                    'Message recurrence armed (every 6h); first fire 2026-07-02T09:00:00.000Z. End your turn to go dormant.',
+                ].join('\n'),
+            },
+        ],
+    }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(armed, /<accent>trigger armed · fires 2026-07-02T09:00:00\.000Z<\/accent>/);
+    assert.match(armed, /<muted>inbox_message · every · → mq123 · tr-1<\/muted>/);
+    const armedExpanded = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: [
+                    'Armed inbox_message trigger tr-1 (every) — fires 2026-07-02T09:00:00.000Z, recurs every 6h, target mq123.',
+                    '',
+                    'Message recurrence armed (every 6h); first fire 2026-07-02T09:00:00.000Z. End your turn to go dormant.',
+                ].join('\n'),
+            },
+        ],
+    }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(armedExpanded, /Message recurrence armed \(every 6h\); first fire 2026-07-02T09:00:00\.000Z\. End your turn to go dormant\./);
+    const delivered = def
+        .renderResult({ content: [{ type: 'text', text: 'Delivered.' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(delivered, /<success>delivered<\/success>/);
+    const deliveredExpanded = def
+        .renderResult({ content: [{ type: 'text', text: 'Delivered.' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(deliveredExpanded, /Delivered\./);
+    const revived = def
+        .renderResult({ content: [{ type: 'text', text: 'Delivered — the dormant target was revived to receive it.' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(revived, /<success>delivered · revived<\/success>/);
+    const revivedExpanded = def
+        .renderResult({ content: [{ type: 'text', text: 'Delivered — the dormant target was revived to receive it.' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(revivedExpanded, /Delivered — the dormant target was revived to receive it\./);
+    const fresh = def
+        .renderResult({ content: [{ type: 'text', text: 'Fresh-revived mq123 now — it resumes a clean window re-reading its roadmap/disk.' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(fresh, /<success>fresh-revived mq123<\/success>/);
+    const freshExpanded = def
+        .renderResult({ content: [{ type: 'text', text: 'Fresh-revived mq123 now — it resumes a clean window re-reading its roadmap/disk.' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(freshExpanded, /it resumes a clean window re-reading its roadmap\/disk\./);
+});
+test('a crtr node yield card collapses to a refresh-armed status line, not the raw bullets', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node yield' });
+    const withExtras = def
+        .renderResult({ content: [{ type: 'text', text: '- node_id: mq123\n- promoted: true\n- model: strong\n- will_refresh: true' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(withExtras, /<accent>yield armed — refreshes on next wake<\/accent>/);
+    assert.match(withExtras, /<muted>promoted → orchestrator · model: strong<\/muted>/);
+    const withExtrasExpanded = def
+        .renderResult({ content: [{ type: 'text', text: '- node_id: mq123\n- promoted: true\n- model: strong\n- will_refresh: true' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(withExtrasExpanded, /promoted: true/);
+    assert.match(withExtrasExpanded, /model: strong/);
+    const plain = def
+        .renderResult({ content: [{ type: 'text', text: '- node_id: mq123\n- will_refresh: true' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(plain, /<accent>yield armed — refreshes on next wake<\/accent>/);
+    assert.doesNotMatch(plain, /promoted/);
+    const plainExpanded = def
+        .renderResult({ content: [{ type: 'text', text: '- node_id: mq123\n- will_refresh: true' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(plainExpanded, /node_id: mq123/);
+});
+test('a crtr node lifecycle close card collapses to a cascade digest, not the raw prose sentence', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node lifecycle close --node mq123' });
+    const cascade = def
+        .renderResult({ content: [{ type: 'text', text: 'Closed mq123 and its exclusive subtree — 3 node(s) closed, 1 spared (still managed from outside the subtree).' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(cascade, /<success>closed mq123<\/success>/);
+    assert.match(cascade, /<warning>2 descendants canceled<\/warning>/);
+    assert.match(cascade, /<muted>1 spared \(managed elsewhere\)<\/muted>/);
+    const cascadeExpanded = def
+        .renderResult({ content: [{ type: 'text', text: 'Closed mq123 and its exclusive subtree — 3 node(s) closed, 1 spared (still managed from outside the subtree).' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(cascadeExpanded, /Closed mq123 and its exclusive subtree — 3 node\(s\) closed, 1 spared \(still managed from outside the subtree\)\./);
+    const solo = def
+        .renderResult({ content: [{ type: 'text', text: 'Closed mq123 and its exclusive subtree — 1 node(s) closed.' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(solo, /<success>closed mq123<\/success>/);
+    assert.doesNotMatch(solo, /descendants? canceled/);
+    const soloExpanded = def
+        .renderResult({ content: [{ type: 'text', text: 'Closed mq123 and its exclusive subtree — 1 node(s) closed.' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(soloExpanded, /Closed mq123 and its exclusive subtree — 1 node\(s\) closed\./);
+});
+const TRIGGERS_LIST_OUTPUT = [
+    '3 pending trigger(s) in scope self.',
+    '',
+    '| id | owner | target | action | mode | type | next | recur | timeout | label | eval_state | last_eval_at | last_exit | last_stderr | created |',
+    '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |',
+    '| tr-1 | self | mq1 | msg | inbox_message | at | 2026-07-02T00:00:00.000Z |  |  | ping |  |  |  |  | 2026-06-01T00:00:00.000Z |',
+    '| tr-2 | self | mq2 | msg | fresh_revive | every | 2026-07-03T00:00:00.000Z | every 6h |  |  |  |  |  |  | 2026-06-01T00:00:00.000Z |',
+    '| tr-3 | self | spawn:developer@/x | new | node_birth | when | 2026-07-01T00:00:00.000Z |  | 2026-07-08T00:00:00.000Z |  | armed |  |  |  | 2026-06-01T00:00:00.000Z |',
+    '',
+    'Cancel one with `crtr node triggers cancel <id>`. Fired one-shots are gone; a recurrence shows its NEXT fire/eval, not past slots.',
+].join('\n');
+test('a crtr node triggers list card collapses to a pending-count + top rows, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr node triggers list' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: TRIGGERS_LIST_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /3 pending/);
+    assert.match(collapsed, /<muted>at · next 2026-07-02T00:00:00\.000Z · mq1<\/muted>/);
+    assert.match(collapsed, /<muted>when · next 2026-07-01T00:00:00\.000Z · spawn:developer@\/x<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| id \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: TRIGGERS_LIST_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| id \| owner \| target \|/);
+    assert.match(expanded, /tr-3 \| self \| spawn:developer@\/x/);
+    const empty = def
+        .renderResult({ content: [{ type: 'text', text: 'No pending triggers in scope self.\n\nCancel one with `crtr node triggers cancel <id>`.' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(empty, /<muted>none pending<\/muted>/);
+    const emptyExpanded = def
+        .renderResult({ content: [{ type: 'text', text: 'No pending triggers in scope self.\n\nCancel one with `crtr node triggers cancel <id>`.' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(emptyExpanded, /No pending triggers in scope self\./);
+});
+test('a crtr feed read card collapses to a drained-pointer digest, not the raw coalesced sections', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr feed read' });
+    const drained = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: [
+                    "3 unread pointers drained from mq123's inbox.",
+                    '',
+                    'From worker-a — 2 updates:',
+                    '  [push] did a thing  (ref: worker-a:reports/x.md)',
+                    '  [push] did another  (ref: worker-a:reports/y.md)',
+                    '',
+                    'From worker-b — 1 update:',
+                    '  [push] finished  (ref: worker-b:reports/z.md)',
+                ].join('\n'),
+            },
+        ],
+    }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(drained, /3 pointers drained from 2 nodes/);
+    assert.match(drained, /<muted>worker-a, worker-b<\/muted>/);
+    assert.doesNotMatch(drained, /ref: worker-a/);
+    const drainedExpanded = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: [
+                    "3 unread pointers drained from mq123's inbox.",
+                    '',
+                    'From worker-a — 2 updates:',
+                    '  [push] did a thing  (ref: worker-a:reports/x.md)',
+                    '  [push] did another  (ref: worker-a:reports/y.md)',
+                    '',
+                    'From worker-b — 1 update:',
+                    '  [push] finished  (ref: worker-b:reports/z.md)',
+                ].join('\n'),
+            },
+        ],
+    }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(drainedExpanded, /ref: worker-a:reports\/x\.md/);
+    const empty = def
+        .renderResult({ content: [{ type: 'text', text: 'No unread pointers for mq123 (unread=0).\n\nYour inbox is empty — nothing has arrived yet.' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(empty, /<muted>nothing unread<\/muted>/);
+    const emptyExpanded = def
+        .renderResult({ content: [{ type: 'text', text: 'No unread pointers for mq123 (unread=0).\n\nYour inbox is empty — nothing has arrived yet.' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(emptyExpanded, /Your inbox is empty — nothing has arrived yet\./);
+});
+test('a crtr feed message card previews an identity line + body teaser, not the raw label', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr feed message m1' });
+    const found = def
+        .renderResult({ content: [{ type: 'text', text: ['Full message m1 (from mq123):', '', 'Line one', 'Line two', 'Line three', 'Line four'].join('\n') }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(found, /m1 · from mq123/);
+    assert.match(found, /Line one/);
+    assert.match(found, /…/);
+    assert.doesNotMatch(found, /Line four/);
+    const foundExpanded = def
+        .renderResult({ content: [{ type: 'text', text: ['Full message m1 (from mq123):', '', 'Line one', 'Line two', 'Line three', 'Line four'].join('\n') }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(foundExpanded, /Line four/);
+    const notFound = def
+        .renderResult({ content: [{ type: 'text', text: "No inbox entry with id m1 in mq123's inbox. Re-read the digest with `crtr feed read --all`." }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(notFound, /No inbox entry with id m1/);
+    const notFoundExpanded = def
+        .renderResult({ content: [{ type: 'text', text: "No inbox entry with id m1 in mq123's inbox. Re-read the digest with `crtr feed read --all`." }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(notFoundExpanded, /Re-read the digest with `crtr feed read --all`\./);
+});
+test('a crtr feed peek card collapses to a verdict + working/done/dead counts, not the raw rows', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr feed peek' });
+    const zeroClear = def
+        .renderResult({ content: [{ type: 'text', text: 'No nodes below you (0 subscriptions, 0 unread). Nothing will wake you.' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(zeroClear, /<success>PASS · nothing below<\/success>/);
+    const zeroClearExpanded = def
+        .renderResult({ content: [{ type: 'text', text: 'No nodes below you (0 subscriptions, 0 unread). Nothing will wake you.' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(zeroClearExpanded, /Nothing will wake you\./);
+    const zeroUnread = def
+        .renderResult({ content: [{ type: 'text', text: 'No nodes below you (0 subscriptions, 4 unread). 4 unread reports sit in your inbox.' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(zeroUnread, /<warning>0 below · 4 unread<\/warning>/);
+    const zeroUnreadExpanded = def
+        .renderResult({ content: [{ type: 'text', text: 'No nodes below you (0 subscriptions, 4 unread). 4 unread reports sit in your inbox.' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(zeroUnreadExpanded, /4 unread reports sit in your inbox\./);
+    const withDead = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: [
+                    '⚠ 1 below you is dead and will NOT wake you.',
+                    '',
+                    '3 nodes below you — 1 working, 1 done, 1 dead, 2 unread:',
+                    '- ● worker-a (mq1) · developer · active · spawned 5m ago · cyc 2 · pushed 1m ago [push]',
+                    '- ✓ worker-b (mq2) · developer · done · spawned 10m ago · cyc 3 · pushed 2m ago [push]',
+                    '- ✗ worker-c (mq3) · developer · dead · spawned 20m ago · cyc 1 · no push yet',
+                ].join('\n'),
+            },
+        ],
+    }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(withDead, /1 working · 1 done · 1 dead/);
+    assert.match(withDead, /<warning>1 dead — will not wake you<\/warning>/);
+    assert.doesNotMatch(withDead, /pushed 1m ago/);
+    const withDeadExpanded = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: [
+                    '⚠ 1 below you is dead and will NOT wake you.',
+                    '',
+                    '3 nodes below you — 1 working, 1 done, 1 dead, 2 unread:',
+                    '- ● worker-a (mq1) · developer · active · spawned 5m ago · cyc 2 · pushed 1m ago [push]',
+                    '- ✓ worker-b (mq2) · developer · done · spawned 10m ago · cyc 3 · pushed 2m ago [push]',
+                    '- ✗ worker-c (mq3) · developer · dead · spawned 20m ago · cyc 1 · no push yet',
+                ].join('\n'),
+            },
+        ],
+    }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(withDeadExpanded, /pushed 1m ago/);
+    const noDead = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: [
+                    'Safe to yield — 1 worker running async will wake you.',
+                    '',
+                    '2 nodes below you — 1 working, 1 done, 0 dead, 3 unread:',
+                    '- ● worker-a (mq1) · developer · active · spawned 5m ago · cyc 2 · pushed 1m ago [push]',
+                    '- ✓ worker-b (mq2) · developer · done · spawned 10m ago · cyc 3 · pushed 2m ago [push]',
+                ].join('\n'),
+            },
+        ],
+    }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(noDead, /1 working · 1 done/);
+    assert.doesNotMatch(noDead, /0 dead/);
+    assert.match(noDead, /<warning>3 unread<\/warning>/);
+    const noDeadExpanded = def
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: [
+                    'Safe to yield — 1 worker running async will wake you.',
+                    '',
+                    '2 nodes below you — 1 working, 1 done, 0 dead, 3 unread:',
+                    '- ● worker-a (mq1) · developer · active · spawned 5m ago · cyc 2 · pushed 1m ago [push]',
+                    '- ✓ worker-b (mq2) · developer · done · spawned 10m ago · cyc 3 · pushed 2m ago [push]',
+                ].join('\n'),
+            },
+        ],
+    }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(noDeadExpanded, /Safe to yield — 1 worker running async will wake you\./);
+});
+test('crtr push urgent/final cards collapse to a one-line outcome + report basename', () => {
+    const urgentDef = createCrtrBashToolDefinition({ command: 'crtr push urgent' });
+    const urgent = urgentDef
+        .renderResult({ content: [{ type: 'text', text: 'Urgent report fanned to 3 subscriber(s) — they are force-woken.\n\n- report: /Users/x/nodes/mq1/reports/20260101-urgent.md' }] }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(urgent, /<warning>urgent → 3 subscribers woken<\/warning>/);
+    const urgentExpanded = urgentDef
+        .renderResult({ content: [{ type: 'text', text: 'Urgent report fanned to 3 subscriber(s) — they are force-woken.\n\n- report: /Users/x/nodes/mq1/reports/20260101-urgent.md' }] }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(urgentExpanded, /report: \/Users\/x\/nodes\/mq1\/reports\/20260101-urgent\.md/);
+    const finalDef = createCrtrBashToolDefinition({ command: 'crtr push final' });
+    const final = finalDef
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: 'Result recorded — node finished; its engine shuts down on next stop. Nothing more to do here: STOP your turn immediately. Reply with just "Done." and nothing else.\n\n- report: /Users/x/nodes/mq1/reports/20260101-final.md',
+            },
+        ],
+    }, { expanded: false }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(final, /<success>final pushed · node done<\/success>/);
+    assert.match(final, /<muted>20260101-final\.md<\/muted>/);
+    const finalExpanded = finalDef
+        .renderResult({
+        content: [
+            {
+                type: 'text',
+                text: 'Result recorded — node finished; its engine shuts down on next stop. Nothing more to do here: STOP your turn immediately. Reply with just "Done." and nothing else.\n\n- report: /Users/x/nodes/mq1/reports/20260101-final.md',
+            },
+        ],
+    }, { expanded: true }, theme, {})
+        .render(120)
+        .join('\n');
+    assert.match(finalExpanded, /report: \/Users\/x\/nodes\/mq1\/reports\/20260101-final\.md/);
+});
+// ---------------------------------------------------------------------------
+// Batch C — human/memory/pkg summarizers (preview-registry.ts "Batch C")
+// ---------------------------------------------------------------------------
+const HUMAN_ASK_DELIVERED_OUTPUT = [
+    '- job_id: mrASK0001',
+    '',
+    '**dir:** /Users/silas/Code/cli/crouter',
+    '',
+    "**follow_up:** The human's answer is delivered to your inbox when they respond — no need to poll.",
+].join('\n');
+const HUMAN_ASK_DRAINED_OUTPUT = [
+    '- job_id: mrASK0002',
+    '',
+    '**dir:** /Users/silas/Code/cli/crouter',
+    '',
+    '**follow_up:** Not in tmux: a human must drain it — run `crtr human inbox` (or re-run inside tmux). The answer then arrives in your inbox.',
+].join('\n');
+test('a crtr human ask card collapses to a posted/drained status + question teaser, not the raw fields', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr human ask "Should we ship the preview rollout now?"' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_ASK_DELIVERED_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /<accent>ask posted → waiting on human<\/accent>/);
+    assert.match(collapsed, /<muted>Should we ship the preview rollout now\?<\/muted>/);
+    assert.doesNotMatch(collapsed, /- job_id:/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_ASK_DELIVERED_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /job_id: mrASK0001/);
+    assert.match(expanded, /no need to poll/);
+    const drained = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_ASK_DRAINED_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(drained, /<warning>ask posted — drain via `human inbox`<\/warning>/);
+    assert.match(drained, /<muted>Should we ship the preview rollout now\?<\/muted>/);
+    const drainedExpanded = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_ASK_DRAINED_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(drainedExpanded, /Not in tmux: a human must drain it/);
+});
+const HUMAN_REVIEW_LIVE_OUTPUT = [
+    '- job_id: mrREV0001',
+    '',
+    '**dir:** /Users/silas/Code/cli/crouter',
+    '',
+    '**output:** /Users/silas/Code/cli/crouter/spec.review.md',
+    '',
+    "**follow_up:** The document is live on the human's screen for anchored, line-by-line review. The pane tracks the file — edit the .md in place and it re-renders on save, so never cancel and re-present just to show a change. Do not poll, verify it opened, or background this call; end your turn. The human reviews on their own time, and their comments (with any line edits) arrive in your inbox and wake you when they submit.",
+].join('\n');
+const HUMAN_REVIEW_DRAINED_OUTPUT = [
+    '- job_id: mrREV0002',
+    '',
+    '**dir:** /Users/silas/Code/cli/crouter',
+    '',
+    '**output:** /Users/silas/Code/cli/crouter/spec.review.md',
+    '',
+    '**follow_up:** Not in tmux: a human must drain it — run `crtr human inbox` (or re-run inside tmux). The answer then arrives in your inbox.',
+].join('\n');
+test('a crtr human review card collapses to a posted/drained status + file basename, not the raw fields', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr human review /Users/silas/Code/cli/crouter/spec.md' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_REVIEW_LIVE_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /<accent>review posted: spec\.md → waiting on human<\/accent>/);
+    assert.doesNotMatch(collapsed, /- job_id:/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_REVIEW_LIVE_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /job_id: mrREV0001/);
+    assert.match(expanded, /anchored, line-by-line review/);
+    const drained = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_REVIEW_DRAINED_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(drained, /<warning>review posted: spec\.md — drain via `human inbox`<\/warning>/);
+});
+const HUMAN_LIST_OUTPUT = [
+    '- total: 2',
+    '',
+    '2 items:',
+    '',
+    '| id | job_id | dir | title | kind | blocked_since | asking_node_id | asking_node_name | conversation_id | conversation_title | interaction_count |',
+    '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |',
+    '| h1 | mrJOB1 | /Users/silas/Code/cli/crouter | Ship the rollout? | decision | 2026-06-30T12:00:00.000Z | mrNODE1 | orchestrator | c1 | Rollout plan | 3 |',
+    '| h2 | mrJOB2 | /Users/silas/Code/cli/crouter | Quick check |  | 2026-06-30T12:05:00.000Z | mrNODE2 | reviewer | c2 | Spec review | 1 |',
+].join('\n');
+test('a crtr human list card collapses to a pending count + kind digest, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr human list' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_LIST_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /2 pending/);
+    assert.match(collapsed, /<muted>decision×1<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| id \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_LIST_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| id \| job_id \| dir \|/);
+    const none = def
+        .renderResult({ content: [{ type: 'text', text: '- total: 0\n\n0 items.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(none, /<success>none pending<\/success>/);
+    // REQUIREMENT: total is nonzero but the page is empty (exhausted
+    // pagination) — must NOT collapse to "none pending" (that's only correct
+    // for a true zero total); fall back to the generic renderer instead.
+    const exhausted = def
+        .renderResult({ content: [{ type: 'text', text: '- total: 3\n\n0 items.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.doesNotMatch(exhausted, /none pending/);
+});
+const HUMAN_DECK_OUTPUT = [
+    '- id: h1',
+    '- title: Ship the rollout?',
+    '- kind: decision',
+    '- interaction_count: 1',
+    '',
+    '1 interactions:',
+    '',
+    '| id | kind | prompt | options | allow_freetext |',
+    '| --- | --- | --- | --- | --- |',
+    '| i1 | decision | Ship it? | {"id":"yes","label":"Yes"}, {"id":"no","label":"No"} | false |',
+].join('\n');
+const HUMAN_DECK_MULTI_OUTPUT = [
+    '- id: h1',
+    '- title: Ship the rollout?',
+    '- kind: decision',
+    '- interaction_count: 2',
+    '',
+    '2 interactions:',
+    '',
+    '| id | kind | prompt | options | allow_freetext |',
+    '| --- | --- | --- | --- | --- |',
+    '| i1 | decision | Ship it? | {"id":"yes","label":"Yes"}, {"id":"no","label":"No"} | true |',
+    '| i2 | question | Any concerns? |  | true |',
+].join('\n');
+test('a crtr human deck card collapses to a prompt teaser + option/freetext digest, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr human deck h1' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_DECK_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /Ship it\?/);
+    assert.match(collapsed, /<muted>2 options<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| id \| kind \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_DECK_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| id \| kind \| prompt \| options \| allow_freetext \|/);
+    const multi = def
+        .renderResult({ content: [{ type: 'text', text: HUMAN_DECK_MULTI_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(multi, /Ship it\?/);
+    assert.match(multi, /<muted>2 options · freetext · 2 interactions<\/muted>/);
+    // REQUIREMENT: a malformed/truncated `allow_freetext` cell (neither
+    // `true` nor `false`) must not silently default to "no freetext" — it
+    // must fall back to the generic renderer instead.
+    const malformedFreetext = [
+        '- id: h1',
+        '- title: Ship the rollout?',
+        '- kind: decision',
+        '- interaction_count: 1',
+        '',
+        '1 interactions:',
+        '',
+        '| id | kind | prompt | options | allow_freetext |',
+        '| --- | --- | --- | --- | --- |',
+        '| i1 | decision | Ship it? | {"id":"yes","label":"Yes"}, {"id":"no","label":"No"} |  |',
+    ].join('\n');
+    const malformed = def
+        .renderResult({ content: [{ type: 'text', text: malformedFreetext }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.doesNotMatch(malformed, /<muted>2 options<\/muted>/);
+});
+const MEMORY_LIST_OUTPUT = [
+    'Docs matching your scope are listed below.',
+    '',
+    '3 items:',
+    '',
+    '| name | title | short_form | kind | scope | path | is_dir |',
+    '| --- | --- | --- | --- | --- | --- | --- |',
+    '| ai/x | AI X | AI helpers reference | knowledge | user | /Users/silas/.crouter/memory/ai/x.md | false |',
+    '| taste/y | Taste Y | Taste doc | preference | project | /Users/silas/Code/cli/crouter/.crouter/memory/taste/y.md | false |',
+    '| todos/z | Todo Z | Todo doc | knowledge | node | /path/todos/z.md | false |',
+].join('\n');
+test('a crtr memory list card collapses to a doc count + kind/scope digest, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr memory list' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_LIST_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /3 docs/);
+    assert.match(collapsed, /<muted>knowledge×2, preference×1 \/ node×1, project×1, user×1<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| name \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_LIST_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| name \| title \| short_form \|/);
+});
+const MEMORY_FIND_OUTPUT = [
+    '- query: batch c fixtures',
+    '',
+    'Matches ranked by relevance.',
+    '',
+    '2 hits:',
+    '',
+    '| name | kind | scope | path | score | short_form |',
+    '| --- | --- | --- | --- | --- | --- |',
+    '| ai/x | knowledge | user | /Users/silas/.crouter/memory/ai/x.md | 0.92 | AI helpers reference |',
+    '| taste/y | preference | project | /Users/silas/Code/cli/crouter/.crouter/memory/taste/y.md | 0.81 | Taste doc |',
+].join('\n');
+const MEMORY_FIND_EMPTY_OUTPUT = ['- query: nonexistent thing', '', 'Matches ranked by relevance.', '', '0 hits.'].join('\n');
+const MEMORY_FIND_GREP_OUTPUT = [
+    '- query: TODO',
+    '',
+    'Matches ranked by relevance.',
+    '',
+    '1 hits:',
+    '',
+    '| path | line | text |',
+    '| --- | --- | --- |',
+    '| /Users/silas/Code/cli/crouter/notes/a.md | 12 | TODO: fix this |',
+].join('\n');
+test('a crtr memory find card collapses to a hit count + name digest, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr memory find "batch c fixtures"' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_FIND_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /2 hits for "batch c fixtures"/);
+    assert.match(collapsed, /<muted>ai\/x, taste\/y<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| name \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_FIND_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| name \| kind \| scope \|/);
+    const empty = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_FIND_EMPTY_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(empty, /<muted>0 hits for "nonexistent thing"<\/muted>/);
+    const grepDef = createCrtrBashToolDefinition({ command: 'crtr memory find TODO --grep' });
+    const grepCollapsed = grepDef
+        .renderResult({ content: [{ type: 'text', text: MEMORY_FIND_GREP_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.doesNotMatch(grepCollapsed, /hits for "TODO"/);
+    assert.match(grepCollapsed, /TODO: fix this/);
+});
+const MEMORY_WRITE_CREATED_OUTPUT = [
+    '- name: taste/batch-c-fixtures',
+    '- kind: knowledge',
+    '- scope: node',
+    '- created: true',
+    '',
+    '**path:** /Users/silas/Code/cli/crouter/.crouter/memory/taste/batch-c-fixtures.md',
+    '',
+    '**follow_up:** Written. Read it back with `crtr memory read taste/batch-c-fixtures`.',
+].join('\n');
+const MEMORY_WRITE_UPDATED_OUTPUT = [
+    '- name: taste/batch-c-fixtures',
+    '- kind: knowledge',
+    '- scope: node',
+    '- created: false',
+    '',
+    '**path:** /Users/silas/Code/cli/crouter/.crouter/memory/taste/batch-c-fixtures.md',
+    '',
+    '**follow_up:** Updated. Read it back with `crtr memory read taste/batch-c-fixtures`.',
+].join('\n');
+test('a crtr memory write card collapses to a wrote/updated status + path, not the raw fields', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr memory write --name taste/batch-c-fixtures --kind knowledge' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_WRITE_CREATED_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /<success>wrote taste\/batch-c-fixtures<\/success>/);
+    assert.match(collapsed, /<muted>\/Users\/silas\/Code\/cli\/crouter\/\.crouter\/memory\/taste\/batch-c-fixtures\.md<\/muted>/);
+    assert.doesNotMatch(collapsed, /- created:/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_WRITE_CREATED_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /created: true/);
+    const updated = def
+        .renderResult({ content: [{ type: 'text', text: MEMORY_WRITE_UPDATED_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(updated, /<success>updated taste\/batch-c-fixtures<\/success>/);
+});
+const PKG_PLUGIN_INSTALL_OUTPUT = ['- name: ai', '- scope: user', '', '/Users/silas/.crouter/plugins/ai'].join('\n');
+const PKG_PLUGIN_INSTALL_SHORT_PATH_OUTPUT = ['- name: ai', '- scope: user', '- path: /a'].join('\n');
+test('a crtr pkg plugin install card collapses to an installed status + scope/path digest, not the raw fields', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr pkg plugin install ai' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_INSTALL_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /<success>installed ai<\/success>/);
+    assert.match(collapsed, /<muted>user · \/Users\/silas\/\.crouter\/plugins\/ai<\/muted>/);
+    assert.doesNotMatch(collapsed, /- name:/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_INSTALL_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\/Users\/silas\/\.crouter\/plugins\/ai/);
+    const shortPath = def
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_INSTALL_SHORT_PATH_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(shortPath, /<muted>user · \/a<\/muted>/);
+});
+const PKG_PLUGIN_UPDATE_UPDATED_OUTPUT = ['1 updated:', '', '| name | updated | sha |', '| --- | --- | --- |', '| ai | true | def5678 |'].join('\n');
+const PKG_PLUGIN_UPDATE_CURRENT_OUTPUT = ['1 updated:', '', '| name | updated | sha |', '| --- | --- | --- |', '| ai | false | abc1234 |'].join('\n');
+const PKG_PLUGIN_UPDATE_MULTI_OUTPUT = [
+    '3 updated:',
+    '',
+    '| name | updated | sha |',
+    '| --- | --- | --- |',
+    '| ai | true | aaa1111 |',
+    '| beta | false | bbb2222 |',
+    '| gamma | true | ccc3333 |',
+].join('\n');
+test('a crtr pkg plugin update card collapses to an updated/current status + sha, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr pkg plugin update --name ai' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_UPDATE_UPDATED_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /<success>updated ai<\/success>/);
+    assert.match(collapsed, /<muted>def5678<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| name \| updated \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_UPDATE_UPDATED_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| name \| updated \| sha \|/);
+    const current = def
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_UPDATE_CURRENT_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(current, /<muted>ai already current<\/muted>/);
+    assert.match(current, /<muted>abc1234<\/muted>/);
+    const multiDef = createCrtrBashToolDefinition({ command: 'crtr pkg plugin update' });
+    const multi = multiDef
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_UPDATE_MULTI_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(multi, /2 updated · 1 already current/);
+    const empty = multiDef
+        .renderResult({ content: [{ type: 'text', text: '0 updated.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(empty, /<muted>nothing to update<\/muted>/);
+    // REQUIREMENT: a malformed `updated` cell (neither `true` nor `false`) in
+    // a multi-row table must not be silently counted as "already current" —
+    // the multi-row loop must reject exactly like the single-row path does.
+    const malformedUpdate = [
+        '3 updated:',
+        '',
+        '| name | updated | sha |',
+        '| --- | --- | --- |',
+        '| ai | true | aaa1111 |',
+        '| beta | maybe | bbb2222 |',
+        '| gamma | false | ccc3333 |',
+    ].join('\n');
+    const malformed = multiDef
+        .renderResult({ content: [{ type: 'text', text: malformedUpdate }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.doesNotMatch(malformed, /already current/);
+});
+const PKG_PLUGIN_LIST_OUTPUT = [
+    '- total: 3',
+    '',
+    '3 items:',
+    '',
+    '| name | scope | version | enabled | source_marketplace | path |',
+    '| --- | --- | --- | --- | --- | --- |',
+    '| ai | user | 0.7.1 | true | crouter-official-marketplace | /Users/silas/.crouter/plugins/ai |',
+    '| beta | user | 1.0.0 | false | crouter-official-marketplace | /Users/silas/.crouter/plugins/beta |',
+    '| gamma | project | 2.3.0 | true | custom-market | /Users/silas/Code/cli/crouter/.crouter/plugins/gamma |',
+].join('\n');
+test('a crtr pkg plugin list card collapses to a plugin/enabled count + name digest, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr pkg plugin list' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_LIST_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /3 plugins · 2 enabled/);
+    assert.match(collapsed, /<muted>ai, beta, gamma<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| name \| scope \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_LIST_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| name \| scope \| version \|/);
+    const empty = def
+        .renderResult({ content: [{ type: 'text', text: '- total: 0\n\n0 items.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(empty, /<muted>0 plugins<\/muted>/);
+    // REQUIREMENT: nonzero total with an empty page (exhausted pagination)
+    // must NOT collapse to "0 plugins" — fall back to the generic renderer.
+    const exhausted = def
+        .renderResult({ content: [{ type: 'text', text: '- total: 3\n\n0 items.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.doesNotMatch(exhausted, /0 plugins/);
+});
+const PKG_PLUGIN_SHOW_OUTPUT = [
+    '- name: ai',
+    '- scope: user',
+    '- path: /Users/silas/.crouter/plugins/ai',
+    '- enabled: true',
+    '- manifest: {"name":"ai","version":"0.7.1","description":"AI helpers"}',
+    '',
+    '2 docs:',
+    '',
+    '| name | path |',
+    '| --- | --- |',
+    '| ai/x | /Users/silas/.crouter/plugins/ai/memory/ai/x.md |',
+    '| ai/y | /Users/silas/.crouter/plugins/ai/memory/ai/y.md |',
+].join('\n');
+const PKG_PLUGIN_SHOW_DISABLED_OUTPUT = [
+    '- name: beta',
+    '- scope: user',
+    '- path: /Users/silas/.crouter/plugins/beta',
+    '- enabled: false',
+    '- manifest: {"name":"beta","version":"1.0.0","description":"Beta helpers"}',
+    '',
+    '0 docs.',
+].join('\n');
+test('a crtr pkg plugin show card collapses to a name@version + enabled status + doc count, not the raw fields', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr pkg plugin show ai' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_SHOW_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /<success>ai@0\.7\.1 · enabled<\/success>/);
+    assert.match(collapsed, /<muted>2 substrate docs<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| name \| path \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_SHOW_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| name \| path \|/);
+    const disabledDef = createCrtrBashToolDefinition({ command: 'crtr pkg plugin show beta' });
+    const disabled = disabledDef
+        .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_SHOW_DISABLED_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(disabled, /<muted>beta@1\.0\.0 · disabled<\/muted>/);
+    assert.match(disabled, /<muted>0 substrate docs<\/muted>/);
+});
+const PKG_MARKET_LIST_OUTPUT = [
+    '- total: 2',
+    '',
+    '2 items:',
+    '',
+    '| name | scope | url | ref | path |',
+    '| --- | --- | --- | --- | --- |',
+    '| crouter-official-marketplace | user | https://github.com/crouton-labs/crouter-official-marketplace | main | /Users/silas/.crouter/marketplaces/crouter-official-marketplace |',
+    '| custom-market | project | https://github.com/example/custom-market | main | /Users/silas/Code/cli/crouter/.crouter/marketplaces/custom-market |',
+].join('\n');
+test('a crtr pkg market list card collapses to a marketplace count + name digest, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr pkg market list' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: PKG_MARKET_LIST_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /2 marketplaces/);
+    assert.match(collapsed, /<muted>crouter-official-marketplace, custom-market<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| name \| scope \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: PKG_MARKET_LIST_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| name \| scope \| url \|/);
+    const empty = def
+        .renderResult({ content: [{ type: 'text', text: '- total: 0\n\n0 items.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(empty, /<muted>0 marketplaces<\/muted>/);
+    // REQUIREMENT: nonzero total with an empty page (exhausted pagination)
+    // must NOT collapse to "0 marketplaces" — fall back to the generic renderer.
+    const exhausted = def
+        .renderResult({ content: [{ type: 'text', text: '- total: 3\n\n0 items.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.doesNotMatch(exhausted, /0 marketplaces/);
+});
+const PKG_MARKET_BROWSE_ROWS = Array.from({ length: 11 }, (_, i) => {
+    const n = i + 1;
+    return `| p${n} | main | github | 0.${n}.0 | Plugin ${n} | tag${n} | false |  |`;
+});
+const PKG_MARKET_BROWSE_OUTPUT = [
+    '- marketplace: crouter-official-marketplace',
+    '- total: 11',
+    '',
+    '11 items:',
+    '',
+    '| name | ref | source | version | description | keywords | installed | installed_scope |',
+    '| --- | --- | --- | --- | --- | --- | --- | --- |',
+    ...PKG_MARKET_BROWSE_ROWS,
+].join('\n');
+test('a crtr pkg market browse card collapses to a plugin count in <market> + capped name digest, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr pkg market browse crouter-official-marketplace' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: PKG_MARKET_BROWSE_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /11 plugins in crouter-official-marketplace/);
+    assert.match(collapsed, /<muted>p1, p2, p3, p4, p5, p6, p7, p8, … 3 more<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| name \| ref \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: PKG_MARKET_BROWSE_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| name \| ref \| source \|/);
+    const empty = def
+        .renderResult({ content: [{ type: 'text', text: '- marketplace: crouter-official-marketplace\n- total: 0\n\n0 items.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(empty, /<muted>0 plugins in crouter-official-marketplace<\/muted>/);
+    // REQUIREMENT: nonzero total with an empty page (exhausted pagination)
+    // must NOT collapse to "0 plugins in <market>" — fall back to generic.
+    const exhausted = def
+        .renderResult({ content: [{ type: 'text', text: '- marketplace: crouter-official-marketplace\n- total: 3\n\n0 items.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.doesNotMatch(exhausted, /0 plugins in crouter-official-marketplace/);
+});
+// ---------------------------------------------------------------------------
+// Batch D — search/sys/surface summarizers + sys sysprompt suppression.
+// ---------------------------------------------------------------------------
+test('sys sysprompt is command-owned suppressOutput, never on failure', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr sys sysprompt abc' });
+    const component = def.renderResult({ content: [{ type: 'text', text: '- node_id: abc\n- captured_at: 2026-07-01T00:00:00.000Z\n- chars: 40000\n\n# System prompt\n...(huge prompt dump)...' }] }, { expanded: false }, theme, {});
+    const collapsed = component.render(80).join('\n');
+    assert.doesNotMatch(collapsed, /huge prompt dump/);
+    assert.match(collapsed, /suppressed — ctrl\+o to expand/);
+    const failedComponent = def.renderResult({ content: [{ type: 'text', text: 'huge dump on failure too' }] }, { expanded: false }, theme, { isError: true });
+    assert.match(failedComponent.render(80).join('\n'), /huge dump on failure too/);
+});
+const SEARCH_WEB_OUTPUT = [
+    '2 results for "test query":',
+    '',
+    '### 1. First Result Title',
+    'https://example.com/page1 · 2024-01-15 · Jane Doe',
+    '- highlight one text here',
+    '- highlight two text here',
+    '',
+    '### 2. Second Result Title',
+    'https://other.org/page2',
+    '- another highlight',
+    '',
+    'Fetch full content for selected result URLs with the contents leaf after checking its schema. No good hits? Broaden the query, drop domain filters, or try --type deep.',
+].join('\n');
+test('a crtr search web card collapses to a result count + title — domain digest, not the raw sections', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr search web "test query"' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: SEARCH_WEB_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /2 results/);
+    assert.match(collapsed, /<muted>First Result Title — example\.com<\/muted>/);
+    assert.match(collapsed, /<muted>Second Result Title — other\.org<\/muted>/);
+    assert.doesNotMatch(collapsed, /### 1\./);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: SEARCH_WEB_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /### 1\. First Result Title/);
+    assert.match(expanded, /### 2\. Second Result Title/);
+    const empty = def
+        .renderResult({ content: [{ type: 'text', text: 'No results for "empty query".\n\nFetch full content for selected result URLs with the contents leaf after checking its schema. No good hits? Broaden the query, drop domain filters, or try --type deep.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(empty, /<muted>0 results for "empty query"<\/muted>/);
+});
+const SEARCH_ANSWER_OUTPUT = [
+    'The answer is 42, according to the sources below.',
+    '',
+    'Sources (2):',
+    '1. Deep Thought Paper — https://example.com/paper',
+    '2. Hitchhiker Wiki — https://wiki.example.org/guide',
+    '',
+    'Read any cited source in full with the contents leaf after checking its schema. Want raw ranked results instead of a synthesized answer? Use the web leaf.',
+].join('\n');
+test('a crtr search answer card collapses to the answer teaser + citation count, not the raw sources list', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr search answer "what is the answer"' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: SEARCH_ANSWER_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /The answer is 42, according to the sources below\./);
+    assert.match(collapsed, /<muted>2 citations<\/muted>/);
+    assert.doesNotMatch(collapsed, /Sources \(2\):/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: SEARCH_ANSWER_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /Sources \(2\):/);
+    assert.match(expanded, /Deep Thought Paper/);
+    const noAnswer = def
+        .renderResult({ content: [{ type: 'text', text: 'No answer was returned.\n\nRead any cited source in full with the contents leaf after checking its schema. Want raw ranked results instead of a synthesized answer? Use the web leaf.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(noAnswer, /<muted>no answer returned<\/muted>/);
+});
+const SEARCH_CONTENTS_OUTPUT = [
+    'Extracted 2 URLs:',
+    '',
+    '### 1. Example Page',
+    'https://example.com/a',
+    'Some highlight text about the page contents that is reasonably long for testing chars count.',
+    '',
+    '### 2. Another Page',
+    'https://example.org/b',
+    '- bullet one',
+    '- bullet two',
+    '',
+    'Stale or empty content? Re-run with --max-age-hours 0 to force a fresh crawl. Need to find more pages? Use the web leaf after checking its schema.',
+].join('\n');
+test('a crtr search contents card collapses to a per-URL title + char-count digest, not the raw sections', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr search contents https://example.com/a,https://example.org/b' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: SEARCH_CONTENTS_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /extracted 2 URLs/);
+    assert.match(collapsed, /<muted>Example Page · \d+ chars<\/muted>/);
+    assert.match(collapsed, /<muted>Another Page · \d+ chars<\/muted>/);
+    assert.doesNotMatch(collapsed, /### 1\./);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: SEARCH_CONTENTS_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /### 1\. Example Page/);
+    const failed = def
+        .renderResult({
+        content: [{
+                type: 'text',
+                text: [
+                    'No content extracted.',
+                    'Failed (2):',
+                    '- https://dead.example.com — 404 Not Found',
+                    '- https://slow.example.com — timeout',
+                    '',
+                    'Stale or empty content? Re-run with --max-age-hours 0 to force a fresh crawl. Need to find more pages? Use the web leaf after checking its schema.',
+                ].join('\n'),
+            }],
+    }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(failed, /<error>0 extracted · 2 failed<\/error>/);
+    const nothingAtAll = def
+        .renderResult({ content: [{ type: 'text', text: 'No content extracted.\n\nStale or empty content? Re-run with --max-age-hours 0 to force a fresh crawl. Need to find more pages? Use the web leaf after checking its schema.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(nothingAtAll, /<muted>no content extracted<\/muted>/);
+});
+const SYS_SETUP_OUTPUT = [
+    'crtr sys setup (non-interactive)',
+    '',
+    'Packages:',
+    '- pi-crtr-extensions — crtr companion extensions. (installed)',
+    '- pi-mode-switch — Alt+M mode cycling. (installed)',
+    '- pi-claude-oauth-adapter — OAuth adapter. (not installed)',
+    '',
+    'System deps:',
+    '- tmux: ✓ installed',
+    '- nvim: brew install neovim',
+    '',
+    '- Exa key: write to /Users/example/.crouter/exa.key or set EXA_API_KEY',
+    'Run `crtr sys setup` in a TTY to open the wizard.',
+].join('\n');
+test('a crtr sys setup card collapses to an ok/pending step digest, not the raw sections', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr sys setup' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: SYS_SETUP_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /<warning>3 ok · 2 pending<\/warning>/);
+    assert.match(collapsed, /<muted>pi-claude-oauth-adapter, nvim<\/muted>/);
+    assert.doesNotMatch(collapsed, /Packages:/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: SYS_SETUP_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /Packages:/);
+    assert.match(expanded, /System deps:/);
+    const allOk = def
+        .renderResult({ content: [{ type: 'text', text: SYS_SETUP_OUTPUT.replace('(not installed)', '(installed)').replace('brew install neovim', '✓ installed') }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(allOk, /<success>5 steps ok<\/success>/);
+});
+const SYS_DOCTOR_PASS_OUTPUT = [
+    '- ok: true',
+    '- failed: 0',
+    '',
+    '2 checks:',
+    '',
+    '| scope | name | status | message | remediation |',
+    '| --- | --- | --- | --- | --- |',
+    '| user | plugin:ai:dir | pass | directory exists |  |',
+    '| user | plugin:ai:manifest | pass | manifest valid |  |',
+].join('\n');
+const SYS_DOCTOR_FAIL_OUTPUT = [
+    '- ok: false',
+    '- failed: 1',
+    '',
+    '2 checks:',
+    '',
+    '| scope | name | status | message | remediation |',
+    '| --- | --- | --- | --- | --- |',
+    '| user | plugin:ai:dir | pass | directory exists |  |',
+    '| user | plugin:beta:dir | fail | directory missing: /path/to/beta |  |',
+].join('\n');
+test('a crtr sys doctor card collapses to PASS or an issue digest, not the raw checks table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr sys doctor' });
+    const pass = def
+        .renderResult({ content: [{ type: 'text', text: SYS_DOCTOR_PASS_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(pass, /<success>PASS · 2 checks<\/success>/);
+    assert.doesNotMatch(pass, /\| scope \| name \|/);
+    const fail = def
+        .renderResult({ content: [{ type: 'text', text: SYS_DOCTOR_FAIL_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(fail, /<error>1 issue<\/error>/);
+    assert.match(fail, /<warning>plugin:beta:dir: directory missing: \/path\/to\/beta<\/warning>/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: SYS_DOCTOR_FAIL_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| scope \| name \| status \|/);
+});
+const SYS_UPDATE_CHECK_OUTPUT = [
+    '- up_to_date: false',
+    '',
+    '2 updates:',
+    '',
+    '| name | kind | current | latest | up_to_date | unreachable |',
+    '| --- | --- | --- | --- | --- | --- |',
+    '| @crouton-kit/crouter | self | 0.3.34 | 0.3.35 | false | false |',
+    '| some-marketplace | marketplace | abc123 | abc123 | true | false |',
+].join('\n');
+test('a crtr sys update --check card collapses to an outdated/checked digest, not the raw table', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr sys update --check' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: SYS_UPDATE_CHECK_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /<warning>1 outdated · 2 checked<\/warning>/);
+    assert.match(collapsed, /<muted>@crouton-kit\/crouter: 0\.3\.34 → 0\.3\.35<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| name \| kind \|/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: SYS_UPDATE_CHECK_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /\| name \| kind \| current \|/);
+    const upToDate = def
+        .renderResult({ content: [{ type: 'text', text: '- up_to_date: true\n\n1 updates:\n\n| name | kind | current | latest | up_to_date | unreachable |\n| --- | --- | --- | --- | --- | --- |\n| a | self | 1.0.0 | 1.0.0 | true | false |' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(upToDate, /<success>PASS · 1 up to date<\/success>/);
+    const applyDone = def
+        .renderResult({ content: [{ type: 'text', text: '- target: all\n- status: done' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(applyDone, /<success>updated · all<\/success>/);
+    const applyFailed = def
+        .renderResult({ content: [{ type: 'text', text: '- target: self\n- status: failed\n- error: network unreachable' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(applyFailed, /<error>update failed · self<\/error>/);
+    assert.match(applyFailed, /<muted>network unreachable<\/muted>/);
+});
+test('a crtr sys feedback card collapses to a filed/saved-locally pointer, not the raw fields', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr sys feedback "crtr crashed"' });
+    const filed = def
+        .renderResult({ content: [{ type: 'text', text: '- status: filed\n- url: https://github.com/crouton-labs/crouter/issues/123' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(filed, /<success>issue filed<\/success>/);
+    assert.match(filed, /<muted>https:\/\/github\.com\/crouton-labs\/crouter\/issues\/123<\/muted>/);
+    const savedText = '- status: saved-locally\n- path: /Users/example/.crouter/feedback/2026-07-01T00-00-00-000Z.md\n- error: gh not available: not found';
+    const saved = def
+        .renderResult({ content: [{ type: 'text', text: savedText }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(saved, /<warning>saved locally — not filed<\/warning>/);
+    assert.match(saved, /<muted>2026-07-01T00-00-00-000Z\.md<\/muted>/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: savedText }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /gh not available: not found/);
+});
+const SURFACE_VIEW_LIST_OUTPUT = [
+    'canvas             Canvas             [builtin]  Live agent graph — who is working, who is blocked',
+    'chat               Chat               [builtin]  Portable chat-as-a-view core',
+    'workspace-sidebar  Workspace          [builtin]  Left rail for `crtr workspace` — this graph + other agents in this cwd',
+].join('\n');
+test('a crtr surface view list card collapses to a view count + id digest, not the raw rows', () => {
+    const def = createCrtrBashToolDefinition({ command: 'crtr surface view list' });
+    const collapsed = def
+        .renderResult({ content: [{ type: 'text', text: SURFACE_VIEW_LIST_OUTPUT }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(collapsed, /3 views/);
+    assert.match(collapsed, /<muted>canvas, chat, workspace-sidebar<\/muted>/);
+    assert.doesNotMatch(collapsed, /Live agent graph/);
+    const expanded = def
+        .renderResult({ content: [{ type: 'text', text: SURFACE_VIEW_LIST_OUTPUT }] }, { expanded: true }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(expanded, /Live agent graph/);
+    const empty = def
+        .renderResult({ content: [{ type: 'text', text: 'No views found. Scaffold one with the view new leaf.' }] }, { expanded: false }, theme, {})
+        .render(140)
+        .join('\n');
+    assert.match(empty, /No views found/);
+});