mixdog 0.9.38 → 0.9.40

package/src/tui/engine/turn.mjs

@@ -6,16 +6,31 @@ 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 {
-    runtime, nextId, tuiDebug, LEAD_TURN_TIMEOUT_MS, flags, pending, itemIndexById, getState, set, pushItem, patchItem, pushNotice, pushUserOrSyntheticItem, markToolCallActive, markToolCallDone, clearActiveToolSummary, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, requestToolApproval, patchToolCardResult, flushToolResults, flushDeferredExecutionPendingResumeKick, drain, drainPendingSteering,
+    runtime, nextId, tuiDebug, LEAD_TURN_TIMEOUT_MS, flags, pending, itemIndexById, getState, set, pushItem, patchItem, updateStreamingTail: updateStreamingTailFromStore, settleStreamingTail: settleStreamingTailFromStore, clearStreamingTail: clearStreamingTailFromStore, pushNotice, pushUserOrSyntheticItem, markToolCallActive, markToolCallDone, clearActiveToolSummary, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, requestToolApproval, patchToolCardResult, flushToolResults, flushDeferredExecutionPendingResumeKick, drain, drainPendingSteering,
   } = bag;
+  // Small fallbacks keep isolated createRunTurn harnesses source-compatible;
+  // the real engine supplies atomic implementations that also maintain revision.
+  const updateStreamingTail = updateStreamingTailFromStore || ((id, patch = {}) => {
+    set({ streamingTail: { ...(getState().streamingTail || {}), ...patch, kind: 'assistant', id, streaming: true } });
+    return true;
+  });
+  const settleStreamingTail = settleStreamingTailFromStore || ((id, patch = {}) => {
+    const tail = getState().streamingTail;
+    if (!tail || tail.id !== id) return false;
+    pushItem({ ...tail, ...patch, kind: 'assistant', id, streaming: false });
+    set({ streamingTail: null });
+    return true;
+  });
+  const clearStreamingTail = clearStreamingTailFromStore || ((id = null) => {
+    if (id == null || getState().streamingTail?.id === id) set({ streamingTail: null });
+    return true;
+  });
 
     async function runTurn(userText, options = {}) {
     const turnIndex = getState().stats.turns || 0;
@@ -42,6 +57,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' } });
 
@@ -62,22 +80,63 @@ export function createRunTurn(bag) {
     let watchdogGraceTimer = null;
     let lastProgressAt = startedAt;
     let lastProgressLabel = 'start';
+    let watchdogDeferralCeilingAt = 0;
+    const configuredLeadToolMaxMs = Number(process.env.MIXDOG_LEAD_TOOL_MAX_MS);
+    const leadToolMaxMs = Number.isFinite(configuredLeadToolMaxMs) && configuredLeadToolMaxMs > 0
+      ? configuredLeadToolMaxMs
+      : 30 * 60 * 1000;
     const clearWatchdog = () => {
       if (watchdogTimer) { clearTimeout(watchdogTimer); watchdogTimer = null; }
       if (watchdogGraceTimer) { clearTimeout(watchdogGraceTimer); watchdogGraceTimer = null; }
     };
+    const refreshWatchdogFromRuntimeLiveness = () => {
+      let liveness;
+      try { liveness = runtime.getTurnLiveness?.(); } catch { return false; }
+      if (liveness?.stage !== 'tool_running') watchdogDeferralCeilingAt = 0;
+      const progressAt = Number(liveness?.lastProgressAt);
+      const now = Date.now();
+      if (!liveness || !Number.isFinite(progressAt) || progressAt <= now - LEAD_TURN_TIMEOUT_MS) return false;
+
+      if (liveness.stage === 'tool_running') {
+        watchdogDeferralCeilingAt = 0;
+        const toolStartedAt = Number(liveness.toolStartedAt);
+        if (!Number.isFinite(toolStartedAt) || toolStartedAt <= 0) return false;
+        const toolSelfDeadlineMs = Number(liveness.toolSelfDeadlineMs);
+        const toolCeilingMs = Math.max(
+          Number.isFinite(toolSelfDeadlineMs) && toolSelfDeadlineMs > 0 ? toolSelfDeadlineMs + 60_000 : 0,
+          leadToolMaxMs,
+        );
+        if (now - toolStartedAt >= toolCeilingMs) return false;
+        watchdogDeferralCeilingAt = toolStartedAt + toolCeilingMs;
+      }
+
+      lastProgressAt = progressAt;
+      lastProgressLabel = `orchestrator:${String(liveness.stage || 'unknown')}`;
+      armWatchdog();
+      return true;
+    };
     const armWatchdog = () => {
       if (watchdogTimer) { clearTimeout(watchdogTimer); watchdogTimer = null; }
       if (watchdogTripped) return;
-      const remaining = Math.max(1, LEAD_TURN_TIMEOUT_MS - Math.max(0, Date.now() - lastProgressAt));
+      const now = Date.now();
+      const remaining = Math.max(1, LEAD_TURN_TIMEOUT_MS - Math.max(0, now - lastProgressAt));
+      const ceilingRemaining = watchdogDeferralCeilingAt > 0
+        ? Math.max(1, watchdogDeferralCeilingAt - now)
+        : Infinity;
+      const delay = Math.min(remaining, ceilingRemaining);
       watchdogTimer = setTimeout(() => {
         if (!isCurrentTurn()) return;
         if (watchdogTripped) return;
-        const idleMs = Date.now() - lastProgressAt;
+        const now = Date.now();
+        const idleMs = now - lastProgressAt;
         if (idleMs < LEAD_TURN_TIMEOUT_MS) {
-          armWatchdog();
-          return;
-        }
+          if (watchdogDeferralCeilingAt > 0 && now >= watchdogDeferralCeilingAt) {
+            if (refreshWatchdogFromRuntimeLiveness()) return;
+          } else {
+            armWatchdog();
+            return;
+          }
+        } else if (refreshWatchdogFromRuntimeLiveness()) return;
         watchdogTripped = true;
         if (_batchTimer !== null) {
           clearTimeout(_batchTimer);
@@ -88,7 +147,7 @@ export function createRunTurn(bag) {
         _pendingThinkingLastEndedAt = 0;
         const elapsed = Date.now() - startedAt;
         tuiDebug(`runTurn WATCHDOG TRIP turn=${turnIndex} elapsedMs=${elapsed} idleMs=${idleMs} lastProgress=${lastProgressLabel} — aborting stuck turn`);
-        pushNotice(`Turn timed out after ${Math.round(idleMs / 1000)}s idle — aborting stuck request. Input will be released shortly if abort does not unwind.`, 'warn', { transcript: true });
+        pushNotice(`Turn timed out after ${Math.round(idleMs / 1000)}s idle (last progress: ${lastProgressLabel}) — aborting stuck request. Input will be released shortly if abort does not unwind.`, 'warn', { transcript: true });
         try { runtime.abort('cli-react-abort-watchdog'); } catch {}
         // Belt-and-suspenders: if runtime.abort() did not reject runtime.ask()
         // (unwind starved), hard-release the turn after a short grace so the
@@ -104,6 +163,11 @@ export function createRunTurn(bag) {
           finalizeToolHeaders();
           clearDeferredTimers();
           flags.flushDeferredBeforeImmediatePush = null;
+          if (currentAssistantId && currentAssistantText.trim()) {
+            settleStreamingTail(currentAssistantId, { text: currentAssistantText });
+          } else {
+            clearStreamingTail(currentAssistantId);
+          }
           // Bump the epoch FIRST so this (still-stuck) turn's later finally becomes
           // a no-op for shared getState() and cannot corrupt the turn we hand off to.
           flags.leadTurnEpoch++;
@@ -117,7 +181,7 @@ export function createRunTurn(bag) {
           flushDeferredExecutionPendingResumeKick();
         }, 5_000);
         watchdogGraceTimer.unref?.();
-      }, remaining);
+      }, delay);
       watchdogTimer.unref?.();
     };
     const markTurnProgress = (label) => {
@@ -125,11 +189,19 @@ export function createRunTurn(bag) {
       if (watchdogTripped) return;
       lastProgressAt = Date.now();
       lastProgressLabel = String(label || 'progress');
-      armWatchdog();
       return true;
     };
     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 +219,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 +236,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,
@@ -281,7 +352,7 @@ export function createRunTurn(bag) {
         const it = newItems[i];
         if (it?.id != null) itemIndexById.set(it.id, base + i);
       }
-      set({ items, ...extra });
+      set({ items, structureRevision: (Number(getState().structureRevision) || 0) + 1, ...extra });
     };
 
     const markPromptCommitted = () => {
@@ -317,7 +388,7 @@ export function createRunTurn(bag) {
         changed = true;
         return { ...item, headerFinalized: true };
       });
-      if (changed) set({ items });
+      if (changed) set({ items, structureRevision: (Number(getState().structureRevision) || 0) + 1 });
       return changed;
     };
 
