@north-light/crouter 0.3.163 → 0.3.165

package/dist/clients/attach/render/condensed-history.js

@@ -0,0 +1,60 @@
+// condensed-history.ts — lightweight rendering of a node's OLD cycles.
+//
+// A node that has yielded several times carries every prior cycle in its welcome
+// snapshot (cycleAwareMessages, session-cycles.ts). Cycles older than the trailing
+// `live_cycles` (config, default 2) are condensed to cycle dividers plus whichever
+// messages `condensed_history` (config, default `none`) admits. Tool calls and
+// results are excluded; across six measured sessions they accounted for 62.9% of
+// rendered lines and 69% of transcript build time.
+//
+// Retained messages stay as components inside one nested container. Settled lines
+// are cached at a stable pane width, while a width change rerenders the nested
+// content so old prose wraps with the rest of the transcript.
+//
+// The full detail of a condensed cycle remains in the node's session file, and
+// `/tree` navigates the real branches.
+import { CRTR_CYCLE_DIVIDER_CUSTOM_TYPE } from '../../../core/runtime/session-cycles.js';
+/** Roles admitted by each `condensed_history` mode. `toolResult`,
+ *  `bashExecution`, and every non-divider `custom` message (crtr output,
+ *  injected context blocks) are never kept, nor are the tool-call components an
+ *  assistant message would otherwise spawn — only its prose. The cycle dividers
+ *  survive every mode, so `none` leaves the seams and nothing else. */
+const ROLES_BY_MODE = {
+    none: new Set(),
+    user: new Set(['user']),
+    agent: new Set(['assistant', 'compactionSummary', 'branchSummary']),
+    both: new Set(['user', 'assistant', 'compactionSummary', 'branchSummary']),
+};
+export function isCycleDivider(message) {
+    return message.role === 'custom' && message.customType === CRTR_CYCLE_DIVIDER_CUSTOM_TYPE;
+}
+/** Does this message survive into the condensed region? */
+export function keepWhenCondensed(message, mode) {
+    if (isCycleDivider(message))
+        return true;
+    return (ROLES_BY_MODE[mode] ?? ROLES_BY_MODE.none).has(message.role ?? '');
+}
+/**
+ * Index into `messages` at which the LIVE (fully rendered) region begins.
+ *
+ * The snapshot is `[cycle 0][divider][cycle 1][divider]…[current cycle]`, so a
+ * transcript with D dividers holds D+1 cycles. Keeping the trailing
+ * `liveCycles` of them means everything up to and including divider
+ * `D - liveCycles` is condensed. Returns 0 — condense nothing — when the node
+ * has not yielded often enough to have older cycles, so a fresh or
+ * single-yield node renders exactly as it always did.
+ */
+export function liveRegionStart(messages, liveCycles) {
+    const keep = Math.max(1, Math.floor(liveCycles));
+    const dividers = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (isCycleDivider(messages[i]))
+            dividers.push(i);
+    }
+    const cycles = dividers.length + 1;
+    if (cycles <= keep)
+        return 0;
+    // The last divider that closes a condensed cycle; the live region opens just
+    // after it (the divider itself stays in the condensed region as the seam).
+    return dividers[cycles - keep - 1] + 1;
+}

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

@@ -1,18 +1,13 @@
-// render/context-message.ts — the viewer's foldable renderer for hidden-context custom
-// messages: the `<crtr-context>` bearings block (customType `crtr-context`) and
-// the ambient `<situational-context>` update (customType
-// `crtr-situational-context`). Both are broker-injected (canvas-context-intro,
-// canvas-inbox-watcher), so the VIEWER has no message renderer for either and
-// would otherwise show the full block always. This reimplements the bearings
-// renderer natively (src/pi-extensions/canvas-context-intro.ts:
-// `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-display cycle (ChatView.cycleToolDisplay →
-// isExpandable) folds it alongside tool output.
+// render/context-message.ts — the terminal viewer's foldable renderer for
+// crouter-generated context. Session bearings, situational updates, fresh-revive
+// kickoffs, context-size nudges, and node inbox digests retain their full model-visible body and
+// runtime role, while this display-only component presents them consistently:
+// collapsed → one dim line; expanded (Ctrl+O) → label + full wrapped body. It
+// implements `setExpanded`, so the global tool-display cycle folds these blocks
+// alongside tool output. Classification lives in shared/generated-context.ts;
+// this component only renders the presentation it is handed.
 import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
