mixdog 0.9.37 → 0.9.39

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);
     }

package/src/tui/engine/tool-result-status.mjs

@@ -8,27 +8,75 @@
  * keeps calling them unchanged.
  */
 import { toolErrorDisplay } from './tool-result-text.mjs';
+import {
+  normalizeToolTerminalStatus,
+  toolResultTerminalStatus,
+} from '../../runtime/shared/tool-status.mjs';
 
 export const CANCELLED_RESULT_STATUS_LINE = '[status: cancelled]';
 
+// Detect a shell command that RAN but exited non-zero (a process exit code)
+// as opposed to a real tool-call failure (`[shell-tool-failed]`) or a
+// timeout/abort. bash-tool.mjs emits `Error: [shell-run-failed] [exit code: N]`
+// for a plain non-zero exit; timeout/signal cases carry `[timeout: …]`/
+// `[signal: …]` instead of an `[exit code: …]` marker. Returns the numeric
+// exit code (>= 0) for a command-exit, or null otherwise.
+export function shellCommandExitCode(text) {
+  const body = String(text || '');
+  // Anchor to the START of the result so a success/non-shell body that merely
+  // QUOTES the marker mid-output is never misclassified. bash-tool emits
+  // `Error: [shell-run-failed] [exit code: N]` as the leading marker header.
+  if (!/^\s*(?:Error:\s*)?\[shell-run-failed\]/i.test(body)) return null;
+  // Restrict marker parsing to the header region (first line) so only the
+  // engine-emitted status header — not quoted command output below — counts.
+  const header = body.split('\n', 1)[0] || '';
+  // Timeout / signal / abort are NOT a plain command exit — keep them "Failed".
+  if (/\[timeout:|\[signal:|timed out|aborted|interrupted/i.test(header)) return null;
+  const m = header.match(/\[exit code:\s*(\d+)\]/i);
+  if (!m) return null;
+  const code = Number(m[1]);
+  return Number.isFinite(code) ? code : null;
+}
+
+// Only provider envelope metadata establishes a failed invocation. Result
+// bodies can contain "Error:"/HTTP/domain/task status text without making the
+// call itself fail. A recognized plain shell exit wins over provider envelope
+// error flags: adapters commonly label non-zero process exits as tool errors
+// even though the shell tool itself ran successfully.
+export function toolCallOutcome(message, rawText) {
+  const exitCode = shellCommandExitCode(rawText);
+  if (exitCode != null) {
+    return { isCallError: false, isExitError: true, exitCode };
+  }
+  const isCallError = message?.isError === true || message?.toolKind === 'error';
+  return {
+    isCallError,
+    isExitError: false,
+    exitCode,
+  };
+}
+
+// Build the collapsed failure/exit detail string. Real tool-call/result
+// failures keep the red-adjacent "Failed" wording; shell command-exits render
+// as the distinct neutral "Exit" state ("Exit N" for a single exit, "Y Exit"
+// grouped). A mixed group surfaces both ("1 Ok · 1 Failed · 1 Exit").
+export function failureDetailText({ succeeded = 0, realErrors = 0, exitErrors = 0, exitCode } = {}) {
+  const parts = [];
+  if (succeeded > 0) parts.push(`${succeeded} Ok`);
+  if (realErrors > 0) parts.push(`${realErrors} Failed`);
+  if (exitErrors > 0) {
+    const solo = exitErrors === 1 && realErrors === 0 && succeeded === 0;
+    parts.push(solo && Number.isFinite(exitCode) ? `Exit ${exitCode}` : `${exitErrors} Exit`);
+  }
+  return parts.join(' · ');
+}
+
 export function normalizedResultStatusToken(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 resultTextTerminalStatus(text) {
-  const body = String(text || '');
-  const tagged = body.match(/<status[^>]*>([\s\S]*?)<\/status>/i)?.[1]?.trim();
-  if (tagged) return normalizedResultStatusToken(tagged);
-  const bracketed = body.match(/^\[status:\s*([^\]]*)\]/mi)?.[1]?.trim();
-  if (bracketed) return normalizedResultStatusToken(bracketed);
-  const inline = body.match(/^(?:status|state):\s*([^\s·,;]+)/mi)?.[1]?.trim();
-  return normalizedResultStatusToken(inline);
+  return toolResultTerminalStatus(text);
 }
 
 export function itemHasKnownTerminalStatus(item, texts = []) {
@@ -57,16 +105,18 @@ export function withCancelledResultMarker(text, item) {
 export function groupedToolResultText(group) {
   const completed = Math.min(group.count, group.completed);
   if (group.count <= 1) return group.results.at(-1)?.text ?? '';
-  if (group.errors > 0) {
-    const succeeded = Math.max(0, completed - group.errors);
+  const exitErrors = Number(group.exitErrors || 0);
+  if (group.errors > 0 || exitErrors > 0) {
+    const realErrors = Math.max(0, Number(group.callErrors || group.errors || 0));
+    const succeeded = Math.max(0, completed - group.errors - exitErrors);
+    const exitCode = group.results.find((result) => result?.isExitError)?.exitCode;
+    // Command-exits carry no failure reason line; only real failures do.
     const reasons = group.results
-      .filter((result) => result?.isError)
+      .filter((result) => result?.isError && !result?.isExitError)
       .map((result) => firstErrorLine(result?.text))
       .filter(Boolean);
     const uniqueReasons = [...new Set(reasons)].slice(0, 2);
-    const base = succeeded > 0
-      ? `${succeeded} Ok · ${group.errors} Failed`
-      : `${group.errors} Failed`;
+    const base = failureDetailText({ succeeded, realErrors, exitErrors, exitCode });
     return [
       `${base}${uniqueReasons[0] ? ` · ${uniqueReasons[0]}` : ''}`,
       ...uniqueReasons.slice(1),
@@ -102,7 +152,7 @@ export function aggregateRawResult(calls) {
   return chunks.join('\n\n');
 }
 
-export function aggregateBucketForCategory(category) {
+export function aggregateBucketForCategory(category, { agentBatch = '' } = {}) {
   // Merge consecutive tool calls of the SAME category into one aggregate card;
   // a different category opens a fresh card (no cross-category merge). The
   // bucket key is the category itself, so a run of Search calls collapses into
@@ -117,6 +167,10 @@ export function aggregateBucketForCategory(category) {
   // header still spells out both. State-changing categories (Patch/Shell/…)
   // stay separate.
   if (key === 'Read' || key === 'Search') return 'category:Read+Search';
+  // Agent actions are grouped only inside the provider callback that emitted
+  // them. This keeps a later provider batch from changing an older outbound
+  // card above an intervening result/transcript boundary.
+  if (key === 'Agent') return agentBatch ? `category:Agent:${agentBatch}` : 'category:Agent';
   return key ? `category:${key}` : 'default';
 }
 

package/src/tui/engine/turn.mjs

@@ -6,11 +6,9 @@ import { applyUsageDelta } from './session-stats.mjs';
 import { pickVerb, pickDoneVerb, compactEventLabel, compactEventDetail } from './labels.mjs';
 import { toolResultText, toolErrorDisplay } from './tool-result-text.mjs';
 import { toolCallId, toolResultCallId, toolCallName, toolCallArgs } from './tool-call-fields.mjs';
-import { toolResultStatus, isErrorToolStatus } from './agent-envelope.mjs';
-import { promptDisplayText } from './queue-helpers.mjs';
-import { memoryCoreResultErrorText } from '../app/input-parsers.mjs';
+import { promptDisplayText, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { yieldToRenderer } from './render-timing.mjs';
-import { aggregateRawResult, aggregateBucketForCategory, aggregateSummaries, assignAggregateSummaryOrder } from './tool-result-status.mjs';
+import { aggregateRawResult, aggregateBucketForCategory, aggregateSummaries, assignAggregateSummaryOrder, failureDetailText, toolCallOutcome } from './tool-result-status.mjs';
 
 export function createRunTurn(bag) {
   const {
@@ -42,6 +40,9 @@ export function createRunTurn(bag) {
       reclaimed: false,
       committed: false,
       requeueEntries: Array.isArray(options.requeueOnAbort) ? options.requeueOnAbort.slice() : [],
+      discardExecutionPendingResumeKeys: Array.isArray(options.discardExecutionPendingResumeKeys)
+        ? options.discardExecutionPendingResumeKeys.slice()
+        : [],
     };
     set({ busy: true, lastTurn: null, spinner: { active: true, verb: pickVerb(turnIndex), startedAt, responseLength: 0, inputTokens: 0, outputTokens: 0, mode: 'requesting' } });
 
@@ -130,6 +131,15 @@ export function createRunTurn(bag) {
     };
     armWatchdog();
     let currentAssistantText = '';
+    // Segments sealed as their own assistant item(s) this turn via
+    // commitAssistantSegment (e.g. a tool preamble, then a no-newline tail
+    // committed by onSteerMessage before an injected steering row). Kept as an
+    // ordered list — NOT one concatenated string — so finalization can strip
+    // each committed segment out of the provider's final content individually.
+    // A single concatenation breaks when the provider omits an earlier segment
+    // (e.g. a tool preamble) from result.content: the combined prefix no longer
+    // matches and the tail would duplicate after the steering row.
+    const committedSegments = [];
     let thinkingText = '';
     let thinkingStartedAt = 0;
     let thinkingSegmentStartedAt = 0;
@@ -147,6 +157,7 @@ export function createRunTurn(bag) {
     const earlyResultBuffer = new Map();
     const aggregateCards = []; // active aggregate cards in the current consecutive tool block
     let tailAggregate = null; // most recently touched aggregate card; only the tail may absorb the next same-bucket call
+    let providerToolBatch = 0;
 
     // ── Deferred tool-card push (scroll/text sync) ────────────────────────────
     // A tool card used to enter the transcript the instant onToolCall fired,
@@ -163,13 +174,11 @@ export function createRunTurn(bag) {
     // cards are pushed alongside the result-bearing one before their own delay
     // elapses and would otherwise paint an empty reserved band.
     // Mirrors components/ToolExecution.jsx TOOL_PENDING_SHOW_DELAY_MS.
-    // [jitter fix] Reserve the tool-card row immediately instead of after a
-    // 1000ms delay. Delayed insertion made rows appear late and shove the body
-    // vertically; pushing now (with the real 'Running' header height via
-    // deferredDisplayReady) keeps the layout stable. The timer path is kept as a
-    // 0ms microtask fallback for entries that are registered but not explicitly
-    // surfaced, preserving call-order flush semantics.
-    const TOOL_CARD_PUSH_DELAY_MS = 0;
+    // Keep a fast call off-screen until it either resolves or has genuinely
+    // been pending long enough to communicate work. This avoids a one-frame
+    // Running→Finished flash while preserving the deferred entry's ordered,
+    // result-forced materialization path.
+    const TOOL_CARD_PUSH_DELAY_MS = 1000;
     let deferredSeqCounter = 0;
     const deferredEntries = []; // creation-order list; each is pushed at most once
     // Push this entry AND every earlier-created still-deferred entry, in order,
@@ -328,13 +337,15 @@ export function createRunTurn(bag) {
         aggregate.ensureVisible?.();
         const errors = allCalls.filter((r) => r.isError).length;
         const callErrors = allCalls.filter((r) => r.isCallError).length;
+        const exitErrors = allCalls.filter((r) => r.isExitError).length;
         const completed = allCalls.filter((r) => r.resolved).length;
-        const succeeded = completed - errors;
+        const succeeded = Math.max(0, completed - errors - exitErrors);
         const rawResult = aggregateRawResult(allCalls);
-        // Merged count summary (see patchToolCardResult); failures keep
-        // 'N Ok · N Failed'. Raw preserved for ctrl+o expansion.
-        const displayDetail = errors > 0
-          ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
+        // Merged count summary (see patchToolCardResult); real failures keep
+        // 'N Failed', shell command-exits render 'Exit N'/'Y Exit'. Raw
+        // preserved for ctrl+o expansion.
+        const displayDetail = errors > 0 || exitErrors > 0
+          ? failureDetailText({ succeeded, realErrors: callErrors, exitErrors, exitCode: allCalls.find((r) => r.isExitError)?.exitCode })
           : formatAggregateDetail(aggregateSummaries(aggregate));
         patchItem(aggregate.itemId, {
           result: displayDetail,
@@ -343,6 +354,7 @@ export function createRunTurn(bag) {
           isError: errors > 0,
           errorCount: errors,
           callErrorCount: callErrors,
+          exitErrorCount: exitErrors,
           count: allCalls.length,
           completedCount: allCalls.length,
           doneCategories: aggregateDoneCategories(allCalls),
@@ -463,6 +475,7 @@ export function createRunTurn(bag) {
       if (sealToolBlock) clearAggregateContinuation();
       const id = currentAssistantId || ensureAssistant(text);
       patchItem(id, { text, streaming: false });
+      committedSegments.push(text);
       closeAssistantSegment();
       return true;
     };
@@ -658,35 +671,33 @@ export function createRunTurn(bag) {
         if (!callRec || callRec.resolved || callRec.completedEarly) return;
         aggregate.ensureVisible?.();
         const rawText = toolResultText(message?.content);
-        // Recover flattened memory "core" op failures (isError dropped upstream)
-        // so they are excluded from the done count — see memoryCoreResultErrorText.
-        // 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, callRec.args) === 'Memory';
-        // Same split as tool-card-results.mjs: a REAL tool-call error drives the
-        // red ● dot; command/result failures only mark the card Failed in L2.
-        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;
+        // Tool result text (including HTTP/domain failures, zero matches, task
+        // statuses, and shell output) is detail, not a failed invocation. Only
+        // the provider's isError/error-tool envelope drives failure counts/red.
+        const { exitCode, isExitError, isCallError } = toolCallOutcome(message, rawText);
+        const isError = isCallError;
         const text = isError ? toolErrorDisplay(rawText, callRec.name || 'tool') : rawText;
         callRec.summary = !isError ? summarizeToolResult(callRec.name, callRec.args, rawText, isError) : null;
         assignAggregateSummaryOrder(aggregate, callRec);
         callRec.isError = isError;
         callRec.isCallError = isCallError;
+        callRec.isExitError = isExitError;
+        callRec.exitCode = exitCode;
         callRec.resultText = text;
         callRec.completedEarly = true;
         const allCalls = [...aggregate.calls.values()];
         const completedCount = allCalls.filter((r) => r.resolved || r.completedEarly).length;
         const errors = allCalls.filter((r) => r.isError).length;
         const callErrors = allCalls.filter((r) => r.isCallError).length;
-        const succeeded = completedCount - errors;
+        const exitErrors = allCalls.filter((r) => r.isExitError).length;
+        const succeeded = Math.max(0, completedCount - errors - exitErrors);
         const rawResult = aggregateRawResult(allCalls);
         // Collapsed detail carries the merged per-call count summary even on
         // the early-notify path; patching '' here flipped the detail row back
         // to the 'Running' placeholder between count updates (the visible
         // jitter). Failures keep 'N Failed'. Raw preserved for ctrl+o expansion.
-        const displayDetail = errors > 0
-          ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
+        const displayDetail = 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 visualCompleted = Math.max(
@@ -699,6 +710,7 @@ export function createRunTurn(bag) {
           isError: errors > 0,
           errorCount: errors,
           callErrorCount: callErrors,
+          exitErrorCount: exitErrors,
           count: allCalls.length,
           completedCount: visualCompleted,
         };
@@ -727,15 +739,22 @@ export function createRunTurn(bag) {
         drainSteering: (_sessionId, drainOptions) => (isCurrentTurn() ? drainPendingSteering(drainOptions) : []),
         onSteerMessage: (text) => {
           if (!markTurnProgress('steer-message')) return;
+          // A suppressed live-completion twin is model-visible only; its
+          // Response card was already pushed at delivery time. Skip the
+          // duplicate transcript item (progress is still marked above since
+          // the content WAS injected into the model turn).
+          if (text === STEERING_SUPPRESSED_DISPLAY) return;
           // Steering can be injected after a terminal no-tool response has
           // already streamed but before runTurn finalizes. Seal the current
           // assistant segment first so the steered user turn and the next
           // assistant response do not get visually merged into one bubble.
           flushStreamBatch();
-          if (currentAssistantId) {
-            patchItem(currentAssistantId, { text: currentAssistantText || assistantText, streaming: false });
-            closeAssistantSegment();
-          }
+          // Commit any pending assistant segment — including a streamed tail
+          // that never got a trailing '\n' (no row/currentAssistantId created
+          // yet). Using the shared segment-commit helper ensures that tail is
+          // materialized as an assistant item instead of being dropped when a
+          // steering/agent-completion injection races turn finalization.
+          commitAssistantSegment({ sealToolBlock: true });
           assistantText = '';
           const value = String(text || '').trim();
           if (value) {
@@ -764,6 +783,7 @@ export function createRunTurn(bag) {
           }
           const batchCalls = (calls || []).filter(Boolean);
           if (batchCalls.length === 0) return;
+          const agentBatch = ++providerToolBatch;
           const committedAssistantSegment = commitAssistantSegment({ sealToolBlock: true });
           if (committedAssistantSegment) {
             // Let the pre-tool assistant preamble paint and settle before the
@@ -787,11 +807,10 @@ export function createRunTurn(bag) {
             // Category drives the aggregate bucket so only same-category calls
             // merge into one card; classify first, then bucket by it.
             const category = classifyToolCategory(name, args);
-            // Agent/bridge calls always get their own standalone card so
-            // ToolExecution's isAgentTool/agentActionTitle path renders a
-            // "Spawn <Agent> (model, tag)" header instead of being folded
-            // into the "Called N agent(s)" category-aggregate card.
-            const bucket = category === 'Agent' ? null : aggregateBucketForCategory(category);
+            // Agent actions aggregate only within this provider-emitted batch.
+            // They stay outbound category cards; asynchronous inbound Responses
+            // are separately tailed by the notification feed and never mix here.
+            const bucket = aggregateBucketForCategory(category, { agentBatch });
             const callId = toolCallId(c);
             const callKey = callId || `__tool_${toolCards.length}_${i}`;
             // The old App scan counted multi-pattern calls via
@@ -854,7 +873,7 @@ export function createRunTurn(bag) {
               ...categoryEntry,
               count: Number(prevCategory?.count || 0) + Number(categoryEntry.count || 1),
             });
-            aggregateCard.calls.set(callKey, { name, args, category, summary: null, summarySeq: null, isError: false, isCallError: false, resultText: null, resolved: false, completedEarly: false });
+            aggregateCard.calls.set(callKey, { name, args, category, summary: null, summarySeq: null, isError: false, isCallError: false, isExitError: false, exitCode: null, resultText: null, resolved: false, completedEarly: false });
             touchedAggregates.add(aggregateCard);
             const card = { itemId: aggregateCard.itemId, callId: callKey, done: false, aggregate: aggregateCard };
             if (callId) {
@@ -1038,16 +1057,37 @@ export function createRunTurn(bag) {
         syncContextStats({ allowEstimated: true });
 
         const finalText = result?.content != null ? String(result.content) : '';
-        if (finalText.trim()) {
+        // Strip text already sealed as its own item(s) this turn (a tool
+        // preamble, then a no-newline tail committed by onSteerMessage before an
+        // injected steering row) so finalization reconciles only the uncommitted
+        // remainder — never re-creating a committed segment as a duplicate item
+        // that also reorders after the steering row. Walk the segments IN ORDER,
+        // peeling each off the front of the remaining content; skip leading
+        // whitespace/newlines between segments. A segment that does not match at
+        // the current position (provider omitted it from result.content, e.g. a
+        // tool preamble) is left in place and the walk moves on.
+        let finalRemainder = finalText;
+        for (const seg of committedSegments) {
+          // Compare against the whitespace-skipped remainder AND a
+          // whitespace-trimmed segment: a segment sealed with its own leading
+          // newline ('\nTAIL') would otherwise never match the skipped remainder
+          // ('TAIL') and duplicate after the steering row.
+          const skipped = finalRemainder.replace(/^\s+/, '');
+          const trimmedSeg = seg ? seg.replace(/^\s+/, '') : '';
+          if (trimmedSeg && skipped.startsWith(trimmedSeg)) {
+            finalRemainder = skipped.slice(trimmedSeg.length);
+          }
+        }
+        if (finalRemainder.trim()) {
           // The persisted transcript is written from the provider's final content,
           // while the live TUI row is fed by streaming deltas. If a provider/parser
           // misses or suppresses an early delta, keeping the streamed buffer here
           // leaves the final on-screen assistant row missing leading characters even
           // though the transcript is correct. Always reconcile the active segment to
           // the final provider text when it is available.
-          const id = currentAssistantId || ensureAssistant(finalText);
-          currentAssistantText = finalText;
-          patchItem(id, { text: finalText, streaming: false });
+          const id = currentAssistantId || ensureAssistant(finalRemainder);
+          currentAssistantText = finalRemainder;
+          patchItem(id, { text: finalRemainder, streaming: false });
         } else if (currentAssistantId && (currentAssistantText.trim() || assistantText.trim())) {
           const streamedText = currentAssistantText || assistantText;
           patchItem(currentAssistantId, { text: streamedText, streaming: false });