mixdog 0.9.39 → 0.9.40

package/src/tui/engine/agent-job-feed.mjs

@@ -59,11 +59,13 @@ export function createAgentJobFeed({
   getPending,
   agentStatusState,
   displayedExecutionNotificationKeys,
+  itemIndexById,
   pushNotice,
   now = () => Date.now(),
   executionResumeTombstoneTtlMs = 30_000,
   executionResumeTombstoneLimit = 128,
 }) {
+  const executionDedupLimit = 256;
   let executionResumeKickDeferred = false;
   // Completion keys explicitly abandoned by Esc. Tombstones are per-feed
   // (therefore per TUI session), short-lived, and bounded: they catch a late
@@ -74,6 +76,60 @@ export function createAgentJobFeed({
   // or has reached its final body. A preview must not permanently suppress the
   // later body, while repeated body retries remain idempotent.
   const displayedExecutionResponseStates = new Map();
+  const terminalExecutionNotificationKeys = new Set();
+  const terminalExecutionResponseKeys = new Set();
+  const executionNotificationKeys = new Map();
+
+  const clearExecutionDedupState = () => {
+    displayedExecutionNotificationKeys.clear();
+    displayedExecutionResponseStates.clear();
+    terminalExecutionNotificationKeys.clear();
+    terminalExecutionResponseKeys.clear();
+    executionNotificationKeys.clear();
+  };
+  const rememberDisplayedExecutionNotificationKey = (key, terminal = false, executionId = '') => {
+    if (!key) return;
+    displayedExecutionNotificationKeys.delete(key);
+    if (executionId) executionNotificationKeys.set(key, executionId);
+    if (terminal) terminalExecutionNotificationKeys.add(key);
+    else terminalExecutionNotificationKeys.delete(key);
+    while (displayedExecutionNotificationKeys.size >= executionDedupLimit) {
+      const oldestTerminal = [...displayedExecutionNotificationKeys]
+        .find((candidate) => terminalExecutionNotificationKeys.has(candidate));
+      if (oldestTerminal == null) break;
+      displayedExecutionNotificationKeys.delete(oldestTerminal);
+      terminalExecutionNotificationKeys.delete(oldestTerminal);
+      executionNotificationKeys.delete(oldestTerminal);
+    }
+    displayedExecutionNotificationKeys.add(key);
+  };
+  const promoteExecutionNotificationKeys = (executionId) => {
+    if (!executionId) return;
+    for (const [key, keyExecutionId] of executionNotificationKeys) {
+      if (keyExecutionId !== executionId || !displayedExecutionNotificationKeys.has(key)) continue;
+      terminalExecutionNotificationKeys.add(key);
+    }
+  };
+  const promoteExecutionDedupState = (executionId) => {
+    if (!executionId) return;
+    promoteExecutionNotificationKeys(executionId);
+    const responseState = displayedExecutionResponseStates.get(executionId);
+    if (responseState) rememberDisplayedExecutionResponseState(executionId, responseState, true);
+  };
+  const rememberDisplayedExecutionResponseState = (key, value, terminal = false) => {
+    if (!key) return;
+    displayedExecutionResponseStates.delete(key);
+    if (terminal) terminalExecutionResponseKeys.add(key);
+    else terminalExecutionResponseKeys.delete(key);
+    while (displayedExecutionResponseStates.size >= executionDedupLimit) {
+      const oldestTerminal = [...displayedExecutionResponseStates.keys()]
+        .find((candidate) => terminalExecutionResponseKeys.has(candidate));
+      if (oldestTerminal == null) break;
+      displayedExecutionResponseStates.delete(oldestTerminal);
+      terminalExecutionResponseKeys.delete(oldestTerminal);
+    }
+    displayedExecutionResponseStates.set(key, value);
+  };
 
   // FIFO accumulation of model-visible bodies from completions that arrived
   // while busy (or while a pending-resume entry was already queued). A single
@@ -182,7 +238,10 @@ export function createAgentJobFeed({
   // jitter into one visible item update.
   function buildAgentJobCardPatch(itemId, text, isError = false) {
     const parsed = parseAgentJob(text);
-    const current = getState().items.find((it) => it.id === itemId);
+    const index = itemIndexById?.get(itemId);
+    const current = Number.isInteger(index) && getState().items[index]?.id === itemId
+      ? getState().items[index]
+      : null;
     const rawDisplayText = agentJobResultText(text, parsed) || String(text ?? '').trim();
     const displayText = isError ? toolErrorDisplay(rawDisplayText, 'agent') : rawDisplayText;
     return {
@@ -207,13 +266,17 @@ export function createAgentJobFeed({
 
   function subscribeRuntimeNotifications() {
     if (typeof runtime.onNotification !== 'function') return null;
-    return runtime.onNotification((event) => {
+    const unsubscribe = runtime.onNotification((event) => {
       if (getDisposed()) return;
       const text = String(event?.content ?? event?.text ?? event ?? '').trim();
       if (!text) return;
       const parsed = parseAgentJob(text);
       const notificationKey = notificationQueueKey(event, text, parsed);
       const delivery = resolveTuiRuntimeNotificationDelivery(event, text);
+      const executionId = String(event?.meta?.execution_id || parsed?.taskId || '').trim();
+      const status = String(event?.meta?.status || parsed?.status || '').toLowerCase();
+      const terminalStatus = /^(completed|complete|done|success|succeeded|ok|failed|error|timeout|killed|cancelled|canceled|denied)$/.test(status);
+      if (terminalStatus) promoteExecutionDedupState(executionId);
       if (delivery.action === 'ignore') return;
       if (delivery.action === 'notice') {
         pushNotice?.(delivery.displayText, delivery.tone || 'info', { transcript: delivery.transcript === true });
@@ -226,16 +289,19 @@ export function createAgentJobFeed({
       if (delivery.action === 'execution-ui') {
         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 terminal = terminalStatus;
         const responseState = executionId ? displayedExecutionResponseStates.get(executionId) : '';
         const bodyAlreadyDisplayed = responseState === 'body';
+        if (cardKey && terminal && displayedExecutionNotificationKeys.has(cardKey)) {
+          rememberDisplayedExecutionNotificationKey(cardKey, true, executionId);
+        }
+        if (terminal) promoteExecutionDedupState(executionId);
         if (firstDelivery && !successfulPreview && !bodyAlreadyDisplayed) {
-          if (cardKey) displayedExecutionNotificationKeys.add(cardKey);
-          if (executionId) displayedExecutionResponseStates.set(executionId, hasBody ? 'body' : 'preview');
+          if (cardKey) rememberDisplayedExecutionNotificationKey(cardKey, terminal, executionId);
+          if (executionId) rememberDisplayedExecutionResponseState(executionId, hasBody ? 'body' : 'preview', terminal);
           // Execution completions are inbound agent responses. The engine keeps
           // their aggregation tail-safe (only an immediately-adjacent inbound
           // response of the same preview/body phase can merge); the fallback
@@ -332,6 +398,9 @@ export function createAgentJobFeed({
       enqueue(modelContent, enqueueOpts);
       return true;
     });
+    return () => {
+      try { unsubscribe?.(); } finally { clearExecutionDedupState(); }
+    };
   }
 
   return {
@@ -342,5 +411,6 @@ export function createAgentJobFeed({
     updateAgentJobCard,
     buildAgentJobCardPatch,
     subscribeRuntimeNotifications,
+    clearExecutionDedupState,
   };
 }

package/src/tui/engine/session-api.mjs

@@ -24,7 +24,7 @@ export function createEngineApi(bag) {
 
 export function createEngineApiA(bag) {
   const {
-    runtime, nextId, flags, pending, listeners, getState, set, pushItem, patchItem, replaceItems, pushNotice, autoClearState, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, updateAgentJobCard, requeueEntriesFront, enqueue, autoClearBeforeSubmit, restoreQueued, resetStatsAndSyncContext, drain, flushDeferredExecutionPendingResumeKick, discardExecutionPendingResume,
+    runtime, nextId, flags, pending, listeners, getState, set, pushItem, patchItem, replaceItems, settleStreamingTail, clearStreamingTail, pushNotice, autoClearState, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, updateAgentJobCard, requeueEntriesFront, enqueue, autoClearBeforeSubmit, restoreQueued, resetStatsAndSyncContext, drain, flushDeferredExecutionPendingResumeKick, discardExecutionPendingResume,
   } = bag;
   return {
     getState: () => getState(),
@@ -617,6 +617,12 @@ export function createEngineApiA(bag) {
         if (flags.disposed) return;
         if (!getState().busy) return;                    // normal abort settled
         if (flags.leadTurnEpoch !== abortEpoch) return;  // a newer turn owns the store
+        const streamingTail = getState().streamingTail;
+        if (streamingTail?.text?.trim()) {
+          settleStreamingTail?.(streamingTail.id, {});
+        } else {
+          clearStreamingTail?.();
+        }
         // Bump the epoch FIRST so the still-stuck turn's eventual finally becomes
         // a no-op for shared getState() writes and cannot corrupt the handoff.
         flags.leadTurnEpoch = (Number(flags.leadTurnEpoch) || 0) + 1;

package/src/tui/engine/session-flow.mjs

@@ -8,7 +8,7 @@ import { appendTuiSteeringPersist, dropTuiSteeringPersist, drainTuiSteeringPersi
 
 export function createSessionFlow(bag) {
   const {
-    runtime, nextId, tuiDebug, flags, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, getState, set, pushItem, replaceItems, pushNotice, pushUserOrSyntheticItem, autoClearState, agentStatusState, routeState, syncContextStats, flushDeferredExecutionPendingResumeKick,
+    runtime, nextId, tuiDebug, flags, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, clearExecutionDedupState, getState, set, pushItem, replaceItems, pushNotice, pushUserOrSyntheticItem, autoClearState, agentStatusState, routeState, syncContextStats, flushDeferredExecutionPendingResumeKick,
   } = bag;
 
   // Upper bound on the awaited compacting clear. requireCompactSuccess makes
@@ -116,6 +116,7 @@ export function createSessionFlow(bag) {
       if (predicate(entry) && (entry.mode || 'prompt') === targetMode && queuePriorityValue(entry.priority) === bestPriority) {
         batch.push(entry);
         pending.splice(i, 1);
+        if (entry.mode === 'task-notification' && entry.key) pendingNotificationKeys.delete(entry.key);
         if (batch.length >= limit) break;
       } else {
         i += 1;
@@ -498,6 +499,7 @@ export function createSessionFlow(bag) {
     getState().busy = false;
     pendingNotificationKeys.clear();
     displayedExecutionNotificationKeys.clear();
+    clearExecutionDedupState?.();
   };
   // Post-success UI sync shared by the normal clear path and a late-fulfilling
   // abandoned compacting clear, so the UI always matches the cleared runtime

package/src/tui/engine/tool-card-results.mjs

@@ -34,7 +34,12 @@ 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
@@ -47,10 +52,10 @@ export function createToolCardResults({
     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;
   }
@@ -107,7 +112,7 @@ export function createToolCardResults({
       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);
@@ -251,7 +256,7 @@ export function createToolCardResults({
           // 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, {
@@ -284,7 +289,7 @@ export function createToolCardResults({
         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, exitErrorCount: group.exitErrors || 0, count: group.count, completedCount: group.completed, completedAt: Date.now() });

package/src/tui/engine/turn.mjs

@@ -12,8 +12,25 @@ import { aggregateRawResult, aggregateBucketForCategory, aggregateSummaries, ass
 
 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;
@@ -63,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);
@@ -89,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
@@ -105,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++;
@@ -118,7 +181,7 @@ export function createRunTurn(bag) {
           flushDeferredExecutionPendingResumeKick();
         }, 5_000);
         watchdogGraceTimer.unref?.();
-      }, remaining);
+      }, delay);
       watchdogTimer.unref?.();
     };
     const markTurnProgress = (label) => {
@@ -126,7 +189,6 @@ export function createRunTurn(bag) {
       if (watchdogTripped) return;
       lastProgressAt = Date.now();
       lastProgressLabel = String(label || 'progress');
-      armWatchdog();
       return true;
     };
     armWatchdog();
@@ -290,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 = () => {
@@ -326,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;
     };
 
@@ -450,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;
     };
@@ -463,7 +525,6 @@ export function createRunTurn(bag) {
       _lastNewlineIdx = -1;
       _emittedNewlineIdx = -2;
       _emittedVisibleText = '';
-      _cachedAssistantIndex = -1;
     };
 
     const commitAssistantSegment = ({ sealToolBlock = false } = {}) => {
@@ -474,7 +535,7 @@ 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;
@@ -518,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
@@ -586,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
@@ -609,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' };
@@ -699,7 +746,10 @@ export function createRunTurn(bag) {
         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)),
@@ -737,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
@@ -1087,10 +1140,10 @@ export function createRunTurn(bag) {
           // the final provider text when it is available.
           const id = currentAssistantId || ensureAssistant(finalRemainder);
           currentAssistantText = finalRemainder;
-          patchItem(id, { text: finalRemainder, streaming: false });
+          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;
       }
@@ -1103,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
@@ -1147,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;