-/** Default label/hint for the `crtr-context` bearings block. Mirrors the
- *  extension's customType stamp. */
+/** Default label/hint for the `crtr-context` bearings block. */
 const LABEL = 'crtr context';
 const COLLAPSED_HINT = ' orienting bearings — ctrl+o to expand';
 /** Char-based wrap that never emits an over-width line (pi-tui hard-crashes on

package/dist/clients/attach/render/crtr-output.d.ts

@@ -1,4 +1,5 @@
 import { Box } from '@earendil-works/pi-tui';
+import { FoldedToolCallController } from './tool-calls.js';
 type Theme = {
     fg: (name: string, text: string) => string;
     bg: (name: string, text: string) => string;
@@ -44,5 +45,5 @@ export declare class CrtrOutputMessageComponent extends Box {
     constructor(content: string, expanded: boolean, theme: Theme);
     setExpanded(expanded: boolean): void;
 }
-export declare function createCrtrBashToolDefinition(args: unknown): unknown | undefined;
+export declare function createCrtrBashToolDefinition(args: unknown, fold?: FoldedToolCallController): unknown | undefined;
 export {};

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

@@ -1,7 +1,7 @@
 import { truncateToVisualLines } from '@earendil-works/pi-coding-agent';
 import { Box, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
 import { HELP_ICON, iconForPath, suppressOutputForPath, summarizePath, } from '../../../core/preview-registry.js';
-import { isFoldedContext } from './tool-calls.js';
+import { FoldedToolCallController } from './tool-calls.js';
 // Hard cap on a collapsed crtr card's total rendered lines (rule 12,
 // inline-ui-placement): help synthesis or a normal truncated result never
 // shows more than this many lines total, blank spacer + status + body +
@@ -688,7 +688,7 @@ export class CrtrOutputMessageComponent extends Box {
         this.addChild(this.body);
     }
 }
-export function createCrtrBashToolDefinition(args) {
+export function createCrtrBashToolDefinition(args, fold = new FoldedToolCallController()) {
     const command = commandFromArgs(args);
     if (!isCrtrBashCommand(command))
         return undefined;
@@ -712,9 +712,9 @@ export function createCrtrBashToolDefinition(args) {
             const prefix = isHelp ? `${icon} crtr help` : `${icon} crtr`;
             const styledPrefix = theme.fg('accent', theme.bold(prefix));
             const styledPath = path
-                ? ` ${isFoldedContext(context) ? styleFoldedCrtrTokens(pathTokens, theme) : theme.fg('toolTitle', theme.bold(path))}`
+                ? ` ${fold.folded ? styleFoldedCrtrTokens(pathTokens, theme) : theme.fg('toolTitle', theme.bold(path))}`
                 : '';
-            return new Text(`${styledPrefix}${styledPath}`, 0, 0);
+            return fold.capture(new Text(`${styledPrefix}${styledPath}`, 0, 0));
         },
         renderResult(result, options, theme, context) {
             return new CrtrResultComponent(resultText(result), options, context, theme, command);

package/dist/clients/attach/render/edit-diff.d.ts

@@ -1,6 +1,21 @@
-/**
- * Attach-viewer tool definition for `edit`: pi's builtin definition drives
- * all state (preview computation, header, success/error bg), then the diff
- * body is re-skinned Claude-Code-style after every render pass.
- */
-export declare function createCrtrEditToolDefinition(cwd: string): unknown;
+import { FoldedToolCallController } from './tool-calls.js';
+type ToolResultLike = {
+    content?: Array<{
+        type?: unknown;
+        text?: unknown;
+    }>;
+    details?: {
+        diff?: unknown;
+    };
+    isError?: boolean;
+};
+export type EditResultObserver = (result: ToolResultLike, isPartial: boolean) => void;
+export type CrtrEditToolView = {
+    definition: unknown;
+    observeResult: EditResultObserver;
+};
+/** Crouter owns edit presentation while the imported tool owns execution. The
+ *  card has two explicit phases: streamed argument diff, then executed result
+ *  diff. No asynchronous preview can write after settlement. */
+export declare function createCrtrEditToolDefinition(cwd: string, fold?: FoldedToolCallController): CrtrEditToolView;
+export {};

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

