lsd-pi 1.3.6 → 1.3.7

package/packages/pi-coding-agent/src/modes/interactive/components/tool-execution.ts

@@ -11,7 +11,12 @@ import {
 } from "@gsd/pi-tui";
 import stripAnsi from "strip-ansi";
 import type { ToolDefinition } from "../../../core/extensions/types.js";
-import { computeEditDiff, type EditDiffError, type EditDiffResult } from "../../../core/tools/edit-diff.js";
+import {
+	computeEditDiff,
+	computeWriteDiff,
+	type EditDiffError,
+	type EditDiffResult,
+} from "../../../core/tools/edit-diff.js";
 import { allTools } from "../../../core/tools/index.js";
 import { shouldCollapse } from "../../../core/tool-priority.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "../../../core/tools/truncate.js";
@@ -21,7 +26,7 @@ import { renderTerminalText } from "../../../utils/terminal-serializer.js";
 import { getLanguageFromPath, highlightCode, theme } from "../theme/theme.js";
 import { type EditorScheme, editorLink } from "../utils/editor-link.js";
 import { shortenPath } from "../utils/shorten-path.js";
-import { renderDiff } from "./diff.js";
+import { renderDiff, renderDiffLines } from "./diff.js";
 import { keyHint } from "./keybinding-hints.js";
 import { truncateToVisualLines } from "./visual-truncate.js";
 
