mixdog 0.9.38 → 0.9.39

package/src/tui/engine/agent-job-feed.mjs

@@ -21,9 +21,15 @@ import {
 import { toolErrorDisplay } from './tool-result-text.mjs';
 import {
   notificationQueueKey,
+  executionCardKey,
   resolveTuiRuntimeNotificationDelivery,
 } from './notification-plan.mjs';
+import { shortTextFingerprint } from './queue-helpers.mjs';
 import { readImageAttachmentFromPath } from '../paste-attachments.mjs';
+import {
+  isDeliveredCompletion,
+  recordDeliveredCompletion,
+} from '../../runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
 
 // Channel inbound images arrive as a JSON-array-of-paths meta value (stringified
 // across the notify IPC boundary). Parse defensively; a malformed value simply
@@ -48,13 +54,26 @@ export function createAgentJobFeed({
   enqueue,
   drain,
   pushUserOrSyntheticItem,
+  pushAsyncAgentResponse,
   makeQueueEntry,
   getPending,
   agentStatusState,
   displayedExecutionNotificationKeys,
   pushNotice,
+  now = () => Date.now(),
+  executionResumeTombstoneTtlMs = 30_000,
+  executionResumeTombstoneLimit = 128,
 }) {
   let executionResumeKickDeferred = false;
+  // Completion keys explicitly abandoned by Esc. Tombstones are per-feed
+  // (therefore per TUI session), short-lived, and bounded: they catch a late
+  // duplicate racing the abort without permanently reserving execution IDs or
+  // retaining completion bodies.
+  const discardedExecutionResumeKeys = new Map();
+  // Tracks whether an execution's visible response is only a bodyless preview
+  // or has reached its final body. A preview must not permanently suppress the
+  // later body, while repeated body retries remain idempotent.
+  const displayedExecutionResponseStates = new Map();
 
   // FIFO accumulation of model-visible bodies from completions that arrived
   // while busy (or while a pending-resume entry was already queued). A single
@@ -62,8 +81,49 @@ export function createAgentJobFeed({
   // the queue preserves every body and merges them into the resume turn.
   const executionResumeKickBodies = [];
 
-  function kickExecutionPendingResume(body = '') {
-    if (body) executionResumeKickBodies.push(body);
+  function executionResumeKey(body, completionKey = '') {
+    if (completionKey && typeof completionKey === 'object') {
+      completionKey = completionKey.executionId || completionKey.key || '';
+    }
+    const explicitKey = String(completionKey || '').trim();
+    if (explicitKey.startsWith('execution:') || explicitKey.startsWith('body:')) return explicitKey;
+    if (explicitKey) return `execution:${explicitKey}`;
+    const value = String(body || '').trim();
+    return value ? `body:${shortTextFingerprint(value)}` : '';
+  }
+
+  function pruneDiscardedExecutionResumeKeys() {
+    const nowMs = Number(now()) || Date.now();
+    for (const [key, expiresAt] of discardedExecutionResumeKeys) {
+      if (expiresAt <= nowMs) discardedExecutionResumeKeys.delete(key);
+    }
+  }
+
+  function isDiscardedExecutionResumeKey(key) {
+    if (!key) return false;
+    pruneDiscardedExecutionResumeKeys();
+    return discardedExecutionResumeKeys.has(key);
+  }
+
+  function rememberDiscardedExecutionResumeKey(key) {
+    if (!key) return;
+    pruneDiscardedExecutionResumeKeys();
+    const limit = Math.max(1, Number(executionResumeTombstoneLimit) || 128);
+    while (!discardedExecutionResumeKeys.has(key) && discardedExecutionResumeKeys.size >= limit) {
+      const oldest = discardedExecutionResumeKeys.keys().next().value;
+      if (oldest == null) break;
+      discardedExecutionResumeKeys.delete(oldest);
+    }
+    const ttlMs = Math.max(1, Number(executionResumeTombstoneTtlMs) || 30_000);
+    // Refresh insertion order so the bounded map evicts the oldest tombstone.
+    discardedExecutionResumeKeys.delete(key);
+    discardedExecutionResumeKeys.set(key, (Number(now()) || Date.now()) + ttlMs);
+  }
+
+  function kickExecutionPendingResume(body = '', completionKey = '') {
+    const key = executionResumeKey(body, completionKey);
+    if (body && isDiscardedExecutionResumeKey(key)) return;
+    if (body) executionResumeKickBodies.push({ body, key });
     if (getDisposed()) return;
     if (getState().busy) {
       executionResumeKickDeferred = true;
@@ -77,8 +137,15 @@ export function createAgentJobFeed({
     executionResumeKickDeferred = false;
     // Drain every accumulated body into ONE resume turn so no completion body
     // is lost when several deferred while busy.
-    const resumeBody = executionResumeKickBodies.splice(0).filter(Boolean).join('\n\n');
-    pending.push(makeQueueEntry(resumeBody, { mode: 'pending-resume', priority: 'next' }));
+    const resumeBodies = executionResumeKickBodies.splice(0);
+    const resumeBody = resumeBodies.map(({ body: value }) => value).filter(Boolean).join('\n\n');
+    const resumeCompletionKeys = resumeBodies.map(({ key }) => key).filter(Boolean);
+    pending.push(makeQueueEntry(resumeBody, {
+      mode: 'pending-resume',
+      priority: 'next',
+      abortDiscardOnAbort: true,
+      resumeCompletionKeys,
+    }));
     void drain();
   }
 
@@ -87,11 +154,25 @@ export function createAgentJobFeed({
     kickExecutionPendingResume();
   }
 
-  function scheduleExecutionPendingResumeKick(body = '') {
+  function scheduleExecutionPendingResumeKick(body = '', completionKey = '') {
     // Carry the model-visible body directly into the pending-resume entry so
     // the resumed turn sends it, instead of relying on the session-pending
     // completion marker (dropped by askSession pre-drain).
-    queueMicrotask(() => kickExecutionPendingResume(body));
+    queueMicrotask(() => kickExecutionPendingResume(body, completionKey));
+  }
+
+  function discardExecutionPendingResume(completionKeys = []) {
+    const keys = (Array.isArray(completionKeys) ? completionKeys : [completionKeys])
+      .map((key) => executionResumeKey('', key))
+      .filter(Boolean);
+    if (keys.length === 0) return;
+    for (const key of keys) rememberDiscardedExecutionResumeKey(key);
+    for (let i = executionResumeKickBodies.length - 1; i >= 0; i -= 1) {
+      if (isDiscardedExecutionResumeKey(executionResumeKickBodies[i].key)) {
+        executionResumeKickBodies.splice(i, 1);
+      }
+    }
+    executionResumeKickDeferred = executionResumeKickBodies.length > 0;
   }
 
   // Pure builder for the agent-job card patch. Split out so callers that are
@@ -117,6 +198,13 @@ export function createAgentJobFeed({
     patchItem(itemId, buildAgentJobCardPatch(itemId, text, isError));
   }
 
+  function refreshAgentStatus(parsed) {
+    if (!parsed?.taskId) return;
+    const status = String(parsed.status || '').toLowerCase();
+    const terminal = /^(completed|complete|done|success|succeeded|ok|failed|error|timeout|killed|cancelled|canceled|denied)$/.test(status);
+    set(agentStatusState(terminal ? { force: true } : undefined));
+  }
+
   function subscribeRuntimeNotifications() {
     if (typeof runtime.onNotification !== 'function') return null;
     return runtime.onNotification((event) => {
@@ -132,43 +220,81 @@ export function createAgentJobFeed({
         return true;
       }
       if (delivery.action === 'status-only') {
-        if (parsed?.taskId) set(agentStatusState({ force: true }));
+        refreshAgentStatus(parsed);
         return true;
       }
       if (delivery.action === 'execution-ui') {
-        const firstDelivery = !notificationKey || !displayedExecutionNotificationKeys.has(notificationKey);
-        if (firstDelivery) {
-          if (notificationKey) displayedExecutionNotificationKeys.add(notificationKey);
-          pushUserOrSyntheticItem(delivery.displayText, nextId());
+        const cardKey = executionCardKey(event, text, parsed);
+        const firstDelivery = !cardKey || !displayedExecutionNotificationKeys.has(cardKey);
+        const executionId = String(event?.meta?.execution_id || parsed?.taskId || '').trim();
+        const status = String(event?.meta?.status || parsed?.status || '').toLowerCase();
+        const hasBody = /\n\s*\n[\s\S]*\S/.test(text);
+        const isFailure = /^(failed|error|timeout|killed|cancelled|canceled|denied)$/.test(status);
+        const successfulPreview = !hasBody && !isFailure && /^(completed|complete|done|success|succeeded|ok)$/.test(status);
+        const responseState = executionId ? displayedExecutionResponseStates.get(executionId) : '';
+        const bodyAlreadyDisplayed = responseState === 'body';
+        if (firstDelivery && !successfulPreview && !bodyAlreadyDisplayed) {
+          if (cardKey) displayedExecutionNotificationKeys.add(cardKey);
+          if (executionId) displayedExecutionResponseStates.set(executionId, hasBody ? 'body' : 'preview');
+          // Execution completions are inbound agent responses. The engine keeps
+          // their aggregation tail-safe (only an immediately-adjacent inbound
+          // response of the same preview/body phase can merge); the fallback
+          // preserves the standalone path for minimal/test harnesses.
+          (pushAsyncAgentResponse || pushUserOrSyntheticItem)(delivery.displayText, nextId(), 'injected', { responseKey: executionId });
         }
-        if (parsed?.taskId) set(agentStatusState({ force: true }));
+        refreshAgentStatus(parsed);
         const resumeBody = String(delivery.modelContent || '').trim();
         if (resumeBody) {
-          enqueue(resumeBody, {
+          const completionKey = executionResumeKey(resumeBody, executionId);
+          // Consolidated completion dedup keyed off execution_id (+ text hash):
+          // if this exact execution completion was already delivered — either by
+          // an earlier TUI enqueue here or by runtime-core's ack — do NOT enqueue
+          // a duplicate model-visible twin. A re-arriving completion while IDLE
+          // would otherwise re-enqueue and let post-turn drain() spawn a fresh
+          // turn. Still ack (modelVisibleDelivered) so runtime-core's
+          // mirror/fallback stays suppressed; the card first-delivery push and
+          // status refresh above already ran.
+          if (isDiscardedExecutionResumeKey(completionKey) || isDeliveredCompletion({ executionId, text: resumeBody })) {
+            if (event && typeof event === 'object') event.modelVisibleDelivered = true;
+            return true;
+          }
+          const enqueued = enqueue(resumeBody, {
             mode: 'task-notification',
             // Claude Code parity: live execution completions are queued as
             // task notifications so the active loop can attach them after the
             // next tool batch; no special pending-resume bypass.
             priority: 'next',
             key: notificationKey || undefined,
+            abortDiscardOnAbort: true,
+            resumeCompletionKeys: completionKey ? [completionKey] : [],
             displayText: delivery.displayText || text,
             // The immediate Response card was already pushed above
             // (pushUserOrSyntheticItem). Keep this queued twin model-visible
             // but suppress its drain-time transcript card to avoid a duplicate.
             suppressDisplay: true,
           });
+          // Self-sufficient TUI dedup: mark delivered right here (mark-once at
+          // delivery, keyed by execution_id) so a re-arriving completion is
+          // skipped above without depending solely on the runtime-core ack
+          // roundtrip — removes the split-brain asymmetry. Gated on a CONFIRMED
+          // enqueue: enqueue() returns false only when an identical-key
+          // task-notification twin is already queued (session-flow.mjs
+          // pendingNotificationKeys.has(key)), in which case the completion is
+          // already pending delivery and must not be double-recorded.
+          if (enqueued) recordDeliveredCompletion({ executionId, text: resumeBody });
           // EXPLICIT ack to the emitting runtime: the model-visible completion
           // body was injected into the active loop here, so notifyFnForSession
           // must NOT also mirror it into the pending queue (double injection).
           // A bare truthy return below is display/status handling only — this
-          // flag is the sole model-visible-delivery signal.
+          // flag is the sole model-visible-delivery signal. Set for BOTH the
+          // real-enqueue and the enqueue===false (already-queued twin) cases:
+          // either way the completion is pending delivery on the TUI path, so
+          // runtime-core must still not mirror it.
           if (event && typeof event === 'object') event.modelVisibleDelivered = true;
         }
         return true;
       }
-      if (parsed?.taskId) {
-        set(agentStatusState({ force: true }));
-      }
+      refreshAgentStatus(parsed);
       const modelContent = String(delivery.modelContent ?? delivery.displayText ?? text).trim();
       const imagePaths = parseInboundImagePaths(event?.meta?.image_paths);
       if (!modelContent && imagePaths.length === 0) return true;
@@ -212,6 +338,7 @@ export function createAgentJobFeed({
     kickExecutionPendingResume,
     flushDeferredExecutionPendingResumeKick,
     scheduleExecutionPendingResumeKick,
+    discardExecutionPendingResume,
     updateAgentJobCard,
     buildAgentJobCardPatch,
     subscribeRuntimeNotifications,

package/src/tui/engine/agent-response-tail.mjs

@@ -0,0 +1,68 @@
+// Pure, tail-only inbound-agent response aggregation. The caller decides
+// whether the transcript tail is eligible; this helper never searches older
+// rows, so a retry cannot mutate across a real transcript boundary.
+function responseEntry(response = {}) {
+  return {
+    key: String(response.key || ''),
+    raw: String(response.rawResult ?? response.raw ?? '').trim(),
+    result: response.result,
+    hasBody: response.hasBody === true,
+    isError: response.isError === true,
+  };
+}
+
+export function formatAgentResponseRaw(entries = []) {
+  return entries
+    .map((entry, index) => {
+      const raw = String(entry?.raw || '').trim();
+      return raw ? `${index + 1}. agent\n${raw}` : '';
+    })
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function priorEntries(previous) {
+  if (Array.isArray(previous?.agentResponseEntries) && previous.agentResponseEntries.length) {
+    return previous.agentResponseEntries.map(responseEntry);
+  }
+  return [responseEntry({
+    key: previous?.agentResponseKey,
+    rawResult: previous?.rawResult ?? previous?.result,
+    result: previous?.result,
+    hasBody: previous?.agentResponseHasBody,
+    isError: previous?.isError,
+  })];
+}
+
+export function appendAgentResponseTail(previous, response, now = Date.now()) {
+  if (previous?.kind !== 'tool' || previous.agentDirection !== 'inbound') return null;
+  const next = responseEntry(response);
+  const entries = priorEntries(previous);
+  const existingIndex = next.key ? entries.findIndex((entry) => entry.key === next.key) : -1;
+
+  if (existingIndex >= 0) {
+    // A preview/final/retry for the same execution is one response. Replace
+    // that entry in-place only because this aggregate is still the transcript
+    // tail; never turn it into another count or a nested raw block.
+    entries[existingIndex] = next;
+  } else {
+    // Distinct responses can merge only when their presentation phase matches.
+    // A visible bodyless failure stays a separate row from a later full body.
+    if (previous.agentResponseHasBody !== next.hasBody) return null;
+    entries.push(next);
+  }
+
+  return {
+    args: response.args,
+    result: response.result,
+    rawResult: formatAgentResponseRaw(entries) || null,
+    isError: entries.some((entry) => entry.isError),
+    count: entries.length,
+    completedCount: entries.length,
+    completedAt: now,
+    agentResponseEntries: entries,
+    agentResponseKeys: entries.map((entry) => entry.key).filter(Boolean),
+    agentResponseHasBody: entries.every((entry) => entry.hasBody),
+    agentResponseAggregate: entries.length > 1,
+  };
+}

package/src/tui/engine/notification-plan.mjs

@@ -47,6 +47,22 @@ export function notificationQueueKey(event, text, parsed) {
   return [id, type || fallbackKind, status, hasBody].filter(Boolean).join(':');
 }
 
+/**
+ * Stable dedup key for the execution transcript CARD. Unlike notificationQueueKey
+ * it drops the volatile type/status dimensions so a duplicate completion re-arriving
+ * with a different type/status (same execution_id) cannot push a second card. The
+ * hasBody dimension is preserved so a bodyless preview (b0) and the real result (b1)
+ * remain distinct cards (intentional preview→result upgrade). Falls back to
+ * notificationQueueKey when no execution_id is present.
+ */
+export function executionCardKey(event, text, parsed) {
+  const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
+  const executionId = String(meta.execution_id || '').trim();
+  if (!executionId) return notificationQueueKey(event, text, parsed);
+  const hasBody = /\n\s*\n[\s\S]*\S/.test(String(text || '')) ? 'b1' : 'b0';
+  return `card:${executionId}:${hasBody}`;
+}
+
 export function isExecutionNotification(event, text, parsed) {
   const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
   if (meta.execution_id || meta.execution_surface) return true;

package/src/tui/engine/session-api.mjs

@@ -24,7 +24,7 @@ export function createEngineApi(bag) {
 
 export function createEngineApiA(bag) {
   const {
-    runtime, nextId, flags, pending, listeners, getState, set, pushItem, patchItem, replaceItems, pushNotice, autoClearState, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, updateAgentJobCard, requeueEntriesFront, enqueue, autoClearBeforeSubmit, restoreQueued, resetStatsAndSyncContext, drain, flushDeferredExecutionPendingResumeKick,
+    runtime, nextId, flags, pending, listeners, getState, set, pushItem, patchItem, replaceItems, pushNotice, autoClearState, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, updateAgentJobCard, requeueEntriesFront, enqueue, autoClearBeforeSubmit, restoreQueued, resetStatsAndSyncContext, drain, flushDeferredExecutionPendingResumeKick, discardExecutionPendingResume,
   } = bag;
   return {
     getState: () => getState(),
@@ -573,10 +573,15 @@ export function createEngineApiA(bag) {
         ? restoreState.pastedTexts
         : null;
       const requeueEntries = restoreState && !restoreState.committed && Array.isArray(restoreState.requeueEntries)
-        ? restoreState.requeueEntries.slice()
+        ? restoreState.requeueEntries.filter(
+          (entry) => entry?.abortDiscardOnAbort !== true && entry?.mode !== 'pending-resume',
+        )
         : [];
       const aborted = runtime.abort('cli-react-abort');
       if (restoreState) {
+        if (aborted !== false && Array.isArray(restoreState.discardExecutionPendingResumeKeys)) {
+          discardExecutionPendingResume?.(restoreState.discardExecutionPendingResumeKeys);
+        }
         if ((restoreText || requeueEntries.length > 0) && aborted !== false) {
           restoreState.reclaimed = true;
           const idSet = new Set((restoreState.submittedIds || []).filter((id) => id != null));
@@ -592,6 +597,7 @@ export function createEngineApiA(bag) {
         }
         restoreState.restorable = false;
         restoreState.requeueEntries = [];
+        restoreState.discardExecutionPendingResumeKeys = [];
       }
       // ── Bounded manual-abort recovery ───────────────────────────────────
       // runtime.abort() above normally rejects the in-flight runtime.ask() so

package/src/tui/engine/session-flow.mjs

@@ -54,6 +54,12 @@ export function createSessionFlow(bag) {
       skipSlashCommands: options.skipSlashCommands === true,
       displayText: mode === 'task-notification' ? notificationDisplayText(displayText) : String(displayText || ''),
       suppressDisplay: options.suppressDisplay === true,
+      // Completion resumes are consumed exactly once: Esc abandons their
+      // uncommitted body instead of putting it back at the queue front.
+      abortDiscardOnAbort: options.abortDiscardOnAbort === true,
+      resumeCompletionKeys: Array.isArray(options.resumeCompletionKeys)
+        ? options.resumeCompletionKeys.filter((key) => key != null && String(key).trim())
+        : [],
       steeringPersistId: options.steeringPersistId || null,
       steeringPersistRestored: options.steeringPersistRestored === true,
     };
@@ -194,6 +200,17 @@ export function createSessionFlow(bag) {
           pushUserOrSyntheticItem(entry.text, entry.id, isQueuedEntryEditable(entry) ? 'user' : 'injected');
         }
         const nonEditable = batch.filter((entry) => !isQueuedEntryEditable(entry));
+        // A completion resume is owned by the completion that woke it. Esc
+        // consumes that ownership; unlike ordinary notifications it must never
+        // be requeued from an uncommitted turn. Keep normal task notifications
+        // recoverable exactly as before.
+        const discardOnAbort = nonEditable.filter(
+          (entry) => entry?.abortDiscardOnAbort === true || entry?.mode === 'pending-resume',
+        );
+        const requeueOnAbort = nonEditable.filter((entry) => !discardOnAbort.includes(entry));
+        const discardExecutionPendingResumeKeys = discardOnAbort.flatMap(
+          (entry) => Array.isArray(entry?.resumeCompletionKeys) ? entry.resumeCompletionKeys : [],
+        );
         const batchPastedImages = mergePastedImages(batch);
         const batchPastedTexts = mergePastedTexts(batch);
         const turnStatus = await bag.runTurn(merged, {
@@ -203,7 +220,8 @@ export function createSessionFlow(bag) {
           onCommitted: () => commitSteeringQueueEntries(batch),
           submittedIds: [...ids],
           restorable: nonEditable.length === 0,
-          requeueOnAbort: nonEditable,
+          requeueOnAbort,
+          discardExecutionPendingResumeKeys,
         });
         if (flags.drainEpoch !== drainEpoch) return;
         // A deferred cleared-session UI sync (from a late-settling abandoned

package/src/tui/engine/tool-card-results.mjs

@@ -10,17 +10,18 @@
  * the factory argument (getters/callbacks) — never stale snapshots. Every body
  * is the original engine.mjs logic verbatim.
  */
-import { summarizeToolResult, aggregateDoneCategories, classifyToolCategory } from '../../runtime/shared/tool-surface.mjs';
+import { summarizeToolResult, aggregateDoneCategories } from '../../runtime/shared/tool-surface.mjs';
 import { toolResultText, toolErrorDisplay, toolGroupedDisplayFallback } from './tool-result-text.mjs';
 import { toolResultCallId } from './tool-call-fields.mjs';
-import { memoryCoreResultErrorText } from '../app/input-parsers.mjs';
-import { parseAgentJob, toolResultStatus, isErrorToolStatus } from './agent-envelope.mjs';
+import { parseAgentJob } from './agent-envelope.mjs';
 import {
   withCancelledResultMarker,
   groupedToolResultText,
   aggregateRawResult,
   aggregateSummaries,
   assignAggregateSummaryOrder,
+  failureDetailText,
+  toolCallOutcome,
 } from './tool-result-status.mjs';
 import { formatAggregateDetail } from '../../runtime/shared/tool-surface.mjs';
 import { carryTranscriptMeasuredRowsCache } from '../app/transcript-window.mjs';
@@ -34,6 +35,17 @@ export function createToolCardResults({
   buildAgentJobCardPatch,
   agentStatusState,
 }) {
+  // A finalized/failed non-aggregate card must never carry an empty body:
+  // an empty-body error card is classified fully-failed-with-no-body upstream
+  // (transcript-tool-failures) and null-renders (card disappears). Stamp a
+  // minimal non-empty fallback, preferring meaningful text, then Exit N, then
+  // a bare Failed status.
+  function finalizedErrorFallbackBody(body, text, exitCode) {
+    if (String(body || '').trim()) return body;
+    if (String(text || '').trim()) return text;
+    if (exitCode != null) return `Exit ${exitCode}`;
+    return 'Failed';
+  }
   function patchToolItem(id, patch) {
     const prev = getState().items.find((it) => it.id === id);
     const ok = patchItem(id, patch);
@@ -60,22 +72,11 @@ export function createToolCardResults({
     // Aggregate card handling — collect semantic summaries per call
     const aggregate = card.aggregate;
     const callRec = aggregate && callId ? aggregate.calls.get(callId) : null;
-    // Backend "core" memory-op failures are flattened to plain text (isError
-    // dropped upstream — see memoryCoreResultErrorText); recover that signal so
-    // failed memory writes are excluded from the done count. Gated to Memory
-    // calls: the text-matcher's ^(error|failed) catch-all would otherwise
-    // misflag legitimate non-memory success output.
-    const isMemoryCall = classifyToolCategory(callRec?.name || card?.name || '', callRec?.args || {}) === 'Memory';
-    // Split the failure signal into two:
-    //   isCallError  — a REAL tool-call failure (backend isError / error
-    //                  toolKind). ONLY this paints the ● dot red.
-    //   isResultError — a command/result failure (shell exit code, [error…]
-    //                  text, failed status text, flattened core memory-op
-    //                  failure). These still mark the card Failed in the L2
-    //                  detail but must NOT turn the dot red.
-    const isCallError = message?.isError === true || message?.toolKind === 'error';
-    const isResultError = /^\s*\[?error/i.test(rawText) || isErrorToolStatus(toolResultStatus(rawText)) || (isMemoryCall && memoryCoreResultErrorText(rawText) != null);
-    const isError = isCallError || isResultError;
+    // Only a provider-marked invocation failure contributes to failure count,
+    // red state, or Failed aggregate copy. Tool-reported HTTP/domain/status
+    // outcomes remain successful calls with their raw/semantic result detail.
+    const { exitCode, isExitError, isCallError } = toolCallOutcome(message, rawText);
+    const isError = isCallError;
     const text = isError ? toolErrorDisplay(rawText, card?.name || 'tool') : rawText;
 
     if (aggregate && card.itemId === aggregate.itemId) {
@@ -89,19 +90,22 @@ export function createToolCardResults({
       assignAggregateSummaryOrder(aggregate, callRec);
       callRec.isError = isError;
       callRec.isCallError = isCallError;
+      callRec.isExitError = isExitError;
+      callRec.exitCode = exitCode;
       callRec.resultText = text;
       callRec.resolved = true;
       const allCalls = [...aggregate.calls.values()];
       const completed = allCalls.filter((r) => r.resolved).length;
       const errors = allCalls.filter((r) => r.isError).length;
       const callErrors = allCalls.filter((r) => r.isCallError).length;
+      const exitErrors = allCalls.filter((r) => r.isExitError).length;
       // Collapsed detail carries the merged per-call count summary
       // ("512 lines, 6 matches, 3 files") so the finished card answers "how
       // much" without ctrl+o. Failures keep a bare 'N Ok · N Failed' status so
       // an error stays visible while collapsed.
-      const succeeded = completed - errors;
-      const detailText = errors > 0
-        ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
+      const succeeded = Math.max(0, completed - errors - exitErrors);
+      const detailText = errors > 0 || exitErrors > 0
+        ? failureDetailText({ succeeded, realErrors: callErrors, exitErrors, exitCode: allCalls.find((r) => r.isExitError)?.exitCode })
         : formatAggregateDetail(aggregateSummaries(aggregate));
       const currentItem = getState().items.find((it) => it.id === card.itemId);
       const earlyCompleted = allCalls.filter((r) => r.resolved || r.completedEarly).length;
@@ -116,6 +120,7 @@ export function createToolCardResults({
         isError: errors > 0,
         errorCount: errors,
         callErrorCount: callErrors,
+        exitErrorCount: exitErrors,
         count: allCalls.length,
         completedCount: visualCompleted,
         doneCategories: aggregateDoneCategories(allCalls),
@@ -127,20 +132,25 @@ export function createToolCardResults({
     }
 
     // Non-aggregate (legacy agent-job cards, etc.)
-    const group = toolGroups.get(card.itemId) || { count: 1, completed: 0, errors: 0, callErrors: 0, results: [] };
+    const group = toolGroups.get(card.itemId) || { count: 1, completed: 0, errors: 0, callErrors: 0, exitErrors: 0, results: [] };
     group.completed = Math.min(group.count, group.completed + 1);
     group.errors += isError ? 1 : 0;
     group.callErrors = (group.callErrors || 0) + (isCallError ? 1 : 0);
-    group.results.push({ text, isError });
+    group.exitErrors = (group.exitErrors || 0) + (isExitError ? 1 : 0);
+    group.results.push({ text, isError, isExitError, exitCode });
     toolGroups.set(card.itemId, group);
     const resultText = groupedToolResultText(group);
-    const displayResult = toolGroupedDisplayFallback(resultText, text, rawText);
+    let displayResult = toolGroupedDisplayFallback(resultText, text, rawText);
+    if (group.errors > 0 && !String(displayResult || '').trim()) {
+      displayResult = finalizedErrorFallbackBody(displayResult, text, exitCode);
+    }
     const patch = {
       result: displayResult,
       text: displayResult,
       isError: group.errors > 0,
       errorCount: group.errors,
       callErrorCount: group.callErrors || 0,
+      exitErrorCount: group.exitErrors || 0,
       count: group.count,
       completedCount: group.completed,
       completedAt: Date.now(),
@@ -159,6 +169,11 @@ export function createToolCardResults({
       // The agent fields win (final display) while patch keeps the completion
       // metadata (count/completedCount/completedAt/rawResult) for expand.
       Object.assign(patch, buildAgentJobCardPatch(card.itemId, rawText, isError));
+      // Re-apply the empty-body guard: buildAgentJobCardPatch may overwrite the
+      // stamped fallback with an empty agent-job body, letting the card vanish.
+      if (group.errors > 0 && !String(patch.result || '').trim()) {
+        patch.result = patch.text = finalizedErrorFallbackBody(patch.result, text, exitCode);
+      }
     }
     patchToolItem(card.itemId, patch);
     card.done = true;
@@ -223,12 +238,14 @@ export function createToolCardResults({
         const totalCompleted = completed;
         const errors = allCalls.filter((r) => r.isError).length;
         const callErrors = allCalls.filter((r) => r.isCallError).length;
-        const succeeded = completed - errors;
+        const exitErrors = allCalls.filter((r) => r.isExitError).length;
+        const succeeded = Math.max(0, completed - errors - exitErrors);
         const rawResult = aggregateRawResult(allCalls);
-        // Collapsed detail carries the merged per-call count summary; failures
-        // keep a bare 'N Ok · N Failed' status. Raw is kept for ctrl+o.
-        let displayDetail = errors > 0
-          ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
+        // Collapsed detail carries the merged per-call count summary; real
+        // failures keep 'N Failed', shell command-exits show 'Exit N'/'Y Exit'.
+        // Raw is kept for ctrl+o.
+        let displayDetail = errors > 0 || exitErrors > 0
+          ? failureDetailText({ succeeded, realErrors: callErrors, exitErrors, exitCode: allCalls.find((r) => r.isExitError)?.exitCode })
           : formatAggregateDetail(aggregateSummaries(aggregate));
         if (cancelled) {
           // Cancelled aggregates MUST keep the [status: cancelled] marker on the
@@ -244,6 +261,7 @@ export function createToolCardResults({
           isError: errors > 0,
           errorCount: errors,
           callErrorCount: callErrors,
+          exitErrorCount: exitErrors,
           count: allCalls.length,
           completedCount: totalCompleted,
           doneCategories: aggregateDoneCategories(allCalls),
@@ -257,15 +275,19 @@ export function createToolCardResults({
         continue;
       }
       // Non-aggregate finalize
-      const group = toolGroups.get(card.itemId) || { count: 1, completed: 0, errors: 0, results: [] };
+      const group = toolGroups.get(card.itemId) || { count: 1, completed: 0, errors: 0, exitErrors: 0, results: [] };
       group.completed = Math.min(group.count, group.completed + 1);
       toolGroups.set(card.itemId, group);
       let resultText = groupedToolResultText(group);
+      if (group.errors > 0 && !String(resultText || '').trim()) {
+        const exitRec = (group.results || []).find((r) => r && r.isExitError);
+        resultText = finalizedErrorFallbackBody(resultText, exitRec?.text, exitRec?.exitCode);
+      }
       if (cancelled) {
         const currentItem = getState().items.find((it) => it.id === card.itemId);
         resultText = withCancelledResultMarker(resultText, currentItem);
       }
-      patchToolItem(card.itemId, { result: resultText, text: resultText, isError: group.errors > 0, errorCount: group.errors, callErrorCount: group.callErrors || 0, count: group.count, completedCount: group.completed, completedAt: Date.now() });
+      patchToolItem(card.itemId, { result: resultText, text: resultText, isError: group.errors > 0, errorCount: group.errors, callErrorCount: group.callErrors || 0, exitErrorCount: group.exitErrors || 0, count: group.count, completedCount: group.completed, completedAt: Date.now() });
       card.done = true;
       if (card.callId) done.add(card.callId);
     }