@north-light/crouter 0.3.172 → 0.3.174

package/dist/clients/attach/input/overlay-owner.d.ts

@@ -0,0 +1,41 @@
+import type { CustomEditor } from '@earendil-works/pi-coding-agent';
+import type { Component, KeybindingsManager, TUI } from '@earendil-works/pi-tui';
+import type { BrokerDataFrame, BrokerSnapshot, ClientToBroker, RpcExtensionUIRequest, RpcExtensionUIResponse } from '../../../core/runtime/broker-protocol.js';
+import type { ReadOpRequest } from '../../../core/broker-client/index.js';
+import { type Picker, type PickerControls } from '../overlays/pickers.js';
+export interface InputOverlayHooks {
+    send: (frame: ClientToBroker) => void;
+    notify: (message: string) => void;
+    onDialogResponse: (response: RpcExtensionUIResponse) => void;
+    onRequest?: (frame: ReadOpRequest) => Promise<BrokerDataFrame>;
+    onMountPicker?: (component: Component) => void;
+    onUnmountPicker?: () => void;
+    state: () => BrokerSnapshot['state'] | undefined;
+}
+/** Owns transient dialog and picker lifetime. Editor submission remains with
+ * InputController; this collaborator owns mount, replacement, dismissal, and
+ * focus restoration for every transient input surface. */
+export declare class InputOverlayOwner {
+    private readonly tui;
+    private readonly editor;
+    private readonly keybindings;
+    private readonly hooks;
+    private dialog;
+    private dialogId;
+    private picker;
+    private openSeq;
+    constructor(tui: TUI, editor: CustomEditor, keybindings: KeybindingsManager, hooks: InputOverlayHooks);
+    attachDialog(request: RpcExtensionUIRequest): void;
+    dismissDialog(id: string): void;
+    openModelPicker(): Promise<void>;
+    openSessionPicker(): Promise<void>;
+    openTreePicker(): Promise<void>;
+    openForkPicker(): Promise<void>;
+    openSettingsPicker(): Promise<void>;
+    openScopedModelsPicker(): Promise<void>;
+    openMcpPicker(serverName?: string): void;
+    openFileReviewPicker(candidates: string[], cwd: string, onChoose: (file: string) => void): void;
+    openAuthPicker(prepare: () => Promise<(controls: PickerControls) => Picker>): Promise<void>;
+    private openPicker;
+    private showPicker;
+}

package/dist/clients/attach/input/overlay-owner.js

