@north-light/crouter 0.3.169 → 0.3.171

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

@@ -22,11 +22,14 @@
 // path while builtin tools, diffs, and partial-result streaming keep working.
 import { Container, Loader, Spacer, Text } from '@earendil-works/pi-tui';
 import { AssistantMessageComponent, BashExecutionComponent, BranchSummaryMessageComponent, CompactionSummaryMessageComponent, CustomMessageComponent, parseSkillBlock, SkillInvocationMessageComponent, ToolExecutionComponent, UserMessageComponent, } from '@earendil-works/pi-coding-agent';
+import { ICON } from '../../../core/inspector/model.js';
+import { TOOL_ICON } from '../../../core/preview-registry.js';
 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 { assistantVisibleText, isTrueUserMessage, normalizeToolGroupSummary, normalizeToolGroupSummaryRecord, } from '../../../shared/tool-groups.js';
 import { transformMessageDiagrams } from './diagram.js';
 import { styleAttachMarkdownHeadings, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-headings.js';
 import { createCrtrEditToolDefinition } from './edit-diff.js';
@@ -35,6 +38,7 @@ import { ringCompletionBell } from '../chrome/completion-bell.js';
 import { extractFilePaths } from '../visible-paths.js';
 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';
 /** Theme-derived chrome colors (spinner / dim / error) are supplied by the
@@ -85,6 +89,17 @@ 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;
+    }
+}
 /** 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) {
@@ -165,6 +180,25 @@ class FoldedToolSeparator extends Spacer {
         this.setLines(this.folded && this.separatesToolGroup ? 1 : 0);
     }
 }
+/** The broker-generated recap of one maximal non-prose run. It remains a
+ * direct history child so the render cache's per-child identity stays valid while
+ * the group members are hidden. The title is viewer-owned and deterministic;
+ * only the bullets and generated counts come from the broker. */
+class GroupSummaryLine extends Text {
+    setSummary(summary, toolCount, dim) {
+        if (!summary) {
+            this.setText('');
+            return;
+        }
+        const count = (value, singular, plural) => `${value} ${value === 1 ? singular : plural}`;
+        const stats = [`${TOOL_ICON.bash} ${count(toolCount, 'tool call', 'tool calls')}`];
+        if (summary.nodesSpawned >= 1)
+            stats.push(`${ICON.graph} ${count(summary.nodesSpawned, 'node spawned', 'nodes spawned')}`);
+        if (summary.filesEdited >= 1)
+            stats.push(`${TOOL_ICON.edit} ${count(summary.filesEdited, 'file edited', 'files edited')}`);
+        this.setText([dim(`✦ ${stats.join(' · ')}`), ...summary.bullets.map((bullet) => dim(`  • ${bullet.trim()}`))].join('\n'));
+    }
+}
 class MinimizableToolComponent extends ToolExecutionComponent {
     minimized = false;
     expandedState = false;
@@ -207,51 +241,18 @@ 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;
-    }
-}
 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();
+    historyContainer = new MeasuredContainer();
     /** Activity/status area below history. Holds working/compaction/retry loaders. */
