mixdog 0.9.22 → 0.9.24

package/src/tui/app/use-transcript-scroll.mjs

@@ -84,30 +84,86 @@ export function useTranscriptScroll({
       const scroll = stitchHarvestScrollRef.current;
       for (const row of rows) {
         if (!row || typeof row.y !== 'number') continue;
-        stitchBufferRef.current.set(row.y - scroll, typeof row.text === 'string' ? row.text : '');
+        // Store text AND the soft-wrap continuation flag so the stitch join can
+        // rejoin word-wrapped rows into their logical line (mirrors output.js).
+        stitchBufferRef.current.set(row.y - scroll, {
+          text: typeof row.text === 'string' ? row.text : '',
+          sw: row.sw === true,
+        });
       }
     }, 0);
   }, [store]);
 
+  // Synchronous sibling of harvestStitchRowsSoon: snapshot the rows CURRENTLY
+  // under the selection into the stitch buffer immediately, keyed by the given
+  // (pre-scroll) offset. Called right before a scroll shifts those rows out of
+  // view — mirrors selection.ts captureScrolledRows, which grabs the outgoing
+  // rows BEFORE scrollBy overwrites them. The deferred harvest could never see
+  // rows that a fast drag/wheel scrolled past between paint and its setTimeout.
+  // selectionRows is harvested by the renderer UNCONDITIONALLY (even on the
+  // captureText:false motion paints, output.js), so this works mid-drag.
+  const harvestStitchRowsNow = useCallback((scroll) => {
+    if (dragRef.current.region !== 'transcript') return;
+    const rows = store.getRenderSelectionRows?.();
+    if (!Array.isArray(rows)) return;
+    const s = Number(scroll) || 0;
+    for (const row of rows) {
+      if (!row || typeof row.y !== 'number') continue;
+      stitchBufferRef.current.set(row.y - s, {
+        text: typeof row.text === 'string' ? row.text : '',
+        sw: row.sw === true,
+      });
+    }
+  }, [store]);
+
   // Map the CURRENT rect + current scrollTarget onto the content-key range and