@@ -328,13 +399,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 +416,7 @@ export function createRunTurn(bag) {
           isError: errors > 0,
           errorCount: errors,
           callErrorCount: callErrors,
+          exitErrorCount: exitErrors,
           count: allCalls.length,
           completedCount: allCalls.length,
           doneCategories: aggregateDoneCategories(allCalls),
@@ -438,7 +512,7 @@ export function createRunTurn(bag) {
         // Seed the new row with the already-visible text so the ● gutter and the
         // first body line appear in the SAME set()/emit() — no empty "●-only"
         // row that scrolls once on its own and again when the body lands.
-        pushItem({ kind: 'assistant', id: currentAssistantId, text: String(initialText || ''), streaming: true });
+        updateStreamingTail(currentAssistantId, { text: String(initialText || '') });
       }
       return currentAssistantId;
     };
@@ -451,7 +525,6 @@ export function createRunTurn(bag) {
       _lastNewlineIdx = -1;
       _emittedNewlineIdx = -2;
       _emittedVisibleText = '';
-      _cachedAssistantIndex = -1;
     };
 
     const commitAssistantSegment = ({ sealToolBlock = false } = {}) => {
@@ -462,7 +535,8 @@ export function createRunTurn(bag) {
       }
       if (sealToolBlock) clearAggregateContinuation();
       const id = currentAssistantId || ensureAssistant(text);
-      patchItem(id, { text, streaming: false });
+      settleStreamingTail(id, { text });
+      committedSegments.push(text);
       closeAssistantSegment();
       return true;
     };
