mixdog 0.9.38 → 0.9.40

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

@@ -245,6 +245,7 @@ function toolHasDisplayResultForRows(item) {
 
 function toolExpandedRawTextForRows(item, rawRt) {
   if (item?.aggregate) return rawRt;
+  if (item?.agentResponseAggregate) return rawRt;
   const hasDisplayResult = toolHasDisplayResultForRows(item);
   if (hasDisplayResult) return toolDisplayedResultTextForRows(item);
   return stripLeadingStatusMarkerFromTextForRows(rawRt || '');
@@ -831,7 +832,7 @@ export function buildTranscriptRowIndexIncremental(items, {
   suppressMeasuredRowHeights = false,
   measuredRowsVersion = 0,
   cacheRef = null,
-  prefixSig = null,
+  prefixRevision = null,
 } = {}) {
   const allItems = Array.isArray(items) ? items : [];
   const tail = trailingStreamingItem(allItems);
@@ -849,11 +850,10 @@ export function buildTranscriptRowIndexIncremental(items, {
   }
   const prefixLen = allItems.length - 1;
   const cache = holder.current;
-  // Prefix identity is carried by `prefixSig` (a hash of every prefix item's
-  // WeakMap sigPart, computed once in the hook). String equality catches a
-  // same-length MIDDLE-item replacement (tool-card patch swaps a middle object →
-  // fresh fragment → different sig), which a last-item ref check would miss.
-  // Fast path: same prefix length + tail id + prefixSig, and columns/expanded/
+  // Prefix identity is carried by the engine's monotonic structure revision.
+  // Every settled-item mutation, including same-length middle tool-card patches,
+  // bumps it without requiring a render-time walk over the transcript.
+  // Fast path: same prefix length + tail id + revision, and columns/expanded/
   // suppress/version all match. Only the tail row can differ → recompute + append.
   if (cache
     && cache.columns === columns
@@ -861,10 +861,10 @@ export function buildTranscriptRowIndexIncremental(items, {
     && cache.suppress === suppressMeasuredRowHeights
     && cache.version === measuredRowsVersion
     && cache.prefixLen === prefixLen
-    && prefixSig != null
-    && cache.prefixSig === prefixSig
+    && prefixRevision != null
+    && cache.prefixRevision === prefixRevision
     && cache.tailId === tail.id) {
-    // prefixSig matches → prefix rows provably unchanged; NO prefix walk / no
+    // revision matches → prefix rows provably unchanged; NO prefix walk / no
     // re-estimation. Only the tail row can differ, recompute it.
     {
       const tailMeasured = suppressMeasuredRowHeights
@@ -893,7 +893,7 @@ export function buildTranscriptRowIndexIncremental(items, {
     suppress: suppressMeasuredRowHeights,
     version: measuredRowsVersion,
     prefixLen,
-    prefixSig,
+    prefixRevision,
     tailId: tail.id,
     prefixRowsArr: full.rows.slice(0, prefixLen),
     prefixPrefixRows: full.prefixRows.slice(0, prefixLen + 1),

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

@@ -18,7 +18,6 @@ import {
   hasStreamingRowStateToPrune,
   transcriptItemVariantKey,
   buildTranscriptRowIndexIncremental,
-  transcriptStructureSignature,
   estimateTranscriptItemRowsCached,
   setStreamingBottomPinned,
   transcriptRenderWindow,
@@ -32,7 +31,9 @@ import {
 import { shouldSuppressFullyFailedToolItem } from '../transcript-tool-failures.mjs';
 
 export function useTranscriptWindow({
-  items,
+  items: settledItems,
+  structureRevision,
+  streamingTail,
   themeEpoch,
   frameColumns,
   toolOutputExpanded,
@@ -129,42 +130,12 @@ export function useTranscriptWindow({
     return fn;
   }, []);
 
-  // Key the heavy O(n) row-index + windowing memos on a STRUCTURE signature
-  // instead of the `items` array identity. The engine swaps `items`
-  // for a new array on every streaming flush (~8ms) while only the final
-  // assistant item's text grows; depending on array identity re-ran both memos
-  // each delta frame and visibly throttled the stream. The signature changes
-  // only when transcript structure or the streaming item's estimated height
-  // changes, so steady per-character growth keeps both memos warm.
-  //
-  // The signature itself is memoized on `items` identity (+columns/
-  // expanded) so re-renders that DO NOT touch items — drag motion, scroll,
-  // input typing — skip the O(n) signature walk entirely. During streaming the
-  // engine hands us a fresh `items` array each flush, so this memo
-  // recomputes and still tracks the streaming item's height correctly.
-  // Split the structure signature into prefix (all items except the trailing
-  // streaming item) + tail. On a streaming flush only the tail item object is
-  // replaced; every prefix item keeps identity, so the prefix sig is O(1)-
-  const streamingTailItem = useMemo(() => {
-    const last = (items || []).length > 0 ? items[items.length - 1] : null;
-    return last && last.kind === 'assistant' && last.streaming ? last : null;
-  }, [items]);
-  const prefixLen = streamingTailItem ? (items || []).length - 1 : (items || []).length;
-  // Key on `items` identity (engine swaps the array every flush — INCLUDING a
-  // tool-card patch that replaces a MIDDLE item object), so a same-length
-  // middle-item replacement is caught (new object → fresh WeakMap fragment →
-  // different prefixSig string). The walk itself is cheap: transcript-
-  // StructureSignature reads a WeakMap sigPart per item (no re-estimation for
-  // unchanged objects) and joins — O(n) map lookups, not O(n) measurement. The
-  // row-index memo stays keyed on the prefixSig STRING, so a tail-only flush
-  // (identical prefix objects → identical string) still skips the row rebuild.
-  const prefixSig = useMemo(
-    () => transcriptStructureSignature(
-      streamingTailItem ? (items || []).slice(0, prefixLen) : (items || []),
-      frameColumns, toolOutputExpanded,
-    ),
-    [items, streamingTailItem, prefixLen, frameColumns, toolOutputExpanded],
-  );
+  // The settled array no longer changes during streaming. Geometry is keyed by
+  // the engine revision plus the live tail's resolved height, so same-height
+  // text flushes do not copy/walk the settled prefix or rerun heavy memos.
+  const streamingTailItem = streamingTail?.kind === 'assistant' && streamingTail.streaming
+    ? streamingTail
+    : null;
   const scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
   const transcriptPinnedForStreaming = followingRef.current
     || scrolledUpRowsForPin <= transcriptBottomSlackRows;
@@ -173,13 +144,18 @@ export function useTranscriptWindow({
   // applies while bottom-pinned (right geometry on first commit, no judder) and
   // every tail-resolving path reads the same height (no sig/geometry divergence).
   setStreamingBottomPinned(transcriptPinnedForStreaming);
-  const tailSig = streamingTailItem
-    ? `a${streamingTailItem.id}:${estimateTranscriptItemRowsCached(streamingTailItem, frameColumns, toolOutputExpanded)}`
-    : '_';
-  const transcriptStructureSig = `${prefixSig}#${tailSig}`;
-  const transcriptStreamingActive = (items || []).some(
-    (item) => item?.kind === 'assistant' && item?.streaming,
+  const tailRows = streamingTailItem
+    ? estimateTranscriptItemRowsCached(streamingTailItem, frameColumns, toolOutputExpanded)
+    : 0;
+  const tailSig = streamingTailItem ? `${streamingTailItem.id}:${tailRows}` : '_';
+  const revision = Math.max(0, Number(structureRevision) || 0);
+  const transcriptItems = useMemo(
+    () => streamingTailItem ? [...(settledItems || []), streamingTailItem] : (settledItems || []),
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- tail text at the same resolved height is injected into the bounded visible slice below
+    [settledItems, revision, streamingTailItem?.id, tailRows],
   );
+  const transcriptStructureSig = `${revision}#${tailSig}`;
+  const transcriptStreamingActive = !!streamingTailItem;
   const scrolledUpForStreamingMeasure = scrolledUpRowsForPin > transcriptBottomSlackRows;
   const prevEstimateGeometry = transcriptGeomRef.current?.suppressMeasuredRowHeights === true;
   const hasStreamingReadingAnchor = !!transcriptAnchorRef.current
@@ -199,15 +175,15 @@ export function useTranscriptWindow({
   // rebuild for the settled prefix. All those invalidators are folded into the
   // memo deps below (sig captures item/column/expanded structure; the rest are
   // listed explicitly), so the memo only recomputes when one of them changes.
-  const transcriptRowIndex = useMemo(() => buildTranscriptRowIndexIncremental(items, {
+  const transcriptRowIndex = useMemo(() => buildTranscriptRowIndexIncremental(transcriptItems, {
     columns: frameColumns,
     toolOutputExpanded,
     suppressMeasuredRowHeights,
     measuredRowsVersion,
     cacheRef: incrementalRowIndexCacheRef,
-    prefixSig,
-  // eslint-disable-next-line react-hooks/exhaustive-deps -- intentional: prefixSig/tailSig capture the relevant item changes (raw `items` dropped so a tail-only flush never re-enters the builder via array identity); measuredRowsVersion folds in app-level measured height corrections
-  }), [prefixSig, tailSig, measuredRowsVersion, suppressMeasuredRowHeights]);
+    prefixRevision: revision,
+  // eslint-disable-next-line react-hooks/exhaustive-deps -- revision/tail height capture structural geometry; measuredRowsVersion folds in measured corrections
+  }), [revision, tailSig, frameColumns, toolOutputExpanded, measuredRowsVersion, suppressMeasuredRowHeights]);
   // ── Same-frame anchor lock ───────────────────────────────────────────────
   // While the user reads older transcript (anchor captured, not dirty), resolve
   // the scroll offset that keeps the anchored viewport-top row fixed for THIS
@@ -243,7 +219,7 @@ export function useTranscriptWindow({
   if (anchorLockActive) {
     const locked = resolveAnchorScrollOffset({
       anchor: transcriptAnchorRef.current,
-      items: items,
+      items: transcriptItems,
       curPrefix: curPrefixForLock,
       totalRows: lockTotalRows,
       viewRows: lockViewRows,
@@ -288,7 +264,7 @@ export function useTranscriptWindow({
         const captured = { id: anchorItem.id, offset: Math.max(0, prevTopRow - (prevPrefix[idx] || 0)) };
         const locked = resolveAnchorScrollOffset({
           anchor: captured,
-          items: items,
+          items: transcriptItems,
           curPrefix: curPrefixForLock,
           totalRows: lockTotalRows,
           viewRows: lockViewRows,
@@ -343,7 +319,7 @@ export function useTranscriptWindow({
         const captured = { id: anchorItem.id, offset: Math.max(0, prevTopRow - (prevPrefix[idx] || 0)) };
         const locked = resolveAnchorScrollOffset({
           anchor: captured,
-          items: items,
+          items: transcriptItems,
           curPrefix: curPrefixForLock,
           totalRows: lockTotalRows,
           viewRows: lockViewRows,
@@ -376,7 +352,7 @@ export function useTranscriptWindow({
   // measuredRowsVersion bumps, the row index absorbs the growth (idEntry.rows ==
   // the new measured height) and the live estimate matches it, so delta → 0.
   if (scrolledUp && !followingRef.current) {
-    const growth = streamingTailMountedGrowth(items, frameColumns, toolOutputExpanded);
+    const growth = streamingTailMountedGrowth(transcriptItems, frameColumns, toolOutputExpanded);
     // Only compensate when the tail is actually mounted in the rendered slice
     // (viewport + overscan). Off-slice it is represented by a row-index-sized
     // bottom spacer that does NOT physically grow this frame, so shifting the
@@ -394,7 +370,7 @@ export function useTranscriptWindow({
       }
     }
   }
-  const transcriptWindow = useMemo(() => transcriptRenderWindow(items, {
+  const transcriptWindow = useMemo(() => transcriptRenderWindow(transcriptItems, {
     scrollOffset: renderScrollOffset,
     viewportHeight: transcriptContentHeight,
     columns: frameColumns,
@@ -451,7 +427,7 @@ export function useTranscriptWindow({
     prefixRows: transcriptRowIndex?.prefixRows || null,
     totalRows: Math.max(0, Number(transcriptWindow.totalRows) || 0),
     viewRows: Math.max(1, Number(transcriptContentHeight) || 1),
-    items: items || null,
+    items: transcriptItems || null,
     // The offset THIS frame actually rendered with. The same-frame anchor
     // CAPTURE for a missing/dirty anchor (above) reads this from the PREVIOUS
     // frame to reconstruct the exact top-edge row that was on screen, so the
@@ -469,10 +445,16 @@ export function useTranscriptWindow({
   // height changes. Re-slice the live `items` over the memo's stable
   // [startIndex, endIndex) bounds so the on-screen text is always current
   // while the expensive indexing/windowing stays warm.
-  const transcriptVisibleItems = (items || []).slice(
+  const transcriptVisibleItems = (transcriptItems || []).slice(
     transcriptWindow.startIndex,
     transcriptWindow.endIndex,
   );
+  if (streamingTailItem && transcriptVisibleItems.length > 0) {
+    const last = transcriptVisibleItems.length - 1;
+    if (transcriptVisibleItems[last]?.id === streamingTailItem.id) {
+      transcriptVisibleItems[last] = streamingTailItem;
+    }
+  }
   // The bottom meta band is spinner-only, so nothing is pulled out of the
   // transcript for it. A finished turn's done row (turndone/statusdone) renders
   // inline in scrollback like any other item — no filtering, no double-paint.
@@ -703,7 +685,7 @@ export function useTranscriptWindow({
     // move the item's prefix start and are absorbed the same way. No deltas, no
     // fallback, no drift.
     const viewRows = Math.max(1, Number(transcriptContentHeight) || 1);
-    const itemList = items || [];
+    const itemList = transcriptItems || [];
     let anchor = transcriptAnchorRef.current;
     // (Re)capture the anchor from the current viewport-top edge when missing or
     // invalidated by a manual scroll. anchorRow = absolute row at the top edge.

package/src/tui/components/ToolExecution.jsx

@@ -86,7 +86,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, callErrorCount, expanded, columns = 80, attached = false, count = 1, completedCount = 0, startedAt = 0, completedAt = 0, aggregate = false, categories = {}, doneCategories = null, headerFinalized = true, deferredDisplayReady = false }) {
+export function ToolExecution({ name, args, result, rawResult, isError, errorCount, callErrorCount, exitErrorCount, expanded, columns = 80, attached = false, count = 1, completedCount = 0, startedAt = 0, completedAt = 0, aggregate = false, categories = {}, doneCategories = null, headerFinalized = true, deferredDisplayReady = false, agentResponseAggregate = false }) {
   const rowWidth = Math.max(1, Number(columns || 80));
   const groupCount = Math.max(1, Number(count || 1));
   const doneCount = Math.max(0, Math.min(groupCount, Number(completedCount || (result == null ? 0 : groupCount))));
@@ -138,6 +138,9 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   // paint the dot red. Fall back to 0 (never `isError`) when the engine did not
   // supply a call-error count so a result failure can't leak into the dot.
   const callFailedCount = clampFailureCount(callErrorCount, groupCount, false);
+  // Shell command-exits (ran, non-zero exit). Counted separately so the dot
+  // paints the neutral warning "Exit" color instead of red or green success.
+  const exitFailedCount = clampFailureCount(exitErrorCount, groupCount, false);
   const displayGroupCount = groupCount;
   const displayCategories = normalizeCountMap(categories || {});
   // In the DONE state, count only successful calls: error-terminated calls are
@@ -212,7 +215,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
     const aggregateTerminalStatus = pending
       ? 'running'
       : (resultTerminalStatus(rt) || (isError || failedCount > 0 ? 'failed' : 'completed'));
-    const dotColor = toolStatusColor({ pending, groupCount, callFailedCount, terminalStatus: aggregateTerminalStatus });
+    const dotColor = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus: aggregateTerminalStatus });
     const dotText = pending && !blinkOn ? ' ' : TURN_MARKER;
     const gutter = 2;
     const showHeaderExpandHint = hasRawResult;
@@ -310,7 +313,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   const firstResultLine = hasDisplayResult ? String(lines[0] ?? '') : '';
   const firstResultLineClipped = hasDisplayBody && stringWidth(firstResultLine) > maxResultChars;
   const hasHiddenDetail = !pending && hasDisplayBody && (totalLines > 1 || firstResultLineClipped || Boolean(resultSummary));
-  const shellStatus = isShellSurface ? shellDisplayStatus({ pending, failedCount, isError, result: displayedResultText }) : '';
+  const shellStatus = isShellSurface ? shellDisplayStatus({ pending, failedCount, exitFailedCount, isError, result: displayedResultText }) : '';
   const shellElapsed = isShellSurface ? (shellResultElapsed(displayedResultText) || elapsed) : '';
   const backgroundElapsed = backgroundMeta
     ? backgroundTaskElapsed(backgroundMeta, elapsed)
@@ -384,7 +387,9 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   const showRawResult = expanded && (hasDisplayBody || hasRawResult)
     && (!isBackgroundMetadataResult || hasRawResult);
   const detailLines = showRawResult
-    ? (hasDisplayBody ? lines : (rawRt ? stripLeadingStatusMarkerLines(rawRt.split('\n')) : []))
+    ? (agentResponseAggregate && hasRawResult
+      ? stripLeadingStatusMarkerLines(rawRt.split('\n'))
+      : (hasDisplayBody ? lines : (rawRt ? stripLeadingStatusMarkerLines(rawRt.split('\n')) : [])))
     : (collapsedDetail ? [collapsedDetail] : []);
   const isPendingPlaceholderDetail = !showRawResult && Boolean(pendingDetailPlaceholder);
   const detailColor = isPendingPlaceholderDetail ? theme.subtle : theme.text;
@@ -426,7 +431,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
     const keepAgentDetail = (isError || agentFailureText) && !(agentHeaderFailure && !agentSurfaceBrief);
     visibleDetailLines = keepAgentDetail ? [agentDetailLine] : [];
   }
-  const finalStatusColor = toolStatusColor({ pending, groupCount, callFailedCount, terminalStatus });
+  const finalStatusColor = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus });
   const dotColor = finalStatusColor;
   // Agent surface cards use directional markers: `←` for requests going OUT
   // (spawn/send/etc.) and `→` for the response coming back IN. Background
@@ -446,7 +451,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   const markerText = isDirectionalMarker ? `${markerGlyph} ` : markerGlyph;
   const dotText = pending && !blinkOn ? ' ' : markerText;
   let labelText;
-  if (isAgentResponse) labelText = agentResponseTitle(parsedArgs);
+  if (isAgentResponse) labelText = agentResponseTitle(parsedArgs, displayGroupCount);
   else if (isBackgroundResponse) labelText = backgroundTaskResultTitle(normalizedName, backgroundMeta || parsedArgs);
   else if (isBackgroundMetadataResult) labelText = backgroundTaskActionTitle(normalizedName, backgroundMeta);
   else if (isShellSurface) labelText = shellHeader(shellStatus, displayGroupCount);

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} callErrorCount={item.callErrorCount} 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} />;
+      node = <ToolExecution name={item.name} args={item.args} result={item.result} rawResult={item.rawResult} isError={item.isError} errorCount={item.errorCount} callErrorCount={item.callErrorCount} exitErrorCount={item.exitErrorCount} 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} agentResponseAggregate={item.agentResponseAggregate} />;
       break;
     }
     case 'notice':

package/src/tui/components/tool-execution/surface-detail.mjs

@@ -21,11 +21,18 @@ export function isShellTool(normalizedName, label = '') {
   return n === 'shell' || n === 'bash' || n === 'bash_session' || n === 'shell_command' || n === 'job_wait' || l === 'run';
 }
 
-export function shellDisplayStatus({ pending = false, failedCount = 0, isError = false, result = '' } = {}) {
+export function shellDisplayStatus({ pending = false, failedCount = 0, exitFailedCount = 0, isError = false, result = '' } = {}) {
   const status = shellResultStatus(result);
   if (pending || /^(running|pending|queued)$/.test(status)) return 'running';
   if (/^cancel/.test(status)) return 'cancelled';
-  if (/^(failed|error|killed|timeout)$/.test(status) || isError || failedCount > 0) return 'failed';
+  if (/^(failed|error|killed|timeout)$/.test(status)) return 'failed';
+  // A command that RAN but exited non-zero is a command-exit, not a real
+  // failure: render the neutral "Exit" state unless there is ALSO a real
+  // tool-call/result failure in the group.
+  const realFailed = Math.max(0, Number(failedCount) - Number(exitFailedCount));
+  if (realFailed > 0) return 'failed';
+  if (Number(exitFailedCount) > 0) return 'exit';
+  if (isError || failedCount > 0) return 'failed';
   return 'completed';
 }
 
@@ -98,7 +105,9 @@ export function joinActionAgent(action, agent) {
   return agent ? `${action} ${agent}` : action;
 }
 
-export function agentResponseTitle(args) {
+export function agentResponseTitle(args, count = 1) {
+  const total = Math.max(1, Number(count) || 1);
+  if (total > 1) return `Responses ${total} agents`;
   const name = titleizeAgentName(args?.agent || args?.subagent_type || args?.name || '');
   // The agent + model identify the responder; the response summary itself
   // is hidden in the collapsed card (ctrl+o expand still shows the full body).
@@ -392,14 +401,19 @@ export function clampFailureCount(errorCount, groupCount, isError) {
 //   cancelled        -> theme.warning
 // The RED/orange failure color is driven ONLY by real tool-call errors
 // (`callFailedCount` — backend isError / error toolKind), NOT by command/result
-// failures like a shell non-zero exit or a `[status: failed]` result. Those
-// keep the card's L2 detail showing "Failed" but leave the dot on the success
-// color. `terminalStatus` is still consulted so a cancelled card stays warning.
-export function toolStatusColor({ pending, groupCount, callFailedCount = 0, terminalStatus = '' }) {
+// failures like a `[status: failed]` result. A shell command-exit
+// (`exitFailedCount`) is its own distinct neutral state: warning color, never
+// red. `terminalStatus` is still consulted so a cancelled card stays warning.
+export function toolStatusColor({ pending, groupCount, callFailedCount = 0, exitFailedCount = 0, terminalStatus = '' }) {
   if (pending) return theme.text;
   const status = normalizeTerminalStatus(terminalStatus);
   if (status === 'cancelled') return theme.warning;
-  if (callFailedCount <= 0) return theme.success;
-  if (groupCount > 1 && callFailedCount < groupCount) return theme.mixdogOrange || theme.warning;
-  return theme.error;
+  if (status === 'denied') return theme.warning;
+  if (callFailedCount > 0) {
+    if (groupCount > 1 && callFailedCount < groupCount) return theme.mixdogOrange || theme.warning;
+    return theme.error;
+  }
+  // Command-exit(s) with no real tool-call failure: distinct warning state.
+  if (exitFailedCount > 0) return theme.warning;
+  return theme.success;
 }

package/src/tui/components/tool-execution/text-format.mjs

@@ -8,6 +8,10 @@ import { displayWidth } from '../../display-width.mjs';
 import { theme } from '../../theme.mjs';
 import { formatElapsed } from '../../time-format.mjs';
 import stripAnsi from 'strip-ansi';
+import {
+  normalizeToolTerminalStatus,
+  toolResultTerminalStatus,
+} from '../../../runtime/shared/tool-status.mjs';
 
 export const MIN_RESULT_LINE_CHARS = 24;
 // Hard cap for the collapsed result detail row (the second line under the ⎿
@@ -108,37 +112,24 @@ export function shellResultStatus(value) {
 }
 
 export function normalizeTerminalStatus(value) {
-  const raw = String(value || '').trim().toLowerCase();
-  if (!raw) return '';
-  if (/^(running|pending|queued|in_progress|in-progress)$/.test(raw)) return 'running';
-  if (/^(completed|complete|done|success|succeeded|ok)$/.test(raw)) return 'completed';
-  if (/^(failed|fail|error|errored|timeout|timed_out|killed)$/.test(raw)) return 'failed';
-  if (/^(cancelled|canceled|cancel)$/.test(raw)) return 'cancelled';
-  return '';
+  return normalizeToolTerminalStatus(value);
 }
 
 export function displayTerminalStatus(value) {
+  // 'exit' is a shell-only pseudo-status (command RAN but exited non-zero); it
+  // is intentionally NOT a normalized terminal status so it never colors red.
+  if (String(value || '').trim().toLowerCase() === 'exit') return 'Exit';
   const status = normalizeTerminalStatus(value);
   if (status === 'running') return 'Running';
   if (status === 'completed') return 'Finished';
   if (status === 'failed') return 'Failed';
   if (status === 'cancelled') return 'Cancelled';
+  if (status === 'denied') return 'Denied';
   return '';
 }
 
 export function resultTerminalStatus(value) {
-  const text = String(value || '');
-  const tagged = text.match(/<status[^>]*>([\s\S]*?)<\/status>/i)?.[1]?.trim();
-  if (tagged) return normalizeTerminalStatus(tagged);
-  const bracketed = text.match(/^\[status:\s*([^\]]*)\]/mi)?.[1]?.trim();
-  if (bracketed) return normalizeTerminalStatus(bracketed);
-  // Loose inline `status: x` / `state: x` matches are a last-resort fallback —
-  // prefer the engine-controlled `<status>` tag or `[status: …]` marker above.
-  // A loose match can false-positive on prose that happens to start with
-  // "status:" (rare, but shellResultStatus below already owns real shell
-  // output parsing; this fallback stays narrow and unchanged in behavior).
-  const inline = text.match(/^(?:status|state):\s*([^\s·,;]+)/mi)?.[1]?.trim();
-  return normalizeTerminalStatus(inline);
+  return toolResultTerminalStatus(value);
 }
 
 const LEADING_STATUS_MARKER_LINE_RE = /^\[status:\s*[^\]]*\]\s*$/i;