@north-light/crouter 0.3.159 → 0.3.161

package/dist/clients/attach/render/chat-view.js

@@ -30,10 +30,12 @@ import { SITUATIONAL_CONTEXT_CUSTOM_TYPE } from '../../../core/runtime/situation
 import { transformMessageDiagrams } from './diagram.js';
 import { styleAttachMarkdownHeadings, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-headings.js';
 import { createCrtrEditToolDefinition } from './edit-diff.js';
+import { FOLDED_STATE_KEY, createCrtrPlainBashToolDefinition, createCrtrReadToolDefinition, createCrtrWriteToolDefinition, } from './tool-calls.js';
 import { ringCompletionBell } from '../chrome/completion-bell.js';
 import { extractFilePaths } from '../visible-paths.js';
 import { FrozenHistoryComponent, keepWhenCondensed, liveRegionStart } from './frozen-history.js';
-import { readConfig } from '../../../core/config.js';
+import { ViewerAssistantMessageComponent } from './assistant-message.js';
+import { readConfig, updateRawConfigAtomically } from '../../../core/config.js';
 import { DEFAULT_CONDENSED_HISTORY, DEFAULT_LIVE_CYCLES } from '../../../types.js';
 /** customType stamped on the injected `<crtr-context>` bearings block (mirrors
  *  CONTEXT_INTRO_CUSTOM_TYPE in canvas-context-intro.ts — kept as a local literal
@@ -76,6 +78,27 @@ function readCondensedHistory() {
         return DEFAULT_CONDENSED_HISTORY;
     }
 }
+/** The user's `fold_finished_tools` setting — the persisted starting state of the
+ *  fold view setting. Toggling it in a viewer writes it back (`persistFoldFinishedTools`),
+ *  so the choice carries into later chats and later viewers. */
+function readFoldFinishedTools() {
+    try {
+        return readConfig('user').fold_finished_tools;
+    }
+    catch {
+        return false;
+    }
+}
+/** Persist the fold view setting to user config. Best-effort: a viewer must never
+ *  die because the config file is unwritable — the in-viewer toggle still applies. */
+function persistFoldFinishedTools(value) {
+    try {
+        updateRawConfigAtomically('user', (latest) => ({ ...latest, fold_finished_tools: value }));
+    }
+    catch {
+        // ignored — the fold still applies to this viewer.
+    }
+}
 /** A component supports the Ctrl+O global tool-output toggle. Mirrors pi's
  *  `isExpandable` duck-type (interactive-mode.js): any rendered child carrying a
  *  `setExpanded(boolean)` method — tool executions, custom/compaction/branch/skill
@@ -87,6 +110,98 @@ function isExpandable(obj) {
         'setExpanded' in obj &&
         typeof obj.setExpanded === 'function');
 }
+/** Every SGR escape, for measuring a line's visible content. */
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+/** Same match, with the SGR parameter list captured for rewriting. */
+const SGR_PARAMS_RE = /\x1b\[([0-9;]*)m/g;
+/** Drop every background-color SGR parameter from a line, keeping foreground and
+ *  text styles. The minimized fold is a dense index of what ran, so the tool's
+ *  pending/success/error background band (pi paints it across the full pane width)
+ *  reads as noise there — one call per line, unhighlighted. `0` (full reset) is
+ *  kept: it clears the background too, and nothing follows it to re-set one. */
+function stripBackground(line) {
+    return line.replace(SGR_PARAMS_RE, (_whole, params) => {
+        const parts = params.split(';');
+        const kept = [];
+        for (let i = 0; i < parts.length; i++) {
+            const code = Number(parts[i] === '' ? 0 : parts[i]);
+            // Extended background (`48;5;n` / `48;2;r;g;b`) — skip the code AND its args.
+            if (code === 48) {
+                const mode = Number(parts[i + 1]);
+                i += mode === 5 ? 2 : mode === 2 ? 4 : 1;
+                continue;
+            }
+            // Standard (40-47) and bright (100-107) backgrounds. `49` (reset to the
+            // default background) is KEPT — it is the thing we want, and dropping it
+            // would let a neighbouring row's background bleed into this line.
+            if ((code >= 40 && code <= 47) || (code >= 100 && code <= 107))
+                continue;
+            kept.push(String(code));
+        }
+        return kept.length > 0 ? `\x1b[${kept.join(';')}m` : '';
+    });
+}
+/** A tool component that can fold itself down to its CALL. pi's `ToolExecutionComponent`
+ *  only knows expanded/collapsed, so the minimized state is crtr's — and the tool's own
+ *  renderCall owns its folded form: every crtr-owned definition (read/write/edit/bash)
+ *  reads the fold flag off its shared render-state bag and emits ONLY its one-line
+ *  `<icon> <tool> <path>` header while folded. Folded render then paints just the call
+ *  component (result and Box chrome dropped), so a wrapped path keeps its wrap rows
+ *  naturally — no measuring or slicing of rendered ANSI rows. Tools without a crtr
+ *  definition are not foldable and always render in full. */
+/** A one-line separator that appears only while its adjacent tool group is
+ * folded. It stays in the transcript so toggling folded tools reflows the same
+ * message/tool boundary without rebuilding the chat. */
+class FoldedToolSeparator extends Spacer {
+    folded = false;
+    separatesToolGroup = false;
+    setFolded(folded) {
+        this.folded = folded;
+        this.refresh();
+    }
+    setSeparatesToolGroup(separatesToolGroup) {
+        this.separatesToolGroup = separatesToolGroup;
+        this.refresh();
+    }
+    refresh() {
+        this.setLines(this.folded && this.separatesToolGroup ? 1 : 0);
+    }
+}
+class MinimizableToolComponent extends ToolExecutionComponent {
+    minimized = false;
+    foldable = false;
+    /** Only tools whose renderCall is fold-aware (the crtr-owned definitions) may
+     *  fold; chat-view marks them at construction. */
+    setFoldable(foldable) {
+        this.foldable = foldable;
+    }
+    /** Flip the fold: expose it on the definitions' shared render-state bag, then
+     *  re-run `updateDisplay()` (the same path pi's own `setExpanded` uses) so the
+     *  fold-aware renderCall rebuilds the call component in its new form. NOT
+     *  `invalidate()` — pi's `ToolExecutionComponent.invalidate` recurses through
+     *  its renderer children and killed the viewer process. */
+    setMinimized(minimized) {
+        if (!this.foldable || this.minimized === minimized)
+            return;
+        this.minimized = minimized;
+        const internals = this;
+        internals.rendererState[FOLDED_STATE_KEY] = minimized;
+        internals.updateDisplay();
+    }
+    render(width) {
+        if (!this.minimized)
+            return super.render(width);
+        const call = this
+            .callRendererComponent;
+        if (!call)
+            return super.render(width);
+        // trimEnd drops right-hand padding, which only existed to carry the
+        // background band these lines no longer paint.
+        return call.render(width)
+            .filter((line) => line.replace(ANSI_RE, '').trim().length > 0)
+            .map((line) => stripBackground(line).trimEnd());
+    }
+}
 const defaultErrorStyle = (s) => `\x1b[31m${s}\x1b[39m`;
 /** Keep settled conversation history out of picker/editor render hot paths. The
  *  root TUI still compares the cached lines, but it no longer re-renders every
@@ -146,7 +261,12 @@ export class ChatView {
     imageWidthCells;
     hideThinking;
     hiddenThinkingLabel;
+    /** Ctrl+O: pi's two-state tool-output expansion. */
     toolOutputExpanded;
+    /** The view setting (Alt+C → w → f): fold every SETTLED tool call to its single
+     *  call line. Independent of `toolOutputExpanded` — it survives an expand/collapse
+     *  and only ever applies to tool calls that are done. */
+    foldSettledTools = readFoldFinishedTools();
     onFooterEvent;
     /** Theme-derived colorizers for the activity/status area. */
     spinnerStyle;
@@ -157,6 +277,12 @@ export class ChatView {
     /** The assistant message component currently being streamed (between
      *  message_start and message_end for an assistant turn). */
     streamingComponent;
+    /** The separator immediately after the live assistant component. It becomes
+     *  visible when that response has visible prose or thinking and folded tools. */
+    streamingToolSeparator;
+    /** Content classes for each separator, so Ctrl+T can add/remove thinking gaps
+     * without rebuilding the transcript. */
+    foldedToolSeparatorContents = new Map();
     /** Tool-call id → its execution component, for the duration of the call. */
     pendingTools = new Map();
     /** The `!` bash component currently streaming (between bash_start and bash_end). */
@@ -286,15 +412,20 @@ export class ChatView {
                     snapshot.state.isStreaming &&
                     message.stopReason !== 'aborted' &&
                     message.stopReason !== 'error';
+                let separator;
                 if (isStreamingTail) {
-                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel);
+                    this.streamingComponent = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel);
                     this.append(this.streamingComponent);
                     this.streamingComponent.updateContent(styleAttachMessageMarkdown(message));
+                    separator = this.streamingToolSeparator = this.appendFoldedToolSeparator();
                 }
                 else {
-                    this.addMessageToChat(message);
+                    separator = this.appendAssistantMessage(message);
                 }
-                for (const content of this.assistantToolCalls(message)) {
+                const toolCalls = this.assistantToolCalls(message);
+                if (separator)
+                    this.setAssistantSeparatorContent(separator, message);
+                for (const content of toolCalls) {
                     this.pushTranscriptValue(content.arguments);
                     const component = this.makeToolComponent(content.name, content.id, content.arguments);
                     this.append(component);
@@ -327,6 +458,10 @@ export class ChatView {
         for (const [id, component] of renderedPendingTools) {
             this.pendingTools.set(id, component);
         }
+        // A rebuild constructs fresh components, which are born unfolded; re-apply the
+        // setting so a reconnect/welcome does not silently unfold the transcript.
+        if (this.foldSettledTools)
+            this.applyToolDisplay();
         // If we attached mid-turn, the `agent_start` that spins up the working loader
         // already fired before we connected — restore it from the snapshot's streaming
         // state so an actively-working node shows the spinner right away.
@@ -403,6 +538,7 @@ export class ChatView {
             this.historyContainer.removeChild(this.streamingComponent);
             this.streamingComponent = undefined;
         }
+        this.streamingToolSeparator = undefined;
         this.pendingTools.clear();
         this.setActivity(undefined);
         this.settleBashComponent();
@@ -424,13 +560,32 @@ export class ChatView {
      *  are frozen as text, so they are unaffected by design. */
     toggleToolsExpanded() {
         this.toolOutputExpanded = !this.toolOutputExpanded;
+        this.applyToolDisplay();
+        return this.toolOutputExpanded;
+    }
+    /** The `fold finished tool calls` view setting (`/fold-tools`, Alt+C → w → f).
+     *  Returns the new state so the caller can surface a notice. */
+    toggleFoldSettledTools() {
+        this.foldSettledTools = !this.foldSettledTools;
+        persistFoldFinishedTools(this.foldSettledTools);
+        this.applyToolDisplay();
+        return this.foldSettledTools;
+    }
+    /** Push both display settings onto every rendered component. A tool call still in
+     *  `pendingTools` is in flight, so it is never folded — you keep watching live
+     *  output, and it folds on its own once `tool_execution_end` settles it. */
+    applyToolDisplay() {
+        const inFlight = new Set(this.pendingTools.values());
+        this.updateFoldedToolSeparators(inFlight);
         for (const child of this.historyContainer.children) {
+            if (child instanceof MinimizableToolComponent) {
+                child.setMinimized(this.foldSettledTools && !inFlight.has(child));
+            }
             if (isExpandable(child))
                 child.setExpanded(this.toolOutputExpanded);
         }
         this.historyContainer.markDirty();
         this.tui.requestRender();
-        return this.toolOutputExpanded;
     }
     /** Ctrl+T / app.thinking.toggle — flip thinking-block visibility and apply it to
      *  every assistant message (the in-flight streaming bubble is itself a child of
@@ -441,6 +596,9 @@ export class ChatView {
             if (child instanceof AssistantMessageComponent)
                 child.setHideThinkingBlock(this.hideThinking);
         }
+        for (const [separator, content] of this.foldedToolSeparatorContents) {
+            separator.setSeparatesToolGroup(content.hasText || (!this.hideThinking && content.hasThinking));
+        }
         this.historyContainer.markDirty();
         this.tui.requestRender();
         return this.hideThinking;
@@ -485,9 +643,11 @@ export class ChatView {
                     this.addMessageToChat(event.message);
                 }
                 else if (event.message.role === 'assistant') {
-                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel);
+                    this.streamingComponent = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel);
                     this.append(this.streamingComponent);
                     this.streamingComponent.updateContent(styleAttachMessageMarkdown(event.message));
+                    this.streamingToolSeparator = this.appendFoldedToolSeparator();
+                    this.setAssistantSeparatorContent(this.streamingToolSeparator, event.message);
                 }
                 break;
             }
@@ -501,7 +661,10 @@ export class ChatView {
                     const updated = styleAttachMessageMarkdown(transformMessageDiagrams(event.message, this.renderWidth()));
                     this.streamingComponent.updateContent(updated);
                     this.historyContainer.markDirty(this.streamingComponent);
-                    for (const content of this.assistantToolCalls(event.message)) {
+                    const toolCalls = this.assistantToolCalls(event.message);
+                    if (this.streamingToolSeparator)
+                        this.setAssistantSeparatorContent(this.streamingToolSeparator, event.message);
+                    for (const content of toolCalls) {
                         this.pushTranscriptValue(content.arguments);
                         const existing = this.pendingTools.get(content.id);
                         if (existing) {
@@ -564,6 +727,7 @@ export class ChatView {
                     }
                     this.historyContainer.markDirty(this.streamingComponent);
                     this.streamingComponent = undefined;
+                    this.streamingToolSeparator = undefined;
                 }
                 break;
             }
@@ -594,6 +758,10 @@ export class ChatView {
                 if (component) {
                     component.updateResult({ ...event.result, isError: event.isError });
                     this.pendingTools.delete(event.toolCallId);
+                    // Settled → it now obeys the fold setting it was exempt from while live.
+                    if (this.foldSettledTools)
+                        component.setMinimized(true);
+                    this.updateFoldedToolSeparators();
                     this.historyContainer.markDirty(component);
                 }
                 break;
@@ -787,8 +955,7 @@ export class ChatView {
                 break;
             }
             case 'assistant': {
-                // Settled history message — render its supported diagram fences inline too.
-                this.append(new AssistantMessageComponent(styleAttachMessageMarkdown(transformMessageDiagrams(message, this.renderWidth())), this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel));
+                this.appendAssistantMessage(message);
                 break;
             }
             // toolResult is rendered inline with its tool call (handled in applySnapshot).
@@ -799,15 +966,67 @@ export class ChatView {
     // -------------------------------------------------------------------------
     // Helpers
     // -------------------------------------------------------------------------
+    /** Render an assistant reply plus its initially-hidden boundary separator. */
+    appendAssistantMessage(message) {
+        this.append(new ViewerAssistantMessageComponent(styleAttachMessageMarkdown(transformMessageDiagrams(message, this.renderWidth())), this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel));
+        const separator = this.appendFoldedToolSeparator();
+        this.setAssistantSeparatorContent(separator, message);
+        return separator;
+    }
+    /** Add a separator in transcript order now; it renders only after a following
+     * tool settles in the folded view. */
+    appendFoldedToolSeparator() {
+        const separator = new FoldedToolSeparator();
+        this.append(separator);
+        return separator;
+    }
+    /** Make each separator visible only if its immediately-following tool call is
+     * actually folded; in-flight calls remain flush with their live output. */
+    updateFoldedToolSeparators(inFlight = new Set(this.pendingTools.values())) {
+        const children = this.historyContainer.children;
+        for (let i = 0; i < children.length; i++) {
+            const separator = children[i];
+            if (!(separator instanceof FoldedToolSeparator))
+                continue;
+            const followingTool = children[i + 1];
+            separator.setFolded(this.foldSettledTools &&
+                followingTool instanceof MinimizableToolComponent &&
+                !inFlight.has(followingTool));
+            this.historyContainer.markDirty(separator);
+        }
+    }
+    /** Track whether an assistant response contains prose or thinking, then make
+     * its separator eligible only for content the current Ctrl+T setting shows. */
+    setAssistantSeparatorContent(separator, message) {
+        const content = message.content;
+        const parts = Array.isArray(content) ? content : [];
+        const hasText = parts.some((part) => typeof part === 'object' &&
+            part !== null &&
+            part.type === 'text' &&
+            typeof part.text === 'string' &&
+            part.text.trim() !== '');
+        const hasThinking = parts.some((part) => typeof part === 'object' &&
+            part !== null &&
+            part.type === 'thinking' &&
+            typeof part.thinking === 'string' &&
+            part.thinking.trim() !== '');
+        this.foldedToolSeparatorContents.set(separator, { hasText, hasThinking });
+        separator.setSeparatesToolGroup(hasText || (!this.hideThinking && hasThinking));
+    }
     /** Tool component with native viewer renderers for crouter-owned tool output. */
     makeToolComponent(name, id, args) {
         const toolDefinition = name === 'bash'
-            ? createCrtrBashToolDefinition(args)
+            ? (createCrtrBashToolDefinition(args) ?? createCrtrPlainBashToolDefinition(this.cwd))
             : name === 'edit'
                 ? createCrtrEditToolDefinition(this.cwd)
-                : undefined;
+                : name === 'read'
+                    ? createCrtrReadToolDefinition(this.cwd)
+                    : name === 'write'
+                        ? createCrtrWriteToolDefinition(this.cwd)
+                        : undefined;
         let component;
-        component = new ToolExecutionComponent(name, id, args, { showImages: this.showImages, imageWidthCells: this.imageWidthCells }, toolDefinition, this.componentTui(() => component), this.cwd);
+        component = new MinimizableToolComponent(name, id, args, { showImages: this.showImages, imageWidthCells: this.imageWidthCells }, toolDefinition, this.componentTui(() => component), this.cwd);
+        component.setFoldable(toolDefinition !== undefined);
         component.setExpanded(this.toolOutputExpanded);
         return component;
     }
@@ -832,6 +1051,8 @@ export class ChatView {
         this.setActivity(undefined);
         this.settleBashComponent();
         this.streamingComponent = undefined;
+        this.streamingToolSeparator = undefined;
+        this.foldedToolSeparatorContents.clear();
         this.pendingTools.clear();
         this.lastAssistantText = undefined;
         this.transcriptTexts.length = 0;

package/dist/clients/attach/render/context-message.js

@@ -8,7 +8,7 @@
 // `renderContextMessage`) and reuses the same collapsed/expand shape for
 // situational context so both render consistently: collapsed → one dim line;
 // expanded (Ctrl+O) → label + full wrapped body. It implements `setExpanded`,
-// so the Ctrl+O tool-output toggle (ChatView.toggleToolsExpanded →
+// so the Ctrl+O tool-display cycle (ChatView.cycleToolDisplay →
 // isExpandable) folds it alongside tool output.
 import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
 /** Default label/hint for the `crtr-context` bearings block. Mirrors the

package/dist/clients/attach/render/edit-diff.js

@@ -14,6 +14,8 @@
 // ANSI re-parsing of pi's output is ever needed.
 import { createEditToolDefinition } from '@earendil-works/pi-coding-agent';
 import { Container, Spacer, Text } from '@earendil-works/pi-tui';
+import { TOOL_ICON } from '../../../core/preview-registry.js';
+import { foldedFileCallLine, isFoldedContext, prefixToolText } from './tool-calls.js';
 const FALLBACK_ADDED = { r: 181, g: 189, b: 104 }; // pi dark green
 const FALLBACK_REMOVED = { r: 204, g: 102, b: 102 }; // pi dark red
 const FALLBACK_CARD_BG = { r: 40, g: 50, b: 40 }; // pi dark toolSuccessBg
@@ -219,6 +221,12 @@ function restyleEditCallBox(box, theme) {
     // (mirrors pi's getEditHeaderBg), so tinted lines restore to that color.
     box.addChild(buildDiffBody(preview.diff, theme, theme.getBgAnsi('toolSuccessBg')));
 }
+/** Put the edit glyph in front of pi's `edit <path>` header line. The header is
+ *  the first child of the card and the ONLY line a folded edit keeps, so this is
+ *  what the human sees when the diff is collapsed away. */
+function prefixEditHeaderIcon(box, theme) {
+    prefixToolText(box.children[0], `${theme.fg('accent', TOOL_ICON.edit)} `);
+}
 /**
  * Attach-viewer tool definition for `edit`: pi's builtin definition drives
  * all state (preview computation, header, success/error bg), then the diff
@@ -233,10 +241,20 @@ export function createCrtrEditToolDefinition(cwd) {
         parameters: {},
         renderShell: 'self',
         renderCall(args, theme, context) {
+            // Folded: the renderer owns its folded form — one line, `<icon> edit <path>`,
+            // no diff. The real edit card persists in context.state.callComponent (the
+            // builtin prefers it over a non-Box lastComponent), so unfolding restores it.
+            if (isFoldedContext(context)) {
+                const a = args;
+                const raw = typeof a?.file_path === 'string' ? a.file_path : typeof a?.path === 'string' ? a.path : '';
+                return new Text(foldedFileCallLine('edit', raw, theme, context.cwd ?? cwd), 0, 0);
+            }
             const component = builtin.renderCall(args, theme, context);
             const callBox = context.state.callComponent;
-            if (callBox)
+            if (callBox) {
                 restyleEditCallBox(callBox, theme);
+                prefixEditHeaderIcon(callBox, theme);
+            }
             return component;
         },
         renderResult(result, options, theme, context) {
@@ -246,6 +264,7 @@ export function createCrtrEditToolDefinition(cwd) {
                 // builtin renderResult re-ran buildEditCallComponent (pi styling) —
                 // restyle the refreshed body.
                 restyleEditCallBox(callBox, theme);
+                prefixEditHeaderIcon(callBox, theme);
                 return component;
             }
             // Fallback path (no call box state, e.g. a bare result replay): render

package/dist/clients/attach/render/glyph-codepoints.d.ts

@@ -0,0 +1,3 @@
+/** Replace every private-use `U+XXXX` reference in `text` with the character it
+ *  names. Non-PUA references and malformed digits pass through untouched. */
+export declare function expandGlyphCodepoints(text: string): string;

package/dist/clients/attach/render/glyph-codepoints.js

@@ -0,0 +1,42 @@
+// glyph-codepoints.ts — render `U+XXXX` as the glyph it names, for the private-
+// use areas only.
+//
+// Nerd Font icons live in the Unicode private-use areas, and PUA codepoints are
+// effectively absent from model tokenizer vocabularies: an agent cannot type one
+// into its reply (the character never becomes tokens, so it is simply missing
+// from the message) and cannot even perceive one in a prompt. Agents CAN name a
+// codepoint accurately, so the viewer closes the gap at the other end — an agent
+// writes `U+F188` and the reader sees the bug glyph.
+//
+// Scoped to the private-use areas on purpose. Those are exactly the codepoints
+// an agent cannot write literally, so expanding them adds an ability rather than
+// taking one away; every other codepoint reference (`U+0041`, `U+241C`) is left
+// as text, because a message discussing Unicode wants the hex on screen and
+// could have contained the character itself if it meant the character.
+/** `U+` followed by 4-6 hex digits, not glued to a surrounding word. Case
+ *  insensitive on both the prefix and the digits. */
+const CODEPOINT = /\bU\+([0-9A-Fa-f]{4,6})\b/g;
+/** Private-use areas: the BMP block plus planes 15 and 16. Nerd Fonts use the
+ *  BMP block and, since v3, the supplementary block above U+F0000. */
+function isPrivateUse(cp) {
+    return ((cp >= 0xe000 && cp <= 0xf8ff) ||
+        (cp >= 0xf0000 && cp <= 0xffffd) ||
+        (cp >= 0x100000 && cp <= 0x10fffd));
+}
+/** Replace every private-use `U+XXXX` reference in `text` with the character it
+ *  names. Non-PUA references and malformed digits pass through untouched. */
+export function expandGlyphCodepoints(text) {
+    if (!text.includes('U+') && !text.includes('u+'))
+        return text;
+    return text.replace(CODEPOINT, (match, hex) => {
+        const cp = Number.parseInt(hex, 16);
+        if (!isPrivateUse(cp))
+            return match;
+        try {
+            return String.fromCodePoint(cp);
+        }
+        catch {
+            return match;
+        }
+    });
+}

package/dist/clients/attach/render/markdown-headings.js

@@ -7,6 +7,12 @@
 // owns parsing, wrapping, inline formatting, and H1/H2's established styling.
 // This stays attach-local — persisted messages and copied text remain ordinary
 // Markdown without terminal escape sequences.
+//
+// The same per-block copy carries the viewer's other source-text transform:
+// private-use `U+XXXX` references become their glyphs (see glyph-codepoints.ts),
+// so an agent that cannot type a Nerd Font character can still put one on
+// screen.
+import { expandGlyphCodepoints } from './glyph-codepoints.js';
 const ATX_HEADING = /^(\s{0,3})(#{3,6})(?:[ \t]+|$)(.*?)([ \t]+#+[ \t]*)?$/;
 const FENCE_OPEN = /^\s{0,3}(`{3,}|~{3,})/;
 // A constant-lightness ramp from warm yellow to cool blue, with saturation
@@ -49,6 +55,11 @@ export function styleAttachMarkdownHeadings(markdown) {
         return `${indent}${headingColor(hashes.length)(body)}`;
     }).join('\n');
 }
+/** Every source-text transform the viewer applies to a Markdown-bearing block,
+ *  in one place: heading hierarchy, then glyph expansion. */
+function renderableText(markdown) {
+    return expandGlyphCodepoints(styleAttachMarkdownHeadings(markdown));
+}
 /** Copy a pi message for terminal rendering and decorate only Markdown-bearing
  * text/thinking blocks. The broker's source event is never mutated. */
 export function styleAttachMessageMarkdown(message) {
@@ -56,7 +67,7 @@ export function styleAttachMessageMarkdown(message) {
         return message;
     const candidate = message;
     if (typeof candidate.content === 'string') {
-        return { ...candidate, content: styleAttachMarkdownHeadings(candidate.content) };
+        return { ...candidate, content: renderableText(candidate.content) };
     }
     if (!Array.isArray(candidate.content))
         return message;
@@ -67,10 +78,10 @@ export function styleAttachMessageMarkdown(message) {
                 return part;
             const block = part;
             if (block.type === 'text' && typeof block.text === 'string') {
-                return { ...block, text: styleAttachMarkdownHeadings(block.text) };
+                return { ...block, text: renderableText(block.text) };
             }
             if (block.type === 'thinking' && typeof block.thinking === 'string') {
-                return { ...block, thinking: styleAttachMarkdownHeadings(block.thinking) };
+                return { ...block, thinking: renderableText(block.thinking) };
             }
             return part;
         }),
@@ -78,5 +89,5 @@ export function styleAttachMessageMarkdown(message) {
 }
 /** Copy an expanded pi summary without changing its persisted source. */
 export function styleAttachSummaryMarkdown(message) {
-    return { ...message, summary: styleAttachMarkdownHeadings(message.summary) };
+    return { ...message, summary: renderableText(message.summary) };
 }

package/dist/clients/attach/render/tool-calls.d.ts

@@ -0,0 +1,32 @@
+type Theme = {
+    fg: (name: string, text: string) => string;
+    bold: (text: string) => string;
+};
+/** Key in a tool's shared render-state bag (`context.state`) carrying the
+ *  viewer's fold. `MinimizableToolComponent` sets it; the fold-aware renderCalls
+ *  below read it and emit ONLY their one-line header while it is true, which is
+ *  what makes a folded card exactly `<icon> <tool> <path>` with no body — the
+ *  renderer owns its folded form, no post-hoc slicing of rendered rows. */
+export declare const FOLDED_STATE_KEY = "crtrFolded";
+export declare function isFoldedContext(context: {
+    state?: object;
+}): boolean;
+/** The one-line folded form of a file tool's call: `<icon> <label> <path>`. */
+export declare function foldedFileCallLine(tool: 'read' | 'write' | 'edit', rawPath: string, theme: Theme, cwd: string): string;
+/** Prefix a pi-built `Text` in place (its `text` field is TS-private but a plain
+ *  runtime property). Used where the header line is baked into the same string as
+ *  a body we want to keep verbatim — write's syntax-highlighted content preview,
+ *  edit's header inside its own card. Silently no-ops if pi's Text ever stops
+ *  looking like this, so the worst case is a missing glyph, never a crash. */
+export declare function prefixToolText(component: unknown, prefix: string): void;
+/** Attach-viewer `read`: an icon + the path (plus any `:offset-limit` range).
+ *  The call is a single line by construction, so a folded read shows exactly
+ *  what it read and nothing else. */
+export declare function createCrtrReadToolDefinition(cwd: string): unknown;
+/** Attach-viewer `write`: pi's builtin call renderer (it owns the
+ *  syntax-highlighted content preview and its expand hint) with the icon
+ *  prefixed onto its header line. Folded, only that header survives. */
+export declare function createCrtrWriteToolDefinition(cwd: string): unknown;
+/** Attach-viewer `bash` for anything that is not a `crtr` invocation. */
+export declare function createCrtrPlainBashToolDefinition(cwd: string): unknown;
+export {};