mixdog 0.9.38 → 0.9.40

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';
@@ -33,12 +34,28 @@ export function createToolCardResults({
   updateAgentJobCard,
   buildAgentJobCardPatch,
   agentStatusState,
+  itemIndexById,
 }) {
+  const itemById = (id) => {
+    const index = itemIndexById?.get(id);
+    return Number.isInteger(index) ? getState().items[index]?.id === id ? getState().items[index] : null : null;
+  };
+  // 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 prev = itemById(id);
     const ok = patchItem(id, patch);
     if (!ok || !prev) return ok;
-    const next = getState().items.find((it) => it.id === id);
+    const next = itemById(id);
     if (next && next !== prev) carryTranscriptMeasuredRowsCache(prev, next);
     return ok;
   }
@@ -60,22 +77,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,21 +95,24 @@ 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 currentItem = itemById(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)));
       const rawResult = aggregateRawResult(allCalls);
@@ -116,6 +125,7 @@ export function createToolCardResults({
         isError: errors > 0,
         errorCount: errors,
         callErrorCount: callErrors,
+        exitErrorCount: exitErrors,
         count: allCalls.length,
         completedCount: visualCompleted,
         doneCategories: aggregateDoneCategories(allCalls),
@@ -127,20 +137,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 +174,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,18 +243,20 @@ 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
           // result so terminalStatus parsing resolves to 'cancelled'. Only normal
           // completions drop the summary; cancelled ones prepend the marker.
-          const currentItem = getState().items.find((it) => it.id === card.itemId);
+          const currentItem = itemById(card.itemId);
           displayDetail = withCancelledResultMarker(displayDetail, currentItem);
         }
         patchToolItem(card.itemId, {
@@ -244,6 +266,7 @@ export function createToolCardResults({
           isError: errors > 0,
           errorCount: errors,
           callErrorCount: callErrors,
+          exitErrorCount: exitErrors,
           count: allCalls.length,
           completedCount: totalCompleted,
           doneCategories: aggregateDoneCategories(allCalls),
@@ -257,15 +280,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);
+        const currentItem = itemById(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';
 }