@north-light/crouter 0.3.163 → 0.3.164

package/dist/builtin-memory/internal/INDEX.md

@@ -14,6 +14,7 @@ Open this dir whenever a task turns on understanding the runtime itself or chang
 
 - **nodes-and-canvas** — the agent-runtime model: nodes on the canvas graph, spawn/delegate, the push/feed spine, lifecycle (mode + lifecycle axes), and revive (manual + daemon auto-revive).
 - **storage-tiers** — where every kind of state lives: the two tiers (scope root and canvas home) and their durability/ownership contracts.
+- **memory-loading** — the memory load model: the two hooks (boot catalog, file-read), the four-rung ladder, gates, applies-to/read-when routing, boot-render ordering, and store mounting/precedence — read when diagnosing why a doc did or didn't load.
 - **agent-shaping** — the when-to-use-which layer over the four dials that shape a node: kinds (the builtin roster, sub-kinds, and custom personas), modes (base vs orchestrator), profiles, and the memory tiers (node/profile/project/user/builtin).
 - **workflow-codification** — the codification loop for repeatable tasks: do the work hands-on under a capture session, mine the HAR, then codify it as scripts (scope-root `scripts/`) + a slash-invokable memory doc, with the self-heal rule that a failed script is re-derived and rewritten.
 - **plugins** — authoring a crtr plugin: the plugin.json manifest, directory layout, scopes, install mechanics, versioning, command plugins (contributing top-level CLI commands via commands.json + one executable), and configured CLIs (contributing commands as definition + HTTP from a remote manifest, no executable).

package/dist/builtin-memory/internal/memory-loading.md