@@ -119,6 +124,9 @@ export class ToolExecutionComponent extends Container {
     // Cached edit diff preview (computed when args arrive, before tool executes)
     private editDiffPreview?: EditDiffResult | EditDiffError;
     private editDiffArgsKey?: string; // Track which args the preview is for
+    // Cached write diff preview (computed when args arrive, before tool executes)
+    private writeDiffPreview?: EditDiffResult | EditDiffError;
+    private writeDiffArgsKey?: string; // Track which args the preview is for
     // Cached converted images for Kitty protocol (which requires PNG), keyed by index
     private convertedImages: Map<number, { data: string; mimeType: string }> = new Map();
     // Incremental syntax highlighting cache for write tool call args
@@ -176,6 +184,40 @@ export class ToolExecutionComponent extends Container {
         return isBuiltInName && !hasCustomRenderers;
     }
 
+    private setPrimaryContent(useBox: boolean): void {
+        const hasBox = this.children.includes(this.contentBox);
+        const hasText = this.children.includes(this.contentText);
+
+        if (useBox) {
+            if (hasText) this.removeChild(this.contentText);
+            if (!hasBox) this.addChild(this.contentBox);
+        } else {
+            if (hasBox) this.removeChild(this.contentBox);
+            if (!hasText) this.addChild(this.contentText);
+        }
+    }
+
+    private getDiffTextToRender(): string | undefined {
+        if (this.toolName === "write") {
+            if (!this.isPartial && this.writeDiffPreview && !("error" in this.writeDiffPreview) && this.writeDiffPreview.diff) {
+                return this.writeDiffPreview.diff;
+            }
+            return undefined;
+        }
+
+        if (this.toolName !== "edit" || this.result?.isError) {
+            return undefined;
+        }
+
+        if (this.result?.details?.diff) {
+            return this.result.details.diff;
+        }
+        if (this.editDiffPreview && !("error" in this.editDiffPreview) && this.editDiffPreview.diff) {
+            return this.editDiffPreview.diff;
+        }
+        return undefined;
+    }
+
     updateArgs(args: any): void {
         this.args = args;
         if (this.toolName === "write" && this.isPartial) {
@@ -287,10 +329,37 @@ export class ToolExecutionComponent extends Container {
             if (rawPath !== null && fileContent !== null) {
                 this.rebuildWriteHighlightCacheFull(rawPath, fileContent);
             }
+            this.maybeComputeWriteDiff();
         }
         this.maybeComputeEditDiff();
     }
 
+    /**
+     * Compute write diff preview when we have complete args.
+     * This runs async and updates display when done.
+     */
+    private maybeComputeWriteDiff(): void {
+        if (this.toolName !== "write") return;
+
+        const path = this.args?.path ?? this.args?.file_path;
+        const content = this.args?.content;
+
+        if (!path || content === undefined) return;
+
+        const argsKey = JSON.stringify({ path, content });
+        if (this.writeDiffArgsKey === argsKey) return;
+
+        this.writeDiffArgsKey = argsKey;
+
+        computeWriteDiff(path, content, this.cwd).then((result) => {
+            if (this.writeDiffArgsKey === argsKey) {
+                this.writeDiffPreview = result;
+                this.updateDisplay();
+                this.ui.requestRender();
+            }
+        });
+    }
+
     /**
      * Compute edit diff preview when we have complete args.
      * This runs async and updates display when done.
@@ -396,8 +465,8 @@ export class ToolExecutionComponent extends Container {
         return Date.now() - this.startTime;
     }
 
-    shouldHideWhenCollapsed(): boolean {
-        return !this.isPartial && shouldCollapse(this.toolName, this.result?.isError ?? false);
+    shouldHideWhenCollapsed(collapseToolCalls = true): boolean {
+        return collapseToolCalls && !this.isPartial && shouldCollapse(this.toolName, this.result?.isError ?? false);
     }
 
     setRenderMode(mode: "minimal" | "normal"): void {
@@ -469,15 +538,22 @@ export class ToolExecutionComponent extends Container {
         }
 
         const useBuiltInRenderer = this.shouldUseBuiltInRenderer();
+        const diffTextToRender = this.getDiffTextToRender();
         let customRendererHasContent = false;
 
         // Use built-in rendering for built-in tools (or overrides without custom renderers)
         if (useBuiltInRenderer) {
+            const useDiffBox = !!diffTextToRender && !this.shouldHideCollapsedPreview();
+            this.setPrimaryContent(this.toolName === "bash" || useDiffBox);
             if (this.toolName === "bash") {
                 // Bash uses Box with visual line truncation - no background
                 this.contentBox.setBgFn((text: string) => text);
                 this.contentBox.clear();
                 this.renderBashContent(statusIndicator);
+            } else if (useDiffBox && diffTextToRender) {
+                this.contentBox.setBgFn((text: string) => text);
+                this.contentBox.clear();
+                this.renderBuiltInDiffContent(statusIndicator, diffTextToRender);
             } else {
                 // Other built-in tools: use Text directly with caching - no background
                 this.contentText.setCustomBgFn((text: string) => text);
@@ -619,6 +695,21 @@ export class ToolExecutionComponent extends Container {
         this.hideComponent = this.manuallyHidden || computedHidden;
     }
 
+    /**
+     * Render built-in edit/write diff blocks with width-aware full-line backgrounds.
+     */
+    private renderBuiltInDiffContent(statusIndicator: string, diffText: string): void {
+        const header = this.formatToolExecution(statusIndicator).split("\n\n", 1)[0] ?? "";
+        this.contentBox.addChild(new Text(header, 0, 0));
+        this.contentBox.addChild({
+            render: (width: number) => {
+                const contentWidth = Math.max(1, width - 2);
+                return ["", ...renderDiffLines(diffText, contentWidth).map((line) => ` ${line} `)];
+            },
+            invalidate: () => { },
+        });
+    }
+
     /**
      * Render bash content using visual line truncation (like bash-execution.ts)
      */
@@ -874,15 +965,38 @@ export class ToolExecutionComponent extends Container {
             const rawPath = str(this.args?.file_path ?? this.args?.path);
             const fileContent = str(this.args?.content);
             const path = rawPath !== null ? shortenPath(rawPath) : null;
+            const firstChangedLine = this.writeDiffPreview && "firstChangedLine" in this.writeDiffPreview
+                ? this.writeDiffPreview.firstChangedLine
+                : undefined;
 
             let writePathDisplay = path === null ? invalidArg : path ? theme.fg("accent", path) : theme.fg("toolOutput", "...");
             if (rawPath && path) {
-                writePathDisplay = editorLink(rawPath, writePathDisplay, { cwd: this.cwd, scheme: this.editorScheme });
+                writePathDisplay = editorLink(rawPath, writePathDisplay, {
+                    cwd: this.cwd,
+                    line: firstChangedLine ?? undefined,
+                    scheme: this.editorScheme,
+                });
+            }
+            if (firstChangedLine) {
+                writePathDisplay += theme.fg("warning", `:${firstChangedLine}`);
             }
             text = `${statusIndicator} ${theme.fg("toolTitle", theme.bold("write"))} ${writePathDisplay}`;
 
             if (fileContent === null) {
                 text += `\n\n${theme.fg("error", "[invalid content arg - expected string]")}`;
+            } else if (this.result?.isError) {
+                const errorText = this.getTextOutput();
+                if (errorText) {
+                    text += `\n\n${theme.fg("error", errorText)}`;
+                }
+            } else if (!this.isPartial && this.writeDiffPreview) {
+                if ("error" in this.writeDiffPreview) {
+                    text += `\n\n${theme.fg("error", this.writeDiffPreview.error)}`;
+                } else if (this.writeDiffPreview.diff) {
+                    text += hideCollapsedPreview
+                        ? this.collapsedHintWithPrefix()
+                        : `\n\n${renderDiff(this.writeDiffPreview.diff, { filePath: rawPath ?? undefined })}`;
+                }
             } else if (fileContent) {
                 const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
 
@@ -924,14 +1038,6 @@ export class ToolExecutionComponent extends Container {
                     }
                 }
             }
-
-            // Show error if tool execution failed
-            if (this.result?.isError) {
-                const errorText = this.getTextOutput();
-                if (errorText) {
-                    text += `\n\n${theme.fg("error", errorText)}`;
-                }
-            }
         } else if (this.toolName === "edit") {
             const rawPath = str(this.args?.file_path ?? this.args?.path);
             const path = rawPath !== null ? shortenPath(rawPath) : null;

package/packages/pi-coding-agent/src/modes/interactive/components/tool-summary-line.ts

@@ -7,11 +7,68 @@ interface CollapsedTool {
 	elapsed: number;
 }
 
+// Tools that can be mixed together in one summary line
+const MIXED_GROUPABLE_TOOLS = new Set([
+	"read", "find", "ls", "grep", "lsp",
+]);
+
+type SummaryDescriptor = {
+	action: string;
+	singular: string;
+	plural: string;
+};
+
+const TOOL_SUMMARY_DESCRIPTORS: Record<string, SummaryDescriptor> = {
+	read: { action: "reading", singular: "file", plural: "files" },
+	write: { action: "editing", singular: "file", plural: "files" },
+	edit: { action: "editing", singular: "file", plural: "files" },
+	grep: { action: "searching for", singular: "pattern", plural: "patterns" },
+	find: { action: "finding", singular: "path", plural: "paths" },
+	ls: { action: "listing", singular: "directory", plural: "directories" },
+	lsp: { action: "looking up", singular: "symbol", plural: "symbols" },
+	bash: { action: "running", singular: "command", plural: "commands" },
+	bg_shell: { action: "running", singular: "background command", plural: "background commands" },
+	fetch_page: { action: "reading", singular: "page", plural: "pages" },
+	resolve_library: { action: "searching for", singular: "library", plural: "libraries" },
+	get_library_docs: { action: "reading", singular: "doc", plural: "docs" },
+	web_search: { action: "searching web for", singular: "query", plural: "queries" },
+	"search-the-web": { action: "searching web for", singular: "query", plural: "queries" },
+	search_and_read: { action: "researching", singular: "topic", plural: "topics" },
+	google_search: { action: "searching web for", singular: "query", plural: "queries" },
+};
+
+function formatCount(count: number, singular: string, plural: string): string {
+	return `${count} ${count === 1 ? singular : plural}`;
+}
+
+function summarizeToolGroup(name: string, count: number): string {
+	if (name.startsWith("browser_")) {
+		return `using browser for ${formatCount(count, "step", "steps")}`;
+	}
+
+	const descriptor = TOOL_SUMMARY_DESCRIPTORS[name];
+	if (!descriptor) {
+		return count > 1 ? `${name} ×${count}` : name;
+	}
+
+	return `${descriptor.action} ${formatCount(count, descriptor.singular, descriptor.plural)}`;
+}
+
 export class ToolSummaryLine extends Container {
 	private tools: CollapsedTool[] = [];
 	private hidden = false;
 	private contentText: Text;
 
+	canGroupWith(toolName: string): boolean {
+		if (this.tools.length === 0) return true;
+		// Mixed-groupable tools can share a summary line regardless of order
+		if (MIXED_GROUPABLE_TOOLS.has(toolName) && this.tools.every((t) => MIXED_GROUPABLE_TOOLS.has(t.name))) {
+			return true;
+		}
+		// Otherwise only same-tool grouping
+		return this.tools.every((tool) => tool.name === toolName);
+	}
+
 	constructor() {
 		super();
 		this.contentText = new Text("", 1, 0);
@@ -53,12 +110,11 @@ export class ToolSummaryLine extends Container {
 		}
 
 		const groupedTools = [...counts.entries()]
-			.map(([name, count]) => (count > 1 ? `${name} ×${count}` : name))
+			.map(([name, count]) => summarizeToolGroup(name, count))
 			.join(" · ");
 		const elapsed = (totalElapsed / 1000).toFixed(1);
 		const indicator = theme.fg("success", "●");
-		const title = theme.fg("toolTitle", theme.bold("collapsed tools"));
 		const details = theme.fg("muted", `${groupedTools} · ${elapsed}s`);
-		this.contentText.setText(`${indicator} ${title} ${details}`);
+		this.contentText.setText(`${indicator} ${details}`);
 	}
 }

package/packages/pi-coding-agent/src/modes/interactive/controllers/__tests__/chat-controller.collapsed-tool-summary.test.ts

@@ -16,6 +16,15 @@ function assistantMessage(content: any[] = []): any {
     };
 }
 
+function toolStartEvent(toolCallId: string, toolName: string, args: Record<string, unknown> = {}): any {
+    return {
+        type: "tool_execution_start",
+        toolCallId,
+        toolName,
+        args,
+    };
+}
+
 function toolEndEvent(toolCallId: string, toolName: string): any {
     return {
         type: "tool_execution_end",
@@ -44,7 +53,7 @@ function createChatContainer() {
     };
 }
 
-function createHost(): any {
+function createHost(options: { collapseToolCalls?: boolean; collapsedToolCallsExpanded?: boolean; toolOutputExpanded?: boolean } = {}): any {
     const chatContainer = createChatContainer();
     return {
         isInitialized: true,
@@ -61,10 +70,12 @@ function createHost(): any {
             getShowImages: () => true,
             getToolOutputMode: () => "normal",
             getEditorScheme: () => "auto",
+            getCollapseToolCalls: () => options.collapseToolCalls ?? true,
         },
         pendingTools: new Map(),
         collapsedToolSummaryLine: undefined,
-        toolOutputExpanded: false,
+        collapsedToolCallsExpanded: options.collapsedToolCallsExpanded ?? options.toolOutputExpanded ?? false,
+        toolOutputExpanded: options.toolOutputExpanded ?? false,
         hideThinkingBlock: false,
         notificationSoundEnabled: false,
         defaultEditor: { onEscape: undefined, bottomHint: "" },
@@ -124,7 +135,75 @@ function summaryLines(host: any): ToolSummaryLine[] {
 }
 
 describe("chat-controller collapsed tool summary lifecycle", () => {
-    it("keeps single grouped summary across text-only message updates", async () => {
+    it("hides collapsible tool calls immediately to avoid blink before grouping", async () => {
+        const host = createHost();
+
+        await handleAgentEvent(host, {
+            type: "message_start",
+            message: assistantMessage(),
+        });
+
+        await handleAgentEvent(host, toolStartEvent("tool-1", "read", { path: "README.md" }));
+        const pending = host.pendingTools.get("tool-1");
+        assert.ok(pending);
+        assert.equal(pending.isHidden(), true);
+
+        await handleAgentEvent(host, toolEndEvent("tool-1", "read"));
+        assert.equal(summaryLines(host).length, 1);
+    });
+
+    it("hides streamed tool-call blocks immediately to avoid blink before grouping", async () => {
+        const host = createHost();
+
+        await handleAgentEvent(host, {
+            type: "message_start",
+            message: assistantMessage(),
+        });
+
+        await handleAgentEvent(host, {
+            type: "message_update",
+            message: assistantMessage([
+                { type: "toolCall", id: "tool-1", name: "read", arguments: { path: "README.md" } },
+            ]),
+        } as any);
+
+        const pending = host.pendingTools.get("tool-1");
+        assert.ok(pending);
+        assert.equal(pending.isHidden(), true);
+
+        await handleAgentEvent(host, toolEndEvent("tool-1", "read"));
+        assert.equal(summaryLines(host).length, 1);
+    });
+
+    it("reveals initially hidden on-error tools when they fail", async () => {
+        const host = createHost();
+
+        await handleAgentEvent(host, {
+            type: "message_start",
+            message: assistantMessage(),
+        });
+
+        await handleAgentEvent(host, toolStartEvent("tool-1", "bash", { command: "exit 1" }));
+        const pending = host.pendingTools.get("tool-1");
+        assert.ok(pending);
+        assert.equal(pending.isHidden(), true);
+
+        await handleAgentEvent(host, {
+            type: "tool_execution_end",
+            toolCallId: "tool-1",
+            toolName: "bash",
+            isError: true,
+            result: {
+                content: [{ type: "text", text: "failed" }],
+                details: {},
+            },
+        });
+
+        assert.equal(summaryLines(host).length, 0);
+        assert.equal(pending.isHidden(), false);
+    });
+
+    it("groups consecutive identical collapsed tools", async () => {
         const host = createHost();
 
         await handleAgentEvent(host, {
@@ -146,7 +225,47 @@ describe("chat-controller collapsed tool summary lifecycle", () => {
 
         const summaries = summaryLines(host);
         assert.equal(summaries.length, 1);
-        assert.ok(stripAnsi(summaries[0].render(160).join("\n")).includes("read ×2 · 1.0s"));
+        assert.ok(stripAnsi(summaries[0].render(160).join("\n")).includes("reading 2 files · 1.0s"));
+    });
+
+    it("does not group web fetches", async () => {
+        const host = createHost();
+
+        await handleAgentEvent(host, {
+            type: "message_start",
+            message: assistantMessage(),
+        });
+
+        addPendingTool(host, "tool-1", 200);
+        await handleAgentEvent(host, toolEndEvent("tool-1", "fetch_page"));
+
+        addPendingTool(host, "tool-2", 300);
+        await handleAgentEvent(host, toolEndEvent("tool-2", "fetch_page"));
+
+        const summaries = summaryLines(host);
+        assert.equal(summaries.length, 2);
+        assert.ok(stripAnsi(summaries[0].render(160).join("\n")).includes("reading 1 page · 0.2s"));
+        assert.ok(stripAnsi(summaries[1].render(160).join("\n")).includes("reading 1 page · 0.3s"));
+    });
+
+    it("keeps different collapsed tool types in separate summaries", async () => {
+        const host = createHost();
+
+        await handleAgentEvent(host, {
+            type: "message_start",
+            message: assistantMessage(),
+        });
+
+        addPendingTool(host, "tool-1", 200);
+        await handleAgentEvent(host, toolEndEvent("tool-1", "read"));
+
+        addPendingTool(host, "tool-2", 300);
+        await handleAgentEvent(host, toolEndEvent("tool-2", "find"));
+
+        const summaries = summaryLines(host);
+        assert.equal(summaries.length, 2);
+        assert.ok(stripAnsi(summaries[0].render(160).join("\n")).includes("reading 1 file · 0.2s"));
+        assert.ok(stripAnsi(summaries[1].render(160).join("\n")).includes("finding 1 path · 0.3s"));
     });
 
     it("resets grouping after visible tool result", async () => {
@@ -173,7 +292,7 @@ describe("chat-controller collapsed tool summary lifecycle", () => {
         assert.ok(stripAnsi(summaries[1].render(160).join("\n")).includes("0.4s"));
     });
 
-    it("merges adjacent collapsed groups across empty assistant message boundaries", async () => {
+    it("groups identical collapsed tools across empty assistant message boundaries", async () => {
         const host = createHost();
 
         await handleAgentEvent(host, {
@@ -194,7 +313,7 @@ describe("chat-controller collapsed tool summary lifecycle", () => {
 
         const summaries = summaryLines(host);
         assert.equal(summaries.length, 1);
-        assert.ok(stripAnsi(summaries[0].render(160).join("\n")).includes("read ×2 · 0.7s"));
+        assert.ok(stripAnsi(summaries[0].render(160).join("\n")).includes("reading 2 files · 0.7s"));
     });
 
     it("starts new collapsed group after visible assistant content", async () => {
@@ -225,4 +344,53 @@ describe("chat-controller collapsed tool summary lifecycle", () => {
         assert.ok(stripAnsi(summaries[0].render(160).join("\n")).includes("0.3s"));
         assert.ok(stripAnsi(summaries[1].render(160).join("\n")).includes("0.4s"));
     });
+
+    it("keeps collapsed tool calls visible in intermediate mode", async () => {
+        const host = createHost({ collapseToolCalls: true, collapsedToolCallsExpanded: true });
+
+        await handleAgentEvent(host, {
+            type: "message_start",
+            message: assistantMessage(),
+        });
+
+        const tool = addPendingTool(host, "tool-1", 250);
+        await handleAgentEvent(host, toolEndEvent("tool-1", "read"));
+
+        const summaries = summaryLines(host);
+        assert.equal(tool.hidden, false);
+        assert.equal(summaries.length, 1);
+        assert.deepEqual(summaries[0].render(160), []);
+    });
+
+    it("keeps collapsed tools visible when verbose mode is active", async () => {
+        const host = createHost({ collapseToolCalls: true, toolOutputExpanded: true });
+
+        await handleAgentEvent(host, {
+            type: "message_start",
+            message: assistantMessage(),
+        });
+
+        const tool = addPendingTool(host, "tool-1", 250);
+        await handleAgentEvent(host, toolEndEvent("tool-1", "read"));
+
+        const summaries = summaryLines(host);
+        assert.equal(tool.hidden, false);
+        assert.equal(summaries.length, 1);
+        assert.deepEqual(summaries[0].render(160), []);
+    });
+
+    it("does not collapse tool calls when setting is disabled", async () => {
+        const host = createHost({ collapseToolCalls: false });
+
+        await handleAgentEvent(host, {
+            type: "message_start",
+            message: assistantMessage(),
+        });
+
+        const tool = addPendingTool(host, "tool-1", 250);
+        await handleAgentEvent(host, toolEndEvent("tool-1", "read"));
+
+        assert.equal(tool.hidden, false);
+        assert.equal(summaryLines(host).length, 0);
+    });
 });

package/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.ts

@@ -9,6 +9,15 @@ import { ToolSummaryLine } from "../components/tool-summary-line.js";
 import { shouldCollapse } from "../../../core/tool-priority.js";
 import { appKey } from "../components/keybinding-hints.js";
 
+const GROUPABLE_COLLAPSED_TOOLS = new Set([
+    "read",
+    "find",
+    "ls",
+    "grep",
+    "lsp",
+
+]);
+
 export async function handleAgentEvent(host: InteractiveModeStateHost & {
     init: () => Promise<void>;
     getMarkdownThemeWithSettings: () => any;
@@ -42,6 +51,24 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
         host.collapsedToolSummaryLine = undefined;
     };
 
+    // Tools that always render as their own visible row, never folded into a summary line
+    const ALWAYS_DIRECT_TOOLS = new Set([
+        "bash", "bg_shell",
+        "web_search", "search-the-web", "google_search", "search_and_read",
+        "fetch_page", "resolve_library", "get_library_docs",
+    ]);
+
+    const shouldStartToolHidden = (toolName: string): boolean => {
+        const collapseToolCalls = host.settingsManager.getCollapseToolCalls?.() ?? false;
+        if (!collapseToolCalls || host.collapsedToolCallsExpanded) {
+            return false;
+        }
+        if (ALWAYS_DIRECT_TOOLS.has(toolName)) {
+            return false;
+        }
+        return shouldCollapse(toolName, false);
+    };
+
     const hasVisibleRender = (child: { render?: (width: number) => string[] } | undefined): boolean => {
         if (!child?.render) return true;
         try {
@@ -51,14 +78,20 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
         }
     };
 
+    const canGroupCollapsedTool = (toolName: string): boolean => GROUPABLE_COLLAPSED_TOOLS.has(toolName);
+
     const findAdjacentCollapsedToolSummary = (
+        toolName: string,
         anchor?: { render: (width: number) => string[] },
     ): ToolSummaryLine | undefined => {
+        if (!canGroupCollapsedTool(toolName)) {
+            return undefined;
+        }
         const anchorIndex = anchor ? host.chatContainer.children.indexOf(anchor) : host.chatContainer.children.length;
         for (let i = anchorIndex - 1; i >= 0; i--) {
             const child = host.chatContainer.children[i];
             if (child instanceof ToolSummaryLine) {
-                return child;
+                return child.canGroupWith(toolName) ? child : undefined;
             }
             if (child instanceof ToolExecutionComponent && child.isHidden()) {
                 continue;
@@ -71,17 +104,15 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
         return undefined;
     };
 
-    const appendCollapsedToolSummary = (toolName: string, elapsed: number, anchor?: { render: (width: number) => string[] }): void => {
-        let summary = host.collapsedToolSummaryLine;
-        if ((!summary || !host.chatContainer.children.includes(summary)) && anchor) {
-            summary = findAdjacentCollapsedToolSummary(anchor);
-            if (summary) {
-                host.collapsedToolSummaryLine = summary;
-            }
-        }
-        if (!summary || !host.chatContainer.children.includes(summary)) {
+    const appendCollapsedToolSummary = (
+        toolName: string,
+        elapsed: number,
+        anchor?: { render: (width: number) => string[] },
+    ): ToolSummaryLine => {
+        let summary = findAdjacentCollapsedToolSummary(toolName, anchor);
+        if (!summary) {
             summary = new ToolSummaryLine();
-            summary.setHidden(host.toolOutputExpanded);
+            summary.setHidden(host.collapsedToolCallsExpanded);
             if (anchor) {
                 const anchorIndex = host.chatContainer.children.indexOf(anchor);
                 if (anchorIndex >= 0) {
@@ -92,9 +123,10 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
             } else {
                 host.chatContainer.addChild(summary);
             }
-            host.collapsedToolSummaryLine = summary;
         }
+        host.collapsedToolSummaryLine = summary;
         summary.addTool(toolName, elapsed);
+        return summary;
     };
 
     switch (event.type) {
@@ -221,6 +253,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                                 host.ui,
                             );
                             component.setExpanded(host.toolOutputExpanded);
+                            component.setHidden(shouldStartToolHidden(content.name));
                             host.chatContainer.addChild(component);
                             host.pendingTools.set(content.id, component);
                         } else {
@@ -240,6 +273,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                                 host.ui,
                             );
                             component.setExpanded(host.toolOutputExpanded);
+                            component.setHidden(shouldStartToolHidden(content.name));
                             host.chatContainer.addChild(component);
                             host.pendingTools.set(content.id, component);
                         }
@@ -322,6 +356,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                     host.ui,
                 );
                 component.setExpanded(host.toolOutputExpanded);
+                component.setHidden(shouldStartToolHidden(event.toolName));
                 host.chatContainer.addChild(component);
                 host.pendingTools.set(event.toolCallId, component);
                 host.ui.requestRender();
@@ -371,9 +406,10 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
             const component = host.pendingTools.get(event.toolCallId);
             if (component) {
                 component.updateResult({ ...event.result, isError: event.isError });
-                if (shouldCollapse(event.toolName, event.isError)) {
+                const collapseToolCalls = host.settingsManager.getCollapseToolCalls?.() ?? false;
+                if (collapseToolCalls && shouldCollapse(event.toolName, event.isError) && !ALWAYS_DIRECT_TOOLS.has(event.toolName)) {
                     appendCollapsedToolSummary(event.toolName, component.getElapsed(), component);
-                    component.setHidden(true);
+                    component.setHidden(!host.collapsedToolCallsExpanded);
                 } else {
                     component.setHidden(false);
                     resetCollapsedToolSummary();