-  // join buffered rows sorted by key with '\n' (skipping missing keys). Returns
-  // '' when unusable so callers can fall back to render/remembered text.
+  // join buffered rows sorted by key with '\n'. Returns { text, complete }:
+  // `complete` is true only when the harvested keys covering the selection form
+  // a CONTIGUOUS run (no interior gap). The old code silently skipped missing
+  // keys and returned only the string, so a gap (a scrolled-off row that was
+  // never harvested) produced a stitched copy with a line dropped in the middle
+  // — a mangled, shorter-than-real result the caller then preferred purely on
+  // length. Callers must gate on `complete` before preferring the stitch.
+  // Returns { text: '', complete: false } when unusable so callers fall back to
+  // render/remembered text.
   const getStitchedSelectionText = useCallback(() => {
+    const empty = { text: '', complete: false };
     const buf = stitchBufferRef.current;
-    if (!buf.size) return '';
-    if (dragRef.current.region !== 'transcript') return '';
+    if (!buf.size) return empty;
+    if (dragRef.current.region !== 'transcript') return empty;
     const rect = dragRef.current.rect;
-    if (!rect) return '';
+    if (!rect) return empty;
     const y1 = Number(rect.y1);
     const y2 = Number(rect.y2);
-    if (!Number.isFinite(y1) || !Number.isFinite(y2)) return '';
+    if (!Number.isFinite(y1) || !Number.isFinite(y2)) return empty;
     const scroll = Number(scrollTargetRef.current) || 0;
     const lo = Math.min(y1, y2) - scroll;
     const hi = Math.max(y1, y2) - scroll;
     const keys = [...buf.keys()].filter((k) => k >= lo && k <= hi).sort((a, b) => a - b);
-    if (!keys.length) return '';
-    const text = keys.map((k) => buf.get(k)).filter((t) => t != null).join('\n');
-    return text.trim() ? text : '';
+    if (!keys.length) return empty;
+    // FULL coverage of the selection's [lo..hi] row range with no hole. Keys are
+    // already filtered to [lo..hi] and unique, so a count equal to the range
+    // size means every selected row is present (interior AND both endpoints).
+    // Internal contiguity alone was not enough: an endpoint-missing stitch (e.g.
+    // the top/bottom selected row never harvested) is internally contiguous yet
+    // drops a boundary line, so it must NOT be marked complete and win in copy.
+    const complete = keys.length === hi - lo + 1;
+    // SOFT-WRAP JOIN (same rule as output.js getSelectedText): a row whose sw
+    // flag is set is a word-wrap continuation — concatenate it onto the prior
+    // logical line WITHOUT a newline; only source/hard breaks emit '\n'. Blank
+    // inner rows ('' text) survive as empty logical lines (paragraph gaps).
+    // Trailing whitespace is trimmed once per logical-line end.
+    const logical = [];
+    for (const k of keys) {
+      const entry = buf.get(k);
+      if (entry == null) continue;
+      const t = typeof entry === 'string' ? entry : (entry.text ?? '');
+      const sw = typeof entry === 'string' ? false : entry.sw === true;
+      if (sw && logical.length > 0) logical[logical.length - 1] += t;
+      else logical.push(t);
+    }
+    const text = logical.map((l) => l.replace(/\s+$/u, '')).join('\n');
+    return text.trim() ? { text, complete } : empty;
   }, []);
 
   const stopSmoothScroll = useCallback(() => {
@@ -221,6 +277,36 @@ export function useTranscriptScroll({
     return true;
   }, [store, rememberSelectionTextSoon, harvestStitchRowsSoon]);
 
+  // Shared guard for EVERY direct (non-throttled) paint path: a pending
+  // throttled repaint (state.timer/state.pending, armed by
+  // applySelectionRectThrottled) would fire AFTER a direct paint and stamp a
+  // stale pre-scroll/pre-direction rect over the current one — surfacing as two
+  // coexisting highlights. Cancel it before any direct paint.
+  const cancelPendingSelectionPaint = useCallback(() => {
+    const state = selectionPaintRef.current;
+    if (state.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
+    state.pending = null;
+  }, []);
+
+  // Commit an armed-but-unpainted throttled rect NOW, so paths that read the
+  // rendered selection (the pre-scroll stitch harvest) see the newest fast-drag
+  // rect rather than the previous rendered one. Cancel-only would drop the
+  // pending rect and lose rows it covered that scroll off before the rebuild.
+  const flushPendingSelectionPaint = useCallback(() => {
+    const state = selectionPaintRef.current;
+    if (!state.timer && !state.pending) return;
+    const pending = state.pending;
+    if (state.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
+    state.pending = null;
+    if (pending) paintSelectionRect(pending, { rememberText: false, immediate: true });
+  }, [paintSelectionRect]);
+
   const applySelectionRect = useCallback((rect) => {
     const clippedRect = withSelectionClip(rect);
     dragRef.current.rect = clippedRect || null;
@@ -228,14 +314,9 @@ export function useTranscriptScroll({
       selectionTextRef.current = '';
       clearStitchBuffer();
     }
-    const state = selectionPaintRef.current;
-    if (state.timer) {
-      clearTimeout(state.timer);
-      state.timer = null;
-      state.pending = null;
-    }
+    cancelPendingSelectionPaint();
     paintSelectionRect(clippedRect, { rememberText: true, immediate: true });
-  }, [paintSelectionRect, withSelectionClip, clearStitchBuffer]);
+  }, [paintSelectionRect, withSelectionClip, clearStitchBuffer, cancelPendingSelectionPaint]);
 
   const applySelectionRectThrottled = useCallback((rect) => {
     const clippedRect = withSelectionClip(rect, { captureText: false });
@@ -246,11 +327,7 @@ export function useTranscriptScroll({
     const now = Date.now();
     const elapsed = now - state.t;
     if (elapsed >= SELECTION_PAINT_INTERVAL_MS) {
-      if (state.timer) {
-        clearTimeout(state.timer);
-        state.timer = null;
-        state.pending = null;
-      }
+      cancelPendingSelectionPaint();
       paintSelectionRect(clippedRect, { rememberText: false });
       return;
     }
@@ -265,7 +342,7 @@ export function useTranscriptScroll({
       }, Math.max(1, SELECTION_PAINT_INTERVAL_MS - elapsed));
       state.timer.unref?.();
     }
-  }, [paintSelectionRect, withSelectionClip]);
+  }, [paintSelectionRect, withSelectionClip, cancelPendingSelectionPaint]);
 
   const selectionPointAtCurrentScroll = useCallback((point, pointScroll = 0) => {
     if (!point) return null;
@@ -298,13 +375,13 @@ export function useTranscriptScroll({
     } else {
       const lr = store.getLineRectAt?.(y);
       if (lr) { mLo = { x: lr.x1, y: lr.y1 }; mHi = { x: lr.x2, y: lr.y2 }; }
-      else { mLo = { x: 0, y }; mHi = { x, y }; }
+      else { mLo = { x: 0, y }; mHi = { x: Math.max(0, frameColumns - 1), y }; }
     }
     const rect = (a, b) => ({ mode: 'linear', x1: a.x, y1: a.y, x2: b.x, y2: b.y });
     if (comparePoints(mHi, spanLo) < 0) return rect(spanHi, mLo);
     if (comparePoints(mLo, spanHi) > 0) return rect(spanLo, mHi);
     return rect(spanLo, spanHi);
-  }, [store, selectionPointAtCurrentScroll]);
+  }, [store, frameColumns, selectionPointAtCurrentScroll]);
 
   const transcriptViewportRows = useCallback(() => {
     const top = Math.max(0, Number(transcriptViewportRef.current?.top) || 0);
@@ -356,6 +433,17 @@ export function useTranscriptScroll({
     const maxTarget = Math.max(0, Number(maxScrollRowsRef.current) || 0);
     const target = Math.max(0, Math.min(maxTarget, scrollTargetRef.current + deltaRows));
     const appliedDelta = target - scrollTargetRef.current;
+    // Before the scroll moves selected rows out of view, snapshot the rows
+    // currently under the selection into the stitch buffer keyed by the
+    // PRE-scroll offset (ref selection.ts captureScrolledRows). Runs for BOTH
+    // an active drag and a wheel-shift of a released selection, so Ctrl+C
+    // reconstructs the full text no matter how far it scrolled off-screen.
+    if (appliedDelta !== 0 && dragRef.current.region === 'transcript' && dragRef.current.rect) {
+      // Commit any pending throttled rect first so the harvest reads the newest
+      // rendered selection (not the previous rect) before those rows scroll off.
+      flushPendingSelectionPaint();
+      harvestStitchRowsNow(Number(scrollTargetRef.current) || 0);
+    }
     // Any manual wheel/keyboard scroll takes precedence over an in-flight
     // transcript follow: drop the glide so the user's intent wins.
     if (appliedDelta !== 0) cancelTranscriptFollow();
@@ -411,8 +499,17 @@ export function useTranscriptScroll({
       } else {
         rect = shiftSelectionRectY(dragRef.current.rect, appliedDelta);
       }
-      const clippedRect = withSelectionClip(rect);
+      // Active-drag rebuild paints directly, so route through the themed clip
+      // (captureText:false, matching rememberText:false below) — a bare rect
+      // without selectionBackground falls back to a near-white full-width block
+      // with vanishing text (vendor/ink output.js). Also cancel any armed
+      // throttled repaint first: it would fire the pre-scroll rect AFTER this
+      // one, leaving two coexisting highlights.
+      const clippedRect = dragRef.current.active
+        ? withSelectionClip(rect, { captureText: false })
+        : withSelectionClip(rect);
       dragRef.current = { ...dragRef.current, rect: clippedRect };
+      cancelPendingSelectionPaint();
       // Never re-harvest selection text from a scroll-shifted rect: the shift
       // clips the rect to the viewport, so a harvest here would OVERWRITE the
       // full text remembered at drag-release with only the still-visible rows
@@ -426,7 +523,7 @@ export function useTranscriptScroll({
     stopSmoothScroll();
     scrollPositionRef.current = target;
     setScrollOffset(Math.round(target));
-  }, [startSmoothScroll, stopSmoothScroll, paintSelectionRect, selectionPointAtCurrentScroll, withSelectionClip, cancelTranscriptFollow, buildSpanRect]);
+  }, [startSmoothScroll, stopSmoothScroll, paintSelectionRect, selectionPointAtCurrentScroll, withSelectionClip, cancelTranscriptFollow, buildSpanRect, harvestStitchRowsNow, cancelPendingSelectionPaint, flushPendingSelectionPaint]);
 
   // Leading-edge coalescer for edge-drag auto-scroll + wheel deltas: the first
   // delta after an idle period flushes immediately (single wheel ticks/short

package/src/tui/app/use-transcript-window.mjs

@@ -60,6 +60,18 @@ export function useTranscriptWindow({
 }) {
   const transcriptTotalRowsRef = useRef(0);
   const preservedScrollDeltaRef = useRef(0);
+  // Pessimistic "committed" max-scroll for the IMMEDIATE wheel/keyboard clamp.
+  // transcriptWindow.maxScrollRows is derived from the row index, which uses
+  // ESTIMATED heights for rows in the mounted slice. On the frame a scroll-up
+  // FIRST mounts a new row, its estimate may overshoot the real Yoga height, so
+  // that frame's maxScrollRows is inflated and a wheel offset clamped only
+  // against it scrolls past committed geometry — opening a one-frame blank band
+  // at the top until the post-commit harvest corrects it. We hold this cap only
+  // while a row IN the mounted slice is still unmeasured; the harvest measures
+  // it on the next commit and the estimate is adopted. Expansion can never be
+  // blocked longer than that frame (and is bypassed entirely when measured-rows
+  // mode is off — no harvest ever runs, so the estimate is the only geometry).
+  const committedMaxScrollRowsRef = useRef(0);
   // Per-hook-instance settled-prefix row-index cache for the incremental
   // builder. Was module-level (leaked across hook instances); now local so
   // each transcript window owns its own tail-flush cache.
@@ -389,7 +401,49 @@ export function useTranscriptWindow({
     rowIndex: transcriptRowIndex,
   // eslint-disable-next-line react-hooks/exhaustive-deps -- intentional: sig+scroll/viewport capture the relevant changes
   }), [transcriptStructureSig, renderScrollOffset, transcriptContentHeight, transcriptRowIndex]);
-  maxScrollRowsRef.current = transcriptWindow.maxScrollRows;
+  // Publish the max for the immediate wheel/keyboard clamp (see the
+  // committedMaxScrollRowsRef note above). Adopt the estimate-based max unless a
+  // row in THIS frame's mounted slice is still unmeasured — that is the only
+  // case where an over-estimated freshly-mounted row can inflate maxScrollRows
+  // ahead of committed Yoga geometry. Off-slice appended rows (bottom spacer,
+  // never mounted) don't trigger the hold, so scroll can always reach the true
+  // oldest rows; and with measured-rows mode off, no harvest ever runs, so the
+  // raw estimate is published unconditionally.
+  const estimateMaxScrollRows = Math.max(0, Number(transcriptWindow.maxScrollRows) || 0);
+  let holdCommittedMax = false;
+  if (TRANSCRIPT_MEASURED_ROWS && estimateMaxScrollRows > committedMaxScrollRowsRef.current) {
+    // Expansion requested: only trust it once every mounted-slice row has a
+    // committed measurement that is VALID FOR THIS geometry. A just-mounted row
+    // lacks a cache entry until the post-commit harvest records its real height;
+    // and a cache entry left over from a prior columns/tool-expanded/variant is
+    // stale (the harvest re-measures it against these same fields), so it must
+    // also count as unmeasured — otherwise the pre-harvest estimate for the new
+    // geometry could re-open the overshoot right after such a change.
+    const toolExpandedFlag = toolOutputExpanded ? 1 : 0;
+    const mountedSlice = transcriptWindow.items || [];
+    for (let i = 0; i < mountedSlice.length; i++) {
+      const it = mountedSlice[i];
+      if (!it || shouldSuppressFullyFailedToolItem(it)) continue;
+      if (it.kind === 'assistant' && it.streaming) {
+        const idPrev = streamingMeasuredRowsById.get(it.id);
+        if (!idPrev || idPrev.columns !== frameColumns || idPrev.toolExpanded !== toolExpandedFlag) {
+          holdCommittedMax = true;
+          break;
+        }
+      } else {
+        const prev = transcriptMeasuredRowsCache.get(it);
+        if (!prev
+          || prev.columns !== frameColumns
+          || prev.toolExpanded !== toolExpandedFlag
+          || prev.variantKey !== transcriptItemVariantKey(it)) {
+          holdCommittedMax = true;
+          break;
+        }
+      }
+    }
+  }
+  if (!holdCommittedMax) committedMaxScrollRowsRef.current = estimateMaxScrollRows;
+  maxScrollRowsRef.current = committedMaxScrollRowsRef.current;
   // Publish this frame's geometry so a manual scroll can capture the reading
   // anchor synchronously (see captureTranscriptAnchorAt).
   transcriptGeomRef.current = {

package/src/tui/components/Message.jsx

@@ -71,7 +71,7 @@ export const UserMessage = React.memo(function UserMessage({ text, attached = fa
   const bandColumns = Math.max(1, columns - 1);
   return (
     <Box flexDirection="column" width={bandColumns} marginTop={attached ? 0 : 1} backgroundColor={theme.userMessageBackground} paddingLeft={2} paddingRight={1}>
-      <Text color={theme.text} wrap="wrap">{text}</Text>
+      <Text color={theme.mixdogIvory} wrap="wrap">{text}</Text>
     </Box>
   );
 });

package/src/tui/components/PromptInput.jsx

@@ -660,7 +660,9 @@ export function PromptInput({
     }
 
     if (!commandPaletteActive && ((key.ctrl && inputKey === 'v') || (key.meta && inputKey === 'v'))) {
-      handleExternalPaste('', { source: 'clipboard-image-shortcut' });
+      // Ctrl+V / Meta+V: read OS clipboard (text first, image fallback) — the
+      // empty text arg tags the shortcut path in handlePromptPaste.
+      handleExternalPaste('', { source: 'clipboard-shortcut' });
       return;
     }
 

package/src/tui/components/QueuedCommands.jsx

@@ -7,13 +7,20 @@
  * line is promoted to a real transcript user row only when it starts executing
  * (see engine drain()).
  *
+ * Default (expanded) mode renders the FULL wrapped text at the same content
+ * width the promoted transcript user row uses, so promotion does not change
+ * the row height mid-flight (the old 1-line truncation made the frame visibly
+ * jump when a wrapped message expanded on promotion). App.jsx reserves the
+ * matching height via queuedBandRows() and flips `compact` on when the queue
+ * would not fit the frame — compact mode truncates each entry to one row.
+ *
  * Renders nothing when the queue is empty.
  */
 import React from 'react';
 import { Box, Text } from 'ink';
 import { theme } from '../theme.mjs';
 
-export function QueuedCommands({ queued, columns }) {
+export function QueuedCommands({ queued, columns, compact = false }) {
   if (!queued || queued.length === 0) return null;
   // Each queued line reads as a full-width band like a user message (same
   // background, 2-col gutter), but stays readable while it waits to be sent.
@@ -21,19 +28,23 @@ export function QueuedCommands({ queued, columns }) {
   // One cell short of the edge: writing the last terminal column triggers
   // Windows auto-wrap/scroll that drifts the alt-screen frame (see UserMessage).
   const bandColumns = Math.max(1, columns - 1);
+  // Content width = bandColumns(columns-1) - paddingLeft(2) - paddingRight(1)
+  // = columns-4. Compact truncation appends '…' (1 cell), so the slice must
+  // leave room for that suffix and avoid a wrap to row 2.
+  const contentWidth = Math.max(1, columns - 4);
   return (
     <Box flexDirection="column">
       {queued.map((item) => {
-        // Truncate to 1 line so the row reservation (queued.length in App.jsx)
-        // stays accurate — wrapped text would push the input box off-screen.
-        // Content width = bandColumns(columns-1) - paddingLeft(2) - paddingRight(1)
-        // = columns-4. When truncating we append '…' (1 cell), so the slice
-        // must leave room for that suffix and avoid a wrap to row 2.
-        const contentWidth = Math.max(1, columns - 4);
         const sourceText = String(item.displayText || item.text || '');
-        const displayText = sourceText.length > contentWidth
-          ? (contentWidth <= 1 ? '…'.repeat(contentWidth) : sourceText.slice(0, Math.max(1, contentWidth - 1)) + '…')
-          : sourceText;
+        let displayText = sourceText;
+        if (compact) {
+          // Compact fallback: exactly 1 row per entry (queued.length reserve).
+          // Collapse newlines first — a raw '\n' would still break the row.
+          const oneLine = sourceText.replace(/\r?\n/g, ' ');
+          displayText = oneLine.length > contentWidth
+            ? (contentWidth <= 1 ? '…'.repeat(contentWidth) : oneLine.slice(0, Math.max(1, contentWidth - 1)) + '…')
+            : oneLine;
+        }
         return (
           <Box key={item.id} width={bandColumns} backgroundColor={theme.userMessageBackground} paddingLeft={2} paddingRight={1}>
             <Text wrap="wrap">

package/src/tui/components/StatusLine.jsx

@@ -295,8 +295,8 @@ function localOldestWorkerStartMs(agentWorkers = [], agentJobs = []) {
 // L2 assembly only — themed SGR (statusColors SUCCESS/STATUS/SUBTLE), already in
 // the active palette, so this must NOT be passed through normalizeStatusLine.
 // Returns the joined L2 string or '' when no active segment. Order:
-// Agents → Exploring → Searching → Shells. (Shell segment is disk-based and not
-// available to the instant-local path; intentionally omitted here.)
+// Agents → Exploring → Web Searching → Shells. (Shell segment is disk-based and
+// not available to the instant-local path; intentionally omitted here.)
 function localStatusLineL2({
   agentWorkers = [],
   agentJobs = [],
@@ -325,7 +325,7 @@ function localStatusLineL2({
   }
   if (searchInfo && localNum(searchInfo.count) > 0) {
     const elapsed = localNum(searchInfo.startedAt) > 0 ? localFormatElapsed(now - localNum(searchInfo.startedAt)) : '';
-    l2Parts.push(`${spin} ${STATUS}Searching${RESET}${elapsedSuffix(elapsed)}`);
+    l2Parts.push(`${spin} ${STATUS}Web Searching${RESET}${elapsedSuffix(elapsed)}`);
   }
   return l2Parts.length ? l2Parts.join(segSep) : '';
 }

package/src/tui/components/ToolExecution.jsx

@@ -83,7 +83,7 @@ function statusCopy(name, label, count, doneCount, pending, isError, args = {})
   // dropping the pad just normalizes the spacing.
   return formatToolActionHeader(name, args, { pending, count });
 }
-export function ToolExecution({ name, args, result, rawResult, isError, errorCount, expanded, columns = 80, attached = false, count = 1, completedCount = 0, startedAt = 0, completedAt = 0, aggregate = false, categories = {}, headerFinalized = true, deferredDisplayReady = false }) {
+export function ToolExecution({ name, args, result, rawResult, isError, errorCount, expanded, columns = 80, attached = false, count = 1, completedCount = 0, startedAt = 0, completedAt = 0, aggregate = false, categories = {}, doneCategories = null, headerFinalized = true, deferredDisplayReady = false }) {
   const rowWidth = Math.max(1, Number(columns || 80));
   const [blinkOn, setBlinkOn] = useState(true);
   const [blinkExpired, setBlinkExpired] = useState(false);
@@ -120,6 +120,18 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   const failedCount = clampFailureCount(errorCount, groupCount, isError);
   const displayGroupCount = groupCount;
   const displayCategories = normalizeCountMap(categories || {});
+  // In the DONE state, count only successful calls: error-terminated calls are
+  // excluded from the category totals via the engine-supplied doneCategories
+  // map (failures still surface in the 'N Ok · N Failed' detail). The pending/
+  // in-flight header keeps using the raw call-time counts unchanged.
+  const normalizedDoneCategories = doneCategories ? normalizeCountMap(doneCategories) : displayCategories;
+  // All-failed aggregate collapses doneCategories to zero counts, which would
+  // render a blank header. Fall back to the raw call-time counts so the done
+  // header is never empty; the 'N Failed' detail still marks the failure.
+  const hasDoneCounts = Object.values(normalizedDoneCategories || {}).some(
+    (v) => (v && typeof v === 'object' ? Number(v.count || 0) : Number(v || 0)) > 0,
+  );
+  const displayDoneCategories = hasDoneCounts ? normalizedDoneCategories : displayCategories;
 
   useEffect(() => {
     if (!pending) {
@@ -206,7 +218,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
     // No stableVerbWidth: see statusCopy — the padding only left a mid-header
     // gap ("Searched  1 pattern, Read    1 file") since Ink trims trailing
     // spaces and never stabilized the flip.
-    const headerText = safeInlineText(formatAggregateHeader(displayCategories || {}, { pending: headerPending, order: headerOrder }));
+    const headerText = safeInlineText(formatAggregateHeader((headerPending ? displayCategories : displayDoneCategories) || {}, { pending: headerPending, order: headerOrder }));
     let detailText;
     if (hasResult) {
       // The aggregate card reserves EXACTLY ONE detail row when it is not
@@ -456,7 +468,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   labelText = safeInlineText(labelText);
   // Show the parenthesized arg summary for grouped cards too, matching single
   // calls so the header carries the same context.
-  const toolSearchSummary = !pending && normalizedName === 'tool_search' && hasResult
+  const toolSearchSummary = !pending && normalizedName === 'load_tool' && hasResult
     ? toolSearchLoadedSummary(displayedResultText)
     : '';
   const rawSummaryText = safeInlineText(isAgentResponse || isBackgroundResponse
@@ -486,7 +498,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
     && hasDisplayBody
     && (totalLines > 1 || firstResultLineClipped || Boolean(shellCollapsedSummary && shellCollapsedSummary !== firstResultLine));
   const showHeaderExpandHint = (isShellSurface ? shellHasExpandableBody : (isAgentSurfaceCard ? agentHasExpandableBody : (hasHiddenDetail || backgroundMetadataExpandable)))
-    && normalizedName !== 'tool_search';
+    && normalizedName !== 'load_tool';
   const expandHintColor = theme.subtle;
 
   // Build a single-line header that never wraps: reserve width for the fixed

package/src/tui/components/TranscriptItem.jsx

@@ -77,7 +77,7 @@ export const Item = React.memo(function Item({ item, prevKind, columns, toolOutp
         node = <ToolHookDenialCard item={item} columns={columns} />;
         break;
       }
-      node = <ToolExecution name={item.name} args={item.args} result={item.result} rawResult={item.rawResult} isError={item.isError} errorCount={item.errorCount} expanded={toolOutputExpanded || item.expanded} columns={columns} attached={false} count={item.count} completedCount={item.completedCount} startedAt={item.startedAt} completedAt={item.completedAt} aggregate={item.aggregate} categories={item.categories} headerFinalized={item.headerFinalized} deferredDisplayReady={item.deferredDisplayReady} themeEpoch={themeEpoch} />;
+      node = <ToolExecution name={item.name} args={item.args} result={item.result} rawResult={item.rawResult} isError={item.isError} errorCount={item.errorCount} expanded={toolOutputExpanded || item.expanded} columns={columns} attached={false} count={item.count} completedCount={item.completedCount} startedAt={item.startedAt} completedAt={item.completedAt} aggregate={item.aggregate} categories={item.categories} doneCategories={item.doneCategories} headerFinalized={item.headerFinalized} deferredDisplayReady={item.deferredDisplayReady} themeEpoch={themeEpoch} />;
       break;
     }
     case 'notice':