mixdog 0.9.38 → 0.9.39

package/src/tui/dist/index.mjs

@@ -1976,10 +1976,11 @@ function bridgeAgentModelSummary(args) {
   ]);
 }
 function summarizeLineWindow(a) {
+  const hasOffset = a.offset != null;
   const offset = a.offset ?? a.start_line ?? a.startLine ?? a.line;
   const limit = a.limit ?? a.line_count ?? a.lineCount ?? a.lines;
   if (offset == null && limit == null) return "";
-  const start = Number(offset);
+  const start = Number(offset) + (hasOffset ? 1 : 0);
   const count = Number(limit);
   if (Number.isFinite(start) && Number.isFinite(count) && count > 0) {
     return `lines ${start}-${Math.max(start, start + count - 1)}`;
@@ -2839,7 +2840,9 @@ function toolWorkUnit(name, args = {}, category = "") {
     case "read_mcp_resource":
       return unitDescriptor("Read", { count: queryCount(a, "uri", "uris") || 1, noun: "resource" });
     case "apply_patch": {
-      const creating = a.old_string === "";
+      const patchText = String(a.patch ?? "");
+      const creating = a.old_string === "" || /^\*\*\*\s+Add File:/mi.test(patchText);
+      const deleting = !creating && a.new_string === "" && a.old_string != null || /^\*\*\*\s+Delete File:/mi.test(patchText);
       if (a.dry_run === true) {
         return unitDescriptor("Patch", {
           count: patchFileCount(a) || 1,
@@ -2850,8 +2853,8 @@ function toolWorkUnit(name, args = {}, category = "") {
       }
       return unitDescriptor("Patch", {
         count: patchFileCount(a) || 1,
-        active: creating ? "Creating" : "Editing",
-        done: creating ? "Created" : "Edited",
+        active: creating ? "Creating" : deleting ? "Deleting" : "Editing",
+        done: creating ? "Created" : deleting ? "Deleted" : "Edited",
         noun: "file"
       });
     }
@@ -10233,6 +10236,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 || "");
@@ -12383,10 +12387,11 @@ var compareModelRecency = (a, b) => {
   }
   const ta = releaseTime(a);
   const tb = releaseTime(b);
-  if (ta !== tb) return tb - ta;
-  if (!!a?.latest !== !!b?.latest) return a?.latest ? -1 : 1;
   const versionDelta = compareModelVersion(a, b);
+  if (ta > 0 && tb > 0 && ta !== tb) return tb - ta;
   if (versionDelta) return versionDelta;
+  if (!!a?.latest !== !!b?.latest) return a?.latest ? -1 : 1;
+  if (ta !== tb) return tb - ta;
   return String(a?.display || a?.id || "").localeCompare(String(b?.display || b?.id || ""));
 };
 var modelFamily = (m) => {
@@ -15835,11 +15840,9 @@ function createModelPicker({
     setChannelPrompt(null);
     setHookPrompt(null);
     setSettingsPrompt(null);
-    const modelPickerRequest = ++modelPickerRequestRef.current;
+    modelPickerRequestRef.current += 1;
     let modelPickerClosed = false;
-    let activeModelProvider = null;
     let providerListHighlightProvider = null;
-    const isActiveModelPicker = () => !modelPickerClosed && modelPickerRequestRef.current === modelPickerRequest;
     const returnTo = typeof options.returnTo === "function" ? options.returnTo : null;
     const returnLabel = String(options.returnLabel || "Agents");
     const returnOnNestedCancel = options.returnOnNestedCancel === true;
@@ -15853,7 +15856,6 @@ function createModelPicker({
     let providerModels = Array.isArray(cacheRef.current.models) ? cacheRef.current.models : [];
     let refreshModelsPromise = null;
     let renderedQuickModels = false;
-    let renderActiveProviderModels = null;
     if (!providerModels.length || options.refreshModels === true) {
       setPicker({
         title: options.title || "Model",
@@ -15904,16 +15906,12 @@ function createModelPicker({
         providerListHighlightProvider = renderOptions.highlightProvider;
       }
       const highlightProvider = renderOptions.highlightProvider || providerListHighlightProvider || null;
-      activeModelProvider = null;
-      renderActiveProviderModels = null;
       const openProviderModelsPicker = (provider) => {
         if (!provider) return;
-        activeModelProvider = provider;
-        renderActiveProviderModels = () => openProviderModelsPicker(provider);
         const providerModels2 = models.filter((model) => model.provider === provider);
         const preferredEffort = (values = []) => {
           const allowed = values.filter(Boolean);
-          for (const value of ["high", "medium", "low", "none", "xhigh", "max"]) {
+          for (const value of ["high", "medium", "low", "none", "xhigh", "max", "ultra"]) {
             if (allowed.includes(value)) return value;
           }
           return allowed[0] || null;
@@ -15986,6 +15984,7 @@ ${model?.id || ""}`;
           if (value === "medium") return "\u25D1";
           if (value === "high") return "\u25D5";
           if (value === "max") return "\u25C6";
+          if (value === "ultra") return "\u2726";
           return "\u25CF";
         };
         const effortColor = (value) => {
@@ -15994,6 +15993,7 @@ ${model?.id || ""}`;
           if (value === "medium") return theme.claude;
           if (value === "high") return theme.error;
           if (value === "max") return theme.permission;
+          if (value === "ultra") return theme.permission;
           return theme.error;
         };
         const modelFooter = (model = null) => {
@@ -16128,33 +16128,23 @@ ${model?.id || ""}`;
       });
     };
     renderModelPicker();
-    const applyFreshModels = (freshModels) => {
-      if (!isActiveModelPicker()) return;
+    const adoptFreshModels = (freshModels) => {
       if (!Array.isArray(freshModels) || freshModels.length === 0) return;
-      providerModels = freshModels;
-      models = normalizeModelOptions(providerModels);
-      cacheRef.current = { models: providerModels, at: Date.now() };
-      if (activeModelProvider === null) {
-        renderModelPicker();
-      } else if (typeof renderActiveProviderModels === "function") {
-        renderActiveProviderModels();
-      }
+      cacheRef.current = { models: freshModels, at: Date.now() };
     };
     if (renderedQuickModels && refreshModelsPromise) {
-      void refreshModelsPromise.then(applyFreshModels).catch(() => {
+      void refreshModelsPromise.then(adoptFreshModels).catch(() => {
       });
     } else if (cacheIsStale) {
       if (!providerModelsTtlRefreshPromise) {
         providerModelsTtlRefreshPromise = Promise.resolve(loadModels({ force: true })).then((freshModels) => {
-          if (Array.isArray(freshModels) && freshModels.length > 0) {
-            cacheRef.current = { models: freshModels, at: Date.now() };
-          }
+          adoptFreshModels(freshModels);
           return freshModels;
         }).finally(() => {
           providerModelsTtlRefreshPromise = null;
         });
       }
-      void providerModelsTtlRefreshPromise.then(applyFreshModels).catch(() => {
+      void providerModelsTtlRefreshPromise.catch(() => {
       });
     }
   };
@@ -18531,6 +18521,29 @@ import stringWidth9 from "string-width";
 
 // src/tui/components/tool-execution/text-format.mjs
 import stripAnsi6 from "strip-ansi";
+
+// src/runtime/shared/tool-status.mjs
+function normalizeToolTerminalStatus(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";
+  if (/^(denied|deny|refused|rejected)$/.test(raw)) return "denied";
+  return "";
+}
+function toolResultTerminalStatus(text) {
+  const body = String(text || "");
+  const tagged = body.match(/<status[^>]*>([\s\S]*?)<\/status>/i)?.[1]?.trim();
+  if (tagged) return normalizeToolTerminalStatus(tagged);
+  const bracketed = body.match(/^\[status:\s*([^\]]*)\]/mi)?.[1]?.trim();
+  if (bracketed) return normalizeToolTerminalStatus(bracketed);
+  const inline = body.match(/^(?:status|state):\s*([^\s·,;]+)/mi)?.[1]?.trim();
+  return normalizeToolTerminalStatus(inline);
+}
+
+// src/tui/components/tool-execution/text-format.mjs
 var MIN_RESULT_LINE_CHARS = 24;
 var RESULT_LINE_HARD_MAX = 80;
 var SUMMARY_MAX_CHARS = 48;
@@ -18600,30 +18613,20 @@ function shellResultStatus(value) {
   return match ? String(match[1] || "").toLowerCase() : "";
 }
 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);
 }
 function displayTerminalStatus(value) {
+  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 "";
 }
 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);
-  const inline = text.match(/^(?:status|state):\s*([^\s·,;]+)/mi)?.[1]?.trim();
-  return normalizeTerminalStatus(inline);
+  return toolResultTerminalStatus(value);
 }
 var LEADING_STATUS_MARKER_LINE_RE2 = /^\[status:\s*[^\]]*\]\s*$/i;
 function stripLeadingStatusMarkerLines(lines) {
@@ -18647,11 +18650,15 @@ function isShellTool(normalizedName, label = "") {
   const l = String(label || "").toLowerCase();
   return n === "shell" || n === "bash" || n === "bash_session" || n === "shell_command" || n === "job_wait" || l === "run";
 }
-function shellDisplayStatus({ pending = false, failedCount = 0, isError = false, result = "" } = {}) {
+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";
+  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";
 }
 function shellHeader(status, count = 1) {
@@ -18707,7 +18714,9 @@ function withModelAndTag(label, args) {
 function joinActionAgent(action, agent) {
   return agent ? `${action} ${agent}` : action;
 }
-function agentResponseTitle(args) {
+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 || "");
   return withModelAndTag(joinActionAgent("Response", name), args);
 }
@@ -18962,13 +18971,17 @@ function clampFailureCount(errorCount, groupCount, isError) {
   if (Number.isFinite(explicit)) return Math.max(0, Math.min(groupCount, Math.floor(explicit)));
   return isError ? groupCount : 0;
 }
-function toolStatusColor({ pending, groupCount, callFailedCount = 0, terminalStatus = "" }) {
+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;
+  }
+  if (exitFailedCount > 0) return theme.warning;
+  return theme.success;
 }
 
 // src/tui/components/tool-execution/ResultBody.jsx
@@ -18999,7 +19012,7 @@ var TOOL_ANIM_TICK_MS = TOOL_BLINK_MS;
 function statusCopy(name, label, count, doneCount, pending, isError, args = {}) {
   return formatToolActionHeader(name, args, { pending, count });
 }
-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 }) {
+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))));
@@ -19023,6 +19036,7 @@ function ToolExecution({ name, args, result, rawResult, isError, errorCount, cal
   const elapsed = elapsedMs >= 1e3 ? formatElapsed(elapsedMs) : "";
   const failedCount = clampFailureCount(errorCount, groupCount, isError);
   const callFailedCount = clampFailureCount(callErrorCount, groupCount, false);
+  const exitFailedCount = clampFailureCount(exitErrorCount, groupCount, false);
   const displayGroupCount = groupCount;
   const displayCategories = normalizeCountMap(categories || {});
   const normalizedDoneCategories = doneCategories ? normalizeCountMap(doneCategories) : displayCategories;
@@ -19048,7 +19062,7 @@ function ToolExecution({ name, args, result, rawResult, isError, errorCount, cal
       detailText = "";
     }
     const aggregateTerminalStatus = pending ? "running" : resultTerminalStatus(rt) || (isError || failedCount > 0 ? "failed" : "completed");
-    const dotColor2 = toolStatusColor({ pending, groupCount, callFailedCount, terminalStatus: aggregateTerminalStatus });
+    const dotColor2 = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus: aggregateTerminalStatus });
     const dotText2 = pending && !blinkOn ? " " : TURN_MARKER;
     const gutter2 = 2;
     const showHeaderExpandHint2 = hasRawResult;
@@ -19103,7 +19117,7 @@ function ToolExecution({ name, args, result, rawResult, isError, errorCount, cal
   const firstResultLine = hasDisplayResult ? String(lines[0] ?? "") : "";
   const firstResultLineClipped = hasDisplayBody && stringWidth9(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) : isBackgroundTaskTool(normalizedName) ? backgroundTaskElapsed(parsedArgs, elapsed) : "";
   const toolArgPath = parsedArgs?.path ?? parsedArgs?.file_path ?? parsedArgs?.file ?? "";
@@ -19128,7 +19142,7 @@ function ToolExecution({ name, args, result, rawResult, isError, errorCount, cal
   const collapsedDetail = pending ? pendingDetailPlaceholder : isShellSurface ? prefixElapsed(mergeTerminalDetail(shellStatus, shellCollapsedSummary), shellElapsed) : mergeTerminalDetail(terminalStatus, nonShellDetail);
   const backgroundMetadataExpandable = isBackgroundMetadataResult && hasRawResult && !pending;
   const showRawResult = expanded && (hasDisplayBody || hasRawResult) && (!isBackgroundMetadataResult || hasRawResult);
-  const detailLines = showRawResult ? hasDisplayBody ? lines : rawRt ? stripLeadingStatusMarkerLines(rawRt.split("\n")) : [] : collapsedDetail ? [collapsedDetail] : [];
+  const detailLines = showRawResult ? 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;
   const isAgentResult = !isBackgroundResult && !pending && isAgentTool(normalizedName) && hasDisplayResult;
@@ -19148,14 +19162,14 @@ function ToolExecution({ name, args, result, rawResult, isError, errorCount, cal
     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;
   const markerGlyph = isAgentResponse ? AGENT_RESPONSE_MARKER : isAgentSurfaceCard ? AGENT_CALL_MARKER : TURN_MARKER;
   const isDirectionalMarker = isAgentResponse || isAgentSurfaceCard;
   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);
@@ -19364,7 +19378,7 @@ var Item = React19.memo(function Item2({ item, prevKind, columns, toolOutputExpa
         node = /* @__PURE__ */ jsx19(ToolHookDenialCard, { item, columns });
         break;
       }
-      node = /* @__PURE__ */ jsx19(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, 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 = /* @__PURE__ */ jsx19(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, 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":
@@ -19672,6 +19686,32 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
       searchModelsCacheRef.current = { models: null, at: 0 };
     }
   }, []);
+  useEffect10(() => {
+    let alive = true;
+    const timer2 = setTimeout(async () => {
+      const seq = onboardingPrefetchSeqRef.current;
+      try {
+        const models = await Promise.resolve(store.listProviderModels?.() || []);
+        if (alive && seq === onboardingPrefetchSeqRef.current && Array.isArray(models) && models.length > 0 && !Array.isArray(providerModelsCacheRef.current.models)) {
+          providerModelsCacheRef.current = { models, at: Date.now() };
+        }
+      } catch {
+      }
+      if (!alive) return;
+      try {
+        const searchModels = await Promise.resolve(store.listSearchModels?.() || []);
+        if (alive && Array.isArray(searchModels) && searchModels.length > 0 && !Array.isArray(searchModelsCacheRef.current.models)) {
+          searchModelsCacheRef.current = { models: searchModels, at: Date.now() };
+        }
+      } catch {
+      }
+    }, 1500);
+    timer2.unref?.();
+    return () => {
+      alive = false;
+      clearTimeout(timer2);
+    };
+  }, [store]);
   const { onboardingWarnReopen, openOnboardingAuthStep } = createOnboardingSteps({
     store,
     setPicker,
@@ -22507,18 +22547,6 @@ function bracketField(text, name) {
   const re = new RegExp(`^\\[${name}:\\s*([^\\]]*)\\]`, "mi");
   return re.exec(String(text ?? ""))?.[1]?.trim() || "";
 }
-function toolResultStatus(text) {
-  const value = String(text ?? "");
-  const tagged = textBetweenTag2(value, "status");
-  if (tagged) return tagged.trim();
-  const bracketed = bracketField(value, "status");
-  if (bracketed) return bracketed.trim();
-  const inline = /^(?:status|state):\s*([^\s·,;]+)/mi.exec(value);
-  return inline ? inline[1].trim() : "";
-}
-function isErrorToolStatus(status) {
-  return /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(String(status || "").trim());
-}
 function parseSyntheticAgentMessage(text) {
   const value = String(text ?? "").trim();
   if (!value) return null;
@@ -22771,6 +22799,13 @@ function notificationQueueKey(event, text, parsed) {
   const hasBody = /\n\s*\n[\s\S]*\S/.test(String(text || "")) ? "b1" : "b0";
   return [id, type || fallbackKind, status, hasBody].filter(Boolean).join(":");
 }
+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}`;
+}
 function isExecutionNotification(event, text, parsed) {
   const meta = event?.meta && typeof event.meta === "object" ? event.meta : {};
   if (meta.execution_id || meta.execution_surface) return true;
@@ -22869,23 +22904,43 @@ var yieldToRenderer = ({ frames = 1 } = {}) => new Promise((resolve5) => {
 
 // src/tui/engine/tool-result-status.mjs
 var CANCELLED_RESULT_STATUS_LINE = "[status: cancelled]";
+function shellCommandExitCode(text) {
+  const body = String(text || "");
+  if (!/^\s*(?:Error:\s*)?\[shell-run-failed\]/i.test(body)) return null;
+  const header = body.split("\n", 1)[0] || "";
+  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;
+}
+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
+  };
+}
+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(" \xB7 ");
+}
 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);
 }
 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);
 }
 function itemHasKnownTerminalStatus(item, texts = []) {
   const settled = (token) => token === "completed" || token === "failed" || token === "cancelled";
@@ -22907,11 +22962,14 @@ ${body}`;
 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 reasons = group.results.filter((result) => result?.isError).map((result) => firstErrorLine(result?.text)).filter(Boolean);
+  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;
+    const reasons = group.results.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 \xB7 ${group.errors} Failed` : `${group.errors} Failed`;
+    const base = failureDetailText({ succeeded, realErrors, exitErrors, exitCode });
     return [
       `${base}${uniqueReasons[0] ? ` \xB7 ${uniqueReasons[0]}` : ""}`,
       ...uniqueReasons.slice(1)
@@ -22945,9 +23003,10 @@ ${text}`);
   }
   return chunks.join("\n\n");
 }
-function aggregateBucketForCategory(category) {
+function aggregateBucketForCategory(category, { agentBatch = "" } = {}) {
   const key = String(category || "").trim();
   if (key === "Read" || key === "Search") return "category:Read+Search";
+  if (key === "Agent") return agentBatch ? `category:Agent:${agentBatch}` : "category:Agent";
   return key ? `category:${key}` : "default";
 }
 function aggregateSummaries(aggregate) {
@@ -23066,6 +23125,12 @@ function createToolCardResults({
   buildAgentJobCardPatch,
   agentStatusState
 }) {
+  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);
@@ -23083,10 +23148,8 @@ function createToolCardResults({
     const rawText = toolResultText(message?.content);
     const aggregate = card.aggregate;
     const callRec = aggregate && callId ? aggregate.calls.get(callId) : null;
-    const isMemoryCall = classifyToolCategory(callRec?.name || card?.name || "", callRec?.args || {}) === "Memory";
-    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;
+    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) {
       if (!callRec) return false;
@@ -23099,14 +23162,17 @@ 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 succeeded = completed - errors;
-      const detailText = errors > 0 ? succeeded > 0 ? `${succeeded} Ok \xB7 ${errors} Failed` : `${errors} Failed` : formatAggregateDetail(aggregateSummaries(aggregate));
+      const exitErrors = allCalls.filter((r) => r.isExitError).length;
+      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;
       const visualCompleted = Math.max(completed, earlyCompleted, Math.min(allCalls.length, Number(currentItem?.completedCount || 0)));
@@ -23119,6 +23185,7 @@ function createToolCardResults({
         isError: errors > 0,
         errorCount: errors,
         callErrorCount: callErrors,
+        exitErrorCount: exitErrors,
         count: allCalls.length,
         completedCount: visualCompleted,
         doneCategories: aggregateDoneCategories(allCalls),
@@ -23128,20 +23195,25 @@ function createToolCardResults({
       if (callId) done.add(callId);
       return true;
     }
-    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()
@@ -23154,6 +23226,9 @@ function createToolCardResults({
         set(agentStatusState({ force: true }));
       }
       Object.assign(patch, buildAgentJobCardPatch(card.itemId, rawText, isError));
+      if (group.errors > 0 && !String(patch.result || "").trim()) {
+        patch.result = patch.text = finalizedErrorFallbackBody(patch.result, text, exitCode);
+      }
     }
     patchToolItem(card.itemId, patch);
     card.done = true;
@@ -23204,9 +23279,10 @@ 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);
-        let displayDetail = errors > 0 ? succeeded > 0 ? `${succeeded} Ok \xB7 ${errors} Failed` : `${errors} Failed` : formatAggregateDetail(aggregateSummaries(aggregate));
+        let displayDetail = errors > 0 || exitErrors > 0 ? failureDetailText({ succeeded, realErrors: callErrors, exitErrors, exitCode: allCalls.find((r) => r.isExitError)?.exitCode }) : formatAggregateDetail(aggregateSummaries(aggregate));
         if (cancelled) {
           const currentItem = getState().items.find((it) => it.id === card.itemId);
           displayDetail = withCancelledResultMarker(displayDetail, currentItem);
@@ -23218,6 +23294,7 @@ function createToolCardResults({
           isError: errors > 0,
           errorCount: errors,
           callErrorCount: callErrors,
+          exitErrorCount: exitErrors,
           count: allCalls.length,
           completedCount: totalCompleted,
           doneCategories: aggregateDoneCategories(allCalls),
@@ -23230,15 +23307,19 @@ function createToolCardResults({
         }
         continue;
       }
-      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);
     }
@@ -23246,6 +23327,73 @@ function createToolCardResults({
   return { patchToolCardResult, flushToolResults };
 }
 
+// src/runtime/agent/orchestrator/session/manager/delivered-completions.mjs
+import { createHash as createHash3 } from "node:crypto";
+var DELIVERED_TTL_MS = 6 * 60 * 60 * 1e3;
+var DELIVERED_MAX_ENTRIES = 512;
+var _delivered = /* @__PURE__ */ new Map();
+function hashCompletionText(text) {
+  const value = String(text ?? "").trim();
+  if (!value) return null;
+  return createHash3("sha1").update(value).digest("hex");
+}
+function execKey(executionId) {
+  const id = executionId == null ? "" : String(executionId).trim();
+  return id ? `id:${id}` : null;
+}
+function textKey(text) {
+  const h = hashCompletionText(text);
+  return h ? `tx:${h}` : null;
+}
+function pruneExpired(now) {
+  for (const [key, expiresAt] of _delivered) {
+    if (expiresAt <= now) _delivered.delete(key);
+  }
+}
+function enforceBound() {
+  while (_delivered.size > DELIVERED_MAX_ENTRIES) {
+    const oldest = _delivered.keys().next().value;
+    if (oldest === void 0) break;
+    _delivered.delete(oldest);
+  }
+}
+function recordDeliveredCompletion({ executionId, text } = {}) {
+  const now = Date.now();
+  pruneExpired(now);
+  const expiresAt = now + DELIVERED_TTL_MS;
+  let recorded = false;
+  for (const key of [execKey(executionId), textKey(text)]) {
+    if (!key) continue;
+    _delivered.delete(key);
+    _delivered.set(key, expiresAt);
+    recorded = true;
+  }
+  if (recorded) enforceBound();
+  return recorded;
+}
+function isDeliveredCompletion({ executionId, text } = {}) {
+  const now = Date.now();
+  const keys = [execKey(executionId), textKey(text)].filter(Boolean);
+  let hit = false;
+  for (const key of keys) {
+    const expiresAt2 = _delivered.get(key);
+    if (expiresAt2 === void 0) continue;
+    if (expiresAt2 <= now) {
+      _delivered.delete(key);
+      continue;
+    }
+    hit = true;
+  }
+  if (!hit) return false;
+  const expiresAt = now + DELIVERED_TTL_MS;
+  for (const key of keys) {
+    if (!_delivered.has(key)) continue;
+    _delivered.delete(key);
+    _delivered.set(key, expiresAt);
+  }
+  return true;
+}
+
 // src/tui/engine/agent-job-feed.mjs
 function parseInboundImagePaths(raw) {
   if (typeof raw !== "string" || !raw) return [];
@@ -23266,16 +23414,58 @@ function createAgentJobFeed({
   enqueue,
   drain,
   pushUserOrSyntheticItem,
+  pushAsyncAgentResponse,
   makeQueueEntry,
   getPending,
   agentStatusState,
   displayedExecutionNotificationKeys,
-  pushNotice
+  pushNotice,
+  now = () => Date.now(),
+  executionResumeTombstoneTtlMs = 3e4,
+  executionResumeTombstoneLimit = 128
 }) {
   let executionResumeKickDeferred = false;
+  const discardedExecutionResumeKeys = /* @__PURE__ */ new Map();
+  const displayedExecutionResponseStates = /* @__PURE__ */ new Map();
   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) || 3e4);
+    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;
@@ -23287,16 +23477,34 @@ function createAgentJobFeed({
       return;
     }
     executionResumeKickDeferred = false;
-    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: key2 }) => key2).filter(Boolean);
+    pending.push(makeQueueEntry(resumeBody, {
+      mode: "pending-resume",
+      priority: "next",
+      abortDiscardOnAbort: true,
+      resumeCompletionKeys
+    }));
     void drain();
   }
   function flushDeferredExecutionPendingResumeKick() {
     if (!executionResumeKickDeferred || getDisposed() || getState().busy) return;
     kickExecutionPendingResume();
   }
-  function scheduleExecutionPendingResumeKick(body = "") {
-    queueMicrotask(() => kickExecutionPendingResume(body));
+  function scheduleExecutionPendingResumeKick(body = "", completionKey = "") {
+    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;
   }
   function buildAgentJobCardPatch(itemId, text, isError = false) {
     const parsed = parseAgentJob(text);
@@ -23314,6 +23522,12 @@ function createAgentJobFeed({
   function updateAgentJobCard(itemId, text, isError = false) {
     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 } : void 0));
+  }
   function subscribeRuntimeNotifications() {
     if (typeof runtime.onNotification !== "function") return null;
     return runtime.onNotification((event) => {
@@ -23329,38 +23543,53 @@ 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, nextId2());
+        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");
+          (pushAsyncAgentResponse || pushUserOrSyntheticItem)(delivery.displayText, nextId2(), "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);
+          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 || void 0,
+            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
           });
+          if (enqueued) recordDeliveredCompletion({ executionId, text: resumeBody });
           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;
@@ -23403,12 +23632,68 @@ function createAgentJobFeed({
     kickExecutionPendingResume,
     flushDeferredExecutionPendingResumeKick,
     scheduleExecutionPendingResumeKick,
+    discardExecutionPendingResume,
     updateAgentJobCard,
     buildAgentJobCardPatch,
     subscribeRuntimeNotifications
   };
 }
 
+// src/tui/engine/agent-response-tail.mjs
+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
+  };
+}
+function formatAgentResponseRaw(entries = []) {
+  return entries.map((entry, index) => {
+    const raw = String(entry?.raw || "").trim();
+    return raw ? `${index + 1}. agent
+${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
+  })];
+}
+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) {
+    entries[existingIndex] = next;
+  } else {
+    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
+  };
+}
+
 // src/tui/engine/tui-steering-persist.mjs
 import { randomBytes as randomBytes3 } from "crypto";
 import { join as join8 } from "path";
@@ -23778,6 +24063,10 @@ 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
     };
@@ -23893,6 +24182,13 @@ function createSessionFlow(bag) {
           pushUserOrSyntheticItem(entry.text, entry.id, isQueuedEntryEditable(entry) ? "user" : "injected");
         }
         const nonEditable = batch.filter((entry) => !isQueuedEntryEditable(entry));
+        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, {
@@ -23902,7 +24198,8 @@ function createSessionFlow(bag) {
           onCommitted: () => commitSteeringQueueEntries(batch),
           submittedIds: [...ids],
           restorable: nonEditable.length === 0,
-          requeueOnAbort: nonEditable
+          requeueOnAbort,
+          discardExecutionPendingResumeKeys
         });
         if (flags.drainEpoch !== drainEpoch) return;
         flushDeferredClearedSessionUi();
@@ -24250,7 +24547,8 @@ function createRunTurn(bag) {
       submittedIds,
       reclaimed: false,
       committed: false,
-      requeueEntries: Array.isArray(options.requeueOnAbort) ? options.requeueOnAbort.slice() : []
+      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" } });
     let assistantText = "";
@@ -24333,6 +24631,7 @@ function createRunTurn(bag) {
     };
     armWatchdog();
     let currentAssistantText = "";
+    const committedSegments = [];
     let thinkingText = "";
     let thinkingStartedAt = 0;
     let thinkingSegmentStartedAt = 0;
@@ -24348,7 +24647,8 @@ function createRunTurn(bag) {
     const earlyResultBuffer = /* @__PURE__ */ new Map();
     const aggregateCards = [];
     let tailAggregate = null;
-    const TOOL_CARD_PUSH_DELAY_MS = 0;
+    let providerToolBatch = 0;
+    const TOOL_CARD_PUSH_DELAY_MS = 1e3;
     let deferredSeqCounter = 0;
     const deferredEntries = [];
     const flushDeferredUpTo = (entry) => {
@@ -24515,10 +24815,11 @@ 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);
-        const displayDetail = errors > 0 ? succeeded > 0 ? `${succeeded} Ok \xB7 ${errors} Failed` : `${errors} Failed` : formatAggregateDetail(aggregateSummaries(aggregate));
+        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,
           text: displayDetail,
@@ -24526,6 +24827,7 @@ function createRunTurn(bag) {
           isError: errors > 0,
           errorCount: errors,
           callErrorCount: callErrors,
+          exitErrorCount: exitErrors,
           count: allCalls.length,
           completedCount: allCalls.length,
           doneCategories: aggregateDoneCategories(allCalls),
@@ -24616,6 +24918,7 @@ function createRunTurn(bag) {
       if (sealToolBlock) clearAggregateContinuation();
       const id = currentAssistantId || ensureAssistant(text);
       patchItem(id, { text, streaming: false });
+      committedSegments.push(text);
       closeAssistantSegment();
       return true;
     };
@@ -24732,24 +25035,25 @@ function createRunTurn(bag) {
         if (!callRec || callRec.resolved || callRec.completedEarly) return;
         aggregate.ensureVisible?.();
         const rawText = toolResultText(message?.content);
-        const isMemoryCall = classifyToolCategory(callRec.name, callRec.args) === "Memory";
-        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;
+        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);
-        const displayDetail = errors > 0 ? succeeded > 0 ? `${succeeded} Ok \xB7 ${errors} Failed` : `${errors} Failed` : formatAggregateDetail(aggregateSummaries(aggregate));
+        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(
           completedCount,
@@ -24761,6 +25065,7 @@ function createRunTurn(bag) {
           isError: errors > 0,
           errorCount: errors,
           callErrorCount: callErrors,
+          exitErrorCount: exitErrors,
           count: allCalls.length,
           completedCount: visualCompleted
         };
@@ -24786,10 +25091,7 @@ function createRunTurn(bag) {
           if (!markTurnProgress("steer-message")) return;
           if (text === STEERING_SUPPRESSED_DISPLAY) return;
           flushStreamBatch();
-          if (currentAssistantId) {
-            patchItem(currentAssistantId, { text: currentAssistantText || assistantText, streaming: false });
-            closeAssistantSegment();
-          }
+          commitAssistantSegment({ sealToolBlock: true });
           assistantText = "";
           const value = String(text || "").trim();
           if (value) {
@@ -24810,6 +25112,7 @@ function createRunTurn(bag) {
           }
           const batchCalls = (calls || []).filter(Boolean);
           if (batchCalls.length === 0) return;
+          const agentBatch = ++providerToolBatch;
           const committedAssistantSegment = commitAssistantSegment({ sealToolBlock: true });
           if (committedAssistantSegment) {
             await yieldToRenderer({ frames: 2 });
@@ -24822,7 +25125,7 @@ function createRunTurn(bag) {
             const name = toolCallName(c);
             const args = toolCallArgs(c);
             const category = classifyToolCategory(name, args);
-            const bucket = category === "Agent" ? null : aggregateBucketForCategory(category);
+            const bucket = aggregateBucketForCategory(category, { agentBatch });
             const callId = toolCallId(c);
             const callKey = callId || `__tool_${toolCards.length}_${i}`;
             const activeCount = Number(aggregateToolCategoryEntry(name, args, category)?.count || 1);
@@ -24865,7 +25168,7 @@ 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) {
@@ -25013,10 +25316,18 @@ function createRunTurn(bag) {
         flushStreamBatch();
         syncContextStats({ allowEstimated: true });
         const finalText = result?.content != null ? String(result.content) : "";
-        if (finalText.trim()) {
-          const id = currentAssistantId || ensureAssistant(finalText);
-          currentAssistantText = finalText;
-          patchItem(id, { text: finalText, streaming: false });
+        let finalRemainder = finalText;
+        for (const seg of committedSegments) {
+          const skipped = finalRemainder.replace(/^\s+/, "");
+          const trimmedSeg = seg ? seg.replace(/^\s+/, "") : "";
+          if (trimmedSeg && skipped.startsWith(trimmedSeg)) {
+            finalRemainder = skipped.slice(trimmedSeg.length);
+          }
+        }
+        if (finalRemainder.trim()) {
+          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 });
@@ -25807,7 +26118,8 @@ function createEngineApiA(bag) {
     restoreQueued,
     resetStatsAndSyncContext,
     drain,
-    flushDeferredExecutionPendingResumeKick
+    flushDeferredExecutionPendingResumeKick,
+    discardExecutionPendingResume
   } = bag;
   return {
     getState: () => getState(),
@@ -26301,9 +26613,14 @@ function createEngineApiA(bag) {
       const restorePastedTexts = canRestore && restoreState?.pastedTexts ? restoreState.pastedTexts : null;
       const discardPastedImages = restoreState?.restorable && hasPendingSteering && restoreState?.pastedImages ? restoreState.pastedImages : null;
       const discardPastedTexts = restoreState?.restorable && hasPendingSteering && restoreState?.pastedTexts ? restoreState.pastedTexts : null;
-      const requeueEntries = restoreState && !restoreState.committed && Array.isArray(restoreState.requeueEntries) ? restoreState.requeueEntries.slice() : [];
+      const requeueEntries = restoreState && !restoreState.committed && Array.isArray(restoreState.requeueEntries) ? 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));
@@ -26319,6 +26636,7 @@ function createEngineApiA(bag) {
         }
         restoreState.restorable = false;
         restoreState.requeueEntries = [];
+        restoreState.discardExecutionPendingResumeKeys = [];
       }
       const abortEpoch = flags.leadTurnEpoch;
       const recoveryMs = Number(flags.manualAbortRecoveryMs) > 0 ? Number(flags.manualAbortRecoveryMs) : MANUAL_ABORT_RECOVERY_MS;
@@ -26579,6 +26897,59 @@ async function createEngineSession({
     if (origin === "user") appendPromptHistory(state.cwd, text);
     pushItem({ kind: "user", id, text });
   };
+  const pushAsyncAgentResponse = (text, id = nextId(), origin = "injected", metadata = {}) => {
+    const synthetic = parseSyntheticAgentMessage(text);
+    const isAgent = synthetic?.name === "agent";
+    if (!isAgent) return pushUserOrSyntheticItem(text, id, origin);
+    const responseHasBody = /\n\s*\n[\s\S]*\S/.test(String(text || ""));
+    const rawResult = synthetic.rawResult ?? text;
+    const args = {
+      ...synthetic.args && typeof synthetic.args === "object" ? synthetic.args : {},
+      type: "result"
+    };
+    const responseKey = String(metadata.responseKey || metadata.executionId || args.task_id || "").trim();
+    const previous = state.items.at(-1);
+    if (previous?.kind === "tool" && previous.agentDirection === "inbound") {
+      const patch = appendAgentResponseTail(previous, {
+        key: responseKey,
+        args,
+        result: synthetic.result,
+        rawResult,
+        hasBody: responseHasBody,
+        isError: synthetic.isError === true
+      });
+      if (patch) {
+        patchItem(previous.id, patch);
+        return true;
+      }
+    }
+    pushItem({
+      kind: "tool",
+      id,
+      name: "agent",
+      args,
+      result: synthetic.result,
+      rawResult,
+      isError: synthetic.isError === true,
+      expanded: false,
+      count: 1,
+      completedCount: 1,
+      startedAt: Date.now(),
+      completedAt: Date.now(),
+      agentDirection: "inbound",
+      agentResponseKey: responseKey,
+      agentResponseHasBody: responseHasBody,
+      agentResponseAggregate: false,
+      agentResponseEntries: [{
+        key: responseKey,
+        raw: String(rawResult ?? "").trim(),
+        result: synthetic.result,
+        hasBody: responseHasBody,
+        isError: synthetic.isError === true
+      }]
+    });
+    return true;
+  };
   const pushToast = (text, tone = "info", ttlMs = 3e3) => {
     const id = nextId();
     const value = String(text ?? "").trim();
@@ -26668,6 +27039,7 @@ async function createEngineSession({
     kickExecutionPendingResume,
     flushDeferredExecutionPendingResumeKick,
     scheduleExecutionPendingResumeKick,
+    discardExecutionPendingResume,
     updateAgentJobCard,
     buildAgentJobCardPatch,
     subscribeRuntimeNotifications
@@ -26681,6 +27053,7 @@ async function createEngineSession({
     enqueue: (...args) => bag.enqueue(...args),
     drain: (...args) => bag.drain(...args),
     pushUserOrSyntheticItem,
+    pushAsyncAgentResponse,
     makeQueueEntry: (...args) => bag.makeQueueEntry(...args),
     getPending: () => pending,
     agentStatusState,
@@ -26728,6 +27101,7 @@ async function createEngineSession({
     removeNotice,
     setProgressHint,
     pushUserOrSyntheticItem,
+    pushAsyncAgentResponse,
     upsertSyntheticToolItem,
     markToolCallActive,
     markToolCallDone,
@@ -26747,6 +27121,7 @@ async function createEngineSession({
     kickExecutionPendingResume,
     flushDeferredExecutionPendingResumeKick,
     scheduleExecutionPendingResumeKick,
+    discardExecutionPendingResume,
     updateAgentJobCard,
     subscribeRuntimeNotifications
   });