mixdog 0.9.38 → 0.9.39

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, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
-import { memoryCoreResultErrorText } from '../app/input-parsers.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,
         };
@@ -737,10 +749,12 @@ export function createRunTurn(bag) {
           // 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) {
@@ -769,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
@@ -792,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
@@ -859,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) {
@@ -1043,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 });

package/src/tui/engine.mjs

@@ -81,6 +81,7 @@ import {
 import { createToolApproval } from './engine/tool-approval.mjs';
 import { createToolCardResults } from './engine/tool-card-results.mjs';
 import { createAgentJobFeed } from './engine/agent-job-feed.mjs';
+import { appendAgentResponseTail } from './engine/agent-response-tail.mjs';
 import {
   appendTuiSteeringPersist,
   dropTuiSteeringPersist,
@@ -424,6 +425,64 @@ export 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);
+    // Tail-only aggregation prevents a later completion from mutating a card
+    // above any outbound tool, assistant, user, or preview/body boundary.
+    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 = 3000) => {
     const id = nextId();
     const value = String(text ?? '').trim();
@@ -524,6 +583,7 @@ export async function createEngineSession({
     kickExecutionPendingResume,
     flushDeferredExecutionPendingResumeKick,
     scheduleExecutionPendingResumeKick,
+    discardExecutionPendingResume,
     updateAgentJobCard,
     buildAgentJobCardPatch,
     subscribeRuntimeNotifications,
@@ -537,6 +597,7 @@ export async function createEngineSession({
     enqueue: (...args) => bag.enqueue(...args),
     drain: (...args) => bag.drain(...args),
     pushUserOrSyntheticItem,
+    pushAsyncAgentResponse,
     makeQueueEntry: (...args) => bag.makeQueueEntry(...args),
     getPending: () => pending,
     agentStatusState,
@@ -574,12 +635,12 @@ export async function createEngineSession({
     flags, lifecycle, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, listeners, itemIndexById,
     getState: () => state, set,
     pushItem, patchItem, replaceItems, pushToast, pushNotice, removeNotice, setProgressHint,
-    pushUserOrSyntheticItem, upsertSyntheticToolItem,
+    pushUserOrSyntheticItem, pushAsyncAgentResponse, upsertSyntheticToolItem,
     markToolCallActive, markToolCallDone, clearActiveToolSummary, clearToastTimers,
     autoClearState, agentStatusState, baseRouteState, routeState, syncContextStats,
     presentNextToolApproval, finishToolApproval, denyAllToolApprovals, requestToolApproval,
     patchToolCardResult, flushToolResults,
-    kickExecutionPendingResume, flushDeferredExecutionPendingResumeKick, scheduleExecutionPendingResumeKick, updateAgentJobCard, subscribeRuntimeNotifications,
+    kickExecutionPendingResume, flushDeferredExecutionPendingResumeKick, scheduleExecutionPendingResumeKick, discardExecutionPendingResume, updateAgentJobCard, subscribeRuntimeNotifications,
   });
   Object.assign(bag, createSessionFlow(bag));
   bag.runTurn = createRunTurn(bag);

package/src/workflows/bench/WORKFLOW.md

@@ -6,41 +6,31 @@ hidden: true
 agents: worker, heavy-worker, reviewer, debugger, maintainer
 ---
 
-# Bench Workflow
+# Bench
 
-Autonomous run: no user is present. Never wait for approval or ask
-questions — decide and proceed immediately. Loop until the task is verified
-complete or provably blocked.
+Autonomous: no user. Never wait for approval or ask questions; decide/proceed.
+Loop until verified complete or provably blocked.
 
-Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
-- Lead directly: simple 1–2 step work, plus coordination, pre-planning, config
-  changes, and final git deployment.
-- Worker: implementation that takes several steps. Heavy Worker:
-  high-complexity, multi-step implementation.
-- Reviewer: verify implementation scopes (diff, regressions, missing checks).
-- Debugger: very high complexity, or when root-causing has already failed at
-  least once.
+Lead supervises, delegates, coordinates, judges, decides. Lead directly handles
+simple 1–2-step work, coordination, pre-planning, config, final git deployment.
+Worker: several-step implementation; Heavy Worker: high-complexity multi-step
+implementation; Reviewer: implementation diff/regression/missing-check review;
+Debugger: very high complexity or root cause already failed once.
 
-1. Plan — form the plan yourself and start executing immediately; no approval
-   step exists.
-2. Delegate — split into the maximum number of independent scopes.
-   - PARALLEL across independent scopes by default (implementation, analysis,
-     review, debugging alike); spawn every scope in the SAME turn. Shared or
-     cross-cutting code does NOT justify merging — split per path and verify
-     the shared parts yourself. The only single scope is a genuinely
-     inseparable dependency; then state it.
-   - SEQUENTIAL within a single complex scope: ordered steps with a
-     build/test-green gate between them, not one shot.
-   - Write briefs per the Lead brief contract.
-   - After spawning async agents, END THE TURN — no polling, guessing, or
-     dependent work until the completion notification resumes you.
-3. Review — pair one reviewer 1:1 with each implementation scope, spawned in the
-   same turn, never deferred or batched; wait for its result. Fact-check agent
-   responses and cross-check implementation and review results yourself before
-   acting. Send fixes back to the original scope and loop verify -> fix ->
-   re-verify until clean. Skip review only for simple, low-risk tasks. If a bug
-   survives 2+ fix cycles, have the debugger investigate first instead of
-   another fix round.
-4. Finish — verify the final state yourself; only stop when the task is
-   complete and verified, or a hard blocker makes progress impossible. State
-   the outcome and evidence in the final message.
+1. Plan: form it and execute immediately; no approval step.
+2. Delegate: split to the maximum independent scopes. Parallelize independent
+   implementation/analysis/review/debugging, spawning every scope in one turn.
+   Shared/cross-cutting code does not justify merging: split by path and verify
+   shared parts yourself. A single scope needs a genuinely inseparable
+   dependency; state it. Within one complex scope, sequence steps with a
+   build/test-green gate between them. Briefs follow the Lead brief contract.
+   After async spawn, end turn: no polling, guessing, or dependent work until
+   completion notification.
+3. Review: one Reviewer per implementation scope, spawned 1:1 in the same turn,
+   never deferred/batched; wait. Fact-check agent responses and cross-check
+   implementation/review yourself before acting. Return fixes to the original
+   scope; loop verify -> fix -> re-verify until clean. Skip only simple,
+   low-risk review. If a bug survives 2+ fix cycles, Debugger investigates
+   before another fix round.
+4. Finish: verify final state yourself; stop only verified complete or hard
+   blocked. Final states outcome and evidence.