@@ -1,21 +1,13 @@
-// render/edit-diff.ts — Claude-Code-style diff rendering for the attach viewer.
+// render/edit-diff.ts — crouter-owned edit presentation for the attach viewer.
 //
-// pi's builtin edit renderer (core/tools/edit.js → renderDiff) paints diff
-// lines with colored FOREGROUND text plus inverse-video on changed tokens.
-// This module re-skins that body the way Claude Code renders diffs: every
-// added line gets a full-width tinted green BACKGROUND, every removed line a
-// full-width tinted red background, with the changed span inside a 1↔1 line
-// modification emphasized in a brighter tint of the same color.
-//
-// We deliberately keep pi's builtin edit definition as the engine — it owns
-// the async preview computation (computeEditsDiff keyed off ctx.state) and
-// the header/status-bg lifecycle — and only swap the rendered diff body.
-// The raw diff string lives on the call component (`preview.diff`), so no
-// 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';
+// The card renders replacement arguments synchronously while they stream, then
+// switches to the executed tool result's full-file diff when the tool settles.
+// Added and removed rows receive full-width tinted backgrounds, with the changed
+// span inside a 1↔1 line modification emphasized in a brighter tint. The imported
+// pi package remains responsible for edit execution, not viewer lifecycle.
+import { generateDiffString } from '@earendil-works/pi-coding-agent';
+import { Box, Container, Spacer, Text } from '@earendil-works/pi-tui';
+import { FoldedToolCallController, foldedFileCallLine } 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
@@ -116,6 +108,30 @@ function countDiffLines(diff) {
     }
     return { added, removed };
 }
+/** Extract every complete replacement pair currently present in the streamed
+ *  arguments. A pair becomes previewable as soon as both strings exist. */
+function editPairs(args) {
+    const value = args;
+    if (Array.isArray(value?.edits)) {
+        return value.edits.flatMap((edit) => {
+            const pair = edit;
+            return typeof pair?.oldText === 'string' && typeof pair?.newText === 'string'
+                ? [{ oldText: pair.oldText, newText: pair.newText }]
+                : [];
+        });
+    }
+    return typeof value?.oldText === 'string' && typeof value?.newText === 'string'
+        ? [{ oldText: value.oldText, newText: value.newText }]
+        : [];
+}
+/** The pre-execution preview is deliberately replacement-local: it can update
+ *  synchronously as arguments stream and never races filesystem mutation. */
+function streamedArgumentDiff(args) {
+    const diffs = editPairs(args)
+        .map(({ oldText, newText }) => generateDiffString(oldText, newText).diff)
+        .filter((diff) => diff.trim().length > 0);
+    return diffs.length > 0 ? diffs.join('\n') : undefined;
+}
 function replaceTabs(text) {
     return text.replace(/\t/g, '   ');
 }
@@ -216,91 +232,74 @@ function buildDiffBody(diffText, theme, restoreBg) {
     }
     return container;
 }
