@north-light/crouter 0.3.170 → 0.3.172

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

@@ -7,11 +7,11 @@
 // spawns pi and never opens the session — it only consumes the relayed
 // `AgentSessionEvent` stream + the `welcome` snapshot over `view.sock`.
 //
-// Ownership boundary: ChatView owns the chat scroll `Container` it is handed,
-// plus an activity/status area pinned to the bottom of that container (working
-// spinner, compaction/retry indicators, inline status/error lines). It does NOT
-// own the editor, the footer, or the terminal title — those are chrome laid out
-// by the attach command (T7). Events that only affect that chrome
+// Ownership boundary: ChatView owns the chat scroll `Container` it is handed.
+// Its activity state (working spinner, compaction/retry indicators) is signaled
+// to the viewer-owned fixed slot when one is supplied. It does NOT own the
+// editor, the footer, or the terminal title — those are chrome laid out by the
+// attach command (T7). Events that only affect that chrome
 // (queue_update / session_info_changed / thinking_level_changed) are forwarded
 // to the optional `onFooterEvent` sink instead of rendered here.
 //
@@ -26,25 +26,29 @@ import { attachMarkdownTheme } from '../config.js';
 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 { generatedContextPresentation } from '../../../shared/generated-context.js';
+import { generatedContextExpandedBody, generatedContextPresentation, isRuntimeRestartContinuation, } from '../../../shared/generated-context.js';
+import { assistantVisibleText, isTrueUserMessage, normalizeToolGroupSummary, normalizeToolGroupSummaryRecord, } from '../../../shared/tool-groups.js';
 import { transformMessageDiagrams } from './diagram.js';
