mixdog 0.9.2 → 0.9.3

package/src/tui/components/PromptInput.jsx

@@ -38,6 +38,7 @@ import {
   replaceSelection,
   selectionRange,
   verticalOffset,
+  wordRangeAt,
 } from '../input-editing.mjs';
 
 function hintStyle(tone) {
@@ -52,6 +53,26 @@ function hintStyle(tone) {
 // paddingX of 1, so the typing start can sit directly against that padding
 // without an extra guard column.
 const IME_LEFT_GUARD_COLUMNS = 0;
+
+// Monotone voice indicator glyphs — right end of the prompt box. All frames
+// are 1-cell-wide (no emoji, no string-width special-casing needed). Modes:
+//   'off'          — voice disabled and no install in flight: renders nothing,
+//                    zero reserved columns.
+//   'installing'   — voice-runtime download in progress (progressHint active):
+//                    braille spinner only.
+//   'idle'         — voice enabled, recorder idle: a slow "breathing" pulse
+//                    (◎ ◍ ◉ ◍) so the indicator isn't a dead static glyph.
+//   'recording'    — steady ◉ + a braille spinner riding next to it (2 cells).
+//   'transcribing' — braille spinner only (recording just stopped, awaiting
+//                    the whisper-server round-trip).
+// A single ~120ms interval drives BOTH the fast braille cycle and the slower
+// idle pulse (idle advances one frame every VOICE_IDLE_FRAME_TICKS ticks) —
+// one timer instead of two, and it only exists while the indicator is
+// visible (mode !== 'off'); it's torn down otherwise, never a permanent timer.
+const VOICE_BRAILLE_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧'];
+const VOICE_IDLE_FRAMES = ['◎', '◍', '◉', '◍'];
+const VOICE_TICK_MS = 120;
+const VOICE_IDLE_FRAME_TICKS = 5; // ~600ms per idle frame (5 * 120ms)
 // Coalesce prompt mouse-drag extend commits (SGR motion can fire faster than ink
 // needs to immediate-render). Matches transcript selection paint cadence.
 const MOUSE_EXTEND_COALESCE_MS = 24;
@@ -150,10 +171,12 @@ export function PromptInput({
   onHistoryNavigate,
   onPasteText,
   onVoiceToggle,
+  voiceIndicatorMode = 'off',
   selectionRef,
   valueRef,
   boxRectRef,
   mouseSelectionRef,
+  suppressShiftNavRef,
 }) {
   const [draft, setDraft] = useState(() => {
     const value = String(initialValue || '');
@@ -171,8 +194,31 @@ export function PromptInput({
   const boxRef = useRef(null);
   const cursorEnabledRef = useRef(false); // latest enabled state, read by the anchor fn at render time
   const contentWidthRef = useRef(80);
+  // Cells reserved on the right for the voice indicator glyph(s) (0 when
+  // hidden, 1 idle/spinner-only, 2 recording's "◉"+braille). Read by the
+  // cursor-anchor closure below (installed ONCE, so it must read live state
+  // via a ref rather than close over a render-local variable) to keep the
+  // caret/wrap math in sync with the actual reserved column, same pattern as
+  // IME_LEFT_GUARD_COLUMNS on the left edge.
+  const voiceIndicatorWidthRef = useRef(0);
   const preferredColumnRef = useRef(null);
   const mouseExtendCoalesceRef = useRef({ pendingNext: null, timer: null, t: 0 });
+  // Voice indicator animation tick. Runs a single ~120ms interval ONLY while
+  // voiceIndicatorMode !== 'off' (installing/idle/recording/transcribing) —
+  // torn down the instant the mode goes 'off', so no permanent timer exists
+  // when voice is disabled and no install is in flight.
+  const [voiceTick, setVoiceTick] = useState(0);
+  useEffect(() => {
+    if (voiceIndicatorMode === 'off') return undefined;
+    const timer = setInterval(() => setVoiceTick((t) => (t + 1) % 1000000), VOICE_TICK_MS);
+    timer.unref?.();
+    return () => clearInterval(timer);
+  }, [voiceIndicatorMode]);
+  // Undo/redo snapshot stack. Each entry is a { value, cursor, selectionAnchor }
+  // draft snapshot. Continuous typing coalesces (see UNDO_COALESCE_MS) so a run
+  // of characters collapses into one undo step; cursor-only moves are NOT
+  // snapshotted. Reset on submit / draftOverride.
+  const undoRef = useRef({ past: [], future: [], lastPushAt: 0, lastValue: null });
   const { value, cursor } = draft;
   draftRef.current = draft;
   if (selectionRef) {
@@ -204,6 +250,7 @@ export function PromptInput({
     const sameDraft = draftStateEqual(draftRef.current, next);
     if (!options.keepPreferredColumn) preferredColumnRef.current = null;
     if (sameDraft) return;
+    if (!options.skipHistory) recordUndoSnapshot(draftRef.current, next, options);
     draftRef.current = next;
     setDraft(next);
     queueMicrotask(flushImmediate);
@@ -248,10 +295,19 @@ export function PromptInput({
       const d = draftRef.current;
       const w = yogaNode?.getComputedWidth?.() ?? 0;
       const guardColumns = w > IME_LEFT_GUARD_COLUMNS ? IME_LEFT_GUARD_COLUMNS : 0;
-      const contentWidth = Math.max(1, (w ? w - guardColumns : contentWidthRef.current) || 80);
+      // Reserve the voice-indicator's own cells (+1 gap column when visible)
+      // out of the SAME width the caret/wrap math uses, mirroring the left
+      // guard above — otherwise a visible indicator would silently overlap
+      // the caret/typed text at the right edge instead of pushing content in.
+      const voiceReserve = voiceIndicatorWidthRef.current > 0 ? voiceIndicatorWidthRef.current + 1 : 0;
+      const contentWidth = Math.max(1, (w ? w - guardColumns - voiceReserve : contentWidthRef.current) || 80);
       contentWidthRef.current = contentWidth;
       const caret = w > 0
-        ? caretPosition(d.value, d.cursor, contentWidth)
+        // PromptInput renders a trailing space cell when the cursor is at
+        // end-of-input, so a caret flush on the last column there still has a
+        // following cell — pass hasTrailingContent=true so it rolls to row N+1
+        // exactly as ink wraps the trailing space.
+        ? caretPosition(d.value, d.cursor, contentWidth, d.cursor >= d.value.length ? true : undefined)
         : { row: 0, col: stringWidth(d.value.slice(0, d.cursor)) };
       return w > 0
         ? { ...caret, col: caret.col + guardColumns }
@@ -264,6 +320,70 @@ export function PromptInput({
     commitDraft(fn(draftRef.current), options);
   };
 
+  // --- undo/redo -----------------------------------------------------------
+  // Continuous-typing coalesce window: successive value-changing edits within
+  // this window collapse into a single undo step.
+  const UNDO_COALESCE_MS = 500;
+  const UNDO_MAX = 100;
+
+  const snapshotOf = (d) => ({ value: d.value, cursor: d.cursor, selectionAnchor: d.selectionAnchor ?? null });
+
+  const resetUndo = () => {
+    undoRef.current = { past: [], future: [], lastPushAt: 0, lastValue: null };
+  };
+
+  // Record a snapshot of the PREVIOUS state before applying `next`. Cursor-only
+  // moves (value unchanged) are never snapshotted. Consecutive value edits
+  // within UNDO_COALESCE_MS coalesce (we keep only the first snapshot of the
+  // run, so a single undo reverts the whole burst).
+  const recordUndoSnapshot = (prev, next, options = {}) => {
+    const stack = undoRef.current;
+    if (prev.value === next.value) {
+      // Cursor/selection-only move: don't snapshot, but BREAK the coalesce run
+      // so a following edit starts a fresh undo step (typing→move→typing must
+      // not collapse into one undo).
+      stack.lastPushAt = 0;
+      stack.lastValue = next.value;
+      return;
+    }
+    const now = Date.now();
+    const coalesce = !options.undoBreak
+      && stack.past.length > 0
+      && (now - stack.lastPushAt) < UNDO_COALESCE_MS
+      && stack.lastValue === prev.value;
+    if (!coalesce) {
+      stack.past.push(snapshotOf(prev));
+      if (stack.past.length > UNDO_MAX) stack.past.shift();
+    }
+    stack.lastPushAt = now;
+    stack.lastValue = next.value;
+    stack.future = [];
+  };
+
+  const performUndo = () => {
+    const stack = undoRef.current;
+    if (stack.past.length === 0) return false;
+    const prev = stack.past.pop();
+    stack.future.push(snapshotOf(draftRef.current));
+    stack.lastPushAt = 0;
+    stack.lastValue = prev.value;
+    commitDraft(prev, { skipHistory: true });
+    return true;
+  };
+
+  const performRedo = () => {
+    const stack = undoRef.current;
+    if (stack.future.length === 0) return false;
+    const next = stack.future.pop();
+    stack.past.push(snapshotOf(draftRef.current));
+    if (stack.past.length > UNDO_MAX) stack.past.shift();
+    stack.lastPushAt = 0;
+    stack.lastValue = next.value;
+    commitDraft(next, { skipHistory: true });
+    return true;
+  };
+  // -------------------------------------------------------------------------
+
   const cancelMouseExtendCoalesce = () => {
     const state = mouseExtendCoalesceRef.current;
     if (state.timer) {
@@ -332,6 +452,28 @@ export function PromptInput({
         const anchor = Number.isFinite(d.selectionAnchor) ? d.selectionAnchor : d.cursor;
         queueMouseExtendCommit({ ...d, cursor: off, selectionAnchor: anchor }, immediate);
       },
+      hasSelection: () => selectionRange(draftRef.current) != null,
+      // Double-click word select: pick the word/punctuation run under the
+      // clicked offset and set selectionAnchor/cursor to its bounds so it
+      // paints via the normal selection highlight. Triple-click line select
+      // uses lineStart/lineEnd instead (see selectLineAt).
+      selectWordAt: (offset) => {
+        cancelMouseExtendCoalesce();
+        const value = draftRef.current.value;
+        const off = Math.max(0, Math.min(value.length, Math.floor(Number(offset) || 0)));
+        const { start, end } = wordRangeAt(value, off);
+        commitDraft({ ...draftRef.current, cursor: end, selectionAnchor: start });
+        mouseExtendCoalesceRef.current.t = Date.now();
+      },
+      selectLineAt: (offset) => {
+        cancelMouseExtendCoalesce();
+        const value = draftRef.current.value;
+        const off = Math.max(0, Math.min(value.length, Math.floor(Number(offset) || 0)));
+        const start = lineStart(value, off);
+        const end = lineEnd(value, off);
+        commitDraft({ ...draftRef.current, cursor: end, selectionAnchor: start });
+        mouseExtendCoalesceRef.current.t = Date.now();
+      },
       clear: () => {
         cancelMouseExtendCoalesce();
         if (selectionRange(draftRef.current)) commitDraft(clearSelection(draftRef.current));
@@ -405,7 +547,8 @@ export function PromptInput({
 
   useEffect(() => {
     if (!draftOverride || typeof draftOverride.value !== 'string') return;
-    commitDraft({ value: draftOverride.value, cursor: draftOverride.value.length, selectionAnchor: null });
+    commitDraft({ value: draftOverride.value, cursor: draftOverride.value.length, selectionAnchor: null }, { skipHistory: true });
+    resetUndo();
   }, [draftOverride?.id]);
 
   useEffect(() => () => {
@@ -419,7 +562,8 @@ export function PromptInput({
       commitDraft(next);
       return;
     }
-    commitDraft({ value: '', cursor: 0, selectionAnchor: null });
+    commitDraft({ value: '', cursor: 0, selectionAnchor: null }, { skipHistory: true });
+    resetUndo();
   };
 
   const submitEnterChunk = (prefix = '') => {
@@ -450,6 +594,21 @@ export function PromptInput({
     const rawInput = String(input ?? '');
     const inputKey = rawInput.toLowerCase();
 
+    // App owns Shift+Arrow when a transcript/status ink-grid selection is live.
+    // Because the parent (App) useInput handler fires AFTER this child handler
+    // for the same event, a flag SET in App's handler is always one event stale.
+    // Instead call a synchronous predicate derived from dragRef at event time.
+    const gridSelectionActive = typeof suppressShiftNavRef === 'function'
+      ? suppressShiftNavRef()
+      : (typeof suppressShiftNavRef?.current === 'function'
+        ? suppressShiftNavRef.current()
+        : Boolean(suppressShiftNavRef?.current));
+    if (gridSelectionActive) {
+      const isShiftArrow = key.shift
+        && (key.leftArrow || key.rightArrow || key.upArrow || key.downArrow || key.home || key.end);
+      if (isShiftArrow) return;
+    }
+
     // Drop SGR mouse-tracking sequences (wheel/click). When app mouse tracking
     // is explicitly enabled, App parses these off raw stdin itself;
     // ink still forwards the bytes here as "input", which would otherwise type
@@ -482,7 +641,22 @@ export function PromptInput({
     const rawShiftDown = rawInput === '\x1b[1;2B' || rawInput === '\x1b[b' || rawInput === '[1;2B';
     const rawShiftRight = rawInput === '\x1b[1;2C' || rawInput === '\x1b[c' || rawInput === '[1;2C';
     const rawShiftLeft = rawInput === '\x1b[1;2D' || rawInput === '\x1b[d' || rawInput === '[1;2D';
-    const shiftHeld = key.shift || rawShiftUp || rawShiftDown || rawShiftLeft || rawShiftRight;
+    // Ctrl+Shift+Arrow modifier sequences: xterm mod=6 (1 + shift(1) + ctrl(4))
+    // arrives as `\x1b[1;6<dir>`; kitty keyboard protocol reports the same chord
+    // as `\x1b[<code>;6<dir>` (also mod=6). Ink decodes neither the `;6` for
+    // arrows, so the bytes arrive raw. Fold into a ctrlShiftHeld signal used to
+    // drive whole-word selection-extend below. `\x1b[1;6<dir>` covers both the
+    // classic xterm form and kitty's default (which emits the legacy arrow form
+    // with the CSI-u modifier param for arrow keys).
+    const rawCtrlShiftUp = rawInput === '\x1b[1;6A' || rawInput === '[1;6A';
+    const rawCtrlShiftDown = rawInput === '\x1b[1;6B' || rawInput === '[1;6B';
+    const rawCtrlShiftRight = rawInput === '\x1b[1;6C' || rawInput === '[1;6C';
+    const rawCtrlShiftLeft = rawInput === '\x1b[1;6D' || rawInput === '[1;6D';
+    const ctrlShiftHeld =
+      rawCtrlShiftUp || rawCtrlShiftDown || rawCtrlShiftLeft || rawCtrlShiftRight
+      || (key.shift && key.ctrl && (key.leftArrow || key.rightArrow || key.upArrow || key.downArrow));
+    const shiftHeld = key.shift || rawShiftUp || rawShiftDown || rawShiftLeft || rawShiftRight
+      || rawCtrlShiftUp || rawCtrlShiftDown || rawCtrlShiftLeft || rawCtrlShiftRight;
     const lineBreakIndex = rawInput.search(/[\r\n]/);
     const rawEnter = rawInput === '\r' || rawInput === '\n' || rawInput === '\r\n';
     const trailingEnterPrefix = singleTrailingLineBreakPrefix(rawInput);
@@ -566,25 +740,58 @@ export function PromptInput({
       return;
     }
 
-    if (key.upArrow || rawUpArrow || rawShiftUp) {
+    // Ctrl+Shift+Left/Right → extend selection whole-word. Kept before the plain
+    // shift-arrow branches so the ctrl+shift chord never falls through to a
+    // char-wise extend. (Up/Down ctrl+shift extend to line-relative vertical
+    // move with extend — same as shift alone; handled in the vertical branch.)
+    if (ctrlShiftHeld && (rawCtrlShiftLeft || (key.ctrl && key.shift && key.leftArrow))) {
+      if (!commandPaletteActive) {
+        updateDraft((d) => moveCursor(d, previousWordOffset(d.value, d.cursor), { extend: true }));
+      }
+      return;
+    }
+    if (ctrlShiftHeld && (rawCtrlShiftRight || (key.ctrl && key.shift && key.rightArrow))) {
+      if (!commandPaletteActive) {
+        updateDraft((d) => moveCursor(d, nextWordOffset(d.value, d.cursor), { extend: true }));
+      }
+      return;
+    }
+
+    if (key.upArrow || rawUpArrow || rawShiftUp || rawCtrlShiftUp) {
       if (commandPaletteActive) {
         onCommandPaletteNavigate?.(-1);
       } else {
-        const hasDraftText = String(draftRef.current.value || '').trim().length > 0;
-        if (!hasDraftText) {
-          if (!restoreQueuedToDraft()) applyHistoryNavigation('up', { emptyDraft: true });
-        } else if (!moveDraftVertically(-1, { extend: shiftHeld })) {
-          applyHistoryNavigation('up', { emptyDraft: false });
+        // A Shift-held Up is a SELECTION gesture, never history navigation:
+        // extend the selection up one visual line, and if already on the first
+        // line extend all the way to document start (offset 0). History
+        // navigation (restoreQueued / applyHistoryNavigation) MUST NOT fire.
+        if (shiftHeld) {
+          if (!moveDraftVertically(-1, { extend: true })) {
+            updateDraft((d) => moveCursor(d, 0, { extend: true }));
+          }
+        } else {
+          const hasDraftText = String(draftRef.current.value || '').trim().length > 0;
+          if (!hasDraftText) {
+            if (!restoreQueuedToDraft()) applyHistoryNavigation('up', { emptyDraft: true });
+          } else if (!moveDraftVertically(-1, { extend: false })) {
+            applyHistoryNavigation('up', { emptyDraft: false });
+          }
         }
       }
       return;
     }
 
-    if (key.downArrow || rawDownArrow || rawShiftDown) {
+    if (key.downArrow || rawDownArrow || rawShiftDown || rawCtrlShiftDown) {
       if (commandPaletteActive) {
         onCommandPaletteNavigate?.(1);
       } else {
-        if (!moveDraftVertically(1, { extend: shiftHeld })) {
+        // Shift-held Down: extend selection down one line, or to document end
+        // (value.length) when already on the last line. Never history nav.
+        if (shiftHeld) {
+          if (!moveDraftVertically(1, { extend: true })) {
+            updateDraft((d) => moveCursor(d, d.value.length, { extend: true }));
+          }
+        } else if (!moveDraftVertically(1, { extend: false })) {
           applyHistoryNavigation('down', { emptyDraft: String(draftRef.current.value || '').trim().length === 0 });
         }
       }
@@ -641,8 +848,8 @@ export function PromptInput({
         commitDraft({ value: '', cursor: 0, selectionAnchor: null });
         return;
       }
-      // Active turn takes precedence over queue restore (matches claude-code
-      // useCancelRequest priority): Esc during a running turn interrupts the
+      // Active turn takes precedence over queue restore: Esc during a
+      // running turn interrupts the
       // turn and leaves queued steering prompts intact to run afterward. Queued
       // messages only pop back into the draft when the turn is idle.
       if (interruptActive) {
@@ -702,6 +909,27 @@ export function PromptInput({
 
     const editingKey = String(input || '').toLowerCase();
 
+    // Undo / redo. Covered encodings:
+    //  • kitty protocol: ctrl+z → input 'z' + key.ctrl; ctrl+y → 'y' + key.ctrl;
+    //    ctrl+shift+z → 'z' + key.ctrl + key.shift (redo).
+    //  • legacy control bytes: Ctrl+Z is \x1a (SUB, 0x1A), Ctrl+Y is \x19 (EM,
+    //    0x19). ink may deliver these as raw input without key.ctrl on some
+    //    terminals, so match the byte directly too.
+    const isCtrlZ = (key.ctrl && editingKey === 'z') || rawInput === '\x1a';
+    const isCtrlY = (key.ctrl && editingKey === 'y') || rawInput === '\x19';
+    if (isCtrlZ && (key.shift || shiftHeld)) {
+      performRedo();
+      return;
+    }
+    if (isCtrlZ) {
+      performUndo();
+      return;
+    }
+    if (isCtrlY) {
+      performRedo();
+      return;
+    }
+
     // ctrl+a selects all like a normal text box; ctrl+e keeps readline line-end.
     if (key.ctrl && editingKey === 'a') {
       updateDraft((d) => (d.value ? { ...d, cursor: d.value.length, selectionAnchor: 0 } : clearSelection(d)));
@@ -834,6 +1062,24 @@ export function PromptInput({
   const displayValue = mask ? value.replace(/[^\n]/g, '*') : value;
   const renderedValue = renderSelectedText(displayValue, selectionRange(draft), cursor === value.length);
   const hintMeta = hintStyle(hintTone);
+  // Monotone voice indicator glyph text — zero-width (rendered as null) when
+  // mode is 'off'. Braille frame drives installing/recording/transcribing;
+  // the idle pulse advances one frame every VOICE_IDLE_FRAME_TICKS ticks of
+  // the SAME interval (slower "breathing" cadence off one shared timer).
+  const voiceBrailleFrame = VOICE_BRAILLE_FRAMES[voiceTick % VOICE_BRAILLE_FRAMES.length];
+  const voiceIdleFrame = VOICE_IDLE_FRAMES[Math.floor(voiceTick / VOICE_IDLE_FRAME_TICKS) % VOICE_IDLE_FRAMES.length];
+  const voiceIndicatorText = voiceIndicatorMode === 'installing' || voiceIndicatorMode === 'transcribing'
+    ? voiceBrailleFrame
+    : voiceIndicatorMode === 'recording'
+      ? `◉${voiceBrailleFrame}`
+      : voiceIndicatorMode === 'idle'
+        ? voiceIdleFrame
+        : '';
+  // stringWidth is unnecessary here — every glyph above is a single
+  // 1-column codepoint (◎◍◉ and the braille frames), and 'recording'
+  // concatenates exactly two 1-cell glyphs, so plain .length gives the
+  // correct cell count without pulling in emoji-width special-casing.
+  voiceIndicatorWidthRef.current = voiceIndicatorText.length;
 
   return (
     <Box ref={boxRef} flexDirection="row" width="100%" flexGrow={1} flexShrink={1} backgroundColor={surfaceBackground()}>
@@ -844,6 +1090,17 @@ export function PromptInput({
           <Text color={hintMeta.textColor}>{hint}</Text>
         </Box>
       ) : null}
+      {voiceIndicatorText ? (
+        <>
+          {/* flexGrow spacer pins the indicator to the RIGHT edge of the row
+              even when the typed text is short; without it the glyph would
+              ride directly after the caret instead of the box edge. */}
+          <Box flexGrow={1} backgroundColor={surfaceBackground()} />
+          <Box flexShrink={0} width={voiceIndicatorText.length + 1} justifyContent="flex-end" backgroundColor={surfaceBackground()}>
+            <Text color={theme.subtle}>{voiceIndicatorText}</Text>
+          </Box>
+        </>
+      ) : null}
     </Box>
   );
 }

package/src/tui/components/ToolExecution.jsx

@@ -571,7 +571,10 @@ function toolSearchLoadedSummary(resultText) {
   try {
     parsed = JSON.parse(String(resultText || ''));
   } catch {
-    return '';
+    const text = String(resultText || '');
+    const match = /^Loaded deferred tools:\s*(.+)$/m.exec(text);
+    if (!match) return '';
+    return [...new Set(match[1].split(',').map((name) => name.trim()).filter(Boolean))].join(', ');
   }
   const tools = parsed?.selected?.tools;
   if (!tools || typeof tools !== 'object') return '';
@@ -610,17 +613,21 @@ function clampFailureCount(errorCount, groupCount, isError) {
 // Single source of truth for the tool-card dot (●) color. Both the aggregate
 // and normal (single-tool) render paths must call this with a resolved
 // `terminalStatus` — do not recompute color inline elsewhere.
-//   running/pending      -> mixdogOrange || warning (blink handled by caller)
-// success               -> theme.success
-//   partial failure       -> mixdogOrange (some, not all, of the group failed)
-//   all failed            -> theme.error
-//   cancelled             -> theme.warning
+//   running/pending  -> theme.text (white; blink handled by caller)
+//   success          -> theme.success
+//   partial failure  -> mixdogOrange || warning (some, not all, of the group failed)
+//   all failed       -> theme.error
+//   cancelled        -> theme.warning
+// Note: callers resolve terminalStatus to 'failed' whenever failedCount > 0
+// (they cannot tell partial from total failure), so a 'failed' status must
+// still fall through to the failedCount check below rather than short-circuit
+// to error — otherwise a mixed-success batch (e.g. 1 of 3 failed) renders as
+// full-failure red instead of partial orange.
 function toolStatusColor({ pending, groupCount, failedCount, terminalStatus = '' }) {
-  if (pending) return theme.mixdogOrange || theme.warning;
+  if (pending) return theme.text;
   const status = normalizeTerminalStatus(terminalStatus);
   if (status === 'cancelled') return theme.warning;
-  if (status === 'failed') return theme.error;
-  if (failedCount <= 0) return theme.success;
+  if (failedCount <= 0) return status === 'failed' ? theme.error : theme.success;
   if (groupCount > 1 && failedCount < groupCount) return theme.mixdogOrange || theme.warning;
   return theme.error;
 }
@@ -809,7 +816,10 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
     // Aggregate cards intentionally omit elapsed time once grouped. A brief
     // `Running · 1s` tick during the grouped→finished handoff reads as visual
     // noise, and the grouped header already communicates that work is active.
-    const pendingPlaceholder = headerPending
+    // The placeholder tracks `pending` (real completion), NOT headerPending:
+    // the header verb stays active until the block seals, but the detail row
+    // must not keep saying "Running" after every call already resolved.
+    const pendingPlaceholder = pending
       ? 'Running'
       : 'Finished';
     const detailLines = showRawAggregate

package/src/tui/components/tool-output-format.mjs

@@ -1,7 +1,7 @@
 /**
  * components/tool-output-format.mjs — shared post-processing for EXPANDED tool
- * result bodies (ctrl+o). Mirrors the Claude Code output pipeline so every tool
- * surface renders the same way instead of a flat run of plain lines:
+ * result bodies (ctrl+o), so every tool surface renders the same way instead
+ * of a flat run of plain lines:
  *
  *   - language inference from the read/grep path argument (file extension)
  *   - JSON auto pretty-print (precision-safe, size-capped)