-// ---------------------------------------------------------------------------
-// Tool definition wrapper
-// ---------------------------------------------------------------------------
-/** Replace the pi-rendered diff body inside the edit call Box (children:
- *  [header, Spacer, body]) with the full-background rendering. No-op when
- *  there is no successful preview (header-only or error states keep pi's
- *  rendering untouched). */
-function restyleEditCallBox(box, theme) {
-    const preview = box.preview;
-    if (!preview || 'error' in preview || box.children.length < 2)
-        return;
-    const header = box.children[0];
-    box.clear();
-    box.addChild(header);
-    box.addChild(new Spacer(1));
-    // With a successful preview the edit card bg is always toolSuccessBg
-    // (mirrors pi's getEditHeaderBg), so tinted lines restore to that color.
-    box.addChild(buildDiffBody(preview.diff, theme, theme.getBgAnsi('toolSuccessBg')));
+class EditCallComponent extends Box {
+    constructor() {
+        super(1, 1, (text) => text);
+    }
+    update(header, diff, state, theme) {
+        const background = state.settled
+            ? state.isError ? 'toolErrorBg' : 'toolSuccessBg'
+            : 'toolPendingBg';
+        this.setBgFn((text) => theme.bg(background, text));
+        this.clear();
+        this.addChild(new Text(header, 0, 0));
+        if (!diff)
+            return;
+        this.addChild(new Spacer(1));
+        this.addChild(buildDiffBody(diff, theme, theme.getBgAnsi(background)));
+    }
 }
-/** 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)} `);
+function editPath(args) {
+    const value = args;
+    return typeof value?.file_path === 'string' ? value.file_path : typeof value?.path === 'string' ? value.path : '';
 }
-/**
- * Attach-viewer tool definition for `edit`: pi's builtin definition drives
- * all state (preview computation, header, success/error bg), then the diff
- * body is re-skinned Claude-Code-style after every render pass.
- */
-export function createCrtrEditToolDefinition(cwd) {
-    const builtin = createEditToolDefinition(cwd);
-    return {
+function errorResultText(result) {
+    return (result.content ?? [])
+        .filter((part) => part.type === 'text' && typeof part.text === 'string')
+        .map((part) => part.text)
+        .join('\n');
+}
+/** Crouter owns edit presentation while the imported tool owns execution. The
+ *  card has two explicit phases: streamed argument diff, then executed result
+ *  diff. No asynchronous preview can write after settlement. */
+export function createCrtrEditToolDefinition(cwd, fold = new FoldedToolCallController()) {
+    const state = { settled: false, isError: false };
+    const call = new EditCallComponent();
+    const observeResult = (result, isPartial) => {
+        if (isPartial)
+            return;
+        state.settled = true;
+        state.isError = result.isError === true;
+        const resultDiff = result.details?.diff;
+        state.diff = !state.isError && typeof resultDiff === 'string' ? resultDiff : undefined;
+    };
+    const definition = {
         name: 'edit',
         label: 'edit',
-        description: 'Render edit diffs with full-line backgrounds in the attach viewer.',
+        description: 'Render streamed edit arguments and the executed full-file diff in the attach viewer.',
         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 : '';
-                const preview = context.state.callComponent?.preview;
-                const changes = context.isError
-                    ? undefined
-                    : context.state.settledChanges ?? (preview && !('error' in preview) ? countDiffLines(preview.diff) : undefined);
-                return new Text(foldedFileCallLine('edit', raw, theme, context.cwd ?? cwd, changes), 0, 0);
-            }
-            const component = builtin.renderCall(args, theme, context);
-            const callBox = context.state.callComponent;
-            if (callBox) {
-                restyleEditCallBox(callBox, theme);
-                prefixEditHeaderIcon(callBox, theme);
-            }
-            return component;
+            const diff = state.settled ? state.diff : streamedArgumentDiff(args);
+            const changes = state.settled && !state.isError && state.diff ? countDiffLines(state.diff) : undefined;
+            const header = foldedFileCallLine('edit', editPath(args), theme, context.cwd ?? cwd, changes);
+            if (fold.folded)
+                return fold.capture(new Text(header, 0, 0));
+            call.update(header, diff, state, theme);
+            return fold.capture(call);
         },
-        renderResult(result, options, theme, context) {
-            const resultDiff = result?.details?.diff;
-            if (!options?.isPartial) {
-                if (!context.isError && typeof resultDiff === 'string')
-                    context.state.settledChanges = countDiffLines(resultDiff);
-                else
-                    delete context.state.settledChanges;
-            }
-            const component = builtin.renderResult(result, options, theme, context);
-            const callBox = context.state.callComponent;
-            if (callBox) {
-                // builtin renderResult re-ran buildEditCallComponent (pi styling) —
-                // restyle the refreshed body.
-                restyleEditCallBox(callBox, theme);
-                prefixEditHeaderIcon(callBox, theme);
+        renderResult(result, _options, theme, context) {
+            const component = context.lastComponent instanceof Container ? context.lastComponent : new Container();
+            component.clear();
+            if (!context.isError)
                 return component;
-            }
-            // Fallback path (no call box state, e.g. a bare result replay): render
-            // the result diff standalone. No host Box here, so restore to default bg.
-            if (!context.isError && typeof resultDiff === 'string') {
-                const container = new Container();
-                container.addChild(new Spacer(1));
-                container.addChild(buildDiffBody(resultDiff, theme, '\x1b[49m'));
-                return container;
+            const output = errorResultText(result);
+            if (output) {
+                component.addChild(new Spacer(1));
+                component.addChild(new Text(theme.fg('error', output), 1, 0));
             }
             return component;
         },
     };
+    return { definition, observeResult };
 }

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

@@ -1,16 +1,18 @@
+import { type Component } from '@earendil-works/pi-tui';
 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;
+/** Per-tool fold state owned by the attach viewer. Tool definitions capture the
+ *  call component they render while folded, so the viewer never reaches into
+ *  `ToolExecutionComponent`'s private renderer fields to recover it. */
+export declare class FoldedToolCallController {
+    folded: boolean;
+    private component;
+    setFolded(folded: boolean): void;
+    capture<T extends Component>(component: T): T;
+    callComponent(): Component | undefined;
+}
 export type FileLineChanges = {
     added: number;
     removed: number;
@@ -18,20 +20,14 @@ export type FileLineChanges = {
 /** The one-line folded form of a file tool's call: `<icon> <label> <path>`,
  *  optionally followed by its green/red changed-line counts. */
 export declare function foldedFileCallLine(tool: 'read' | 'write' | 'edit', rawPath: string, theme: Theme, cwd: string, changes?: FileLineChanges): 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;
+export declare function createCrtrReadToolDefinition(cwd: string, fold?: FoldedToolCallController): 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;
+export declare function createCrtrWriteToolDefinition(cwd: string, fold?: FoldedToolCallController): unknown;
 /** Attach-viewer `bash` for anything that is not a `crtr` invocation. */
-export declare function createCrtrPlainBashToolDefinition(cwd: string): unknown;
+export declare function createCrtrPlainBashToolDefinition(cwd: string, fold?: FoldedToolCallController): unknown;
 export {};

package/dist/clients/attach/render/tool-calls.js

@@ -19,14 +19,22 @@ import { TOOL_ICON } from '../../../core/preview-registry.js';
 function str(value) {
     return typeof value === 'string' ? value : '';
 }
-/** 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 const FOLDED_STATE_KEY = 'crtrFolded';
-export function isFoldedContext(context) {
-    return context.state?.[FOLDED_STATE_KEY] === true;
+/** Per-tool fold state owned by the attach viewer. Tool definitions capture the
+ *  call component they render while folded, so the viewer never reaches into
+ *  `ToolExecutionComponent`'s private renderer fields to recover it. */
+export class FoldedToolCallController {
+    folded = false;
+    component;
+    setFolded(folded) {
+        this.folded = folded;
+    }
+    capture(component) {
+        this.component = component;
+        return component;
+    }
+    callComponent() {
+        return this.component;
+    }
 }
 /** Count file lines the way a diff does: a trailing newline terminates the last
  *  line instead of creating an extra empty one. */
@@ -36,7 +44,7 @@ function countFileLines(content) {
     const newlines = content.match(/\n/g)?.length ?? 0;
     return newlines + (content.endsWith('\n') ? 0 : 1);
 }
-/** The green/red line-count suffix shown after a folded write/edit path. */
+/** The green/red changed-line suffix shown after a folded edit path. */
 function lineChangesDisplay(changes, theme) {
     if (!changes)
         return '';
@@ -47,6 +55,12 @@ function lineChangesDisplay(changes, theme) {
         counts.push(theme.fg('toolDiffRemoved', `-${changes.removed}`));
     return counts.length > 0 ? ` ${counts.join(' ')}` : '';
 }
+/** A write has no before/after diff, so report its output size neutrally. */
+function lineCountDisplay(lines, theme) {
+    if (lines === undefined)
+        return '';
+    return ` ${theme.fg('muted', `${lines} ${lines === 1 ? 'line' : 'lines'}`)}`;
+}
 /** The one-line folded form of a file tool's call: `<icon> <label> <path>`,
  *  optionally followed by its green/red changed-line counts. */
 export function foldedFileCallLine(tool, rawPath, theme, cwd, changes) {
@@ -72,18 +86,29 @@ function pathDisplay(rawPath, theme, cwd) {
 function header(icon, label, theme) {
     return `${theme.fg('accent', icon)} ${theme.fg('toolTitle', theme.bold(label))}`;
 }
-/** 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 function prefixToolText(component, prefix) {
-    const text = component;
-    if (typeof text.text !== 'string' || typeof text.setText !== 'function')
-        return;
-    if (text.text.startsWith(prefix))
-        return;
-    text.setText(`${prefix}${text.text}`);
+/** Add an icon to a tool call without mutating the imported renderer's private
+ *  text storage. The imported component remains responsible for its own body. */
+class IconPrefixedToolCall {
+    child;
+    prefix;
+    constructor(child, prefix) {
+        this.child = child;
+        this.prefix = prefix;
+    }
+    update(child, prefix) {
+        this.child = child;
+        this.prefix = prefix;
+    }
+    invalidate() {
+        this.child.invalidate();
+    }
+    render(width) {
+        const prefixWidth = visibleWidth(this.prefix);
+        const lines = this.child.render(Math.max(1, width - prefixWidth));
+        if (lines.length === 0)
+            return [truncateToWidth(this.prefix.trimEnd(), width, '')];
+        return lines.map((line, index) => index === 0 ? truncateToWidth(`${this.prefix}${line}`, width, '') : line);
+    }
 }
 // ---------------------------------------------------------------------------
 // read
@@ -91,7 +116,7 @@ export function prefixToolText(component, prefix) {
 /** 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 function createCrtrReadToolDefinition(cwd) {
+export function createCrtrReadToolDefinition(cwd, fold = new FoldedToolCallController()) {
     const builtin = createReadToolDefinition(cwd);
     return {
         name: 'read',
@@ -110,7 +135,7 @@ export function createCrtrReadToolDefinition(cwd) {
             const line = `${header(TOOL_ICON.read, 'read', theme)} ${pathDisplay(raw, theme, context.cwd ?? cwd)}${range}`;
             const component = context.lastComponent ?? new Text('', 0, 0);
             component.setText(line);
-            return component;
+            return fold.capture(component);
         },
         renderResult(result, options, theme, context) {
             return builtin.renderResult(result, options, theme, context);
@@ -123,30 +148,30 @@ export function createCrtrReadToolDefinition(cwd) {
 /** 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 function createCrtrWriteToolDefinition(cwd) {
+export function createCrtrWriteToolDefinition(cwd, fold = new FoldedToolCallController()) {
     const builtin = createWriteToolDefinition(cwd);
+    let builtinCall;
+    let decoratedCall;
     return {
         name: 'write',
         label: 'write',
         description: 'Render write calls with a crtr icon header in the attach viewer.',
         parameters: {},
         renderCall(args, theme, context) {
-            if (isFoldedContext(context)) {
+            if (fold.folded) {
                 const a = args;
-                const changes = context.isError ? undefined : { added: countFileLines(str(a?.content)), removed: 0 };
-                const line = foldedFileCallLine('write', str(a?.file_path ?? a?.path), theme, context.cwd ?? cwd, changes);
-                // Reuse the previous component when it is Text-like (the builtin's is a
-                // Text subclass), so fold toggles don't churn component identity.
-                const last = context.lastComponent;
-                if (last && typeof last.setText === 'function') {
-                    last.setText(line);
-                    return last;
-                }
-                return new Text(line, 0, 0);
+                const lines = context.isError ? undefined : countFileLines(str(a?.content));
+                const line = foldedFileCallLine('write', str(a?.file_path ?? a?.path), theme, context.cwd ?? cwd) +
+                    lineCountDisplay(lines, theme);
+                return fold.capture(new Text(line, 0, 0));
             }
-            const component = builtin.renderCall(args, theme, context);
-            prefixToolText(component, `${theme.fg('accent', TOOL_ICON.write)} `);
-            return component;
+            builtinCall = builtin.renderCall(args, theme, { ...context, lastComponent: builtinCall });
+            const prefix = `${theme.fg('accent', TOOL_ICON.write)} `;
+            if (decoratedCall)
+                decoratedCall.update(builtinCall, prefix);
+            else
+                decoratedCall = new IconPrefixedToolCall(builtinCall, prefix);
+            return fold.capture(decoratedCall);
         },
         renderResult(result, options, theme, context) {
             return builtin.renderResult(result, options, theme, context);
@@ -242,7 +267,7 @@ class BashCallComponent {
     }
 }
 /** Attach-viewer `bash` for anything that is not a `crtr` invocation. */
-export function createCrtrPlainBashToolDefinition(cwd) {
+export function createCrtrPlainBashToolDefinition(cwd, fold = new FoldedToolCallController()) {
     const builtin = createBashToolDefinition(cwd);
     return {
         name: 'bash',
@@ -262,8 +287,8 @@ export function createCrtrPlainBashToolDefinition(cwd) {
             const component = context.lastComponent instanceof BashCallComponent ? context.lastComponent : new BashCallComponent();
             component.update(theme, str(a?.command), 
             // Folded wins over ctrl+o expansion: a folded bash is always its one-line form.
-            Boolean(context.expanded) && !isFoldedContext(context), typeof a?.timeout === 'number' ? a.timeout : undefined);
-            return component;
+            Boolean(context.expanded) && !fold.folded, typeof a?.timeout === 'number' ? a.timeout : undefined);
+            return fold.capture(component);
         },
         renderResult(result, options, theme, context) {
             return builtin.renderResult(result, options, theme, context);

package/dist/clients/attach/session/bindings.d.ts

@@ -1,9 +1,11 @@
-import { type BindingId, type BindingResolution } from '../../../core/keybindings/index.js';
-export type AttachBindingId = Extract<BindingId, `crtr.attach.${string}` | 'crtr.mode.cycle'>;
+import { type AttachBindingId, type BindingId, type BindingResolution } from '../../../core/keybindings/index.js';
+export type { AttachBindingId } from '../../../core/keybindings/index.js';
 export type AttachBindings = BindingResolution<BindingId>;
+export type AttachActions = Record<AttachBindingId, () => void>;
 export { inboxOpenHint } from '../../../core/keybindings/index.js';
 export declare function matchesAttachBinding(bindings: AttachBindings, id: AttachBindingId, data: string): boolean;
-export declare function dispatchAttachBinding(bindings: AttachBindings, data: string, actions: Record<AttachBindingId, () => void>): boolean;
+export declare function dispatchAttachAction(id: AttachBindingId, actions: AttachActions): void;
+export declare function dispatchAttachBinding(bindings: AttachBindings, data: string, actions: AttachActions): boolean;
 export declare function detachHint(bindings: AttachBindings): string | undefined;
 /** Re-resolve the user's binding catalog and republish it to every consumer:
  *  the graph overlay's own snapshot and (in tmux) the crouter-owned tmux