@@ -0,0 +1,45 @@
+---
+kind: knowledge
+when-and-why-to-read: When you need to know why a memory doc did or didn't load — or are deciding how a new doc should surface — this reference should be read because it names the hook, rung, gate, and ordering that produced the behavior, so you fix loading by turning the right dial instead of guessing at frontmatter.
+short-form: The complete load model — two hooks (boot catalog, file-read), the four-rung ladder, gates, applies-to/read-when routing, boot-render ordering, and store mounting/precedence.
+system-prompt-visibility: name
+file-read-visibility: none
+---
+
+# How memory loads
+
+Every memory doc declares its own loading policy in frontmatter; the runtime never guesses. Loading is two hooks, one four-rung dial per hook, an optional gate, and structural ordering. The authoring contract (flags, routing-line craft) is `crtr memory write -h`; which scope to write to is `internal/agent-shaping`; physical paths are `internal/storage-tiers`. This doc is the mechanics between those: what actually fires, when, and in what order.
+
+## The two hooks
+
+- **System prompt** (`system-prompt-visibility`) — the boot catalog assembled into every node's system prompt at revive.
+- **File read** (`file-read-visibility`) — context attached to the workspace or to files. Two events: **workspace mount** during first-message assembly (docs routed `applies-to: "."`), and a later **matching file read** (docs routed by glob). Nothing positional fires from where the doc happens to sit on disk — only from its declared route.
+
+Each doc sets both rungs explicitly; there is no kind-based default. Usually one axis carries a real rung and the other is `none`.
+
+## The rung ladder
+
+`none` → `name` → `preview` → `content`, per hook:
+
+- `none` — invisible on that hook; findable only by search/read. For archival docs and for the unused axis.
+- `name` — the bare title. The practical floor: an agent can't reach for a doc it has never seen named.
+- `preview` — name + the `when-and-why-to-read` routing line, rendered verbatim. The heart of progressive disclosure: one sentence that lets an agent decide whether to spend the read.
+- `content` — the full body inlined. Reserved for always-relevant docs that are either a bullet's worth of text or a wholly-important operating guide (the root INDEX shape below).
+
+`short-form` is **not** a rung and never enters agent context — it exists for humans browsing `crtr memory list`. Disclosure is name → routing line → whole thing; there is deliberately no "just the summary" level, because agents satisfice on abbreviations and never read the rest.
+
+## Gates and read-when
+
+An optional `gate` predicates visibility on the node's own config — kind, mode, orchestration depth, scope, cwd — using the standard matcher vocabulary (`crtr memory write -h`). No gate means always eligible. Persona prose is just gated content-rung docs (`gate: {kind: developer, mode: base}`); guidance that should scale with effort is one predicate (`orchestration.depth: {gte: 2}`), not a mechanism. `read-when` additionally matches the *read file's* frontmatter on the file-read hook; it refines a route but never replaces the required `applies-to` boundary.
+
+## Store mounting and precedence
+
+At boot/first-message assembly the runtime mounts: builtin docs, the user store (`~/.crouter/memory/`), the selected profile's store, and every project store — ancestor `.crouter/memory/` dirs walking up from cwd plus each project in the profile's purview. Physical duplicates are deduplicated; name collisions resolve nearest-first (project over profile over user over builtin), which is what lets a project doc shadow a builtin one.
+
+A root `INDEX.md` is a workspace's front door: `system-prompt-visibility: none`, `file-read-visibility: content`, `applies-to: "."` — the operating guide loads when that workspace mounts, not in every boot catalog. Multiple mounted roots render broad-to-specific, each under its own envelope name.
+
+## Ordering
+
+The boot render is structural, never a per-doc knob: docs group by rung (content bodies as prose, then previews, then names), and within a group order general-to-specific — scope first (builtin → user → profile → outermost project root → nearest), then tree position (higher directories before deeper), then filename. A numeric `NN-` filename prefix (stripped from the doc's name) is the sparing escape hatch when an exact sequence must be pinned.
+
+`crtr memory lint` is the validator for all of the above: frontmatter schema, both rungs present, routes on every non-`none` file-read rung, rung-scaled body length, dangling `[[links]]`, and each profile-managed project's front door.

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

@@ -50,7 +50,7 @@ test('the attach viewer covers crtr bash tool calls and crtr-output messages nat
     const chatView = read(join(ROOT, 'clients', 'attach', 'render/chat-view.ts'));
     assert.match(chatView, /CRTR_OUTPUT_CUSTOM_TYPE/);
     assert.match(chatView, /new CrtrOutputMessageComponent\(/);
-    assert.match(chatView, /createCrtrBashToolDefinition\(args\)/);
+    assert.match(chatView, /createCrtrBashToolDefinition\(args,\s*fold\)/);
     // MinimizableToolComponent is the viewer's ToolExecutionComponent subclass (it
     // adds the Ctrl+O minimized state); the crtr tool definition still threads through it.
     assert.match(chatView, /new MinimizableToolComponent\([\s\S]*toolDefinition as never/);

package/dist/clients/attach/__tests__/edit-diff.test.js

@@ -1,9 +1,7 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { initTheme } from '@earendil-works/pi-coding-agent';
-import { FOLDED_STATE_KEY } from '../render/tool-calls.js';
 import { createCrtrEditToolDefinition } from '../render/edit-diff.js';
-initTheme(undefined, false);
+import { FoldedToolCallController } from '../render/tool-calls.js';
 const theme = {
     fg: (_name, text) => text,
     bg: (_name, text) => text,
@@ -12,23 +10,26 @@ const theme = {
     getBgAnsi: (_name) => '',
     getColorMode: () => 'truecolor',
 };
-test('folded edit counts keep the executed diff when its speculative preview settles later', () => {
-    const definition = createCrtrEditToolDefinition(process.cwd());
-    const args = { path: 'example.ts', edits: [{ oldText: 'before', newText: 'after' }] };
-    const state = {};
-    const context = {
-        args,
-        argsComplete: false,
-        cwd: process.cwd(),
-        invalidate() { },
+test('edit cards stream argument diffs, then keep the executed result authoritative', () => {
+    const fold = new FoldedToolCallController();
+    const view = createCrtrEditToolDefinition(process.cwd(), fold);
+    const definition = view.definition;
+    const context = { cwd: process.cwd(), isError: false };
+    const streamedArgs = { path: 'example.ts', edits: [{ oldText: 'before', newText: 'streaming' }] };
+    const streamed = definition.renderCall(streamedArgs, theme, context).render(80).join('\n');
+    assert.match(streamed, /before/);
+    assert.match(streamed, /streaming/);
+    view.observeResult({
+        content: [{ type: 'text', text: 'edited' }],
+        details: { diff: '-10 before\n+10 executed\n+11 extra' },
         isError: false,
-        state,
-    };
-    definition.renderCall(args, theme, context);
-    definition.renderResult({ content: [{ type: 'text', text: 'edited' }], details: { diff: '- 1 before\n+ 1 after' } }, { isPartial: false }, theme, context);
-    state.callComponent.preview = { error: 'speculative preview completed after execution' };
-    state[FOLDED_STATE_KEY] = true;
-    const folded = definition.renderCall(args, theme, context).render(80).join('\n');
-    assert.match(folded, /\+1/);
+    }, false);
+    const laterArgs = { path: 'example.ts', edits: [{ oldText: 'before', newText: 'stale preview' }] };
+    const settled = definition.renderCall(laterArgs, theme, context).render(80).join('\n');
+    assert.match(settled, /executed/);
+    assert.doesNotMatch(settled, /stale preview/);
+    fold.setFolded(true);
+    const folded = definition.renderCall(laterArgs, theme, context).render(80).join('\n');
+    assert.match(folded, /\+2/);
     assert.match(folded, /-1/);
 });

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

@@ -30,7 +30,7 @@ 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 { FoldedToolCallController, 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';
@@ -147,13 +147,10 @@ function stripBackground(line) {
     });
 }
 /** 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. */
+ *  only knows expanded/collapsed, so each crtr-owned definition receives a local fold
+ *  controller and captures the compact call component it renders. Folded render paints
+ *  that captured call directly, dropping result and Box chrome while letting a wrapped
+ *  path keep its natural rows. Tools without a crtr definition remain 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. */
@@ -174,30 +171,36 @@ class FoldedToolSeparator extends Spacer {
 }
 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;
+    expandedState = false;
+    foldController;
+    resultObserver;
+    /** A foldable definition owns its folded call component; an edit definition
+     *  may also observe results before the imported shell renders them. */
+    setToolView(foldController, resultObserver) {
+        this.foldController = foldController;
+        this.resultObserver = resultObserver;
     }
-    /** 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. */
+    updateResult(...args) {
+        this.resultObserver?.(args[0], args[1] ?? false);
+        super.updateResult(...args);
+    }
+    setExpanded(expanded) {
+        this.expandedState = expanded;
+        super.setExpanded(expanded);
+    }
+    /** Flip the local fold state, then use the imported component's public
+     *  expansion setter to rebuild its call renderer at the current setting. */
     setMinimized(minimized) {
-        if (!this.foldable || this.minimized === minimized)
+        if (!this.foldController || this.minimized === minimized)
             return;
         this.minimized = minimized;
-        const internals = this;
-        internals.rendererState[FOLDED_STATE_KEY] = minimized;
-        internals.updateDisplay();
+        this.foldController.setFolded(minimized);
+        super.setExpanded(this.expandedState);
     }
     render(width) {
         if (!this.minimized)
             return super.render(width);
-        const call = this
-            .callRendererComponent;
+        const call = this.foldController?.callComponent();
         if (!call)
             return super.render(width);
         // trimEnd drops right-hand padding, which only existed to carry the
@@ -724,7 +727,7 @@ export class ChatView {
                         this.pendingTools.clear();
                     }
                     else {
-                        // Args complete → trigger diff computation for edit tools.
+                        // Finalize renderer caches now that every tool argument is complete.
                         for (const component of this.pendingTools.values()) {
                             component.setArgsComplete();
                             this.historyContainer.markDirty(component);
@@ -1020,18 +1023,26 @@ export class ChatView {
     }
     /** Tool component with native viewer renderers for crouter-owned tool output. */
     makeToolComponent(name, id, args) {
-        const toolDefinition = name === 'bash'
-            ? (createCrtrBashToolDefinition(args) ?? createCrtrPlainBashToolDefinition(this.cwd))
-            : name === 'edit'
-                ? createCrtrEditToolDefinition(this.cwd)
-                : name === 'read'
-                    ? createCrtrReadToolDefinition(this.cwd)
-                    : name === 'write'
-                        ? createCrtrWriteToolDefinition(this.cwd)
-                        : undefined;
+        const fold = new FoldedToolCallController();
+        let resultObserver;
+        let toolDefinition;
+        if (name === 'bash') {
+            toolDefinition = createCrtrBashToolDefinition(args, fold) ?? createCrtrPlainBashToolDefinition(this.cwd, fold);
+        }
+        else if (name === 'edit') {
+            const edit = createCrtrEditToolDefinition(this.cwd, fold);
+            toolDefinition = edit.definition;
+            resultObserver = edit.observeResult;
+        }
+        else if (name === 'read') {
+            toolDefinition = createCrtrReadToolDefinition(this.cwd, fold);
+        }
+        else if (name === 'write') {
+            toolDefinition = createCrtrWriteToolDefinition(this.cwd, fold);
+        }
         let component;
         component = new MinimizableToolComponent(name, id, args, { showImages: this.showImages, imageWidthCells: this.imageWidthCells }, toolDefinition, this.componentTui(() => component), this.cwd);
-        component.setFoldable(toolDefinition !== undefined);
+        component.setToolView(toolDefinition === undefined ? undefined : fold, resultObserver);
         component.setExpanded(this.toolOutputExpanded);
         return component;
     }

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 {};