agent-sh 0.15.5 → 0.15.7

package/dist/shell/tui-renderer.js

@@ -50,7 +50,6 @@ function createRenderState() {
         spinnerStartTime: 0,
         openTool: null,
         pendingToolCompletes: new Map(),
-        orphanContHeaderKind: undefined,
         currentToolKind: undefined,
         toolStartTime: 0,
         toolExitCode: null,
@@ -58,12 +57,6 @@ function createRenderState() {
         commandOutputLineCount: 0,
         commandOutputOverflow: 0,
         commandOverflowLines: [],
-        toolGroupKind: undefined,
-        toolGroupCount: 0,
-        toolGroupCompletedCount: 0,
-        toolGroupAllOk: true,
-        toolGroupRendered: 0,
-        toolGroupSummaries: [],
         isThinking: false,
         showThinkingText: false,
         thinkingPending: false,
@@ -113,15 +106,6 @@ export default function activate(ctx) {
             return `${p.success}✓${p.reset}${summaryStr}${timer}`;
         return `${p.error}✗ exit ${exitCode}${p.reset}${summaryStr}${timer}`;
     });
-    define("tui:render-tool-group-summary", (count, rendered, allOk, summaries) => {
-        const mark = allOk ? `${p.success}✓${p.reset}` : `${p.error}✗${p.reset}`;
-        const summaryStr = summaries.length > 0 ? ` ${p.dim}${summaries.join(", ")}${p.reset}` : "";
-        const collapsed = count - rendered;
-        if (collapsed > 0) {
-            return `  ${p.muted}└${p.reset} ${p.dim}+${collapsed} more${p.reset} ${mark}${summaryStr}`;
-        }
-        return `  ${p.muted}└${p.reset} ${mark}${summaryStr}`;
-    });
     define("tui:render-command-output", (line, _kind) => `${p.dim}  ${line}${p.reset}`);
     define("tui:render-spinner", (label, frame, elapsed, hint) => {
         const timer = elapsed ? ` ${p.dim}${elapsed}${p.reset}` : "";
@@ -245,33 +229,35 @@ export default function activate(ctx) {
     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();
+    let batchSize = 0;
+    /** A lone tool has nothing to interleave with, so deferral applies only to
+     *  read-only kinds in a multi-tool batch. */
+    function isDeferred(kind) {
+        return batchSize > 1 && GROUPABLE_KINDS.has(kind) && batchGroups.has(kind);
+    }
     bus.on("agent:tool-batch", (e) => {
         if (!shouldRender())
             return;
         fencedTransform.flush();
-        finalizeToolGroup();
-        s.orphanContHeaderKind = undefined;
+        finalizeAllGroups();
+        closeToolLine();
         batchGroups = new Map();
+        batchSize = 0;
         for (const group of e.groups) {
-            batchGroups.set(group.kind, {
-                total: group.tools.length,
-                rendered: 0,
-                headerShown: false,
-            });
+            batchSize += group.tools.length;
+            batchGroups.set(group.kind, { total: group.tools.length, completed: 0, finalized: false, order: [], members: new Map() });
         }
     });
     bus.on("agent:tool-started", (e) => {
         if (!shouldRender())
             return;
         fencedTransform.flush();
-        stopCurrentSpinner();
         s.currentToolKind = e.kind;
         s.toolStartTime = Date.now();
-        s.orphanContHeaderKind = undefined;
         if (e.title === "user_shell") {
-            finalizeToolGroup();
+            stopCurrentSpinner();
+            finalizeAllGroups();
             closeToolLine();
             if (!s.renderer)
                 startAgentResponse();
@@ -284,89 +270,57 @@ export default function activate(ctx) {
             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.toolGroupCompletedCount = 0;
-                s.toolGroupRendered = 0;
-                s.toolGroupAllOk = true;
-                s.toolGroupSummaries = [];
-            }
-            s.toolGroupCount++;
-            if (s.toolGroupRendered < GROUP_MAX_VISIBLE) {
-                showToolCall(e.title, "", { ...e, groupContinuation: true });
-                s.toolGroupRendered++;
-            }
-            if (e.toolCallId) {
-                s.pendingToolCompletes.set(e.toolCallId, {
-                    title: e.title,
-                    kind,
-                    displayDetail: e.displayDetail ?? extractDetail(e),
-                });
-            }
-        }
-        else {
-            // Standalone tool — single in its batch kind, or not groupable
-            finalizeToolGroup();
-            showToolCall(e.title, "", { ...e });
+        if (isDeferred(kind)) {
+            const group = batchGroups.get(kind);
+            const id = e.toolCallId ?? `${kind}-${group.order.length}`;
+            group.order.push(id);
+            group.members.set(id, { detail: e.displayDetail ?? extractDetail(e), ok: true, done: false });
+            s.hadToolCalls = true;
+            if (!s.spinner)
+                startThinkingSpinner(); // nothing's drawn yet — stand in until the block renders
+            return;
         }
+        // Eager: a single-tool turn, or a sequential mutating/streaming tool.
+        stopCurrentSpinner();
+        showToolCall(e.title, "", { ...e });
     });
     bus.on("agent:tool-completed", (e) => {
         if (!shouldRender())
             return;
         s.toolExitCode = e.exitCode;
-        if (e.exitCode !== 0)
-            s.toolGroupAllOk = false;
         const resultDisplay = e.resultDisplay;
-        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 (resultDisplay?.summary)
-                s.toolGroupSummaries.push(resultDisplay.summary);
-            if (e.toolCallId)
-                s.pendingToolCompletes.delete(e.toolCallId);
-            s.toolGroupCompletedCount++;
-            s.currentToolKind = undefined;
-            // Finalize as soon as all members return so aggregate lands right
-            // after its children, not below out-of-band renders from the next tool.
-            const batchGroup = batchGroups.get(s.toolGroupKind);
-            if (batchGroup && s.toolGroupCompletedCount >= batchGroup.total) {
-                finalizeToolGroup();
+        const kind = e.kind ?? "execute";
+        const group = batchGroups.get(kind);
+        if (isDeferred(kind) && group) {
+            const id = e.toolCallId ?? group.order[group.completed];
+            const member = id ? group.members.get(id) : undefined;
+            if (member) {
+                member.done = true;
+                member.ok = e.exitCode === 0;
+                member.summary = resultDisplay?.summary;
             }
+            group.completed++;
+            s.currentToolKind = undefined;
+            flushReadyGroups();
+            if (!s.spinner)
+                startThinkingSpinner(); // keep the spinner up for in-flight siblings
         }
         else {
-            // Tools that lost the inline slot render as a labeled ⎿. Orphans
-            // (group finalized before they returned) reroute via showOrphanedComplete.
             const pending = e.toolCallId ? s.pendingToolCompletes.get(e.toolCallId) : undefined;
             if (pending)
                 s.pendingToolCompletes.delete(e.toolCallId);
-            if (pending?.orphaned) {
-                showOrphanedComplete(e.exitCode, resultDisplay, pending.title, pending.kind, pending.displayDetail);
-            }
-            else {
-                showToolComplete(e.exitCode, resultDisplay, pending?.displayDetail ?? pending?.title);
-            }
+            showToolComplete(e.exitCode, resultDisplay, pending?.displayDetail ?? pending?.title);
             s.currentToolKind = undefined;
             s.spinnerStartTime = 0;
             startThinkingSpinner();
         }
     });
+    bus.on("agent:tool-batch-complete", () => {
+        if (!shouldRender())
+            return;
+        // Backstop for a group whose members didn't all complete (e.g. errored).
+        finalizeAllGroups();
+    });
     bus.on("agent:tool-output-chunk", (e) => { if (shouldRender())
         writeCommandOutput(e.chunk); });
     bus.on("agent:tool-output", () => { if (shouldRender())
@@ -465,7 +419,7 @@ export default function activate(ctx) {
         }
     }
     function endAgentResponse() {
-        finalizeToolGroup();
+        finalizeAllGroups();
         closeToolLine();
         stopCurrentSpinner();
         if (s.renderer) {
@@ -502,7 +456,7 @@ export default function activate(ctx) {
         }
     }
     function writeAgentText(text) {
-        finalizeToolGroup();
+        finalizeAllGroups();
         closeToolLine();
         s.hadToolCalls = false;
         if (s.isThinking) {
@@ -526,7 +480,7 @@ export default function activate(ctx) {
         flushForRaw();
         contentGap("code");
         if (language) {
-            s.renderer.writeLine(`${p.dim}${language}${p.reset}`);
+            s.renderer.writeLine(`${p.mdCodeBlockBorder}${language}${p.reset}`);
         }
         let highlighted;
         try {
@@ -549,7 +503,10 @@ export default function activate(ctx) {
             }
         }
         catch {
-            highlighted = code;
+            highlighted = code
+                .split("\n")
+                .map((l) => `${p.mdCodeBlock}${l}${p.reset}`)
+                .join("\n");
         }
         const contentWidth = Math.min(90, width - 2);
         for (const line of highlighted.split("\n")) {
@@ -644,6 +601,7 @@ export default function activate(ctx) {
             filePath,
             maxLines,
             trueColor: true,
+            gutterLine: false,
         });
         const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
         return renderBoxFrame(body, {
@@ -710,9 +668,7 @@ export default function activate(ctx) {
         if (!s.renderer)
             startAgentResponse();
         showCollapsedThinking();
-        // No gap between grouped tools — they're visually connected
-        if (!extra?.groupContinuation)
-            contentGap("tool");
+        contentGap("tool");
         s.renderer.flush();
         drain();
         const lines = renderToolCall({
@@ -724,37 +680,19 @@ export default function activate(ctx) {
             rawInput: extra?.rawInput,
             displayDetail: extra?.displayDetail,
         }, cappedW(), shellCwd);
-        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, cappedW() - 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) {
-            if (extra?.groupContinuation) {
-                // Grouped tools: close the line immediately — checkmarks go on the ⎿ summary
-                s.renderer.writeLine(`  ${batchPrefix}${lines[lines.length - 1]}`);
-                drain();
-            }
-            else {
-                out().write(`  ${batchPrefix}${lines[lines.length - 1]}`);
-                if (extra?.toolCallId) {
-                    s.openTool = {
-                        callId: extra.toolCallId,
-                        title,
-                        kind: extra.kind,
-                        displayDetail: extra.displayDetail ?? extractDetail(extra),
-                    };
-                }
+            out().write(`  ${lines[lines.length - 1]}`);
+            if (extra?.toolCallId) {
+                s.openTool = {
+                    callId: extra.toolCallId,
+                    title,
+                    kind: extra.kind,
+                    displayDetail: extra.displayDetail ?? extractDetail(extra),
+                };
             }
         }
         s.hadToolCalls = true;
@@ -782,26 +720,6 @@ export default function activate(ctx) {
         if (resultDisplay?.body)
             renderResultBody(resultDisplay.body);
     }
-    /** Late completion from a finalized group — re-emit the kind header
-     *  in muted "(cont.)" form so the ⎿ has a legitimate parent, then
-     *  render the completion as a normal labeled ⎿. Subsequent orphans
-     *  of the same kind reuse the existing (cont.) header. */
-    function showOrphanedComplete(exitCode, resultDisplay, title, kind, displayDetail) {
-        if (s.orphanContHeaderKind !== kind) {
-            stopCurrentSpinner();
-            closeToolLine();
-            flushCommandOutput();
-            if (!s.renderer)
-                startAgentResponse();
-            showCollapsedThinking();
-            const icon = (kind && KIND_ICONS[kind]) ?? "▶";
-            const label = kind ?? "tool";
-            s.renderer.writeLine(`${p.muted}${icon} ${label} (cont.)${p.reset}`);
-            drain();
-            s.orphanContHeaderKind = kind;
-        }
-        showToolComplete(exitCode, resultDisplay, displayDetail || title);
-    }
     function renderResultBody(body) {
         if (!s.renderer)
             return;
@@ -848,7 +766,7 @@ export default function activate(ctx) {
     function closeToolLine() {
         if (s.openTool) {
             out().write("\n");
-            // Stash identity so the completion renders as ⎿ labeled, not orphan ✓.
+            // Stash identity so the completion renders as ⎿ labeled, not inline ✓.
             s.pendingToolCompletes.set(s.openTool.callId, {
                 title: s.openTool.title,
                 kind: s.openTool.kind,
@@ -857,40 +775,64 @@ export default function activate(ctx) {
             s.openTool = null;
         }
     }
-    /** Render the group aggregate ⎿ line, or skip if no members have
-     *  completed yet (late completes will render individually as ⎿ labeled). */
-    function finalizeToolGroup() {
-        // Late completes from this group have lost their inline slot; mark
-        // them so showOrphanedComplete re-emits a (cont.) header for their ⎿.
-        if (s.toolGroupKind) {
-            for (const pending of s.pendingToolCompletes.values()) {
-                if (pending.kind === s.toolGroupKind)
-                    pending.orphaned = true;
-            }
-        }
-        const skipAggregate = s.toolGroupCount > 1 && s.toolGroupCompletedCount === 0;
-        if (s.toolGroupCount <= 1 || skipAggregate) {
-            s.toolGroupKind = undefined;
-            s.toolGroupCount = 0;
-            s.toolGroupCompletedCount = 0;
-            s.toolGroupRendered = 0;
-            s.toolGroupAllOk = true;
-            s.toolGroupSummaries = [];
+    /** Render a deferred group as one contiguous block, skipping a group with no
+     *  completed members (e.g. all errored before their events fired). */
+    function finalizeGroup(kind) {
+        const group = batchGroups.get(kind);
+        if (!group || group.finalized)
+            return;
+        group.finalized = true;
+        const members = group.order
+            .map((id) => group.members.get(id))
+            .filter((m) => !!m && m.done);
+        if (members.length === 0)
             return;
-        }
         stopCurrentSpinner();
         closeToolLine();
         if (!s.renderer)
             startAgentResponse();
-        const groupLine = ctx.call("tui:render-tool-group-summary", s.toolGroupCount, s.toolGroupRendered, s.toolGroupAllOk, s.toolGroupSummaries);
-        s.renderer.writeLine(groupLine);
+        showCollapsedThinking();
+        contentGap("tool");
+        s.renderer.flush();
         drain();
-        s.toolGroupKind = undefined;
-        s.toolGroupCount = 0;
-        s.toolGroupCompletedCount = 0;
-        s.toolGroupAllOk = true;
-        s.toolGroupRendered = 0;
-        s.toolGroupSummaries = [];
+        const icon = KIND_ICONS[kind] ?? "▶";
+        const mark = (m) => ctx.call("tui:render-tool-complete", m.ok ? 0 : 1, "", m.summary);
+        if (members.length === 1) {
+            const m = members[0];
+            s.renderer.writeLine(`${p.warning}${icon}${p.reset} ${kind} ${p.dim}${m.detail}${p.reset} ${mark(m)}`);
+        }
+        else {
+            s.renderer.writeLine(`${p.warning}${icon}${p.reset} ${kind}`);
+            const shown = Math.min(members.length, GROUP_MAX_VISIBLE);
+            const allShown = members.length <= GROUP_MAX_VISIBLE;
+            for (let i = 0; i < shown; i++) {
+                const m = members[i];
+                const connector = allShown && i === shown - 1 ? "└" : "├";
+                s.renderer.writeLine(`  ${p.muted}${connector}${p.reset} ${p.dim}${m.detail}${p.reset} ${mark(m)}`);
+            }
+            if (!allShown) {
+                s.renderer.writeLine(`  ${p.muted}└${p.reset} ${p.dim}+${members.length - shown} more${p.reset}`);
+            }
+        }
+        drain();
+    }
+    function finalizeAllGroups() {
+        for (const kind of batchGroups.keys())
+            finalizeGroup(kind);
+    }
+    /** Finalize ready groups in batch order, stopping at the first still in
+     *  flight — so blocks render in dispatch order, not completion order. */
+    function flushReadyGroups() {
+        for (const [kind, group] of batchGroups) {
+            if (group.finalized)
+                continue;
+            // Eager (non-groupable) groups never increment `completed`, so one earlier
+            // in batch order is a barrier here: a deferred group after it renders at
+            // the tool-batch-complete backstop, not incrementally. Order is preserved.
+            if (group.completed < group.total)
+                break;
+            finalizeGroup(kind);
+        }
     }
     function renderCommandLine(line) {
         return ctx.call("tui:render-command-output", line, s.currentToolKind);

package/dist/utils/diff-renderer.js

@@ -8,6 +8,7 @@
 import { highlight } from "cli-highlight";
 import { visibleLen, charWidth } from "./ansi.js";
 import { palette as p } from "./palette.js";
+import { wrapLine } from "./markdown.js";
 // ── Constants ────────────────────────────────────────────────────
 const SPLIT_MIN_WIDTH = 120;
 const UNIFIED_MIN_WIDTH = 40;
@@ -102,6 +103,42 @@ function tokenLcs(a, b) {
     }
     return { oldMatch, newMatch };
 }
+/**
+ * Anchors the shared prefix/suffix as unchanged and runs the O(m·n) LCS only on
+ * the differing middle. Null when that middle exceeds maxProduct.
+ */
+function inlineMatches(a, b, maxProduct) {
+    const m = a.length;
+    const n = b.length;
+    let pre = 0;
+    while (pre < m && pre < n && a[pre].text === b[pre].text)
+        pre++;
+    let suf = 0;
+    while (suf < m - pre && suf < n - pre && a[m - 1 - suf].text === b[n - 1 - suf].text)
+        suf++;
+    const midM = m - pre - suf;
+    const midN = n - pre - suf;
+    if (midM * midN > maxProduct)
+        return null;
+    const oldMatch = new Array(m).fill(false);
+    const newMatch = new Array(n).fill(false);
+    for (let i = 0; i < pre; i++) {
+        oldMatch[i] = true;
+        newMatch[i] = true;
+    }
+    for (let i = 0; i < suf; i++) {
+        oldMatch[m - 1 - i] = true;
+        newMatch[n - 1 - i] = true;
+    }
+    if (midM > 0 && midN > 0) {
+        const mid = tokenLcs(a.slice(pre, m - suf), b.slice(pre, n - suf));
+        for (let i = 0; i < midM; i++)
+            oldMatch[pre + i] = mid.oldMatch[i];
+        for (let j = 0; j < midN; j++)
+            newMatch[pre + j] = mid.newMatch[j];
+    }
+    return { oldMatch, newMatch };
+}
 /**
  * Rewrite full ANSI resets (\x1b[0m) to foreground-only resets,
  * preserving the given background color across the line.
@@ -139,14 +176,14 @@ function highlightInlineChanges(oldLine, newLine, oldPalette, newPalette, useTru
             new: language ? highlightLine(newLine, language) : newLine,
         };
     }
-    // Safety guard: skip if LCS matrix would be too large
-    if (oldTokens.length * newTokens.length > 50000) {
+    const matches = inlineMatches(oldTokens, newTokens, 1_000_000);
+    if (!matches) {
         return {
             old: language ? highlightLine(oldLine, language) : oldLine,
             new: language ? highlightLine(newLine, language) : newLine,
         };
     }
-    const { oldMatch, newMatch } = tokenLcs(oldTokens, newTokens);
+    const { oldMatch, newMatch } = matches;
     const buildHighlighted = (tokens, matched, palette) => {
         let result = "";
         for (let i = 0; i < tokens.length; i++) {
@@ -248,13 +285,19 @@ function renderUnifiedHunk(hunk, layout) {
     const pairs = findChangePairs(hunk);
     const bgWidth = Math.max(1, textWidth - noW - 3);
     const gutter = (n) => `${p.dim}${n} │${p.reset} `;
+    const continuationNo = " ".repeat(noW);
+    // Wrapped rows after the first blank the line number and sigil.
     const change = (no, sigil, bg, fg, text) => {
-        if (!gutterLine) {
-            return `${bg}${padToWidth(`${fg}${no} ${sigil}${p.diffText} ${preserveBg(text, bg)}`, textWidth)}${p.reset}`;
-        }
-        if (useTrueColor)
-            return gutter(no) + padToWidth(`${bg}${fg}${sigil}${p.diffText} ${preserveBg(text, bg)}`, bgWidth) + p.reset;
-        return `${gutter(no)}${fg}${sigil} ${text}${p.reset}`;
+        return wrapLine(text, lineTextW).map((seg, r) => {
+            const n = r === 0 ? no : continuationNo;
+            const sg = r === 0 ? sigil : " ";
+            if (!gutterLine) {
+                return `${bg}${padToWidth(`${fg}${n} ${sg}${p.diffText} ${preserveBg(seg, bg)}`, textWidth)}${p.reset}`;
+            }
+            if (useTrueColor)
+                return gutter(n) + padToWidth(`${bg}${fg}${sg}${p.diffText} ${preserveBg(seg, bg)}`, bgWidth) + p.reset;
+            return `${gutter(n)}${fg}${sg} ${seg}${p.reset}`;
+        });
     };
     const hlCache = new Map();
     const highlightedPair = (pair) => {
@@ -269,33 +312,25 @@ function renderUnifiedHunk(hunk, layout) {
         const line = hunk.lines[i];
         const no = String(line.type === "removed" ? (line.oldNo ?? "") : (line.newNo ?? line.oldNo ?? "")).padStart(noW);
         if (line.type === "context") {
-            const raw = truncateText(line.text, lineTextW);
-            const text = lang ? highlightLine(raw, lang) : raw;
-            out.push(!gutterLine ? `${p.dim}${no}${p.reset}   ${text}` : `${gutter(no)}  ${p.dim}${text}${p.reset}`);
+            const text = lang ? highlightLine(line.text, lang) : line.text;
+            wrapLine(text, lineTextW).forEach((seg, r) => {
+                const n = r === 0 ? no : continuationNo;
+                out.push(!gutterLine ? `${p.dim}${n}${p.reset}   ${seg}` : `${gutter(n)}  ${p.dim}${seg}${p.reset}`);
+            });
             continue;
         }
         const pair = pairs.get(i);
         if (line.type === "removed") {
-            let removedText;
-            if (pair) {
-                removedText = truncateText(highlightedPair(pair).old, lineTextW);
-            }
-            else {
-                const raw = truncateText(line.text, lineTextW);
-                removedText = lang ? highlightLine(raw, lang) : raw;
-            }
-            out.push(change(no, "-", p.errorBg, p.error, removedText));
+            const removedText = pair
+                ? highlightedPair(pair).old
+                : (lang ? highlightLine(line.text, lang) : line.text);
+            out.push(...change(no, "-", p.errorBg, p.error, removedText));
         }
         else {
-            let addedText;
-            if (pair) {
-                addedText = truncateText(highlightedPair(pair).new, lineTextW);
-            }
-            else {
-                const raw = truncateText(line.text, lineTextW);
-                addedText = lang ? highlightLine(raw, lang) : raw;
-            }
-            out.push(change(no, "+", p.successBg, p.success, addedText));
+            const addedText = pair
+                ? highlightedPair(pair).new
+                : (lang ? highlightLine(line.text, lang) : line.text);
+            out.push(...change(no, "+", p.successBg, p.success, addedText));
         }
     }
     return out;

package/dist/utils/executor.js

@@ -1,5 +1,6 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
 import { stripAnsi } from "./ansi.js";
 // Node reports a missing cwd as `spawn <binary> ENOENT` — disambiguate.
 function explainSpawnError(err, cwd) {
@@ -77,21 +78,23 @@ export function executeCommand(opts) {
         return { session, done };
     }
     session.process = child;
-    const handleData = (data) => {
-        const raw = data.toString("utf-8");
+    const handleText = (raw) => {
+        if (!raw)
+            return;
         const clean = stripAnsi(raw);
-        // Accumulate cleaned output for the agent
         session.output += clean;
-        // Enforce output cap — truncate from beginning, keep tail
         if (session.output.length > maxOutput) {
             session.output = session.output.slice(-maxOutput);
             session.truncated = true;
         }
-        // Real-time streaming callback
         opts.onOutput?.(raw);
     };
-    child.stdout?.on("data", handleData);
-    child.stderr?.on("data", handleData);
+    const outDecoder = new StringDecoder("utf-8");
+    const errDecoder = new StringDecoder("utf-8");
+    child.stdout?.on("data", (d) => handleText(outDecoder.write(d)));
+    child.stderr?.on("data", (d) => handleText(errDecoder.write(d)));
+    child.stdout?.on("end", () => handleText(outDecoder.end()));
+    child.stderr?.on("end", () => handleText(errDecoder.end()));
     let cancelKill;
     const timer = setTimeout(() => {
         if (!session.done) {
@@ -169,8 +172,9 @@ export function executeArgv(opts) {
         return { session, done };
     }
     session.process = child;
-    const handleData = (data) => {
-        const raw = data.toString("utf-8");
+    const handleText = (raw) => {
+        if (!raw)
+            return;
         const clean = stripAnsi(raw);
         session.output += clean;
         if (session.output.length > maxOutput) {
@@ -179,8 +183,12 @@ export function executeArgv(opts) {
         }
         opts.onOutput?.(raw);
     };
-    child.stdout?.on("data", handleData);
-    child.stderr?.on("data", handleData);
+    const outDecoder = new StringDecoder("utf-8");
+    const errDecoder = new StringDecoder("utf-8");
+    child.stdout?.on("data", (d) => handleText(outDecoder.write(d)));
+    child.stderr?.on("data", (d) => handleText(errDecoder.write(d)));
+    child.stdout?.on("end", () => handleText(outDecoder.end()));
+    child.stderr?.on("end", () => handleText(errDecoder.end()));
     const timer = setTimeout(() => {
         if (!session.done && session.process) {
             try {

package/dist/utils/floating-panel.d.ts

@@ -222,6 +222,7 @@ export declare class FloatingPanel {
     private updateAutocomplete;
     private applyAutocomplete;
     private clearAutocomplete;
+    private moveAutocomplete;
     private handleIntercept;
     /**
      * Handle scroll input. Returns true if consumed.