@@ -0,0 +1,199 @@
+import { isBlockingDialog, renderDialog } from '../overlays/dialogs.js';
+import { buildForkPicker, buildModelPicker, buildScopedModelsPicker, buildSessionPicker, buildSettingsPicker, buildTreePicker, } from '../overlays/pickers.js';
+import { buildMcpPicker, readMcpServers, startMcpServerAction, MCP_EMPTY_STATE_HINT } from '../overlays/mcp.js';
+import { buildFileReviewPicker } from '../overlays/file-review.js';
+const PICKER_OVERLAY_OPTIONS = { anchor: 'center', width: '80%', maxHeight: '85%' };
+/** Owns transient dialog and picker lifetime. Editor submission remains with
+ * InputController; this collaborator owns mount, replacement, dismissal, and
+ * focus restoration for every transient input surface. */
+export class InputOverlayOwner {
+    tui;
+    editor;
+    keybindings;
+    hooks;
+    dialog;
+    dialogId;
+    picker;
+    openSeq = 0;
+    constructor(tui, editor, keybindings, hooks) {
+        this.tui = tui;
+        this.editor = editor;
+        this.keybindings = keybindings;
+        this.hooks = hooks;
+    }
+    attachDialog(request) {
+        if (request.method === 'notify') {
+            const prefix = request.notifyType === 'error' ? 'Error: ' : request.notifyType === 'warning' ? 'Warning: ' : '';
+            this.hooks.notify(`${prefix}${request.message}`);
+            this.tui.requestRender();
+            return;
+        }
+        if (!isBlockingDialog(request))
+            return;
+        this.dialog?.dismiss();
+        this.dialogId = request.id;
+        this.dialog = renderDialog(this.tui, request, (response) => {
+            this.dialog = undefined;
+            this.dialogId = undefined;
+            this.hooks.onDialogResponse(response);
+        }, this.keybindings);
+        this.tui.requestRender();
+    }
+    dismissDialog(id) {
+        if (this.dialogId !== id)
+            return;
+        this.dialog?.dismiss();
+        this.dialog = undefined;
+        this.dialogId = undefined;
+        this.tui.requestRender();
+    }
+    openModelPicker() {
+        return this.openPicker({ type: 'list_models' }, 'list_models', 'model', (data, close) => buildModelPicker(this.tui, data, this.hooks.send, close));
+    }
+    openSessionPicker() {
+        const request = this.hooks.onRequest;
+        if (request === undefined) {
+            this.hooks.notify("The session picker isn't available in this viewer");
+            return Promise.resolve();
+        }
+        this.openSeq++;
+        this.showPicker((controls) => buildSessionPicker(this.tui, this.hooks.state()?.sessionFile, request, this.keybindings, this.hooks.send, controls.close));
+        return Promise.resolve();
+    }
+    openTreePicker() {
+        return this.openPicker({ type: 'get_tree' }, 'get_tree', 'tree', (data, close) => buildTreePicker(this.tui, data, this.hooks.send, close));
+    }
+    openForkPicker() {
+        return this.openPicker({ type: 'get_tree' }, 'get_tree', 'fork', (data, close) => buildForkPicker(data, this.hooks.send, close));
+    }
+    openSettingsPicker() {
+        return this.openPicker({ type: 'get_settings' }, 'get_settings', 'settings', (data, close) => buildSettingsPicker(data, this.hooks.send, close, this.hooks.notify));
+    }
+    openScopedModelsPicker() {
+        return this.openPicker({ type: 'list_scoped_models' }, 'list_scoped_models', 'scoped-models', (data, close) => buildScopedModelsPicker(data, close, this.hooks.notify));
+    }
+    openMcpPicker(serverName) {
+        const rows = readMcpServers();
+        if (rows.length === 0) {
+            this.hooks.notify(MCP_EMPTY_STATE_HINT);
+            return;
+        }
+        if (serverName !== undefined) {
+            const row = rows.find((candidate) => candidate.name === serverName);
+            if (row === undefined) {
+                this.hooks.notify(`No MCP server named ${JSON.stringify(serverName)} — usage: /mcp [server]`);
+                return;
+            }
+            startMcpServerAction(row, this.hooks.send, this.hooks.notify);
+            return;
+        }
+        this.showPicker((controls) => buildMcpPicker(rows, this.hooks.send, controls.close, this.hooks.notify));
+    }
+    openFileReviewPicker(candidates, cwd, onChoose) {
+        this.showPicker((controls) => buildFileReviewPicker(candidates, cwd, (file) => {
+            controls.close();
+            onChoose(file);
+        }, controls.close, this.hooks.notify));
+    }
+    async openAuthPicker(prepare) {
+        const seq = ++this.openSeq;
+        let build;
+        try {
+            build = await prepare();
+        }
+        catch (error) {
+            this.hooks.notify(`Could not open the auth picker: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        if (seq !== this.openSeq)
+            return;
+        this.showPicker(build);
+    }
+    async openPicker(frame, kind, label, build) {
+        const request = this.hooks.onRequest;
+        if (request === undefined) {
+            this.hooks.notify(`The ${label} picker isn't available in this viewer`);
+            return;
+        }
+        const seq = ++this.openSeq;
+        let reply;
+        try {
+            reply = await request(frame);
+        }
+        catch (error) {
+            this.hooks.notify(`Could not open the ${label} picker: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        if (seq !== this.openSeq)
+            return;
+        if (reply.kind !== kind) {
+            this.hooks.notify(`Unexpected reply building the ${label} picker`);
+            return;
+        }
+        this.showPicker((controls) => build(reply, controls.close));
+    }
+    showPicker(build) {
+        this.picker?.dismiss();
+        const inline = this.hooks.onMountPicker !== undefined && this.hooks.onUnmountPicker !== undefined;
+        let handle;
+        let current;
+        let done = false;
+        const disposeCurrent = () => {
+            const disposable = current?.component;
+            try {
+                disposable?.dispose?.();
+            }
+            catch { /* ignore teardown errors */ }
+        };
+        const mount = (picker) => {
+            if (inline)
+                this.hooks.onMountPicker(picker.component);
+            else
+                handle = this.tui.showOverlay(picker.component, PICKER_OVERLAY_OPTIONS);
+            this.tui.setFocus(picker.focus);
+        };
+        const unmount = () => {
+            if (inline)
+                this.hooks.onUnmountPicker?.();
+            else
+                handle?.hide();
+        };
+        const replace = (component, focus) => {
+            if (done)
+                return;
+            disposeCurrent();
+            unmount();
+            current = { component, focus };
+            mount(current);
+            this.tui.requestRender();
+        };
+        const close = () => {
+            if (done)
+                return;
+            done = true;
+            disposeCurrent();
+            unmount();
+            this.picker = undefined;
+            this.tui.setFocus(this.editor);
+            this.tui.requestRender();
+        };
+        try {
+            current = build({ close, replace });
+        }
+        catch (error) {
+            this.hooks.notify(`Could not open picker: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        mount(current);
+        this.picker = {
+            dismiss: () => {
+                if (done)
+                    return;
+                done = true;
+                disposeCurrent();
+                unmount();
+            },
+        };
+        this.tui.requestRender();
+    }
+}

package/dist/clients/attach/overlays/file-review.d.ts

@@ -1,13 +1,9 @@
-import type { TUI } from '@earendil-works/pi-tui';
-import type { CanvasSource } from '../../../core/canvas/source.js';
 import type { SurfaceHost } from '../../surfaces/host.js';
 import type { Picker } from './pickers.js';
 import { extractFilePaths } from '#core/human/visible-paths';
 export declare function buildFileReviewPicker(candidates: readonly string[], cwd: string, onChoose: (file: string) => void, close: () => void, notify: (message: string) => void): Picker;
 export declare function launchFileReview(host: SurfaceHost, file: string, opts: {
     originNodeId: string;
-    tui: TUI;
-    canvasSource: CanvasSource;
     onNotice: (message: string) => void;
 }): Promise<void>;
 export { extractFilePaths };

package/dist/clients/attach/overlays/file-review.js

@@ -2,8 +2,8 @@ import { homedir } from 'node:os';
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { Input, SelectList, getKeybindings, } from '@earendil-works/pi-tui';
 import { getSelectListTheme } from '@earendil-works/pi-coding-agent';
-import { openComposedReview } from '../../inbox/review/launch.js';
-import { createReviewClient } from '../../inbox/review/review-client.js';
+import { openReviewSurface } from '../../inbox/review/launch.js';
+import { createReviewClient, ReviewTerminalError, terminalRefusalNotice } from '../../inbox/review/review-client.js';
 import { checkReviewableFile, extractFilePaths } from '#core/human/visible-paths';
 const MAX_VISIBLE_ROWS = 12;
 function labelForPath(file, cwd) {
@@ -109,12 +109,20 @@ export function buildFileReviewPicker(candidates, cwd, onChoose, close, notify)
     return { component: picker, focus: picker };
 }
 export async function launchFileReview(host, file, opts) {
+    // The refusal precedes the record creation: a remote viewer can reach neither
+    // the reviewed file nor the companion's pane.
+    if (host.capabilities.remote) {
+        opts.onNotice('The review is unavailable in a remote attach — the file and companion live on the host.');
+        return;
+    }
+    let review;
     try {
-        const review = await createReviewClient().createInline({ originNodeId: opts.originNodeId, file });
-        await openComposedReview(host, { reviewId: review.reviewId, tui: opts.tui, canvasSource: opts.canvasSource });
+        review = await createReviewClient().createInline({ originNodeId: opts.originNodeId, file });
     }
     catch (err) {
-        opts.onNotice(err instanceof Error ? err.message : String(err));
+        opts.onNotice(err instanceof ReviewTerminalError ? terminalRefusalNotice(err) : err instanceof Error ? err.message : String(err));
+        return;
     }
+    await openReviewSurface(host, { review });
 }
 export { extractFilePaths };

package/dist/clients/attach/overlays/graph.js

@@ -40,6 +40,7 @@ import { readFault } from '../../../core/runtime/fault.js';
 import { faultSummary } from '../../../core/canvas/status-glyph.js';
 import { RemoteCanvasSource } from '../../../core/canvas/remote-canvas-source.js';
 import { cliClient } from '../../../commands/api-client.js';
+import { statusRank } from '../../../core/canvas/node-order.js';
 import { beginFrameTelem, navLabel, nodeGlyph, tokensCell, cycleBadge, askBadge, activityCell, shortId, visibleWidth, fillBar, fillWidth, truncate, isAttached, VIEWPORT_FALLBACK_ROWS, DIM, RESET, BOLD, YELLOW, REVERSE, BG_ATTACHED, GREEN, } from '../../../core/canvas/nav-render.js';
 // A BOUNDED, centered modal (CTO ruling: not full-bleed). Width/height are capped
 // at ~72% of the terminal; the overlay clips our lines to maxHeight, and render()
@@ -267,16 +268,7 @@ export class GraphOverlay {
             }
             return cur;
         };
-        const rank = async (id) => {
-            switch ((await node(id))?.status) {
-                case 'active': return 0;
-                case 'idle': return 1;
-                case 'done': return 2;
-                case 'canceled': return 3;
-                case 'dead': return 4;
-                default: return 5;
-            }
-        };
+        const rank = async (id) => statusRank((await node(id))?.status);
         const sortedChildren = async (id) => {
             const cached = sortedChildIds.get(id);
             if (cached !== undefined)

package/dist/clients/attach/render/chat-view.d.ts

@@ -130,6 +130,9 @@ export declare class ChatView {
     private bashComponent;
     /** The single active activity loader (working/compaction/retry), if any. */
     private activityLoader;
+    /** The shared broker transcript state; this renderer projects it into pi TUI
+     *  components while retaining terminal-only folding and virtualization. */
+    private projection;
     /** Broker-selected normal label for this turn; compaction/retry temporarily
      *  replace it and restore it when the run remains active. */
     private workingActivity;
@@ -149,8 +152,6 @@ export declare class ChatView {
      *  snapshot AND the live event stream so `/copy` (getLastAssistantText) works
      *  whether the message arrived before or after attach. */
     private lastAssistantText;
-    /** Recent transcript text, oldest → newest, for the file-review path picker. */
-    private readonly transcriptTexts;
     /** Existing file paths found anywhere in the rendered transcript, newest first. */
     private readonly transcriptFilePaths;
     /** Canonical copyable transcript blocks, in their rendered visual order. */
@@ -188,7 +189,7 @@ export declare class ChatView {
     /** Replay deferred live frames in wire order. The gate is already open, so each
      *  closure re-enters its entry point and dispatches immediately. */
     private replayDeferredFrames;
-    /** Accept the broker's per-turn random choice before its following agent_start. */
+    /** Apply the broker's random choice for a newly received user message. */
     setWorkingActivity(activity: string): void;
     /** Clear live turn state after the broker reports completion or the viewer observes dormancy. */
     settleRun(): void;

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

@@ -27,7 +27,7 @@ import { ContextMessageComponent } from './context-message.js';
 import { CRTR_OUTPUT_CUSTOM_TYPE, CrtrOutputMessageComponent, createCrtrBashToolDefinition, } from './crtr-output.js';
 import { CRTR_CYCLE_DIVIDER_CUSTOM_TYPE } from '../../../core/runtime/session-cycles.js';
 import { generatedContextExpandedBody, generatedContextPresentation, isRuntimeRestartContinuation, } from '../../../shared/generated-context.js';
-import { assistantVisibleText, isTrueUserMessage, normalizeToolGroupSummary, normalizeToolGroupSummaryRecord, } from '../../../shared/tool-groups.js';
+import { assistantVisibleText, isTrueUserMessage, } from '../../../shared/tool-groups.js';
 import { transformMessageDiagrams } from './diagram.js';
 import { transformMessageHtml } from './html-markdown.js';
 import { styleAttachMarkdownHeadings, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-headings.js';
@@ -42,7 +42,7 @@ import { ViewerAssistantMessageComponent } from './assistant-message.js';
 import { CompositeViewportSource, MeasuredContainer, } from './measured-container.js';
 import { readConfig, updateRawConfigAtomically } from '../../../core/config.js';
 import { DEFAULT_CONDENSED_HISTORY, DEFAULT_LIVE_CYCLES } from '../../../types.js';
-import { DEFAULT_WORKING_ACTIVITY } from '../../../shared/working-activity.js';
+import { applySnapshot as projectSnapshot, applyToolGroupSummary as projectToolGroupSummary, applyWorkingActivity as projectWorkingActivity, bashEnd as projectBashEnd, bashOutput as projectBashOutput, bashStart as projectBashStart, initialConvState, reduce as projectEvent, } from '../../conversation/projection.js';
 /** Theme-derived chrome colors (spinner / dim / error) are supplied by the
  *  attach command via `ChatViewOptions.palette` (built from the live theme in
  *  config.ts). pi does not re-export the raw `theme` instance, so standalone
@@ -324,9 +324,12 @@ export class ChatView {
     bashComponent;
     /** The single active activity loader (working/compaction/retry), if any. */
     activityLoader;
+    /** The shared broker transcript state; this renderer projects it into pi TUI
+     *  components while retaining terminal-only folding and virtualization. */
+    projection = initialConvState();
     /** Broker-selected normal label for this turn; compaction/retry temporarily
      *  replace it and restore it when the run remains active. */
-    workingActivity = DEFAULT_WORKING_ACTIVITY;
+    workingActivity = this.projection.workingActivity;
     runActive = false;
     // -- Single-writer snapshot ordering -------------------------------------
     // A non-streaming catch-up yields to the event loop mid-build (so queued stdin
@@ -351,8 +354,6 @@ export class ChatView {
      *  snapshot AND the live event stream so `/copy` (getLastAssistantText) works
      *  whether the message arrived before or after attach. */
     lastAssistantText;
-    /** Recent transcript text, oldest → newest, for the file-review path picker. */
-    transcriptTexts = [];
     /** Existing file paths found anywhere in the rendered transcript, newest first. */
     transcriptFilePaths = [];
     /** Canonical copyable transcript blocks, in their rendered visual order. */
@@ -419,13 +420,12 @@ export class ChatView {
         this.applyingSnapshot = true;
         this.deferredFrames.length = 0;
         this.resetChat();
-        this.workingActivity = typeof snapshot.workingActivity === 'string' && snapshot.workingActivity.trim() !== ''
-            ? snapshot.workingActivity
-            : DEFAULT_WORKING_ACTIVITY;
-        this.runActive = snapshot.state.isStreaming;
-        this.seedToolGroupSummaries(snapshot.toolGroupSummaries);
+        this.projection = projectSnapshot(snapshot, this.projection);
+        this.workingActivity = this.projection.workingActivity;
+        this.runActive = this.projection.isStreaming;
+        this.seedToolGroupSummaries(this.projection.toolGroupSummaryDetails);
         const renderedPendingTools = new Map();
-        const messages = snapshot.messages;
+        const messages = this.projection.messages;
         const lastIndex = messages.length - 1;
         // Cycles older than the trailing `live_cycles` are condensed into one nested
         // container before the live region is built. It retains only configured prose
@@ -447,7 +447,7 @@ export class ChatView {
             // snapshot: its in-flight tail + pending tools must be bound before any
             // relayed message_update/message_end lands, so it builds synchronously
             // (no await → no broker frame can interleave and freeze the live bubble).
-            if (!snapshot.state.isStreaming &&
+            if (!this.projection.isStreaming &&
                 i > liveStart &&
                 (i - liveStart) % SNAPSHOT_YIELD_EVERY === 0) {
                 await new Promise((resolve) => setImmediate(resolve));
@@ -472,7 +472,7 @@ export class ChatView {
                 // message would freeze at its snapshot value until the next turn — the
                 // common case, since you typically attach to a node that is working.
                 const isStreamingTail = i === lastIndex &&
-                    snapshot.state.isStreaming &&
+                    this.projection.isStreaming &&
                     message.stopReason !== 'aborted' &&
                     message.stopReason !== 'error';
                 const hasProse = assistantVisibleText(message).trim() !== '';
@@ -550,7 +550,7 @@ export class ChatView {
         // If we attached mid-turn, the `agent_start` that spins up the working loader
         // already fired before we connected — restore it from the snapshot's streaming
         // state so an actively-working node shows the spinner right away.
-        if (snapshot.state.isStreaming)
+        if (this.projection.isStreaming)
             this.setActivity(this.makeLoader(this.workingActivity));
         this.tui.requestRender();
         // Build complete and still current (a mismatch would have returned above):
@@ -617,11 +617,15 @@ export class ChatView {
         for (const replay of frames)
             replay();
     }
-    /** Accept the broker's per-turn random choice before its following agent_start. */
+    /** Apply the broker's random choice for a newly received user message. */
     setWorkingActivity(activity) {
         if (this.deferIfBuilding(() => this.setWorkingActivity(activity)))
             return;
-        this.workingActivity = activity.trim() === '' ? DEFAULT_WORKING_ACTIVITY : activity;
+        const wasShowingWorkingActivity = this.projection.activity === this.workingActivity;
+        this.projection = projectWorkingActivity(this.projection, activity);
+        this.workingActivity = this.projection.workingActivity;
+        if (this.runActive && wasShowingWorkingActivity)
+            this.setActivity(this.makeLoader(this.workingActivity));
     }
     /** Clear live turn state after the broker reports completion or the viewer observes dormancy. */
     settleRun() {
@@ -727,9 +731,10 @@ export class ChatView {
         // welcome is still building is replayed after it, never interleaved into it.
         if (this.deferIfBuilding(() => this.handleEvent(event)))
             return;
+        this.projection = projectEvent(this.projection, event);
         switch (event.type) {
             case 'agent_start': {
-                this.runActive = true;
+                this.runActive = this.projection.isStreaming;
                 for (const component of this.pendingTools.values())
                     this.settleGroupTool(component);
                 this.pendingTools.clear();
@@ -880,23 +885,25 @@ export class ChatView {
                 break;
             }
             case 'tool_execution_update': {
-                this.pushTranscriptValue(event.partialResult);
+                const result = this.projection.partialToolResults.get(event.toolCallId) ?? event.partialResult;
+                this.pushTranscriptValue(result);
                 const component = this.pendingTools.get(event.toolCallId);
                 if (component) {
-                    component.updateResult({ ...event.partialResult, isError: false }, true);
-                    this.registerCopyBlock(component, 'tool', this.toolResultText(event.partialResult));
+                    component.updateResult(result, true);
+                    this.registerCopyBlock(component, 'tool', this.toolResultText(result));
                     this.historyContainer.markDirty(component);
                 }
                 break;
             }
             case 'tool_execution_end': {
-                this.pushTranscriptValue(event.result);
+                const result = this.projection.partialToolResults.get(event.toolCallId) ?? event.result;
+                this.pushTranscriptValue(result);
                 const component = this.pendingTools.get(event.toolCallId);
                 if (component) {
-                    component.updateResult({ ...event.result, isError: event.isError });
-                    this.registerCopyBlock(component, 'tool', this.toolResultText(event.result));
+                    component.updateResult(result);
+                    this.registerCopyBlock(component, 'tool', this.toolResultText(result));
                     this.pendingTools.delete(event.toolCallId);
-                    this.settleGroupTool(component, event.result, event.isError);
+                    this.settleGroupTool(component, result, event.isError);
                     this.applyToolDisplay();
                     this.historyContainer.markDirty(component);
                 }
@@ -971,6 +978,7 @@ export class ChatView {
     bashStart(command, excludeFromContext) {
         if (this.deferIfBuilding(() => this.bashStart(command, excludeFromContext)))
             return;
+        this.projection = projectBashStart(this.projection, command, excludeFromContext);
         this.closeOpenGroup();
         this.settleBashComponent();
         let component;
@@ -982,6 +990,7 @@ export class ChatView {
     bashOutput(chunk) {
         if (this.deferIfBuilding(() => this.bashOutput(chunk)))
             return;
+        this.projection = projectBashOutput(this.projection, chunk);
         this.pushTranscriptText(chunk);
         if (this.bashComponent) {
             this.bashComponent.appendOutput(chunk);
@@ -992,6 +1001,7 @@ export class ChatView {
     bashEnd(result) {
         if (this.deferIfBuilding(() => this.bashEnd(result)))
             return;
+        this.projection = projectBashEnd(this.projection, result);
         this.settleBashComponent(result);
         this.tui.requestRender();
     }
@@ -1269,9 +1279,8 @@ export class ChatView {
     }
     seedToolGroupSummaries(summaries) {
         this.groupSummaries.clear();
-        for (const [key, summary] of Object.entries(normalizeToolGroupSummaryRecord(summaries))) {
+        for (const [key, summary] of Object.entries(summaries))
             this.groupSummaries.set(key, summary);
-        }
     }
     /** Broker frames can arrive before or after their group's events, and snapshot
      * rebuilding defers them through the single-writer gate, so this stores first
@@ -1279,10 +1288,11 @@ export class ChatView {
     applyToolGroupSummary(key, summary) {
         if (this.deferIfBuilding(() => this.applyToolGroupSummary(key, summary)))
             return;
-        const normalized = normalizeToolGroupSummary(summary);
-        if (key.trim() === '' || normalized === null)
+        this.projection = projectToolGroupSummary(this.projection, key, summary);
+        const projected = this.projection.toolGroupSummaryDetails[key];
+        if (projected === undefined)
             return;
-        this.groupSummaries.set(key, normalized);
+        this.groupSummaries.set(key, projected);
         this.applyToolDisplay();
     }
     applyGroupDisplay(group) {
@@ -1416,7 +1426,6 @@ export class ChatView {
         this.lastAssistantText = undefined;
         this.copyBlockRecords.length = 0;
         this.copyIndex.clear();
-        this.transcriptTexts.length = 0;
         this.transcriptFilePaths.length = 0;
         this.historyContainer.clear();
     }
@@ -1604,9 +1613,6 @@ export class ChatView {
         const trimmed = text.trim();
         if (trimmed === '')
             return;
-        this.transcriptTexts.push(trimmed.slice(0, 8 * 1024));
-        if (this.transcriptTexts.length > 200)
-            this.transcriptTexts.splice(0, this.transcriptTexts.length - 200);
         const paths = extractFilePaths([trimmed], this.cwd);
         if (paths.length === 0)
             return;

package/dist/clients/attach/render/group-activity.d.ts

@@ -8,6 +8,7 @@ export type FileActivity = {
     countsIncomplete: boolean;
 };
 export type MemoryActivity = {
+    action: 'read' | 'write';
     name: string;
     path?: string;
 };

package/dist/clients/attach/render/group-activity.js

@@ -77,7 +77,7 @@ function shellTokens(segment) {
 }
 /** Deliberately match an executable token, not a result-shaped string or a
  * quoted command fragment. */
-function invokesMemoryRead(args) {
+function invokesMemoryCommand(args, verb) {
     const command = object(args)?.command;
     if (typeof command !== 'string')
         return false;
@@ -86,20 +86,22 @@ function invokesMemoryRead(args) {
         while (/^[A-Za-z_][A-Za-z0-9_]*=\S+$/.test(tokens[0] ?? ''))
             tokens.shift();
         const executable = tokens[0]?.split('/').at(-1);
-        return (executable === 'crtr' || executable === 'crouter') && tokens[1] === 'memory' && tokens[2] === 'read';
+        return (executable === 'crtr' || executable === 'crouter') && tokens[1] === 'memory' && tokens[2] === verb;
     });
 }
-/** A resolved read starts with the complete three-line identity emitted by
- * `memory read`; its source path follows as optional display metadata. Links and
- * discovery output intentionally do not satisfy this shape. */
-function resolvedMemories(result) {
+/** A resolved read/write begins with the identity fields emitted by its leaf.
+ * The write receipt also requires `created`, so result-shaped read output can
+ * never be reported as a saved memory. */
+function resolvedMemories(result, action) {
     const memories = [];
-    const identity = /^- name:\s*([^\r\n]+)\r?\n- kind:\s*[^\r\n]+\r?\n- scope:\s*[^\r\n]+(?:\r?\n- path:\s*([^\r\n]+)|\r?\n\r?\n\*\*path:\*\*\s*([^\r\n]+))?/gm;
+    const identity = action === 'read'
+        ? /^- name:\s*([^\r\n]+)\r?\n- kind:\s*[^\r\n]+\r?\n- scope:\s*[^\r\n]+(?:\r?\n- path:\s*([^\r\n]+)|\r?\n\r?\n\*\*path:\*\*\s*([^\r\n]+))?/gm
+        : /^- name:\s*([^\r\n]+)\r?\n- kind:\s*[^\r\n]+\r?\n- scope:\s*[^\r\n]+\r?\n- created:\s*(?:true|false)(?:\r?\n- path:\s*([^\r\n]+)|\r?\n\r?\n\*\*path:\*\*\s*([^\r\n]+))?/gm;
     for (const match of resultText(result).matchAll(identity)) {
         const name = match[1]?.trim();
         const path = (match[2] ?? match[3])?.trim();
         if (name)
-            memories.push(path ? { name, path } : { name });
+            memories.push(path ? { action, name, path } : { action, name });
     }
     return memories;
 }
@@ -168,11 +170,16 @@ export class GroupActivityRecorder {
         return Object.freeze({ files: Object.freeze(files), memories: Object.freeze(memories) });
     }
     extract(entry, result) {
-        if (entry.name === 'bash' && invokesMemoryRead(entry.args)) {
-            for (const memory of resolvedMemories(result)) {
-                if (!this.memorySet.has(memory.name)) {
-                    this.memorySet.add(memory.name);
-                    this.memories.push(memory);
+        if (entry.name === 'bash') {
+            for (const action of ['read', 'write']) {
+                if (!invokesMemoryCommand(entry.args, action))
+                    continue;
+                for (const memory of resolvedMemories(result, action)) {
+                    const key = `${action}:${memory.path ?? memory.name}`;
+                    if (!this.memorySet.has(key)) {
+                        this.memorySet.add(key);
+                        this.memories.push(memory);
+                    }
                 }
             }
             return;