@north-light/crouter 0.3.162 → 0.3.164

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

@@ -1,6 +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 { 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 +
@@ -148,6 +149,32 @@ function commandFromArgs(args) {
     const command = args.command;
     return typeof command === 'string' ? command : '';
 }
+const CRTR_FLAG_TOKEN = /^-{1,2}[A-Za-z0-9]/;
+const CRTR_ATTACHED_FLAG_VALUE = /^(--?[A-Za-z0-9][^=]*)(=)(.*)$/;
+const CRTR_NUMBER_VALUE = /^-?(?:\d+(?:\.\d+)?|\.\d+)$/;
+/** Syntax-color flags and their values while leaving the command path and
+ * positional arguments in the folded row's existing bold title style. */
+function styleFoldedCrtrTokens(tokens, theme) {
+    let expectsValue = false;
+    return tokens.map((token) => {
+        const attached = CRTR_ATTACHED_FLAG_VALUE.exec(token);
+        if (attached !== null) {
+            expectsValue = false;
+            const valueColor = CRTR_NUMBER_VALUE.test(attached[3]) ? 'syntaxNumber' : 'syntaxString';
+            return `${theme.fg('syntaxKeyword', attached[1])}${theme.fg('syntaxOperator', attached[2])}${theme.fg(valueColor, attached[3])}`;
+        }
+        if (expectsValue && !CRTR_FLAG_TOKEN.test(token)) {
+            expectsValue = false;
+            return theme.fg(CRTR_NUMBER_VALUE.test(token) ? 'syntaxNumber' : 'syntaxString', token);
+        }
+        if (CRTR_FLAG_TOKEN.test(token)) {
+            expectsValue = true;
+            return theme.fg('syntaxKeyword', token);
+        }
+        expectsValue = false;
+        return theme.fg('toolTitle', theme.bold(token));
+    }).join(' ');
+}
 function resultText(result) {
     return (result.content ?? [])
         .filter((part) => part?.type === 'text' || typeof part?.text === 'string')
@@ -661,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;
@@ -670,7 +697,7 @@ export function createCrtrBashToolDefinition(args) {
         label: 'bash',
         description: 'Render crtr bash output with crtr-specific chrome in the attach viewer.',
         parameters: {},
-        renderCall(callArgs, theme) {
+        renderCall(callArgs, theme, context) {
             const currentCommand = commandFromArgs(callArgs) || command;
             // Semantic card, not a bash echo: the header names what the invocation
             // IS (help schema vs. a crtr command), and the body previews only the
@@ -684,8 +711,10 @@ export function createCrtrBashToolDefinition(args) {
             const icon = isHelp ? HELP_ICON : iconForPath(pathTokens);
             const prefix = isHelp ? `${icon} crtr help` : `${icon} crtr`;
             const styledPrefix = theme.fg('accent', theme.bold(prefix));
-            const styledPath = path ? ` ${theme.fg('toolTitle', theme.bold(path))}` : '';
-            return new Text(`${styledPrefix}${styledPath}`, 0, 0);
+            const styledPath = path
+                ? ` ${fold.folded ? styleFoldedCrtrTokens(pathTokens, theme) : theme.fg('toolTitle', theme.bold(path))}`
+                : '';
+            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
@@ -102,6 +94,44 @@ function parseDiffLine(line) {
         return null;
     return { prefix: match[1], lineNum: match[2], content: match[3] };
 }
+/** Count only changed rows in pi's display diff; context and ellipsis rows do
+ *  not contribute to the folded file summary. */
+function countDiffLines(diff) {
+    let added = 0;
+    let removed = 0;
+    for (const line of diff.split('\n')) {
+        const parsed = parseDiffLine(line);
+        if (parsed?.prefix === '+')
+            added++;
+        if (parsed?.prefix === '-')
+            removed++;
+    }
+    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, '   ');
 }
@@ -202,81 +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 : '';
-                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) {
-                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 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.
-            const resultDiff = result?.details?.diff;
-            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,32 +1,33 @@
+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;
-/** 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;
+/** 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;
+};
+/** 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;
 /** 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,18 +19,52 @@ 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;
-}
-/** The one-line folded form of a file tool's call: `<icon> <label> <path>`. */
-export function foldedFileCallLine(tool, rawPath, theme, cwd) {
-    return `${header(TOOL_ICON[tool], tool, theme)} ${pathDisplay(rawPath, theme, cwd)}`;
+/** 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. */
+function countFileLines(content) {
+    if (content.length === 0)
+        return 0;
+    const newlines = content.match(/\n/g)?.length ?? 0;
+    return newlines + (content.endsWith('\n') ? 0 : 1);
+}
+/** The green/red changed-line suffix shown after a folded edit path. */
+function lineChangesDisplay(changes, theme) {
+    if (!changes)
+        return '';
+    const counts = [];
+    if (changes.added > 0)
+        counts.push(theme.fg('toolDiffAdded', `+${changes.added}`));
+    if (changes.removed > 0)
+        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) {
+    return `${header(TOOL_ICON[tool], tool, theme)} ${pathDisplay(rawPath, theme, cwd)}${lineChangesDisplay(changes, theme)}`;
 }
 /** `~`-shorten an absolute path the way pi's renderToolPath does (its
  *  render-utils module is not exported from the package root). */
@@ -52,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
@@ -71,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',
@@ -90,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);
@@ -103,29 +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 line = foldedFileCallLine('write', str(a?.file_path ?? a?.path), theme, context.cwd ?? cwd);
-                // 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);
@@ -221,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',
@@ -241,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/connection.d.ts

@@ -30,7 +30,7 @@ export interface AttachConnection {
     readonly meta: Pick<NodeMeta, 'cwd' | 'profile_id'>;
     /** The attached node's persona/lifecycle, when this canvas can tell us —
      *  `undefined` for a remote attach until the viewer refetches it. */
-    readonly nodeIdentity: Pick<NodeMeta, 'kind' | 'mode' | 'lifecycle'> | undefined;
+    readonly nodeIdentity: Pick<NodeMeta, 'kind' | 'mode' | 'lifecycle' | 'icon'> | undefined;
     /** The one socket to the node's headless broker, already connected. */
     readonly socket: BrokerClient;
     /** Re-throw a connect-adjacent failure that landed AFTER `connect` resolved.

package/dist/clients/attach/session/editor-frame.d.ts

@@ -14,7 +14,7 @@ export declare function resolveEditorFrameStyles(bashMode: 0 | 1 | 2, thinkingLe
 export interface EditorChromeHooks {
     /** The viewer's live node identity — a `let` runAttach owns and refreshes
      *  (remote attach starts without one), so it MUST stay a getter. */
-    nodeIdentity: () => Pick<NodeMeta, 'kind' | 'mode' | 'lifecycle'> | undefined;
+    nodeIdentity: () => Pick<NodeMeta, 'kind' | 'mode' | 'lifecycle' | 'icon'> | undefined;
     /** The engine's current thinking level, from live session state. */
     thinkingLevel: () => BrokerSnapshot['state']['thinkingLevel'] | undefined;
     /** Repaint the status line — the bash-level segment tracks `bashMode`. */
@@ -36,6 +36,10 @@ export interface EditorChrome {
     /** Kick an async git-status fetch that repaints the top border. */
     pollGit: () => void;
 }
+/** Render the generated task icon on every non-empty editor title. Session
+ * names are persisted independently by pi, so this derives the icon from the
+ * canvas identity again whenever a viewer attaches or reloads. */
+export declare function displayEditorTitle(sessionName: string | undefined, identity: Pick<NodeMeta, 'kind' | 'mode' | 'icon'> | undefined): string;
 /** The editor-chrome collaborator: owns the shell/bash level (`deriveBashMode`
  *  over `editor.onChange` is its ONE writer) and the `/color` chip override,
  *  and paints every frame-attached adornment — border hue, title chip, context