-    statusContainer = new 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. */
@@ -271,6 +272,14 @@ export class ChatView {
      *  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();
+    showGroupSummaries = this.summarizeToolCalls && this.foldSettledTools;
+    /** Groups exist only while building/rendering the full-fidelity live region. */
+    groups = [];
+    openGroup;
+    groupSummaries = new Map();
+    streamingWasGroupMember = false;
     onFooterEvent;
     /** Theme-derived colorizers for the activity/status area. */
     spinnerStyle;
@@ -320,6 +329,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;
@@ -338,15 +353,25 @@ export class ChatView {
         // 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);
+        this.transcript = new CompositeViewportSource([
+            ...(this.bannerContainer ? [this.bannerContainer] : []),
+            this.historyContainer,
+            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 +390,7 @@ export class ChatView {
         this.applyingSnapshot = true;
         this.deferredFrames.length = 0;
         this.resetChat();
+        this.seedToolGroupSummaries(snapshot.toolGroupSummaries);
         const renderedPendingTools = new Map();
         const messages = snapshot.messages;
         const lastIndex = messages.length - 1;
@@ -379,7 +405,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 +427,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,23 +442,37 @@ export class ChatView {
                     snapshot.state.isStreaming &&
                     message.stopReason !== 'aborted' &&
                     message.stopReason !== 'error';
+                const hasProse = assistantVisibleText(message).trim() !== '';
+                const toolCalls = this.assistantToolCalls(message);
+                const persistedGroupKey = toolCalls[0]?.id;
+                // A broker restart resets its live grouping state. On reattach, the
+                // persisted first-call key is the durable boundary that keeps snapshot
+                // reconstruction from joining the new group to pre-restart tools.
+                if (hasProse ||
+                    (persistedGroupKey !== undefined &&
+                        this.groupSummaries.has(persistedGroupKey) &&
+                        this.openGroup?.key !== undefined &&
+                        this.openGroup.key !== persistedGroupKey)) {
+                    this.closeOpenGroup();
+                }
                 let separator;
                 if (isStreamingTail) {
                     this.streamingComponent = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel);
-                    this.append(this.streamingComponent);
+                    this.appendAssistantPart(this.streamingComponent, !hasProse);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', '');
+                    this.streamingWasGroupMember = !hasProse;
                     this.streamingComponent.updateContent(styleAttachMessageMarkdown(message));
-                    separator = this.streamingToolSeparator = this.appendFoldedToolSeparator();
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', assistantVisibleText(message));
+                    separator = this.streamingToolSeparator = this.appendAssistantSeparator(!hasProse);
                 }
                 else {
-                    separator = this.appendAssistantMessage(message);
+                    separator = this.appendAssistantMessage(message, !hasProse);
                 }
-                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') {
@@ -440,6 +480,8 @@ export class ChatView {
                             ? 'Interrupted'
                             : (message.errorMessage ?? 'Error');
                         component.updateResult({ content: [{ type: 'text', text: errorMessage }], isError: true });
+                        this.registerCopyBlock(component, 'tool', errorMessage);
+                        this.settleGroupTool(component);
                     }
                     else {
                         renderedPendingTools.set(content.id, component);
@@ -451,7 +493,9 @@ export class ChatView {
                 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);
                     renderedPendingTools.delete(message.toolCallId);
                 }
             }
@@ -464,8 +508,7 @@ 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.
@@ -492,7 +535,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 +558,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
@@ -535,12 +581,16 @@ export class ChatView {
     }
     /** Clear live turn state after the broker reports completion or the viewer observes dormancy. */
     settleRun() {
+        for (const component of this.pendingTools.values())
+            this.settleGroupTool(component);
         if (this.streamingComponent) {
             this.historyContainer.removeChild(this.streamingComponent);
+            this.unregisterCopyBlock(this.streamingComponent);
             this.streamingComponent = undefined;
         }
         this.streamingToolSeparator = undefined;
         this.pendingTools.clear();
+        this.applyToolDisplay();
         this.setActivity(undefined);
         this.settleBashComponent();
     }
@@ -555,36 +605,48 @@ 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. Otherwise it remains pi's global output expansion toggle. */
     toggleToolsExpanded() {
+        if (this.summarizeToolCalls && this.foldSettledTools) {
+            this.showGroupSummaries = !this.showGroupSummaries;
+            this.toolOutputExpanded = !this.showGroupSummaries;
+            this.applyToolDisplay();
+            return { kind: 'summaries', shown: this.showGroupSummaries };
+        }
         this.toolOutputExpanded = !this.toolOutputExpanded;
         this.applyToolDisplay();
-        return this.toolOutputExpanded;
+        return { kind: 'output', expanded: this.toolOutputExpanded };
     }
     /** The `fold finished tool calls` view setting (`/fold-tools`, Alt+C → w → 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,6 +677,8 @@ export class ChatView {
             return;
         switch (event.type) {
             case 'agent_start': {
+                for (const component of this.pendingTools.values())
+                    this.settleGroupTool(component);
                 this.pendingTools.clear();
                 this.setActivity(this.makeLoader('Working...'));
                 break;
@@ -644,16 +708,23 @@ 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.streamingWasGroupMember = !hasProse;
+                    this.appendAssistantPart(this.streamingComponent, !hasProse);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', '');
                     this.streamingComponent.updateContent(styleAttachMessageMarkdown(event.message));
-                    this.streamingToolSeparator = this.appendFoldedToolSeparator();
+                    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') {
+                    this.promoteStreamingAssistantToBoundary(event.message);
                     // 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).
@@ -661,6 +732,7 @@ export class ChatView {
                     // of waiting for message_end — noticeable when more text follows it.
                     const updated = styleAttachMessageMarkdown(transformMessageDiagrams(event.message, this.renderWidth()));
                     this.streamingComponent.updateContent(updated);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', assistantVisibleText(event.message));
                     this.historyContainer.markDirty(this.streamingComponent);
                     const toolCalls = this.assistantToolCalls(event.message);
                     if (this.streamingToolSeparator)
@@ -673,8 +745,7 @@ export class ChatView {
                             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);
                         }
                     }
@@ -686,8 +757,11 @@ export class ChatView {
                     break;
                 // Stash the completed reply's text for `/copy` (skip aborted/error turns,
                 // whose text is partial or absent).
+                this.promoteStreamingAssistantToBoundary(event.message);
+                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);
@@ -715,6 +789,8 @@ export class ChatView {
                         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);
                             this.historyContainer.markDirty(component);
                         }
                         this.pendingTools.clear();
@@ -736,8 +812,7 @@ export class ChatView {
                 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);
                 }
                 component.markExecutionStarted();
@@ -749,6 +824,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 +834,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);
+                    this.applyToolDisplay();
                     this.historyContainer.markDirty(component);
                 }
                 break;
@@ -822,7 +897,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 +911,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 +948,18 @@ 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(generated.body, this.toolOutputExpanded, this.dimStyle, (s) => this.spinnerStyle(this.labelStyle(s)), generated.label, ` ${generated.summary} — ctrl+o to expand`);
+            // Bearings and revive kickoffs only belong to an already-open run; they
+            // never create a summary block by themselves. Other injected context may.
+            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 +977,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 +985,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 +993,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 +1006,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 +1058,152 @@ 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(styleAttachMessageMarkdown(transformMessageDiagrams(message, this.renderWidth())), this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel);
+        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 summaryLine = new GroupSummaryLine('', 0, 0);
+        const group = { members: [], summaryLine, toolCount: 0, inFlight: new Set() };
+        this.append(summaryLine);
+        // `Text('')` still occupies a row in pi-tui. It becomes visible only when
+        // a settled, known summary is actually selected for this group.
+        this.historyContainer.setHidden(summaryLine, 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);
+        this.appendGroupMember(component);
+        this.registerCopyBlock(component, 'tool', '');
+        if (group) {
+            group.key ??= id;
+            group.toolCount++;
+            group.inFlight.add(component);
+        }
+        return component;
+    }
+    settleGroupTool(component) {
+        for (const group of this.groups)
+            group.inFlight.delete(component);
+    }
+    /** An assistant starts as a non-boundary while its text is empty. The first
+     * visible prose turns it into the boundary without recreating either pi-owned
+     * component (their direct-child cache identities remain intact). */
+    promoteStreamingAssistantToBoundary(message) {
+        if (!this.streamingWasGroupMember || 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.summaryLine.setSummary(collapsed ? summary : undefined, group.toolCount, this.dimStyle);
+        this.historyContainer.setHidden(group.summaryLine, !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 +1214,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);
         }
@@ -1054,15 +1286,33 @@ export class ChatView {
         this.settleBashComponent();
         this.streamingComponent = undefined;
         this.streamingToolSeparator = undefined;
+        this.streamingWasGroupMember = false;
         this.foldedToolSeparatorContents.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.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) {
@@ -1092,10 +1342,12 @@ export class ChatView {
             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 +1383,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 === '')