@@ -505,7 +579,6 @@ export function createRunTurn(bag) {
     let _lastNewlineIdx = -1;      // offset of the last completed-line '\n' found so far
     let _emittedNewlineIdx = -2;   // newline offset backing _emittedVisibleText (-2 forces first compute)
     let _emittedVisibleText = '';  // cached visible slice for the current newline offset
-    let _cachedAssistantIndex = -1;// cached getState().items index of the streaming assistant row
     // Engine-local streaming scalars. Neither responseLength nor thinkingText is
     // rendered per-token by any consumer: App reads getState().thinking only as a
     // boolean (App.jsx `!!(getState().thinking || liveSpinner?.thinking)`) and the
@@ -573,22 +646,9 @@ export function createRunTurn(bag) {
         // until there is real content to paint.
         if (currentAssistantId || streamingVisibleText.trim()) {
           const id = ensureAssistant(streamingVisibleText);
-          // Emit the accumulated assistant text and spinner update together so a
-          // streaming batch costs one set() → one emit() → one React reconcile.
-          // Cache the streaming row's index; re-find only on a cache miss (row
-          // added/removed) instead of a findIndex scan on every flush.
-          let index = _cachedAssistantIndex;
-          if (index < 0 || getState().items[index]?.id !== id) {
-            index = getState().items.findIndex((it) => it.id === id);
-            _cachedAssistantIndex = index;
-          }
-          if (index >= 0) {
-            const current = getState().items[index];
-            if (!Object.is(current.text, streamingVisibleText) || current.streaming !== true) {
-              const items = getState().items.slice();
-              items[index] = { ...current, text: streamingVisibleText, streaming: true };
-              patch.items = items;
-            }
+          const current = getState().streamingTail;
+          if (!current || current.id !== id || !Object.is(current.text, streamingVisibleText)) {
+            patch.streamingTail = { kind: 'assistant', id, text: streamingVisibleText, streaming: true };
           }
         }
         // Only touch the spinner when there is a real reason: a visible-line
@@ -596,7 +656,7 @@ export function createRunTurn(bag) {
         // pending thinking end timestamp. Refresh responseLength here so the
         // finalize outputTokens fallback stays valid without a per-token push.
         const responseLengthVal = assistantText.length + thinkingText.length;
-        const visibleLineChanged = patch.items !== undefined;
+        const visibleLineChanged = patch.streamingTail !== undefined;
         const thinkingTransition = _publishedThinkingActive === true; // was thinking, now responding
         if (getState().spinner && (visibleLineChanged || thinkingTransition || _pendingThinkingLastEndedAt)) {
           patch.spinner = { ...getState().spinner, responseLength: responseLengthVal, thinking: false, thinkingLastEndedAt: _pendingThinkingLastEndedAt || getState().spinner.thinkingLastEndedAt, mode: compactingActive ? 'compacting' : 'responding' };
@@ -658,37 +718,38 @@ 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 currentIndex = itemIndexById.get(card.itemId);
+        const currentItem = Number.isInteger(currentIndex) && getState().items[currentIndex]?.id === card.itemId
+          ? getState().items[currentIndex]
+          : null;
         const visualCompleted = Math.max(
           completedCount,
           Math.min(allCalls.length, Number(currentItem?.completedCount || 0)),
@@ -699,6 +760,7 @@ export function createRunTurn(bag) {
           isError: errors > 0,
           errorCount: errors,
           callErrorCount: callErrors,
+          exitErrorCount: exitErrors,
           count: allCalls.length,
           completedCount: visualCompleted,
         };
@@ -725,6 +787,9 @@ export function createRunTurn(bag) {
     try {
       const { result, session } = await runtime.ask(userText, {
         drainSteering: (_sessionId, drainOptions) => (isCurrentTurn() ? drainPendingSteering(drainOptions) : []),
+        onStreamDelta: () => {
+          markTurnProgress('stream-delta');
+        },
         onSteerMessage: (text) => {
           if (!markTurnProgress('steer-message')) return;
           // A suppressed live-completion twin is model-visible only; its
@@ -737,10 +802,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 +836,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 +860,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 +926,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,19 +1110,40 @@ 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;
+          settleStreamingTail(id, { text: finalRemainder });
         } else if (currentAssistantId && (currentAssistantText.trim() || assistantText.trim())) {
           const streamedText = currentAssistantText || assistantText;
-          patchItem(currentAssistantId, { text: streamedText, streaming: false });
+          settleStreamingTail(currentAssistantId, { text: streamedText });
         }
         turnFinishedNormally = true;
       }
@@ -1068,7 +1156,7 @@ export function createRunTurn(bag) {
         if (error?.name === 'SessionClosedError') {
           cancelled = true;
           if (assistantText.trim() && currentAssistantId) {
-            patchItem(currentAssistantId, { text: currentAssistantText || assistantText, streaming: false });
+            settleStreamingTail(currentAssistantId, { text: currentAssistantText || assistantText });
           }
           // Finalize pending tool cards so they don't stay "Running..." forever
           // after cancellation. Without this, the spinner vanishes and TurnDone
@@ -1112,6 +1200,13 @@ export function createRunTurn(bag) {
       if (isStaleUnwind) {
         tuiDebug(`runTurn STALE UNWIND turn=${turnIndex} — force-released; skipping shared UI/state writes`);
       } else {
+        if (currentAssistantId && getState().streamingTail?.id === currentAssistantId) {
+          if (currentAssistantText.trim()) {
+            settleStreamingTail(currentAssistantId, { text: currentAssistantText });
+          } else {
+            clearStreamingTail(currentAssistantId);
+          }
+        }
         const producedTranscriptItem =
           getState().items.length + closingItems.length > itemsAtTurnStart;
         const reclaimed = cancelled && flags.activePromptRestore?.reclaimed === true;