agent-sh 0.4.0 → 0.6.0

package/dist/extensions/tui-renderer.js

@@ -14,7 +14,7 @@ import { highlight } from "cli-highlight";
 import { MarkdownRenderer, wrapLine } from "../utils/markdown.js";
 import { createFencedBlockTransform } from "../utils/stream-transform.js";
 import { palette as p } from "../utils/palette.js";
-import { renderToolCall, createSpinner, renderSpinnerLine, } from "../utils/tool-display.js";
+import { renderToolCall, createSpinner, renderSpinnerLine, formatElapsed, } from "../utils/tool-display.js";
 import { renderDiff } from "../utils/diff-renderer.js";
 import { renderBoxFrame } from "../utils/box-frame.js";
 import { getSettings } from "../settings.js";
@@ -42,17 +42,25 @@ function createRenderState() {
     return {
         renderer: null,
         hadToolCalls: false,
+        lastContentKind: null,
         spinner: null,
         spinnerLabel: "",
         spinnerOpts: {},
         spinnerInterval: null,
         spinnerStartTime: 0,
-        lastCommand: "",
         toolLineOpen: false,
         currentToolKind: undefined,
+        toolStartTime: 0,
+        toolExitCode: null,
         commandOutputBuffer: "",
         commandOutputLineCount: 0,
         commandOutputOverflow: 0,
+        commandOverflowLines: [],
+        toolGroupKind: undefined,
+        toolGroupCount: 0,
+        toolGroupAllOk: true,
+        toolGroupRendered: 0,
+        toolGroupSummaries: [],
         isThinking: false,
         showThinkingText: false,
         thinkingPending: false,
@@ -60,9 +68,12 @@ function createRenderState() {
     };
 }
 export default function activate(ctx) {
-    const { bus, getAcpClient, define } = ctx;
+    const { bus, llmClient, define } = ctx;
     const writer = new StdoutWriter();
     const s = createRenderState();
+    // Track backend/model info for display on response border
+    let backendInfo = null;
+    bus.on("agent:info", (info) => { backendInfo = info; });
     // ── Register fenced block transform (code blocks → ContentBlock) ──
     // Nobody is special — tui-renderer uses the same primitive as any extension.
     const fencedTransform = createFencedBlockTransform(bus, {
@@ -75,7 +86,7 @@ export default function activate(ctx) {
     // ── Event subscriptions ─────────────────────────────────────
     bus.on("agent:query", (e) => {
         s.spinnerStartTime = 0;
-        showUserQuery(e.query, e.modeLabel);
+        showUserQuery(e.query);
         startAgentResponse();
         startThinkingSpinner();
     });
@@ -104,70 +115,152 @@ export default function activate(ctx) {
         }
     });
     bus.on("agent:response-chunk", (e) => {
-        if (e.blocks) {
-            // Inject spacing: append \n to text blocks that precede non-text blocks
-            const blocks = e.blocks;
-            for (let i = 0; i < blocks.length; i++) {
-                const block = blocks[i];
-                const next = blocks[i + 1];
-                if (block.type === "text" && next && next.type !== "text") {
-                    block.text += "\n";
-                }
-            }
-            for (const block of blocks) {
-                switch (block.type) {
-                    case "text":
-                        if (block.text)
-                            writeAgentText(block.text);
-                        break;
-                    case "code-block":
-                        writeCodeBlock(block.language, block.code);
-                        break;
-                    case "image":
-                        writeInlineImage(block.data);
-                        break;
-                    case "raw":
-                        flushForRaw();
-                        writer.write(block.escape);
-                        break;
-                }
+        const { blocks } = e;
+        // Inject spacing: append \n to text blocks that precede non-text blocks
+        for (let i = 0; i < blocks.length; i++) {
+            const block = blocks[i];
+            const next = blocks[i + 1];
+            if (block.type === "text" && next && next.type !== "text") {
+                block.text += "\n";
             }
         }
-        else {
-            writeAgentText(e.text);
+        for (const block of blocks) {
+            switch (block.type) {
+                case "text":
+                    if (block.text)
+                        writeAgentText(block.text);
+                    break;
+                case "code-block":
+                    writeCodeBlock(block.language, block.code);
+                    break;
+                case "image":
+                    writeInlineImage(block.data);
+                    break;
+                case "raw":
+                    flushForRaw();
+                    writer.write(block.escape);
+                    break;
+            }
         }
     });
+    // Track token usage for display
+    let pendingUsage = null;
+    bus.on("agent:usage", (e) => { pendingUsage = e; });
     bus.on("agent:response-done", () => {
         s.isThinking = false;
+        if (pendingUsage && s.renderer) {
+            const { prompt_tokens, completion_tokens } = pendingUsage;
+            const maxTokens = backendInfo?.contextWindow ?? 128_000;
+            // prompt_tokens of the latest call = current context usage
+            // (it includes the full conversation history)
+            const ctxK = (prompt_tokens / 1000).toFixed(1);
+            const maxK = (maxTokens / 1000).toFixed(0);
+            const pct = Math.min(100, (prompt_tokens / maxTokens) * 100).toFixed(0);
+            s.renderer.writeLine("");
+            s.renderer.writeLine(`${p.dim}⬆ ${prompt_tokens}  ⬇ ${completion_tokens}  ctx: ${ctxK}k/${maxK}k (${pct}%)${p.reset}`);
+            drain();
+            pendingUsage = null;
+        }
         endAgentResponse();
     });
-    bus.on("agent:tool-call", (e) => {
-        s.lastCommand = e.tool;
+    // ── Tool batch grouping ──────────────────────────────────────────
+    const GROUPABLE_KINDS = new Set(["read", "search"]);
+    const GROUP_MAX_VISIBLE = 5;
+    const KIND_ICONS = { read: "◆", search: "⌕" };
+    // Batch groups: kind → { total, rendered, headerShown }
+    let batchGroups = new Map();
+    bus.on("agent:tool-batch", (e) => {
+        fencedTransform.flush();
+        finalizeToolGroup();
+        batchGroups = new Map();
+        for (const group of e.groups) {
+            batchGroups.set(group.kind, {
+                total: group.tools.length,
+                rendered: 0,
+                headerShown: false,
+            });
+        }
     });
     bus.on("agent:tool-started", (e) => {
         fencedTransform.flush();
         stopCurrentSpinner();
         s.currentToolKind = e.kind;
+        s.toolStartTime = Date.now();
         if (e.title === "user_shell") {
+            finalizeToolGroup();
             closeToolLine();
             if (!s.renderer)
                 startAgentResponse();
+            contentGap("tool");
             s.renderer.flush();
             const cmd = e.rawInput?.command || "";
             s.renderer.writeLine(`${p.dim}▶ user_shell: ${cmd}${p.reset}`);
             drain();
             s.hadToolCalls = true;
+            return;
+        }
+        const kind = e.kind ?? "execute";
+        const group = batchGroups.get(kind);
+        const isGrouped = group && group.total > 1 && GROUPABLE_KINDS.has(kind);
+        if (isGrouped) {
+            // Render group header on first tool of this kind in the batch
+            if (!group.headerShown) {
+                finalizeToolGroup();
+                closeToolLine();
+                if (!s.renderer)
+                    startAgentResponse();
+                showCollapsedThinking();
+                contentGap("tool");
+                s.renderer.flush();
+                drain();
+                const icon = KIND_ICONS[kind] ?? "▶";
+                s.renderer.writeLine(`${p.warning}${icon}${p.reset} ${kind}`);
+                drain();
+                group.headerShown = true;
+                s.toolGroupKind = kind;
+                s.toolGroupCount = 0;
+                s.toolGroupRendered = 0;
+                s.toolGroupAllOk = true;
+                s.toolGroupSummaries = [];
+            }
+            s.toolGroupCount++;
+            if (s.toolGroupRendered < GROUP_MAX_VISIBLE) {
+                showToolCall(e.title, "", {
+                    ...e,
+                    batchIndex: e.batchIndex,
+                    batchTotal: e.batchTotal,
+                    groupContinuation: true,
+                });
+                s.toolGroupRendered++;
+            }
         }
         else {
-            showToolCall(e.title, s.lastCommand, e);
+            // Standalone tool — single in its batch kind, or not groupable
+            finalizeToolGroup();
+            showToolCall(e.title, "", {
+                ...e,
+                batchIndex: e.batchIndex,
+                batchTotal: e.batchTotal,
+            });
         }
-        s.lastCommand = "";
     });
     bus.on("agent:tool-completed", (e) => {
-        showToolComplete(e.exitCode);
-        s.currentToolKind = undefined;
-        s.spinnerStartTime = 0;
-        startThinkingSpinner();
+        s.toolExitCode = e.exitCode;
+        if (e.exitCode !== 0)
+            s.toolGroupAllOk = false;
+        if (s.toolGroupKind) {
+            // Grouped tool — track success/failure and summaries, show aggregate on ⎿ line.
+            // Don't restart spinner between grouped tools — it's already running from group start.
+            if (e.resultDisplay?.summary)
+                s.toolGroupSummaries.push(e.resultDisplay.summary);
+            s.currentToolKind = undefined;
+        }
+        else {
+            showToolComplete(e.exitCode, e.resultDisplay);
+            s.currentToolKind = undefined;
+            s.spinnerStartTime = 0;
+            startThinkingSpinner();
+        }
     });
     bus.on("agent:tool-output-chunk", (e) => writeCommandOutput(e.chunk));
     bus.on("agent:tool-output", () => flushCommandOutput());
@@ -182,7 +275,16 @@ export default function activate(ctx) {
         stopCurrentSpinner();
         endAgentResponse();
     });
-    bus.on("agent:error", (e) => showError(e.message));
+    bus.on("agent:error", (e) => {
+        stopCurrentSpinner();
+        showCollapsedThinking();
+        if (!s.renderer)
+            startAgentResponse();
+        contentGap("info");
+        s.renderer.writeLine(`${p.error}Error: ${e.message}${p.reset}`);
+        s.renderer.writeLine("");
+        drain();
+    });
     bus.on("permission:request", (e) => {
         stopCurrentSpinner();
         flushCommandOutput();
@@ -191,11 +293,12 @@ export default function activate(ctx) {
             drain();
         }
         if (e.kind === "file-write" && e.metadata?.diff) {
+            showCollapsedThinking();
             showFileDiff(e.title, e.metadata.diff);
         }
-        else {
-            endAgentResponse();
-        }
+        // Don't endAgentResponse() here — permission requests that aren't
+        // file-write diffs are handled inline (auto-approved or by extensions).
+        // Closing the response prematurely causes double separator borders.
     });
     bus.on("input:keypress", (e) => {
         if (e.key === "\x0f")
@@ -203,44 +306,74 @@ export default function activate(ctx) {
         if (e.key === "\x14")
             toggleThinkingDisplay(); // Ctrl+T
     });
-    bus.on("ui:info", (e) => showInfo(e.message));
+    bus.on("ui:info", (e) => {
+        stopCurrentSpinner();
+        showInfo(e.message);
+        // Restart spinner if agent is still processing
+        if (s.renderer)
+            startThinkingSpinner();
+    });
     bus.on("ui:error", (e) => showError(e.message));
+    bus.on("ui:suggestion", (e) => {
+        writer.write(`${p.dim}💡 ${e.text}${p.reset}\n`);
+    });
     // ── Rendering functions ─────────────────────────────────────
     function drain() {
         if (!s.renderer)
             return;
         for (const line of s.renderer.drainLines()) {
             writer.write(line + "\n");
+            // Track whether we just emitted a blank line (for contentGap dedup).
+            // Lines from the renderer are indented ("  "), so a blank line is "  " or empty.
+            lastEmittedLineBlank = line.trimEnd() === "" || line.trimEnd().replace(/\x1b\[[^m]*m/g, "").trim() === "";
         }
     }
     function startAgentResponse() {
         s.renderer = new MarkdownRenderer(writer.columns);
         s.hadToolCalls = false;
+        // Preserve lastContentKind across responses so text→tool gaps work
         s.renderer.printTopBorder();
         drain();
     }
+    /**
+     * Insert an empty line when transitioning between different content kinds
+     * (e.g., text → tool, tool → text, diff → tool) for visual breathing room.
+     * Avoids double-blanks by checking if the last emitted line was already empty.
+     */
+    let lastEmittedLineBlank = false;
+    function contentGap(kind) {
+        if (s.lastContentKind && s.lastContentKind !== kind) {
+            if (s.renderer) {
+                s.renderer.flush();
+                drain();
+            }
+            writer.write("\n");
+        }
+        s.lastContentKind = kind;
+    }
     function showCollapsedThinking() {
         if (s.thinkingPending && !s.showThinkingText) {
-            if (!s.renderer)
-                startAgentResponse();
-            s.renderer.writeLine(`${p.muted}… thinking${p.reset}`);
+            // Just clear the pending flag — the spinner already indicates thinking.
+            // No need for a separate "… thinking" label that clutters the output.
             s.thinkingPending = false;
         }
     }
     function endAgentResponse() {
+        finalizeToolGroup();
         closeToolLine();
         stopCurrentSpinner();
         if (s.renderer) {
             s.renderer.flush();
             s.renderer.printBottomBorder();
             drain();
+            writer.write("\n");
             s.renderer = null;
         }
     }
-    function showUserQuery(query, modeLabel) {
-        const boxW = Math.min(84, writer.columns);
+    function showUserQuery(query) {
+        const boxW = writer.columns;
         const contentW = boxW - 4;
-        const lines = [];
+        let lines = [];
         for (const raw of query.split("\n")) {
             if (raw.length <= contentW) {
                 lines.push(`${p.accent}${raw}${p.reset}`);
@@ -258,17 +391,37 @@ export default function activate(ctx) {
                     lines.push(`${p.accent}${remaining}${p.reset}`);
             }
         }
+        // Truncate very long queries to keep the response visible
+        const MAX_QUERY_LINES = 20;
+        if (lines.length > MAX_QUERY_LINES) {
+            const overflow = lines.length - MAX_QUERY_LINES;
+            lines = [
+                ...lines.slice(0, MAX_QUERY_LINES),
+                `${p.dim}… ${overflow} more lines${p.reset}`,
+            ];
+        }
         // Mode-specific border color and title
-        const isExecute = modeLabel === "Execute";
-        const borderColor = isExecute ? p.success : p.accent;
-        const title = modeLabel
-            ? `${borderColor}${p.bold} ${modeLabel} ${p.reset}`
-            : `${p.accent}${p.bold}❯${p.reset}`;
+        const borderColor = p.accent;
+        const title = `${p.accent}${p.bold}❯${p.reset}`;
+        // Backend/model label on the right (backend/model, highlighted)
+        const model = backendInfo?.model ?? llmClient?.model;
+        const backend = backendInfo?.name;
+        let modelLabel;
+        if (backend && model) {
+            modelLabel = `${p.dim}${backend}/${p.reset}${p.bold}${model}${p.reset}`;
+        }
+        else if (model) {
+            modelLabel = `${p.bold}${model}${p.reset}`;
+        }
+        else if (backend) {
+            modelLabel = `${p.bold}${backend}${p.reset}`;
+        }
         const framed = renderBoxFrame(lines, {
             width: boxW,
             style: "rounded",
             borderColor,
             title,
+            titleRight: modelLabel,
         });
         writer.write("\n");
         for (const line of framed) {
@@ -276,8 +429,8 @@ export default function activate(ctx) {
         }
     }
     function writeAgentText(text) {
+        finalizeToolGroup();
         closeToolLine();
-        const needsGap = s.hadToolCalls;
         s.hadToolCalls = false;
         if (s.isThinking) {
             s.isThinking = false;
@@ -292,28 +445,24 @@ export default function activate(ctx) {
         stopCurrentSpinner();
         if (!s.renderer)
             startAgentResponse();
-        if (needsGap)
-            writer.write("\n");
+        contentGap("text");
         s.renderer.push(text);
         drain();
     }
     define("render:code-block", (language, code, width) => {
         flushForRaw();
+        contentGap("code");
         if (language) {
             s.renderer.writeLine(`${p.dim}${language}${p.reset}`);
         }
         let highlighted;
-        if (!language) {
-            // No language specified — render as plain text to avoid false syntax detection
-            highlighted = code;
+        try {
+            highlighted = language
+                ? highlight(code, { language })
+                : highlight(code); // auto-detect
         }
-        else {
-            try {
-                highlighted = highlight(code, { language });
-            }
-            catch {
-                highlighted = `${p.success}${code}${p.reset}`;
-            }
+        catch {
+            highlighted = code;
         }
         const contentWidth = Math.min(90, width - 2);
         for (const line of highlighted.split("\n")) {
@@ -346,41 +495,168 @@ export default function activate(ctx) {
     function writeInlineImage(data) {
         ctx.call("render:image", data);
     }
+    /**
+     * Default renderer for tool result bodies. Extensions can advise this handler
+     * to override rendering for specific body kinds or add new ones:
+     *
+     *   ctx.advise("render:result-body", (next, body, width) => {
+     *     if (body.kind === "diff") return myCustomDiffRenderer(body, width);
+     *     return next(body, width);
+     *   });
+     */
+    define("render:result-body", (body, width) => {
+        if (body.kind === "diff") {
+            return renderDiffBody(body.diff, body.filePath, width);
+        }
+        if (body.kind === "lines") {
+            return renderLinesBody(body.lines, width, body.maxLines);
+        }
+        return [];
+    });
+    /** Render a diff as framed box lines (pure — no TUI state side effects). */
+    function renderDiffBody(diff, filePath, width) {
+        if (diff.isIdentical)
+            return [];
+        const boxW = Math.min(120, width);
+        const contentW = boxW - 4;
+        const diffLines = renderDiff(diff, {
+            width: contentW,
+            filePath,
+            maxLines: getSettings().diffMaxLines,
+            trueColor: true,
+        });
+        const lastLine = diffLines[diffLines.length - 1] ?? "";
+        const isTruncated = lastLine.includes("… ");
+        if (isTruncated) {
+            s.lastTruncatedDiff = { filePath, diff, expanded: false };
+        }
+        else {
+            s.lastTruncatedDiff = null;
+        }
+        const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
+        const footer = isTruncated
+            ? [`  ${p.dim}ctrl+o to expand${p.reset}`]
+            : undefined;
+        return renderBoxFrame(body, {
+            width: boxW,
+            style: "rounded",
+            borderColor: p.dim,
+            title: diffTitle(filePath, diff),
+            footer,
+        });
+    }
+    /** Render output lines with truncation. */
+    function renderLinesBody(lines, width, maxLines) {
+        const max = maxLines ?? 10;
+        const shown = lines.slice(0, max);
+        const contentW = Math.max(1, width - 6);
+        const output = [];
+        for (const line of shown) {
+            const text = line.length > contentW ? line.slice(0, contentW - 1) + "…" : line;
+            output.push(`  ${p.dim}  ${text}${p.reset}`);
+        }
+        if (lines.length > max) {
+            output.push(`  ${p.dim}  … ${lines.length - max} more lines${p.reset}`);
+        }
+        return output;
+    }
+    /** Extract a detail string from tool args for group continuation display. */
+    function extractDetail(extra) {
+        if (extra.locations && extra.locations.length > 0) {
+            const loc = extra.locations[0];
+            const cwd = process.cwd();
+            const home = process.env.HOME;
+            let fp = loc.path;
+            if (fp.startsWith(cwd + "/"))
+                fp = fp.slice(cwd.length + 1);
+            else if (home && fp.startsWith(home + "/"))
+                fp = "~/" + fp.slice(home.length + 1);
+            return loc.line ? `${fp}:${loc.line}` : fp;
+        }
+        const raw = extra.rawInput;
+        if (!raw)
+            return "";
+        if (typeof raw.command === "string")
+            return `$ ${raw.command}`;
+        if (typeof raw.pattern === "string")
+            return raw.pattern;
+        if (typeof raw.path === "string") {
+            const cwd = process.cwd();
+            const home = process.env.HOME;
+            let fp = raw.path;
+            if (fp.startsWith(cwd + "/"))
+                fp = fp.slice(cwd.length + 1);
+            else if (home && fp.startsWith(home + "/"))
+                fp = "~/" + fp.slice(home.length + 1);
+            return fp;
+        }
+        if (typeof raw.query === "string")
+            return `"${raw.query}"`;
+        return "";
+    }
     function showToolCall(title, command, extra) {
         closeToolLine();
         stopCurrentSpinner();
         if (!s.renderer)
             startAgentResponse();
         showCollapsedThinking();
+        // No gap between grouped tools — they're visually connected
+        if (!extra?.groupContinuation)
+            contentGap("tool");
         s.renderer.flush();
         drain();
         const lines = renderToolCall({
             title,
             command: command || undefined,
             kind: extra?.kind,
+            icon: extra?.icon,
             locations: extra?.locations,
             rawInput: extra?.rawInput,
+            displayDetail: extra?.displayDetail,
         }, writer.columns);
+        if (extra?.groupContinuation && lines.length > 0) {
+            // Swap the colored kind icon for a muted tree connector,
+            // and strip the tool name prefix — show detail only.
+            const detail = extra.displayDetail || extractDetail(extra);
+            const maxW = Math.max(1, writer.columns - 6);
+            const text = detail.length > maxW ? detail.slice(0, maxW - 1) + "…" : detail;
+            lines[0] = detail
+                ? `${p.muted}├${p.reset} ${p.dim}${text}${p.reset}`
+                : lines[0].replace(/^\x1b\[[^m]*m.\x1b\[0m/, `${p.muted}├${p.reset}`);
+        }
+        const batchPrefix = "";
         for (let i = 0; i < lines.length - 1; i++) {
             s.renderer.writeLine(lines[i]);
         }
         drain();
         if (lines.length > 0) {
-            writer.write(`  ${lines[lines.length - 1]}`);
-            s.toolLineOpen = true;
+            if (extra?.groupContinuation) {
+                // Grouped tools: close the line immediately — checkmarks go on the ⎿ summary
+                s.renderer.writeLine(`  ${batchPrefix}${lines[lines.length - 1]}`);
+                drain();
+                s.toolLineOpen = false;
+            }
+            else {
+                writer.write(`  ${batchPrefix}${lines[lines.length - 1]}`);
+                s.toolLineOpen = true;
+            }
         }
         s.hadToolCalls = true;
         s.commandOutputLineCount = 0;
         s.commandOutputOverflow = 0;
     }
-    function showToolComplete(exitCode) {
+    function showToolComplete(exitCode, resultDisplay) {
         if (!s.renderer)
             return;
+        stopCurrentSpinner();
+        const elapsed = s.toolStartTime ? formatElapsed(Date.now() - s.toolStartTime) : "";
+        const timer = elapsed ? ` ${p.dim}${elapsed}${p.reset}` : "";
+        const summary = resultDisplay?.summary ? ` ${p.dim}${resultDisplay.summary}${p.reset}` : "";
         const mark = exitCode === null
             ? `${p.muted}(timed out)${p.reset}`
             : exitCode === 0
-                ? `${p.success}✓${p.reset}`
-                : `${p.error}✗ exit ${exitCode}${p.reset}`;
+                ? `${p.success}✓${p.reset}${summary}${timer}`
+                : `${p.error}✗ exit ${exitCode}${p.reset}${summary}${timer}`;
         if (s.toolLineOpen && s.commandOutputLineCount === 0) {
             writer.write(` ${mark}\n`);
             s.toolLineOpen = false;
@@ -391,10 +667,25 @@ export default function activate(ctx) {
             s.renderer.writeLine(`  ${mark}`);
             drain();
         }
+        // Render structured body if present
+        if (resultDisplay?.body) {
+            renderResultBody(resultDisplay.body);
+        }
+    }
+    function renderResultBody(body) {
+        if (!s.renderer)
+            return;
+        const lines = ctx.call("render:result-body", body, writer.columns) ?? [];
+        for (const line of lines) {
+            s.renderer.writeLine(line);
+        }
+        if (lines.length > 0)
+            drain();
     }
+    // Thinking is always assumed available — the TUI renders thinking
+    // tokens whenever they arrive, regardless of backend.
     function hasThinkingMode() {
-        const mode = getAcpClient().getCurrentMode();
-        return !mode || mode.id !== "off";
+        return true;
     }
     function startThinkingSpinner() {
         if (!s.spinnerStartTime)
@@ -430,6 +721,40 @@ export default function activate(ctx) {
             s.toolLineOpen = false;
         }
     }
+    /** Finalize a group of collapsed tool calls, rendering the summary. */
+    function finalizeToolGroup() {
+        if (s.toolGroupCount <= 1) {
+            // 0–1 tools: standalone, nothing to finalize
+            s.toolGroupKind = undefined;
+            s.toolGroupCount = 0;
+            s.toolGroupRendered = 0;
+            s.toolGroupSummaries = [];
+            return;
+        }
+        closeToolLine();
+        if (!s.renderer)
+            startAgentResponse();
+        const mark = s.toolGroupAllOk
+            ? `${p.success}✓${p.reset}`
+            : `${p.error}✗${p.reset}`;
+        const summary = s.toolGroupSummaries.length > 0
+            ? ` ${p.dim}${s.toolGroupSummaries.join(", ")}${p.reset}`
+            : "";
+        const collapsed = s.toolGroupCount - s.toolGroupRendered;
+        if (collapsed > 0) {
+            s.renderer.writeLine(`  ${p.muted}└${p.reset} ${p.dim}+${collapsed} more${p.reset} ${mark}${summary}`);
+        }
+        else {
+            // All items visible — close the tree with └ mark + summary
+            s.renderer.writeLine(`  ${p.muted}└${p.reset} ${mark}${summary}`);
+        }
+        drain();
+        s.toolGroupKind = undefined;
+        s.toolGroupCount = 0;
+        s.toolGroupAllOk = true;
+        s.toolGroupRendered = 0;
+        s.toolGroupSummaries = [];
+    }
     function writeCommandOutput(chunk) {
         if (!s.renderer)
             return;
@@ -447,10 +772,13 @@ export default function activate(ctx) {
             }
             else {
                 s.commandOutputOverflow++;
+                s.commandOverflowLines.push(line);
             }
         }
         drain();
     }
+    /** Max overflow lines to show when a command fails. */
+    const FAIL_OVERFLOW_MAX = 20;
     function flushCommandOutput() {
         if (!s.renderer)
             return;
@@ -464,13 +792,28 @@ export default function activate(ctx) {
             }
             else {
                 s.commandOutputOverflow++;
+                s.commandOverflowLines.push(s.commandOutputBuffer);
             }
             s.commandOutputBuffer = "";
         }
-        if (s.commandOutputOverflow > 0 && maxLines > 0) {
+        // On failure, show the tail of the overflow so the user can see the error
+        const failed = s.toolExitCode !== null && s.toolExitCode !== 0;
+        if (failed && s.commandOverflowLines.length > 0) {
+            const tail = s.commandOverflowLines.slice(-FAIL_OVERFLOW_MAX);
+            const skipped = s.commandOverflowLines.length - tail.length;
+            if (skipped > 0) {
+                s.renderer.writeLine(`${p.dim}  … ${skipped} lines hidden${p.reset}`);
+            }
+            for (const line of tail) {
+                s.renderer.writeLine(`${p.dim}  ${line}${p.reset}`);
+            }
+        }
+        else if (s.commandOutputOverflow > 0 && maxLines > 0) {
             s.renderer.writeLine(`${p.dim}  … ${s.commandOutputOverflow} more lines${p.reset}`);
         }
         s.commandOutputOverflow = 0;
+        s.commandOverflowLines = [];
+        s.toolExitCode = null;
         drain();
     }
     function diffTitle(filePath, diff) {
@@ -482,37 +825,11 @@ export default function activate(ctx) {
     function showFileDiff(filePath, diff) {
         if (diff.isIdentical)
             return;
-        const boxW = Math.min(84, writer.columns);
-        const contentW = boxW - 4;
-        const diffLines = renderDiff(diff, {
-            width: contentW,
-            filePath,
-            maxLines: getSettings().diffMaxLines,
-            trueColor: true,
-            mode: "unified",
-        });
-        const lastLine = diffLines[diffLines.length - 1] ?? "";
-        const isTruncated = lastLine.includes("… ");
-        if (isTruncated) {
-            s.lastTruncatedDiff = { filePath, diff, expanded: false };
-        }
-        else {
-            s.lastTruncatedDiff = null;
-        }
-        const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
-        const footer = isTruncated
-            ? [`  ${p.dim}ctrl+o to expand${p.reset}`]
-            : undefined;
-        const framed = renderBoxFrame(body, {
-            width: boxW,
-            style: "rounded",
-            borderColor: p.dim,
-            title: diffTitle(filePath, diff),
-            footer,
-        });
+        contentGap("diff");
+        const lines = ctx.call("render:result-body", { kind: "diff", diff, filePath }, writer.columns) ?? [];
         if (!s.renderer)
             startAgentResponse();
-        for (const line of framed) {
+        for (const line of lines) {
             s.renderer.writeLine(line);
         }
         drain();
@@ -551,26 +868,9 @@ export default function activate(ctx) {
         }
     }
     function showFileDiffCached(entry) {
-        const { filePath, diff } = entry;
-        const boxW = Math.min(84, writer.columns);
-        const contentW = boxW - 4;
-        const diffLines = renderDiff(diff, {
-            width: contentW,
-            filePath,
-            maxLines: getSettings().diffMaxLines,
-            trueColor: true,
-            mode: "unified",
-        });
-        const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
-        const framed = renderBoxFrame(body, {
-            width: boxW,
-            style: "rounded",
-            borderColor: p.dim,
-            title: diffTitle(filePath, diff),
-            footer: [`  ${p.dim}ctrl+o to expand${p.reset}`],
-        });
+        const lines = ctx.call("render:result-body", { kind: "diff", diff: entry.diff, filePath: entry.filePath }, writer.columns) ?? [];
         writer.write("\n");
-        for (const line of framed) {
+        for (const line of lines) {
             writer.write(line + "\n");
         }
     }