+import { transformMessageHtml } from './html-markdown.js';
 import { styleAttachMarkdownHeadings, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-headings.js';
 import { createCrtrEditToolDefinition } from './edit-diff.js';
+import { GroupActivityRecorder } from './group-activity.js';
+import { GroupRecapComponent } from './group-recap.js';
 import { FoldedToolCallController, createCrtrPlainBashToolDefinition, createCrtrReadToolDefinition, createCrtrWriteToolDefinition, } from './tool-calls.js';
 import { ringCompletionBell } from '../chrome/completion-bell.js';
-import { extractFilePaths } from '../visible-paths.js';
+import { extractFilePaths } from '#core/human/visible-paths';
 import { keepWhenCondensed, liveRegionStart } from './condensed-history.js';
 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';
 /** 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 when no
- *  palette is passed (ChatView used standalone) these defaults stand in: a faint
- *  dim and ANSI red, matching the palette's own fallbacks. The message components
+ *  config.ts). pi does not re-export the raw `theme` instance, so standalone
+ *  ChatViews receive the same semantic ANSI fallback palette. The message components
  *  use the attach Markdown theme, which preserves the user's pi theme while making
  *  fenced code visually distinct. */
-const defaultSpinnerStyle = (s) => `\x1b[2m${s}\x1b[22m`;
 const defaultDimStyle = (s) => `\x1b[2m${s}\x1b[22m`;
 /** How many catch-up messages `applySnapshot` builds between event-loop yields.
  *  Keeps large non-streaming snapshots from monopolizing the main thread so
@@ -85,6 +89,27 @@ function readFoldFinishedTools() {
         return false;
     }
 }
+/** Whether this attach should start folded tool groups on their broker-generated
+ * summaries. The setting is deliberately attach-local: the broker remains the
+ * single summary producer and every viewer independently chooses its display. */
+function readSummarizeToolCalls() {
+    try {
+        return readConfig('user').summarize_tool_calls;
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether folded tool recaps list their actual activity or use compact counts.
+ * The detailed form is the default; each attach reads its own presentation choice. */
+function readDetailedToolRecaps() {
+    try {
+        return readConfig('user').detailed_tool_recaps;
+    }
+    catch {
+        return true;
+    }
+}
 /** Persist the fold view setting to user config. Best-effort: a viewer must never
  *  die because the config file is unwritable — the in-viewer toggle still applies. */
 function persistFoldFinishedTools(value) {
@@ -166,6 +191,8 @@ class FoldedToolSeparator extends Spacer {
     }
 }
 class MinimizableToolComponent extends ToolExecutionComponent {
+    /** Bound by ChatView at append time; pi's base component does not expose it. */
+    activityCallId;
     minimized = false;
     expandedState = false;
     foldController;
@@ -207,51 +234,35 @@ class MinimizableToolComponent extends ToolExecutionComponent {
     }
 }
 const defaultErrorStyle = (s) => `\x1b[31m${s}\x1b[39m`;
-/** Keep settled conversation history out of picker/editor render hot paths. The
- *  root TUI still compares the cached lines, but it no longer re-renders every
- *  markdown/tool component for each repeated navigation key. */
-class RenderCacheContainer extends Container {
-    childCache = new Map();
-    markDirty(component) {
-        if (component)
-            this.childCache.delete(component);
-        else
-            this.childCache.clear();
-    }
-    removeChild(component) {
-        super.removeChild(component);
-        this.childCache.delete(component);
-    }
-    clear() {
-        super.clear();
-        this.childCache.clear();
-    }
-    invalidate() {
-        super.invalidate();
-        this.childCache.clear();
-    }
-    render(width) {
-        const lines = [];
-        for (const child of this.children) {
-            let cached = this.childCache.get(child);
-            if (!cached || cached.width !== width) {
-                cached = { width, lines: child.render(width) };
-                this.childCache.set(child, cached);
-            }
-            lines.push(...cached.lines);
-        }
-        return lines;
-    }
-}
+const defaultAttachPalette = {
+    accent: (s) => `\x1b[33m${s}\x1b[39m`,
+    active: (s) => `\x1b[36m${s}\x1b[39m`,
+    info: (s) => `\x1b[34m${s}\x1b[39m`,
+    muted: defaultDimStyle,
+    faint: defaultDimStyle,
+    border: (s) => s,
+    surface: (s) => s,
+    bold: (s) => `\x1b[1m${s}\x1b[22m`,
+    error: defaultErrorStyle,
+    warning: (s) => `\x1b[33m${s}\x1b[39m`,
+    diffAdded: (s) => `\x1b[32m${s}\x1b[39m`,
+    diffRemoved: (s) => `\x1b[91m${s}\x1b[39m`,
+    bashMode: (s) => `\x1b[32m${s}\x1b[39m`,
+    bashModeAlt: (s) => `\x1b[92m${s}\x1b[39m`,
+};
 export class ChatView {
     tui;
     /** The chat scroll area handed in by the attach command. */
     container;
     /** Settled history is cached independently from the live status area so picker
      *  navigation does not re-render a long conversation on every key repeat. */
-    historyContainer = new RenderCacheContainer();
-    /** Activity/status area below history. Holds working/compaction/retry loaders. */
-    statusContainer = new Container();
+    historyContainer = new MeasuredContainer();
+    /** Standalone ChatViews render activity inline; the attach viewer supplies
+     *  `onActivityChange`, so its transcript excludes this container. */
+    statusContainer = new MeasuredContainer();
+    /** Optional banner, above history and status in the viewport's flat source. */
+    bannerContainer;
+    transcript;
     /** Where `append()` puts a component. Normally `historyContainer`; retargeted to
      *  a nested container while condensed history is being built, so the same
      *  message-rendering path serves both regions. */
@@ -267,17 +278,37 @@ export class ChatView {
     hiddenThinkingLabel;
     /** Ctrl+O: pi's two-state tool-output expansion. */
     toolOutputExpanded;
-    /** The view setting (Alt+C → w → f): fold every SETTLED tool call to its single
+    /** The view setting (Alt+C → z → f): fold every SETTLED tool call to its single
      *  call line. Independent of `toolOutputExpanded` — it survives an expand/collapse
      *  and only ever applies to tool calls that are done. */
     foldSettledTools = readFoldFinishedTools();
+    /** Summary mode only changes Ctrl+O when both persistent settings are on. */
+    summarizeToolCalls = readSummarizeToolCalls();
+    detailedToolRecaps = readDetailedToolRecaps();
+    showGroupSummaries = this.summarizeToolCalls && this.foldSettledTools;
+    /** Groups exist only while building/rendering the full-fidelity live region. */
+    groups = [];
+    openGroup;
+    groupSummaries = new Map();
+    streamingWasGroupMember = false;
     onFooterEvent;
+    /** Viewer hook that places activity in its fixed slot, when available. */
+    onActivityChange;
     /** Theme-derived colorizers for the activity/status area. */
     spinnerStyle;
     dimStyle;
     errorStyle;
+    /** Palette shared with recap rows that render outside pi tool callbacks. */
+    recapPalette;
     /** Bold accent for the expanded crtr-context label. */
     labelStyle = (s) => `\x1b[1m${s}\x1b[22m`;
+    /** Raw broker messages retained beside their viewer components so a local
+     *  Ctrl+O disclosure toggle can re-project settled Markdown without touching
+     *  persisted/copyable source. Includes condensed-history components. */
+    assistantSources = new Map();
+    /** Undefined honors each `<details open>` attribute until Ctrl+O establishes
+     *  one viewer-wide disclosure state. */
+    detailsExpandedOverride;
     /** The assistant message component currently being streamed (between
      *  message_start and message_end for an assistant turn). */
     streamingComponent;
@@ -293,6 +324,10 @@ export class ChatView {
     bashComponent;
     /** The single active activity loader (working/compaction/retry), if any. */
     activityLoader;
+    /** Broker-selected normal label for this turn; compaction/retry temporarily
+     *  replace it and restore it when the run remains active. */
+    workingActivity = DEFAULT_WORKING_ACTIVITY;
+    runActive = false;
     // -- Single-writer snapshot ordering -------------------------------------
     // A non-streaming catch-up yields to the event loop mid-build (so queued stdin
     // drains), which opens a window where later broker frames could otherwise
@@ -320,6 +355,12 @@ export class ChatView {
     transcriptTexts = [];
     /** Existing file paths found anywhere in the rendered transcript, newest first. */
     transcriptFilePaths = [];
+    /** Canonical copyable transcript blocks, in their rendered visual order. */
+    copyBlockRecords = [];
+    copyIndex = new Map();
+    /** Registrations made while building condensed history are collapsed onto its
+     * outer container once that container becomes a top-level viewport block. */
+    condensedCopyBlocks = new WeakMap();
     constructor(tui, container, opts = {}) {
         this.tui = tui;
         this.container = container;
@@ -332,21 +373,34 @@ export class ChatView {
         this.liveCycles = opts.liveCycles ?? readLiveCycles();
         this.condensedHistory = opts.condensedHistory ?? readCondensedHistory();
         this.onFooterEvent = opts.onFooterEvent;
-        this.spinnerStyle = opts.palette?.active ?? defaultSpinnerStyle;
-        this.dimStyle = opts.palette?.muted ?? defaultDimStyle;
-        this.errorStyle = opts.palette?.error ?? defaultErrorStyle;
+        this.onActivityChange = opts.onActivityChange;
+        this.recapPalette = opts.palette ?? defaultAttachPalette;
+        this.spinnerStyle = this.recapPalette.active;
+        this.dimStyle = this.recapPalette.muted;
+        this.errorStyle = this.recapPalette.error;
         // Banner sits above history and OUTSIDE it, so resetChat() (which clears only
         // historyContainer) never wipes it — it persists across every welcome snapshot.
         if (opts.banner && opts.banner.length > 0) {
-            const b = new Container();
-            b.addChild(new Spacer(1));
+            const banner = new MeasuredContainer();
+            banner.addChild(new Spacer(1));
             for (const line of opts.banner)
-                b.addChild(new Text(line, 1, 0));
-            b.addChild(new Spacer(1));
-            this.container.addChild(b);
+                banner.addChild(new Text(line, 1, 0));
+            banner.addChild(new Spacer(1));
+            this.bannerContainer = banner;
+            this.container.addChild(banner);
         }
         this.container.addChild(this.historyContainer);
-        this.container.addChild(this.statusContainer);
+        if (!this.onActivityChange)
+            this.container.addChild(this.statusContainer);
+        this.transcript = new CompositeViewportSource([
+            ...(this.bannerContainer ? [this.bannerContainer] : []),
+            this.historyContainer,
+            ...(this.onActivityChange ? [] : [this.statusContainer]),
+        ]);
+    }
+    /** The transcript as one flat ordered block list for the viewport. */
+    transcriptSource() {
+        return this.transcript;
     }
     // -------------------------------------------------------------------------
     // Catch-up: render the welcome snapshot, then live events resume.
@@ -365,6 +419,11 @@ 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);
         const renderedPendingTools = new Map();
         const messages = snapshot.messages;
         const lastIndex = messages.length - 1;
@@ -379,7 +438,7 @@ export class ChatView {
             if (generation !== this.snapshotGeneration)
                 return;
             if (condensed)
-                this.append(condensed);
+                this.appendCondensedBlock(condensed);
         }
         for (let i = liveStart; i < messages.length; i++) {
             // Yield to the event loop every SNAPSHOT_YIELD_EVERY messages so queued
@@ -401,7 +460,7 @@ export class ChatView {
             if (message.role === 'assistant') {
                 // Keep the `/copy` source current from the catch-up transcript too, not
                 // only the live stream (you usually attach AFTER the last reply landed).
-                const text = this.userMessageText(message);
+                const text = assistantVisibleText(message);
                 if (text.trim()) {
                     this.lastAssistantText = text;
                     this.pushTranscriptText(text);
@@ -416,42 +475,65 @@ export class ChatView {
                     snapshot.state.isStreaming &&
                     message.stopReason !== 'aborted' &&
                     message.stopReason !== 'error';
+                const hasProse = assistantVisibleText(message).trim() !== '';
+                const toolCalls = this.assistantToolCalls(message);
+                const endedWithFailure = message.stopReason === 'aborted' || message.stopReason === 'error';
+                const terminalErrorMessage = message.stopReason === 'aborted'
+                    ? 'Interrupted'
+                    : (message.errorMessage ?? 'Error');
+                // A terminal assistant failure remains visible as its own boundary. Settle
+                // any interrupted calls so the completed span before it can still recap.
+                if (endedWithFailure) {
+                    for (const component of renderedPendingTools.values()) {
+                        const result = { content: [{ type: 'text', text: terminalErrorMessage }], isError: true };
+                        component.updateResult(result);
+                        this.registerCopyBlock(component, 'tool', terminalErrorMessage);
+                        this.settleGroupTool(component, result, true);
+                    }
+                    renderedPendingTools.clear();
+                }
+                if (hasProse || endedWithFailure)
+                    this.closeOpenGroup();
                 let separator;
                 if (isStreamingTail) {
                     this.streamingComponent = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel);
-                    this.append(this.streamingComponent);
-                    this.streamingComponent.updateContent(styleAttachMessageMarkdown(message));
-                    separator = this.streamingToolSeparator = this.appendFoldedToolSeparator();
+                    this.appendAssistantPart(this.streamingComponent, !hasProse);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', '');
+                    this.streamingWasGroupMember = !hasProse;
+                    this.updateAssistantComponent(this.streamingComponent, message);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', assistantVisibleText(message));
+                    separator = this.streamingToolSeparator = this.appendAssistantSeparator(!hasProse);
                 }
                 else {
-                    separator = this.appendAssistantMessage(message);
+                    separator = this.appendAssistantMessage(message, !hasProse && !endedWithFailure);
                 }
-                const toolCalls = this.assistantToolCalls(message);
                 if (separator)
                     this.setAssistantSeparatorContent(separator, message);
                 for (const content of toolCalls) {
                     this.pushTranscriptValue(content.arguments);
-                    const component = this.makeToolComponent(content.name, content.id, content.arguments);
-                    this.append(component);
+                    const component = this.appendToolComponent(content.name, content.id, content.arguments);
                     // (isStreamingTail is never aborted/error, so its tools fall through to
                     //  renderedPendingTools → pendingTools, where live tool events find them.)
                     if (message.stopReason === 'aborted' || message.stopReason === 'error') {
-                        const errorMessage = message.stopReason === 'aborted'
-                            ? 'Interrupted'
-                            : (message.errorMessage ?? 'Error');
-                        component.updateResult({ content: [{ type: 'text', text: errorMessage }], isError: true });
+                        component.updateResult({ content: [{ type: 'text', text: terminalErrorMessage }], isError: true });
+                        this.registerCopyBlock(component, 'tool', terminalErrorMessage);
+                        this.settleGroupTool(component, { content: [{ type: 'text', text: terminalErrorMessage }], isError: true }, true);
                     }
                     else {
                         renderedPendingTools.set(content.id, component);
                     }
                 }
+                if (endedWithFailure)
+                    this.closeOpenGroup();
             }
             else if (message.role === 'toolResult') {
                 this.pushTranscriptText(this.userMessageText(message));
                 const component = renderedPendingTools.get(message.toolCallId);
                 if (component) {
                     component.updateResult(message);
+                    this.registerCopyBlock(component, 'tool', this.toolResultText(message));
                     this.historyContainer.markDirty(component);
+                    this.settleGroupTool(component, message, message.isError === true);
                     renderedPendingTools.delete(message.toolCallId);
                 }
             }
@@ -464,13 +546,12 @@ export class ChatView {
         }
         // A rebuild constructs fresh components, which are born unfolded; re-apply the
         // setting so a reconnect/welcome does not silently unfold the transcript.
-        if (this.foldSettledTools)
-            this.applyToolDisplay();
+        this.applyToolDisplay();
         // If we attached mid-turn, the `agent_start` that spins up the working loader
         // already fired before we connected — restore it from the snapshot's streaming
         // state so an actively-working node shows the spinner right away.
         if (snapshot.state.isStreaming)
-            this.setActivity(this.makeLoader('Working...'));
+            this.setActivity(this.makeLoader(this.workingActivity));
         this.tui.requestRender();
         // Build complete and still current (a mismatch would have returned above):
         // open the gate and replay, in wire order, any live frames that arrived
@@ -492,7 +573,9 @@ export class ChatView {
     async buildCondensedBlock(messages, generation) {
         const condensed = new Container();
         const previousTarget = this.appendTarget;
+        const copyBlocks = [];
         this.appendTarget = condensed;
+        this.condensedCopyBlocks.set(condensed, copyBlocks);
         try {
             let built = 0;
             for (const message of messages) {
@@ -513,8 +596,9 @@ export class ChatView {
         }
         finally {
             this.appendTarget = previousTarget;
+            this.condensedCopyBlocks.delete(condensed);
         }
-        return condensed.children.length > 0 ? condensed : undefined;
+        return condensed.children.length > 0 ? { component: condensed, copyBlocks } : undefined;
     }
     /** Defer a live broker frame when a snapshot build is in flight. Returns true
      *  (and enqueues the replay closure) while building so the caller returns
@@ -533,14 +617,26 @@ export class ChatView {
         for (const replay of frames)
             replay();
     }
+    /** Accept the broker's per-turn random choice before its following agent_start. */
+    setWorkingActivity(activity) {
+        if (this.deferIfBuilding(() => this.setWorkingActivity(activity)))
+            return;
+        this.workingActivity = activity.trim() === '' ? DEFAULT_WORKING_ACTIVITY : activity;
+    }
     /** Clear live turn state after the broker reports completion or the viewer observes dormancy. */
     settleRun() {
+        this.runActive = false;
+        for (const component of this.pendingTools.values())
+            this.settleGroupTool(component);
         if (this.streamingComponent) {
             this.historyContainer.removeChild(this.streamingComponent);
+            this.unregisterCopyBlock(this.streamingComponent);
+            this.assistantSources.delete(this.streamingComponent);
             this.streamingComponent = undefined;
         }
         this.streamingToolSeparator = undefined;
         this.pendingTools.clear();
+        this.applyToolDisplay();
         this.setActivity(undefined);
         this.settleBashComponent();
     }
@@ -555,36 +651,54 @@ export class ChatView {
     // Pure client-side render state — no broker round-trip — ported from pi's
     // `setToolsExpanded` / `toggleThinkingBlockVisibility`.
     // -------------------------------------------------------------------------
-    /** Ctrl+O / app.tools.expand — flip global tool-output expansion and apply it to
-     *  every rendered component that supports it. Returns the new expanded state so
-     *  the caller can surface a notice. Condensed cycles hold no tool components, so
-     *  they are unaffected by design. */
+    /** Ctrl+O prefers summaries when the user enabled both folding and summary
+     * generation. The same disclosure state drives assistant-authored `<details>`
+     * sections, so the transcript has one reveal-more action rather than two. */
     toggleToolsExpanded() {
-        this.toolOutputExpanded = !this.toolOutputExpanded;
+        let result;
+        if (this.summarizeToolCalls && this.foldSettledTools) {
+            this.showGroupSummaries = !this.showGroupSummaries;
+            this.toolOutputExpanded = !this.showGroupSummaries;
+            result = { kind: 'summaries', shown: this.showGroupSummaries };
+        }
+        else {
+            this.toolOutputExpanded = !this.toolOutputExpanded;
+            result = { kind: 'output', expanded: this.toolOutputExpanded };
+        }
+        this.detailsExpandedOverride = this.toolOutputExpanded;
+        this.rerenderAssistantMessages();
         this.applyToolDisplay();
-        return this.toolOutputExpanded;
+        return result;
     }
-    /** The `fold finished tool calls` view setting (`/fold-tools`, Alt+C → w → f).
+    /** The `fold finished tool calls` view setting (`/fold-tools`, Alt+C → z → f).
      *  Returns the new state so the caller can surface a notice. */
     toggleFoldSettledTools() {
         this.foldSettledTools = !this.foldSettledTools;
         persistFoldFinishedTools(this.foldSettledTools);
+        // Turning folding back on restores the configured default (summaries),
+        // rather than preserving a stale Ctrl+O choice from an unfolded view.
+        if (this.summarizeToolCalls && this.foldSettledTools)
+            this.showGroupSummaries = true;
         this.applyToolDisplay();
         return this.foldSettledTools;
     }
     /** Push both display settings onto every rendered component. A tool call still in
-     *  `pendingTools` is in flight, so it is never folded — you keep watching live
-     *  output, and it folds on its own once `tool_execution_end` settles it. */
+     *  flight is never hidden or minimized. Only a settled group with a broker-known
+     *  summary collapses; incomplete/failed generation leaves its folded call lines. */
     applyToolDisplay() {
         const inFlight = new Set(this.pendingTools.values());
-        this.updateFoldedToolSeparators(inFlight);
+        for (const group of this.groups)
+            for (const tool of group.inFlight)
+                inFlight.add(tool);
         for (const child of this.historyContainer.children) {
-            if (child instanceof MinimizableToolComponent) {
+            if (child instanceof MinimizableToolComponent)
                 child.setMinimized(this.foldSettledTools && !inFlight.has(child));
-            }
             if (isExpandable(child))
                 child.setExpanded(this.toolOutputExpanded);
         }
+        for (const group of this.groups)
+            this.applyGroupDisplay(group);
+        this.updateFoldedToolSeparators(inFlight);
         this.historyContainer.markDirty();
         this.tui.requestRender();
     }
@@ -615,8 +729,11 @@ export class ChatView {
             return;
         switch (event.type) {
             case 'agent_start': {
+                this.runActive = true;
+                for (const component of this.pendingTools.values())
+                    this.settleGroupTool(component);
                 this.pendingTools.clear();
-                this.setActivity(this.makeLoader('Working...'));
+                this.setActivity(this.makeLoader(this.workingActivity));
                 break;
             }
             case 'agent_end': {
@@ -644,23 +761,28 @@ export class ChatView {
                     this.addMessageToChat(event.message);
                 }
                 else if (event.message.role === 'assistant') {
+                    const hasProse = assistantVisibleText(event.message).trim() !== '';
+                    if (hasProse)
+                        this.closeOpenGroup();
                     this.streamingComponent = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel);
-                    this.append(this.streamingComponent);
-                    this.streamingComponent.updateContent(styleAttachMessageMarkdown(event.message));
-                    this.streamingToolSeparator = this.appendFoldedToolSeparator();
+                    this.streamingWasGroupMember = !hasProse;
+                    this.appendAssistantPart(this.streamingComponent, !hasProse);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', '');
+                    this.updateAssistantComponent(this.streamingComponent, event.message);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', assistantVisibleText(event.message));
+                    this.streamingToolSeparator = this.appendAssistantSeparator(!hasProse);
                     this.setAssistantSeparatorContent(this.streamingToolSeparator, event.message);
                 }
                 break;
             }
             case 'message_update': {
                 if (this.streamingComponent && event.message.role === 'assistant') {
-                    // Render any ALREADY-COMPLETE diagram fence to a diagram mid-stream
-                    // (transformMessageDiagrams only matches closed fences and is memoized,
-                    // so an unclosed fence still streaming stays raw and settles later).
-                    // This makes a diagram pop the instant its closing ``` arrives instead
-                    // of waiting for message_end — noticeable when more text follows it.
-                    const updated = styleAttachMessageMarkdown(transformMessageDiagrams(event.message, this.renderWidth()));
-                    this.streamingComponent.updateContent(updated);
+                    this.promoteStreamingAssistantToBoundary(event.message);
+                    // Upgrade complete rich-Markdown constructs mid-stream. Incomplete
+                    // Mermaid fences and HTML pairs remain literal until their closing
+                    // marker arrives, then this same settled-message pipeline projects them.
+                    this.updateAssistantComponent(this.streamingComponent, event.message);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', assistantVisibleText(event.message));
                     this.historyContainer.markDirty(this.streamingComponent);
                     const toolCalls = this.assistantToolCalls(event.message);
                     if (this.streamingToolSeparator)
@@ -670,11 +792,11 @@ export class ChatView {
                         const existing = this.pendingTools.get(content.id);
                         if (existing) {
                             existing.updateArgs(content.arguments);
+                            this.noteGroupTool(existing, content.name, content.arguments);
                             this.historyContainer.markDirty(existing);
                         }
                         else {
-                            const component = this.makeToolComponent(content.name, content.id, content.arguments);
-                            this.append(component);
+                            const component = this.appendToolComponent(content.name, content.id, content.arguments);
                             this.pendingTools.set(content.id, component);
                         }
                     }
@@ -684,10 +806,16 @@ export class ChatView {
             case 'message_end': {
                 if (event.message.role !== 'assistant')
                     break;
+                const endedWithFailure = event.message.stopReason === 'aborted' || event.message.stopReason === 'error';
+                // A terminal failure is always its own visible boundary, including an
+                // empty abort created by yield or a daemon restart.
+                this.promoteStreamingAssistantToBoundary(event.message, endedWithFailure);
                 // Stash the completed reply's text for `/copy` (skip aborted/error turns,
                 // whose text is partial or absent).
+                if (this.streamingComponent)
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', assistantVisibleText(event.message));
                 if (event.message.stopReason !== 'aborted' && event.message.stopReason !== 'error') {
-                    const text = this.userMessageText(event.message);
+                    const text = assistantVisibleText(event.message);
                     if (text.trim()) {
                         this.lastAssistantText = text;
                         this.pushTranscriptText(text);
@@ -696,10 +824,9 @@ export class ChatView {
                 if (this.streamingComponent) {
                     const stopReason = event.message.stopReason;
                     let errorMessage = event.message.errorMessage;
-                    // An aborted turn is a user interrupt (Esc). The provider tends to
-                    // attach its own generic text ("Request was aborted."), so override it
-                    // outright — don't gate on the absence of an errorMessage — with a
-                    // plain, human label.
+                    // An aborted turn may be a user interrupt or a lifecycle interruption.
+                    // The provider tends to attach its own generic text ("Request was
+                    // aborted."), so override it outright with one plain, human label.
                     if (stopReason === 'aborted') {
                         errorMessage = 'Interrupted';
                         // Surface the abort on the assistant bubble itself, mirroring pi
@@ -707,14 +834,14 @@ export class ChatView {
                         // updateContent) so the rendered message shows the annotation.
                         event.message.errorMessage = errorMessage;
                     }
-                    // Render every supported complete diagram fence in the settled reply
-                    // before it reaches the markdown renderer (no-op when absent).
-                    const finalMessage = styleAttachMessageMarkdown(transformMessageDiagrams(event.message, this.renderWidth()));
-                    this.streamingComponent.updateContent(finalMessage);
+                    // Project every supported rich-Markdown construct in the settled reply.
+                    this.updateAssistantComponent(this.streamingComponent, event.message);
                     if (stopReason === 'aborted' || stopReason === 'error') {
                         const text = errorMessage ?? 'Error';
                         for (const component of this.pendingTools.values()) {
                             component.updateResult({ content: [{ type: 'text', text }], isError: true });
+                            this.registerCopyBlock(component, 'tool', text);
+                            this.settleGroupTool(component, { content: [{ type: 'text', text }], isError: true }, true);
                             this.historyContainer.markDirty(component);
                         }
                         this.pendingTools.clear();
@@ -730,16 +857,24 @@ export class ChatView {
                     this.streamingComponent = undefined;
                     this.streamingToolSeparator = undefined;
                 }
+                if (endedWithFailure) {
+                    this.closeOpenGroup();
+                    // A summary normally follows this terminal frame, but re-evaluate now
+                    // too so an early recap immediately folds the tools before this seam.
+                    this.applyToolDisplay();
+                }
                 break;
             }
             case 'tool_execution_start': {
                 this.pushTranscriptValue(event.args);
                 let component = this.pendingTools.get(event.toolCallId);
                 if (!component) {
-                    component = this.makeToolComponent(event.toolName, event.toolCallId, event.args);
-                    this.append(component);
+                    component = this.appendToolComponent(event.toolName, event.toolCallId, event.args);
                     this.pendingTools.set(event.toolCallId, component);
                 }
+                else {
+                    this.noteGroupTool(component, event.toolName, event.args);
+                }
                 component.markExecutionStarted();
                 this.historyContainer.markDirty(component);
                 break;
@@ -749,6 +884,7 @@ export class ChatView {
                 const component = this.pendingTools.get(event.toolCallId);
                 if (component) {
                     component.updateResult({ ...event.partialResult, isError: false }, true);
+                    this.registerCopyBlock(component, 'tool', this.toolResultText(event.partialResult));
                     this.historyContainer.markDirty(component);
                 }
                 break;
@@ -758,11 +894,10 @@ export class ChatView {
                 const component = this.pendingTools.get(event.toolCallId);
                 if (component) {
                     component.updateResult({ ...event.result, isError: event.isError });
+                    this.registerCopyBlock(component, 'tool', this.toolResultText(event.result));
                     this.pendingTools.delete(event.toolCallId);
-                    // Settled → it now obeys the fold setting it was exempt from while live.
-                    if (this.foldSettledTools)
-                        component.setMinimized(true);
-                    this.updateFoldedToolSeparators();
+                    this.settleGroupTool(component, event.result, event.isError);
+                    this.applyToolDisplay();
                     this.historyContainer.markDirty(component);
                 }
                 break;
@@ -773,7 +908,7 @@ export class ChatView {
                 break;
             }
             case 'compaction_end': {
-                this.setActivity(undefined);
+                this.setActivity(this.runActive ? this.makeLoader(this.workingActivity) : undefined);
                 if (event.aborted) {
                     this.showStatus(event.reason === 'manual' ? 'Compaction cancelled' : 'Auto-compaction cancelled');
                 }
@@ -804,7 +939,7 @@ export class ChatView {
                 break;
             }
             case 'auto_retry_end': {
-                this.setActivity(undefined);
+                this.setActivity(this.runActive ? this.makeLoader(this.workingActivity) : undefined);
                 if (!event.success) {
                     this.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError ?? 'Unknown error'}`);
                 }
@@ -822,7 +957,7 @@ export class ChatView {
                 break;
         }
         // No unconditional markDirty here: appends/removes invalidate through
-        // RenderCacheContainer, and branches that mutate a child in place explicitly
+        // MeasuredContainer, and branches that mutate a child in place explicitly
         // mark it dirty. Activity-only events leave settled history cached while the
         // independent status loader animates.
         this.tui.requestRender();
@@ -836,6 +971,7 @@ export class ChatView {
     bashStart(command, excludeFromContext) {
         if (this.deferIfBuilding(() => this.bashStart(command, excludeFromContext)))
             return;
+        this.closeOpenGroup();
         this.settleBashComponent();
         let component;
         component = new BashExecutionComponent(command, this.componentTui(() => component), excludeFromContext);
@@ -872,11 +1008,27 @@ export class ChatView {
         if (generated !== null &&
             (message.role !== 'custom' || message.display === true)) {
             this.pushTranscriptText(generated.body);
-            this.append(new ContextMessageComponent(generated.body, this.toolOutputExpanded, this.dimStyle, (s) => this.spinnerStyle(this.labelStyle(s)), generated.label, ` ${generated.summary} — ctrl+o to expand`));
+            const component = new ContextMessageComponent(generatedContextExpandedBody(generated), this.toolOutputExpanded, this.dimStyle, (s) => this.spinnerStyle(this.labelStyle(s)), generated.label, ` ${generated.summary} — ctrl+o to expand`, generated.label === 'crtr context' || generated.kind === 'revive' || generated.kind === 'inbox');
+            // A successor broker's exact restart continuation is a visible seam, not
+            // a group member: the preceding span keeps its own recap and the next tool
+            // call begins a broker-aligned fresh group.
+            if (isRuntimeRestartContinuation(message)) {
+                this.closeOpenGroup();
+                this.append(component);
+                // Bearings and revive kickoffs only belong to an already-open run; they
+                // never create a summary block by themselves. Other injected context may.
+            }
+            else if (generated.kind === 'bearings' || generated.kind === 'revive') {
+                this.appendExistingGroupMember(component);
+            }
+            else {
+                this.appendGroupMember(component);
+            }
             return;
         }
         switch (message.role) {
             case 'bashExecution': {
+                this.closeOpenGroup();
                 this.pushTranscriptText(message.output ?? '');
                 const component = new BashExecutionComponent(message.command, this.tui, message.excludeFromContext);
                 if (message.output)
@@ -894,7 +1046,7 @@ export class ChatView {
                 if (message.display) {
                     this.pushTranscriptText(this.userMessageText(message));
                     if (message.customType === CRTR_OUTPUT_CUSTOM_TYPE) {
-                        this.append(new CrtrOutputMessageComponent(this.userMessageText(message), this.toolOutputExpanded, this.crtrOutputTheme()));
+                        this.appendGroupMember(new CrtrOutputMessageComponent(this.userMessageText(message), this.toolOutputExpanded, this.crtrOutputTheme()));
                         break;
                     }
                     // A refresh-yield cycle boundary (session-cycles.ts, synthetic — never
@@ -902,6 +1054,7 @@ export class ChatView {
                     // message card, so scrolling through a multi-cycle node's full history
                     // reads as one conversation with clear seams between cycles.
                     if (message.customType === CRTR_CYCLE_DIVIDER_CUSTOM_TYPE) {
+                        this.closeOpenGroup();
                         this.append(new Spacer(1));
                         this.append(new Text(this.dimStyle(`── ${this.userMessageText(message)} ──`), 1, 0));
                         this.append(new Spacer(1));
@@ -909,11 +1062,12 @@ export class ChatView {
                     }
                     const component = new CustomMessageComponent(styleAttachMessageMarkdown(message), undefined, attachMarkdownTheme());
                     component.setExpanded(this.toolOutputExpanded);
-                    this.append(component);
+                    this.appendGroupMember(component);
                 }
                 break;
             }
             case 'compactionSummary': {
+                this.closeOpenGroup();
                 this.append(new Spacer(1));
                 const component = new CompactionSummaryMessageComponent(styleAttachSummaryMarkdown(message), attachMarkdownTheme());
                 component.setExpanded(this.toolOutputExpanded);
@@ -921,35 +1075,47 @@ export class ChatView {
                 break;
             }
             case 'branchSummary': {
+                this.closeOpenGroup();
                 this.append(new Spacer(1));
                 const component = new BranchSummaryMessageComponent(styleAttachSummaryMarkdown(message), attachMarkdownTheme());
                 component.setExpanded(this.toolOutputExpanded);
                 this.append(component);
+                this.registerCopyBlock(component, 'assistant', message.summary);
                 break;
             }
             case 'user': {
+                if (isTrueUserMessage(message))
+                    this.closeOpenGroup();
                 const textContent = this.userMessageText(message);
                 if (!textContent)
                     break;
                 this.pushTranscriptText(textContent);
                 if (this.chatChildCount() > 0)
-                    this.append(new Spacer(1));
+                    this.appendUserPart(new Spacer(1), !isTrueUserMessage(message));
                 const skillBlock = parseSkillBlock(textContent);
                 if (skillBlock) {
                     const component = new SkillInvocationMessageComponent({ ...skillBlock, content: styleAttachMarkdownHeadings(skillBlock.content) }, attachMarkdownTheme());
                     component.setExpanded(this.toolOutputExpanded);
-                    this.append(component);
+                    this.appendUserPart(component, !isTrueUserMessage(message));
+                    this.registerCopyBlock(component, 'user', textContent);
                     if (skillBlock.userMessage) {
-                        this.append(new UserMessageComponent(styleAttachMarkdownHeadings(skillBlock.userMessage), attachMarkdownTheme()));
+                        const userMessage = new UserMessageComponent(styleAttachMarkdownHeadings(skillBlock.userMessage), attachMarkdownTheme());
+                        this.appendUserPart(userMessage, !isTrueUserMessage(message));
+                        this.registerCopyBlock(userMessage, 'user', skillBlock.userMessage);
                     }
                 }
                 else {
-                    this.append(new UserMessageComponent(styleAttachMarkdownHeadings(textContent), attachMarkdownTheme()));
+                    const component = new UserMessageComponent(styleAttachMarkdownHeadings(textContent), attachMarkdownTheme());
+                    this.appendUserPart(component, !isTrueUserMessage(message));
+                    this.registerCopyBlock(component, 'user', textContent);
                 }
                 break;
             }
             case 'assistant': {
-                this.appendAssistantMessage(message);
+                const hasProse = assistantVisibleText(message).trim() !== '';
+                if (hasProse)
+                    this.closeOpenGroup();
+                this.appendAssistantMessage(message, !hasProse);
                 break;
             }
             // toolResult is rendered inline with its tool call (handled in applySnapshot).
@@ -961,19 +1127,176 @@ export class ChatView {
     // Helpers
     // -------------------------------------------------------------------------
     /** Render an assistant reply plus its initially-hidden boundary separator. */
-    appendAssistantMessage(message) {
-        this.append(new ViewerAssistantMessageComponent(styleAttachMessageMarkdown(transformMessageDiagrams(message, this.renderWidth())), this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel));
-        const separator = this.appendFoldedToolSeparator();
+    appendAssistantMessage(message, groupMember = false) {
+        const component = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel);
+        this.updateAssistantComponent(component, message);
+        this.appendAssistantPart(component, groupMember);
+        this.registerCopyBlock(component, 'assistant', assistantVisibleText(message));
+        const separator = this.appendAssistantSeparator(groupMember);
         this.setAssistantSeparatorContent(separator, message);
         return separator;
     }
     /** Add a separator in transcript order now; it renders only after a following
      * tool settles in the folded view. */
-    appendFoldedToolSeparator() {
+    appendAssistantSeparator(groupMember = false) {
         const separator = new FoldedToolSeparator();
-        this.append(separator);
+        if (groupMember)
+            this.appendGroupMember(separator);
+        else
+            this.append(separator);
         return separator;
     }
+    appendAssistantPart(component, groupMember) {
+        if (groupMember)
+            this.appendGroupMember(component);
+        else
+            this.append(component);
+    }
+    appendUserPart(component, groupMember) {
+        if (groupMember)
+            this.appendGroupMember(component);
+        else
+            this.append(component);
+    }
+    /** Only the full-fidelity trailing region gets summary groups. Condensed
+     * history intentionally drops tool traffic, so grouping there would create
+     * phantom summary rows and cross the live/condensed boundary. */
+    isLiveGroupRegion() {
+        return this.appendTarget === this.historyContainer;
+    }
+    ensureGroup() {
+        if (!this.isLiveGroupRegion())
+            return undefined;
+        if (this.openGroup)
+            return this.openGroup;
+        const recap = new GroupRecapComponent();
+        const group = {
+            members: [],
+            recap,
+            activity: new GroupActivityRecorder(this.cwd),
+            toolCount: 0,
+            inFlight: new Set(),
+        };
+        this.append(recap);
+        // The recap is a direct history child for cache identity, but zero-row and
+        // hidden until a settled broker summary makes this group collapsible.
+        this.historyContainer.setHidden(recap, true);
+        this.groups.push(group);
+        this.openGroup = group;
+        return group;
+    }
+    closeOpenGroup() {
+        this.openGroup = undefined;
+    }
+    appendGroupMember(component) {
+        const group = this.ensureGroup();
+        this.append(component);
+        if (group)
+            group.members.push(component);
+    }
+    /** Used for context that may join an existing run but must not create one. */
+    appendExistingGroupMember(component) {
+        this.append(component);
+        if (this.isLiveGroupRegion() && this.openGroup)
+            this.openGroup.members.push(component);
+    }
+    removeGroupMember(component) {
+        for (const group of this.groups) {
+            const index = group.members.indexOf(component);
+            if (index !== -1)
+                group.members.splice(index, 1);
+        }
+        this.historyContainer.setHidden(component, false);
+    }
+    /** Add one tool as a group member, moving the assistant's boundary separator
+     * behind the new summary row without changing the separator's identity. */
+    appendToolComponent(name, id, args) {
+        const trailingSeparator = this.isLiveGroupRegion() &&
+            !this.openGroup &&
+            this.historyContainer.children.at(-1) instanceof FoldedToolSeparator
+            ? this.historyContainer.children.at(-1)
+            : undefined;
+        if (trailingSeparator)
+            this.historyContainer.removeChild(trailingSeparator);
+        const group = this.ensureGroup();
+        if (trailingSeparator) {
+            this.append(trailingSeparator);
+            group?.members.push(trailingSeparator);
+        }
+        const component = this.makeToolComponent(name, id, args);
+        component.activityCallId = id;
+        this.appendGroupMember(component);
+        this.registerCopyBlock(component, 'tool', '');
+        if (group) {
+            group.key ??= id;
+            group.toolCount++;
+            group.inFlight.add(component);
+            group.activity.noteCall(id, name, args);
+        }
+        return component;
+    }
+    noteGroupTool(component, name, args) {
+        if (!component.activityCallId)
+            return;
+        for (const group of this.groups) {
+            if (group.members.includes(component))
+                group.activity.noteCall(component.activityCallId, name, args);
+        }
+    }
+    settleGroupTool(component, result, isError = false) {
+        for (const group of this.groups) {
+            group.inFlight.delete(component);
+            if (!component.activityCallId || !group.members.includes(component))
+                continue;
+            if (result === undefined)
+                group.activity.resolveWithoutResult(component.activityCallId);
+            else
+                group.activity.settle(component.activityCallId, result, isError);
+        }
+    }
+    /** An assistant starts as a non-boundary while its text is empty. Visible prose
+     * or a terminal failure turns it into a boundary without recreating either
+     * pi-owned component (their direct-child cache identities remain intact). */
+    promoteStreamingAssistantToBoundary(message, force = false) {
+        if (!this.streamingWasGroupMember || (!force && assistantVisibleText(message).trim() === ''))
+            return;
+        if (this.streamingComponent)
+            this.removeGroupMember(this.streamingComponent);
+        if (this.streamingToolSeparator)
+            this.removeGroupMember(this.streamingToolSeparator);
+        this.streamingWasGroupMember = false;
+        this.closeOpenGroup();
+    }
+    seedToolGroupSummaries(summaries) {
+        this.groupSummaries.clear();
+        for (const [key, summary] of Object.entries(normalizeToolGroupSummaryRecord(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
+     * and applies to every currently-rendered matching group. */
+    applyToolGroupSummary(key, summary) {
+        if (this.deferIfBuilding(() => this.applyToolGroupSummary(key, summary)))
+            return;
+        const normalized = normalizeToolGroupSummary(summary);
+        if (key.trim() === '' || normalized === null)
+            return;
+        this.groupSummaries.set(key, normalized);
+        this.applyToolDisplay();
+    }
+    applyGroupDisplay(group) {
+        const summary = group.key === undefined ? undefined : this.groupSummaries.get(group.key);
+        const collapsed = this.foldSettledTools &&
+            this.showGroupSummaries &&
+            group.toolCount > 0 &&
+            group.inFlight.size === 0 &&
+            summary !== undefined;
+        group.recap.setRecap(collapsed ? summary : undefined, group.toolCount, group.activity.activity(), this.detailedToolRecaps, this.recapPalette);
+        this.historyContainer.setHidden(group.recap, !collapsed);
+        for (const member of group.members)
+            this.historyContainer.setHidden(member, collapsed);
+    }
     /** Make each separator visible only if its immediately-following tool call is
      * actually folded; in-flight calls remain flush with their live output. */
     updateFoldedToolSeparators(inFlight = new Set(this.pendingTools.values())) {
@@ -984,7 +1307,9 @@ export class ChatView {
                 continue;
             const followingTool = children[i + 1];
             separator.setFolded(this.foldSettledTools &&
+                !this.historyContainer.hiddenChildren.has(separator) &&
                 followingTool instanceof MinimizableToolComponent &&
+                !this.historyContainer.hiddenChildren.has(followingTool) &&
                 !inFlight.has(followingTool));
             this.historyContainer.markDirty(separator);
         }
@@ -1037,6 +1362,33 @@ export class ChatView {
     append(child) {
         this.appendTarget.addChild(child);
     }
+    /** Project one raw assistant message through every attach-local Markdown
+     * transform. This is the sole pipeline used by snapshots, streaming, settled
+     * messages, and Ctrl+O re-renders. */
+    renderAssistantMessage(message) {
+        const withDiagrams = transformMessageDiagrams(message, this.renderWidth());
+        const withHtml = transformMessageHtml(withDiagrams, {
+            detailsExpanded: this.detailsExpandedOverride,
+            styles: {
+                kbd: (text) => this.recapPalette.active(this.recapPalette.bold(`‹${text}›`)),
+                mark: (text) => `\x1b[7m${this.recapPalette.bold(this.recapPalette.accent(text))}\x1b[27m`,
+                hint: this.dimStyle,
+            },
+        });
+        return styleAttachMessageMarkdown(withHtml);
+    }
+    /** Retain canonical source and update one stable transcript component with its
+     * viewer-local projection. */
+    updateAssistantComponent(component, message) {
+        this.assistantSources.set(component, message);
+        component.updateContent(this.renderAssistantMessage(message));
+    }
+    /** Re-project every assistant component in place after a disclosure toggle. */
+    rerenderAssistantMessages() {
+        for (const [component, source] of this.assistantSources) {
+            component.updateContent(this.renderAssistantMessage(source));
+        }
+    }
     /** Approximate render width for inline mermaid diagrams. Only affects
      *  termrender's trailing padding (stripped in the transform), so the terminal
      *  column count is close enough without threading the live pane width here. */
@@ -1054,15 +1406,34 @@ export class ChatView {
         this.settleBashComponent();
         this.streamingComponent = undefined;
         this.streamingToolSeparator = undefined;
+        this.streamingWasGroupMember = false;
         this.foldedToolSeparatorContents.clear();
+        this.assistantSources.clear();
+        this.groups.length = 0;
+        this.openGroup = undefined;
+        this.groupSummaries.clear();
         this.pendingTools.clear();
         this.lastAssistantText = undefined;
+        this.copyBlockRecords.length = 0;
+        this.copyIndex.clear();
         this.transcriptTexts.length = 0;
         this.transcriptFilePaths.length = 0;
         this.historyContainer.clear();
     }
     makeLoader(message) {
-        return new Loader(this.tui, this.spinnerStyle, this.dimStyle, message);
+        // Loader updates itself on an interval. Its TUI callback has to evict the
+        // status block's cached frame before requesting the next render.
+        let loader;
+        const statusTui = {
+            requestRender: (force) => {
+                if (loader && !this.onActivityChange)
+                    this.statusContainer.markDirty(loader);
+                this.tui.requestRender(force);
+            },
+            terminal: this.tui.terminal,
+        };
+        loader = new Loader(statusTui, this.spinnerStyle, this.dimStyle, message);
+        return loader;
     }
     /** Let a self-updating history child invalidate only its own cached lines. */
     componentTui(component) {
@@ -1086,16 +1457,22 @@ export class ChatView {
     /** Swap the single active activity indicator (working/compaction/retry). */
     setActivity(loader) {
         this.activityLoader?.stop();
-        this.statusContainer.clear();
         this.activityLoader = loader;
+        if (this.onActivityChange) {
+            this.onActivityChange(loader);
+            return;
+        }
+        this.statusContainer.clear();
         if (loader)
             this.statusContainer.addChild(loader);
     }
     showStatus(message) {
+        this.closeOpenGroup();
         this.append(new Spacer(1));
         this.append(new Text(this.dimStyle(message), 1, 0));
     }
     showError(message) {
+        this.closeOpenGroup();
         this.append(new Spacer(1));
         this.append(new Text(this.errorStyle(message), 1, 0));
     }
@@ -1131,6 +1508,98 @@ export class ChatView {
         const t = this.lastAssistantText?.trim();
         return t ? t : undefined;
     }
+    /** Copyable source text for a transcript block, if it has any. */
+    blockText(block) {
+        const index = this.copyIndex.get(block);
+        return index === undefined ? undefined : this.copyBlockRecords[index]?.text;
+    }
+    /** The canonical ordered copy record, oldest → newest. */
+    copyBlocks() {
+        return this.copyBlockRecords;
+    }
+    /** Newest tool call's result text (`/copy-tool`). */
+    getLastToolOutputText() {
+        for (let i = this.copyBlockRecords.length - 1; i >= 0; i--) {
+            const copyBlock = this.copyBlockRecords[i];
+            if (copyBlock.kind !== 'tool')
+                continue;
+            return copyBlock.text.trim() === '' ? undefined : copyBlock.text;
+        }
+        return undefined;
+    }
+    /** Every copyable block's text, oldest → newest, joined by blank lines. */
+    getTranscriptPlainText() {
+        return this.copyBlockRecords
+            .map((copyBlock) => copyBlock.text)
+            .filter((text) => text.trim() !== '')
+            .join('\n\n');
+    }
+    registerCopyBlock(block, kind, text) {
+        const condensedCopyBlocks = this.condensedCopyBlocks.get(this.appendTarget);
+        if (condensedCopyBlocks) {
+            const index = condensedCopyBlocks.findIndex((copyBlock) => copyBlock.block === block);
+            if (index === -1)
+                condensedCopyBlocks.push({ block, kind, text });
+            else
+                condensedCopyBlocks[index].text = text;
+            return;
+        }
+        const index = this.copyIndex.get(block);
+        if (index === undefined) {
+            this.copyIndex.set(block, this.copyBlockRecords.length);
+            this.copyBlockRecords.push({ block, kind, text });
+        }
+        else {
+            this.copyBlockRecords[index].text = text;
+        }
+    }
+    unregisterCopyBlock(block) {
+        const condensedCopyBlocks = this.condensedCopyBlocks.get(this.appendTarget);
+        if (condensedCopyBlocks) {
+            const index = condensedCopyBlocks.findIndex((copyBlock) => copyBlock.block === block);
+            if (index !== -1)
+                condensedCopyBlocks.splice(index, 1);
+            return;
+        }
+        const index = this.copyIndex.get(block);
+        if (index === undefined)
+            return;
+        this.copyBlockRecords.splice(index, 1);
+        this.copyIndex.delete(block);
+        for (let i = index; i < this.copyBlockRecords.length; i++) {
+            this.copyIndex.set(this.copyBlockRecords[i].block, i);
+        }
+    }
+    appendCondensedBlock({ component, copyBlocks }) {
+        this.append(component);
+        this.registerCopyBlock(component, 'condensed', copyBlocks.map((copyBlock) => copyBlock.text).filter((text) => text.trim() !== '').join('\n\n'));
+    }
+    /** Flatten arbitrary tool result payloads into the visible text copy target. */
+    toolResultText(result) {
+        if (typeof result === 'string')
+            return result;
+        if (typeof result === 'object' && result !== null && 'content' in result) {
+            const content = result.content;
+            if (typeof content === 'string')
+                return content;
+            if (Array.isArray(content)) {
+                return content
+                    .filter((part) => typeof part === 'object' &&
+                    part !== null &&
+                    part.type === 'text' &&
+                    typeof part.text === 'string')
+                    .map((part) => part.text)
+                    .join('');
+            }
+        }
+        try {
+            const text = JSON.stringify(result);
+            return typeof text === 'string' ? text : '';
+        }
+        catch {
+            return '';
+        }
+    }
     pushTranscriptText(text) {
         const trimmed = text.trim();
         if (trimmed === '')