mixdog 0.9.19 → 0.9.21

package/src/tui/engine.mjs

@@ -86,6 +86,11 @@ import {
   drainTuiSteeringPersist,
   flushTuiSteeringPersist,
 } from './engine/tui-steering-persist.mjs';
+import { createContextState } from './engine/context-state.mjs';
+import { recomputePromptHistory } from './engine/prompt-history.mjs';
+import { createSessionFlow } from './engine/session-flow.mjs';
+import { createRunTurn } from './engine/turn.mjs';
+import { createEngineApi } from './engine/session-api.mjs';
 
 // Source tests resolve from src/tui/engine.mjs; the built bundle resolves from
 // src/tui/dist/index.mjs.
@@ -152,68 +157,39 @@ export async function createEngineSession({
   bootProfile('engine:create:runtime-ready', { ms: (performance.now() - startedAt).toFixed(1) });
   const cwd = runtime.cwd || process.cwd();
   const stateStartedAt = performance.now();
-  const autoClearState = () => runtime.getAutoClear?.() || runtime.autoClear || { enabled: true, idleMs: 60 * 60 * 1000, custom: false, providerDefault: 60 * 60 * 1000, provider: null, minContextPercent: 10 };
-  const AGENT_STATUS_CACHE_MS = 250;
-  let agentStatusCache = null;
-  let agentStatusCacheAt = 0;
-  const agentStatusState = ({ force = false } = {}) => {
-    const now = Date.now();
-    if (!force && agentStatusCache && now - agentStatusCacheAt < AGENT_STATUS_CACHE_MS) return agentStatusCache;
-    const status = runtime.agentStatus?.() || {};
-    agentStatusCache = {
-      agentWorkers: Array.isArray(status.agentWorkers) ? status.agentWorkers : [],
-      agentJobs: Array.isArray(status.agentJobs) ? status.agentJobs : [],
-      agentScope: status.agentScope || null,
-    };
-    agentStatusCacheAt = now;
-    return agentStatusCache;
+  const flags = {
+    disposed: false,
+    draining: false,
+    autoClearRunning: false,
+    pendingSessionReset: false,
+    lastUserActivityAt: Date.now(),
+    leadTurnEpoch: 0,
+    activePromptRestore: null,
+    pushingFromDeferredEntry: false,
+    flushDeferredBeforeImmediatePush: null,
   };
-  const baseRouteState = () => ({
-    sessionId: runtime.id,
-    clientHostPid: runtime.clientHostPid || null,
-    model: runtime.model,
-    provider: runtime.provider,
-    effort: runtime.effort,
-    effortOptions: runtime.effortOptions,
-    fast: runtime.fast,
-    fastCapable: runtime.fastCapable,
-    contextWindow: runtime.contextWindow,
-    rawContextWindow: runtime.rawContextWindow,
-    effectiveContextWindowPercent: runtime.effectiveContextWindowPercent,
-    cwd: runtime.cwd || process.cwd(),
-    systemShell: runtime.systemShell || { source: 'auto', command: '', effective: '' },
-    searchRoute: runtime.getSearchRoute?.() || runtime.searchRoute || null,
-    autoClear: autoClearState(),
-    workflow: runtime.workflow || null,
-    remoteEnabled: runtime.isRemoteEnabled?.() === true,
-  });
-
-  const routeState = () => ({
-    ...baseRouteState(),
-    displayContextWindow: state.displayContextWindow || 0,
-    compactBoundaryTokens: state.compactBoundaryTokens || 0,
-    autoCompactTokenLimit: state.autoCompactTokenLimit || 0,
+  const lifecycle = { runtimePulseTimer: null, unsubscribeRuntimeNotifications: null, unsubscribeRemoteState: null };
+  const pending = [];
+  const pendingNotificationKeys = new Set();
+  const displayedExecutionNotificationKeys = new Set();
+  const bag = {};
+  // Route/context/agent-status derivations live in ./engine/context-state.mjs.
+  // getState()/getPendingSessionReset() are late-bound to the `state` and
+  // `pendingSessionReset` closures declared below; the sync helpers mutate
+  // state.stats / display fields IN PLACE exactly as the old inline versions
+  // did (callers follow with a set({ stats: { ...state.stats }, ... })).
+  const {
+    autoClearState,
+    agentStatusState,
+    baseRouteState,
+    routeState,
+    syncContextStats,
+  } = createContextState({
+    runtime,
+    getState: () => state,
+    getPendingSessionReset: () => flags.pendingSessionReset,
   });
 
-  function syncContextDisplayFields(ctx = null) {
-    const status = ctx || runtime.contextStatus?.() || null;
-    if (!status) return;
-    const displayWindow = Number(status.contextWindow || 0);
-    const compactBoundary = Number(status.compaction?.boundaryTokens || 0);
-    // Prefer the resolved trigger (boundary - buffer): the statusline uses it
-    // as the display denominator so context % reads 100% exactly when
-    // auto-compact fires, instead of stalling at ~90% of the boundary.
-    const autoCompact = Number(
-      status.compaction?.triggerTokens
-      || status.compaction?.autoCompactTokenLimit
-      || runtime.session?.autoCompactTokenLimit
-      || 0,
-    );
-    if (displayWindow > 0) state.displayContextWindow = displayWindow;
-    if (compactBoundary > 0) state.compactBoundaryTokens = compactBoundary;
-    if (autoCompact > 0) state.autoCompactTokenLimit = autoCompact;
-  }
-
   const initialAgentState = {
     agentWorkers: [],
     agentJobs: [],
@@ -251,63 +227,6 @@ export async function createEngineSession({
   };
   bootProfile('engine:route-state-ready', { ms: (performance.now() - stateStartedAt).toFixed(1) });
   bootProfile('engine:state-ready', { ms: (performance.now() - stateStartedAt).toFixed(1) });
-  let pendingSessionReset = false;
-  const syncContextStats = ({ allowEstimated = false } = {}) => {
-    if (pendingSessionReset) return null;
-    const ctx = runtime.contextStatus?.() || null;
-    if (!ctx) return null;
-    syncContextDisplayFields(ctx);
-    const hasProviderUsage = Number(state.stats.latestPromptTokens || state.stats.latestInputTokens || state.stats.inputTokens || 0) > 0;
-    const hasApiContextUsage = Number(ctx?.lastApiRequestTokens ?? ctx?.usage?.lastContextTokens ?? 0) > 0;
-    const hasTurnActivity = state.busy === true
-      || state.spinner != null
-      || state.thinking != null;
-    const isFreshSession = !hasProviderUsage && !hasApiContextUsage && !hasTurnActivity;
-    if (isFreshSession) {
-      state.stats.currentEstimatedContextTokens = 0;
-      state.stats.currentContextTokens = 0;
-      state.stats.currentContextSource = null;
-      state.stats.currentContextUpdatedAt = Date.now();
-      return ctx;
-    }
-    const estimatedTokens = Math.max(0, Number(ctx.currentEstimatedTokens ?? ctx.usedTokens ?? 0));
-    const usedTokens = Math.max(0, Number(ctx.usedTokens ?? estimatedTokens ?? 0));
-    const usedSource = String(ctx.usedSource || '').toLowerCase();
-    const shouldPublishEstimate = allowEstimated && (
-      usedSource === 'estimated'
-      || Number(ctx.currentEstimatedTokens) > 0
-      || usedTokens > 0
-    );
-    if (!allowEstimated && !hasProviderUsage && usedSource !== 'last_api_request') return ctx;
-    if (shouldPublishEstimate) {
-      state.stats.currentEstimatedContextTokens = estimatedTokens;
-      state.stats.currentContextSource = 'estimated';
-      state.stats.currentContextTokens = 0;
-    } else if (allowEstimated && (hasProviderUsage || hasApiContextUsage || hasTurnActivity)) {
-      state.stats.currentEstimatedContextTokens = estimatedTokens;
-      state.stats.currentContextSource = usedSource || (estimatedTokens > 0 ? 'estimated' : null);
-      const publishedSource = String(state.stats.currentContextSource || '').toLowerCase();
-      if (publishedSource === 'last_api_request') {
-        const apiUsed = Math.max(0, Number(ctx.lastApiRequestTokens ?? usedTokens ?? 0));
-        state.stats.currentContextTokens = apiUsed;
-      } else if (publishedSource === 'estimated') {
-        state.stats.currentContextTokens = 0;
-      } else {
-        state.stats.currentContextTokens = usedTokens > 0 ? usedTokens : 0;
-      }
-    } else {
-      state.stats.currentEstimatedContextTokens = 0;
-      if (usedSource === 'last_api_request' && Number(ctx.lastApiRequestTokens ?? usedTokens ?? 0) > 0) {
-        state.stats.currentContextTokens = Math.max(0, Number(ctx.lastApiRequestTokens ?? usedTokens ?? 0));
-        state.stats.currentContextSource = 'last_api_request';
-      } else {
-        state.stats.currentContextTokens = 0;
-        state.stats.currentContextSource = null;
-      }
-    }
-    state.stats.currentContextUpdatedAt = Date.now();
-    return ctx;
-  };
   const contextStartedAt = performance.now();
   syncContextStats({ allowEstimated: true });
   bootProfile('engine:context-ready', { ms: (performance.now() - contextStartedAt).toFixed(1) });
@@ -363,33 +282,13 @@ export async function createEngineSession({
     state = { ...state, items: nextItems, promptHistoryList: recomputePromptHistory(nextItems), activeToolSummary: null };
     return nextItems;
   };
-  let flushDeferredBeforeImmediatePush = null;
-  let pushingFromDeferredEntry = false;
   // --- Prompt-history list (newest-first, deduped) maintained incrementally ---
   // App previously rebuilt this from state.items on EVERY transcript change
   // (App.jsx recentPromptHistory useMemo). It only changes when a user item is
   // appended, so rebuild it there and on bulk item swaps, publishing to
-  // state.promptHistoryList.
-  const PROMPT_HISTORY_LIMIT = 50;
-  const promptHistoryKey = (value) => String(value || '').trim().replace(/\s+/g, ' ');
-  const recomputePromptHistory = (sourceItems = null) => {
-    // Pure: derive the newest-first deduped user-prompt history from the given
-    // items (defaults to state.items) and RETURN it. Callers decide whether to
-    // publish via set() so the immutable-emit contract is preserved.
-    const items = Array.isArray(sourceItems) ? sourceItems : (Array.isArray(state.items) ? state.items : []);
-    const seen = new Set();
-    const history = [];
-    for (let i = items.length - 1; i >= 0 && history.length < PROMPT_HISTORY_LIMIT; i -= 1) {
-      const item = items[i];
-      if (item?.kind !== 'user') continue;
-      const text = String(item.text || '').trim();
-      const key = promptHistoryKey(text);
-      if (!key || seen.has(key)) continue;
-      seen.add(key);
-      history.push(text);
-    }
-    return history;
-  };
+  // state.promptHistoryList. Pure derivation now lives in
+  // ./engine/prompt-history.mjs (recomputePromptHistory); callers still pass the
+  // NEW items array explicitly and publish via set().
   // --- Active-tool summary (Explore/Search) maintained incrementally ---
   // App previously scanned every transcript item on every change to derive the
   // prompt-line "Exploring N / Searching N" status. Instead the tool lifecycle
@@ -433,8 +332,8 @@ export async function createEngineSession({
     if (state.activeToolSummary) set({ activeToolSummary: null });
   };
   const pushItem = (item) => {
-    if (!pushingFromDeferredEntry && flushDeferredBeforeImmediatePush) {
-      flushDeferredBeforeImmediatePush();
+    if (!flags.pushingFromDeferredEntry && flags.flushDeferredBeforeImmediatePush) {
+      flags.flushDeferredBeforeImmediatePush();
     }
     const index = state.items.length;
     const items = [...state.items, item];
@@ -497,7 +396,7 @@ export async function createEngineSession({
     set({ toasts: [...state.toasts.filter((toast) => toast.id !== id), { id, text: value, tone }] });
     const timer = setTimeout(() => {
       toastTimers.delete(timer);
-      if (disposed) return;
+      if (flags.disposed) return;
       set({ toasts: state.toasts.filter((toast) => toast.id !== id) });
     }, ttlMs);
     toastTimers.add(timer);
@@ -542,7 +441,7 @@ export async function createEngineSession({
     getState: () => state,
     set,
     nextId,
-    getDisposed: () => disposed,
+    getDisposed: () => flags.disposed,
     timeoutMs: TOOL_APPROVAL_TIMEOUT_MS,
   });
   const patchItem = (id, patch) => {
@@ -567,10 +466,9 @@ export async function createEngineSession({
     return true;
   };
   const toastTimers = new Set();
-  let disposed = false;
-  const runtimePulseTimer = setInterval(() => {
-    if (disposed) return;
-    if (pendingSessionReset) return;
+  lifecycle.runtimePulseTimer = setInterval(() => {
+    if (flags.disposed) return;
+    if (flags.pendingSessionReset) return;
     syncContextStats({ allowEstimated: true });
     set({
       ...routeState(),
@@ -578,7 +476,7 @@ export async function createEngineSession({
       ...agentStatusState(),
     });
   }, 2000);
-  runtimePulseTimer.unref?.();
+  lifecycle.runtimePulseTimer.unref?.();
 
   function clearToastTimers() {
     for (const timer of toastTimers) {
@@ -587,11 +485,6 @@ export async function createEngineSession({
     toastTimers.clear();
   }
 
-  let unsubscribeRuntimeNotifications = null;
-  let lastUserActivityAt = Date.now();
-  let autoClearRunning = false;
-  const pendingNotificationKeys = new Set();
-  const displayedExecutionNotificationKeys = new Set();
   const {
     kickExecutionPendingResume,
     flushDeferredExecutionPendingResumeKick,
@@ -603,25 +496,24 @@ export async function createEngineSession({
     getState: () => state,
     set,
     nextId,
-    getDisposed: () => disposed,
+    getDisposed: () => flags.disposed,
     patchItem,
-    enqueue: (...args) => enqueue(...args),
-    drain: (...args) => drain(...args),
+    enqueue: (...args) => bag.enqueue(...args),
+    drain: (...args) => bag.drain(...args),
     pushUserOrSyntheticItem,
-    makeQueueEntry: (...args) => makeQueueEntry(...args),
+    makeQueueEntry: (...args) => bag.makeQueueEntry(...args),
     getPending: () => pending,
     agentStatusState,
     displayedExecutionNotificationKeys,
   });
-  unsubscribeRuntimeNotifications = subscribeRuntimeNotifications();
+  lifecycle.unsubscribeRuntimeNotifications = subscribeRuntimeNotifications();
 
   // Remote seat superseded by another session: runtime already stopped its
   // worker; sync the indicator and tell the user. Non-user-initiated, so a
   // toast (not transcript) is right.
-  let unsubscribeRemoteState = null;
   if (typeof runtime.onRemoteStateChange === 'function') {
-    unsubscribeRemoteState = runtime.onRemoteStateChange(({ enabled, reason }) => {
-      if (disposed) return;
+    lifecycle.unsubscribeRemoteState = runtime.onRemoteStateChange(({ enabled, reason }) => {
+      if (flags.disposed) return;
       set({ remoteEnabled: enabled === true });
       if (reason === 'superseded') {
         pushNotice('Remote mode OFF — another session took over remote.', 'warn');
@@ -638,2465 +530,21 @@ export async function createEngineSession({
     agentStatusState,
   });
 
-  async function runTurn(userText, options = {}) {
-    const turnIndex = state.stats.turns || 0;
-    const startedAt = Date.now();
-    // Per-turn epoch. Force-release (watchdog grace) bumps the shared counter so
-    // this turn's own eventual `finally` — which may run LONG after force-release
-    // already started a new turn that reuses the per-session mutex — can detect
-    // it is stale and skip all shared-state writes (busy, activePromptRestore,
-    // turndone, drain kick). Neutralizes the stale unwind without touching the mutex.
-    const turnEpoch = ++leadTurnEpoch;
-    const inputBaseline = state.stats.inputTokens;
-    const outputBaseline = state.stats.outputTokens;
-    const submittedIds = Array.isArray(options.submittedIds) ? options.submittedIds : [];
-    const displayText = promptDisplayText(userText, options);
-    let promptCommittedCallbackCalled = false;
-    activePromptRestore = {
-      text: String(displayText || '').trim(),
-      pastedImages: options.pastedImages && typeof options.pastedImages === 'object' ? options.pastedImages : null,
-      pastedTexts: options.pastedTexts && typeof options.pastedTexts === 'object' ? options.pastedTexts : null,
-      onCommitted: typeof options.onCommitted === 'function' ? options.onCommitted : null,
-      restorable: options.restorable !== false,
-      submittedIds,
-      reclaimed: false,
-      committed: false,
-      requeueEntries: Array.isArray(options.requeueOnAbort) ? options.requeueOnAbort.slice() : [],
-    };
-    set({ busy: true, lastTurn: null, spinner: { active: true, verb: pickVerb(turnIndex), startedAt, responseLength: 0, inputTokens: 0, outputTokens: 0, mode: 'requesting' } });
-
-    let assistantText = '';
-    let currentAssistantId = null;
-
-    tuiDebug(`runTurn start turn=${turnIndex} pending=${pending.length} timeoutMs=${LEAD_TURN_TIMEOUT_MS}`);
-    // ── Wall-clock watchdog ───────────────────────────────────────────────
-    // If this turn never unwinds (provider call stuck), trip after the cap:
-    // abort the in-flight run via the existing interrupt path (runtime.abort,
-    // the same one Esc uses), which rejects the pending runtime.ask() with a
-    // SessionClosedError so the normal cancelled-turn teardown runs. If even
-    // that unwind is starved, forceReleaseTurn() in the timer hard-clears busy
-    // and kicks the drain so input is never permanently dead.
-    let watchdogTripped = false;
-    let watchdogTimer = null;
-    let watchdogGraceTimer = null;
-    const clearWatchdog = () => {
-      if (watchdogTimer) { clearTimeout(watchdogTimer); watchdogTimer = null; }
-      if (watchdogGraceTimer) { clearTimeout(watchdogGraceTimer); watchdogGraceTimer = null; }
-    };
-    watchdogTimer = setTimeout(() => {
-      if (disposed) return;
-      watchdogTripped = true;
-      const elapsed = Date.now() - startedAt;
-      tuiDebug(`runTurn WATCHDOG TRIP turn=${turnIndex} elapsedMs=${elapsed} — aborting stuck turn`);
-      pushNotice(`Turn timed out after ${Math.round(elapsed / 1000)}s — aborting stuck request. Input is available again.`, '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
-      // React store is never left with busy=true and no drain in flight.
-      watchdogGraceTimer = setTimeout(() => {
-        if (disposed) return;
-        if (!state.busy) return;
-        if (leadTurnEpoch !== turnEpoch) return; // a newer turn already owns the store
-        tuiDebug(`runTurn WATCHDOG FORCE-RELEASE turn=${turnIndex} — abort unwind starved`);
-        // Bump the epoch FIRST so this (still-stuck) turn's later finally becomes
-        // a no-op for shared state and cannot corrupt the turn we hand off to.
-        leadTurnEpoch++;
-        set({ busy: false, spinner: null, thinking: null, lastTurn: null });
-        activePromptRestore = null;
-        if (draining) draining = false;
-        if (pending.length > 0) void drain();
-      }, 5_000);
-      watchdogGraceTimer.unref?.();
-    }, LEAD_TURN_TIMEOUT_MS);
-    watchdogTimer.unref?.();
-    let currentAssistantText = '';
-    let thinkingText = '';
-    let thinkingStartedAt = 0;
-    let thinkingSegmentStartedAt = 0;
-    let accumulatedThinkingMs = 0;
-    let cancelled = false;
-    let askResult = null;
-    let turnFinishedNormally = false;
-    const itemsAtTurnStart = state.items.length;
-    const cardByCallId = new Map();
-    const toolCards = [];
-    const toolGroups = new Map();
-    const resultsDone = new Set();
-    // Streaming providers can deliver eager onToolResult before onToolCall registers
-    // cards (send() still in flight). Hold those by callId until the batch lands.
-    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
 
-    // ── Deferred tool-card push (scroll/text sync) ────────────────────────────
-    // A tool card used to enter the transcript the instant onToolCall fired,
-    // reserving its estimated height (margin+header+detail) while ToolExecution
-    // only painted blank placeholder rows for TOOL_PENDING_SHOW_DELAY_MS. With a
-    // bottom-fixed viewport that shoved the body up BEFORE any glyph appeared, so
-    // the scroll ran ahead of the text. We now hold each card off-screen for the
-    // same delay and push it only when its real header/detail will paint (delay
-    // elapsed) OR a result lands first (fast tool → completed card, no pending
-    // flicker). Either way the pushed spec is stamped `deferredDisplayReady` so
-    // ToolExecution renders the real header + 'Running' detail immediately
-    // instead of the blank pre-delay placeholder — this matters for the
-    // result-forced chain push (flushDeferredUpTo), where earlier-seq sibling
-    // 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;
-    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,
-    // so transcript order always matches call order even when a later card's
-    // result/timer fires before an earlier one's.
-    const flushDeferredUpTo = (entry) => {
-      if (!entry) return;
-      for (const e of deferredEntries) {
-        if (e.seq > entry.seq) break;
-        if (e.pushed) continue;
-        e.pushed = true;
-        if (e.timer) { clearTimeout(e.timer); e.timer = null; }
-        try { e.push(); } catch {}
-      }
-    };
-    flushDeferredBeforeImmediatePush = () => {
-      if (!deferredEntries.length) return;
-      const last = deferredEntries[deferredEntries.length - 1];
-      if (last) flushDeferredUpTo(last);
-    };
-    const registerDeferredCard = (card) => {
-      const entry = {
-        seq: deferredSeqCounter++,
-        pushed: false,
-        timer: null,
-        // Mark the card visible and return its spec WITHOUT emitting, so a
-        // batched turn-close flush can commit many specs in one set().
-        materialize: () => {
-          card.pushed = true;
-          if (!card.spec) return null;
-          card.spec.deferredDisplayReady = true;
-          return card.spec;
-        },
-        push: () => {
-          const spec = entry.materialize();
-          if (!spec) return;
-          pushingFromDeferredEntry = true;
-          try { pushItem(spec); } finally { pushingFromDeferredEntry = false; }
-        },
-      };
-      card.deferred = entry;
-      card.ensureVisible = () => flushDeferredUpTo(entry);
-      deferredEntries.push(entry);
-      entry.timer = setTimeout(() => {
-        entry.timer = null;
-        if (disposed) return;
-        flushDeferredUpTo(entry);
-      }, TOOL_CARD_PUSH_DELAY_MS);
-      entry.timer.unref?.();
-    };
-    const registerDeferredAggregate = (aggregate) => {
-      const entry = {
-        seq: deferredSeqCounter++,
-        pushed: false,
-        timer: null,
-        materialize: () => {
-          aggregate.pushed = true;
-          if (!aggregate.pendingSpec) return null;
-          aggregate.pendingSpec.deferredDisplayReady = true;
-          return aggregate.pendingSpec;
-        },
-        push: () => {
-          const spec = entry.materialize();
-          if (!spec) return;
-          pushingFromDeferredEntry = true;
-          try { pushItem(spec); } finally { pushingFromDeferredEntry = false; }
-        },
-      };
-      aggregate.deferred = entry;
-      aggregate.ensureVisible = () => flushDeferredUpTo(entry);
-      deferredEntries.push(entry);
-      entry.timer = setTimeout(() => {
-        entry.timer = null;
-        if (disposed) return;
-        flushDeferredUpTo(entry);
-      }, TOOL_CARD_PUSH_DELAY_MS);
-      entry.timer.unref?.();
-    };
-    const clearDeferredTimers = () => {
-      for (const e of deferredEntries) {
-        if (e.timer) { clearTimeout(e.timer); e.timer = null; }
-      }
-    };
-    // Collect (mark pushed + cancel timers) every still-deferred entry up to
-    // `entry` in creation order, returning their specs WITHOUT emitting — the
-    // caller commits them (optionally alongside a trailing turndone item) in a
-    // single set() so turn-close writes land as ONE visible commit.
-    const collectDeferredUpTo = (entry) => {
-      const specs = [];
-      if (!entry) return specs;
-      for (const e of deferredEntries) {
-        if (e.seq > entry.seq) break;
-        if (e.pushed) continue;
-        e.pushed = true;
-        if (e.timer) { clearTimeout(e.timer); e.timer = null; }
-        const spec = e.materialize?.();
-        if (spec) specs.push(spec);
-      }
-      return specs;
-    };
-    // Append pre-built items (deferred cards + turndone) in ONE set(). None are
-    // 'user' kind, so no promptHistory rebuild is needed.
-    const appendItemsBatch = (newItems, extra = {}) => {
-      if (!newItems || !newItems.length) { set(extra); return; }
-      const base = state.items.length;
-      const items = [...state.items, ...newItems];
-      for (let i = 0; i < newItems.length; i++) {
-        const it = newItems[i];
-        if (it?.id != null) itemIndexById.set(it.id, base + i);
-      }
-      set({ items, ...extra });
-    };
-
-    const markPromptCommitted = () => {
-      if (activePromptRestore) {
-        if (!promptCommittedCallbackCalled && typeof activePromptRestore.onCommitted === 'function') {
-          promptCommittedCallbackCalled = true;
-          try { activePromptRestore.onCommitted(); } catch {}
-        }
-        activePromptRestore.restorable = false;
-        activePromptRestore.committed = true;
-        activePromptRestore.requeueEntries = [];
-        activePromptRestore.pastedImages = null;
-        activePromptRestore.pastedTexts = null;
-      }
-    };
-
-    const finalizeToolHeaders = () => {
-      const ids = new Set();
-      for (const card of toolCards || []) {
-        if (card?.itemId) ids.add(card.itemId);
-        // Seal not-yet-pushed specs too, so a card that pushes later (timer)
-        // enters already-finalized instead of flashing the active header form.
-        if (card && card.pushed === false && card.spec) card.spec.headerFinalized = true;
-      }
-      for (const aggregate of aggregateCards || []) {
-        if (aggregate?.itemId) ids.add(aggregate.itemId);
-        if (aggregate && aggregate.pushed === false && aggregate.pendingSpec) aggregate.pendingSpec.headerFinalized = true;
-      }
-      if (ids.size === 0) return false;
-      let changed = false;
-      const items = state.items.map((item) => {
-        if (!ids.has(item?.id) || item.kind !== 'tool' || item.headerFinalized !== false) return item;
-        changed = true;
-        return { ...item, headerFinalized: true };
-      });
-      if (changed) set({ items });
-      return changed;
-    };
-
-    const completeAggregateVisual = () => {
-      for (const aggregate of aggregateCards) {
-        const allCalls = [...aggregate.calls.values()];
-        if (allCalls.length === 0) continue;
-        aggregate.ensureVisible?.();
-        const errors = allCalls.filter((r) => r.isError).length;
-        const completed = allCalls.filter((r) => r.resolved).length;
-        const succeeded = completed - errors;
-        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`)
-          : formatAggregateDetail(aggregateSummaries(aggregate));
-        patchItem(aggregate.itemId, {
-          result: displayDetail,
-          text: displayDetail,
-          rawResult: rawResult || null,
-          isError: errors > 0,
-          count: allCalls.length,
-          completedCount: allCalls.length,
-          completedAt: Date.now(),
-        });
-      }
-    };
-
-    const clearAggregateContinuation = () => {
-      completeAggregateVisual();
-      finalizeToolHeaders();
-      aggregateCards.length = 0;
-      // Seal the block: same-bucket calls after this point must open a fresh
-      // card, never continue one from before the seal (assistant text/turn
-      // end boundary).
-      tailAggregate = null;
-    };
-
-    const rememberActiveAggregate = (aggregate) => {
-      if (!aggregate) return;
-      if (!aggregateCards.includes(aggregate)) aggregateCards.push(aggregate);
-      tailAggregate = aggregate;
-    };
-
-    const ensureAggregateCard = (bucket) => {
-      // Only the TAIL aggregate (most recent card) may absorb the next call,
-      // and only when the bucket matches. Any different-bucket aggregate or
-      // standalone card in between breaks the run, so Search, Memory, Search
-      // renders as three cards in call order — a new call never merges into
-      // an earlier card above the current tail (which read as out-of-order
-      // count changes in the transcript). clearAggregateContinuation seals
-      // the block at assistant-text/turn boundaries.
-      const cached = tailAggregate && tailAggregate.bucket === bucket ? tailAggregate : null;
-      if (cached) {
-        rememberActiveAggregate(cached);
-        return cached;
-      }
-      const itemId = nextId();
-      const aggregate = {
-        itemId,
-        bucket,
-        categories: new Map(),
-        categoryOrder: [],
-        calls: new Map(),
-        nextSummarySeq: 0,
-        pushed: false,
-        startedAt: Date.now(),
-      };
-      // Arm the deferred push once at creation; syncAggregateHeader only keeps
-      // pendingSpec current until the timer/result flushes it in call order.
-      registerDeferredAggregate(aggregate);
-      rememberActiveAggregate(aggregate);
-      return aggregate;
-    };
-
-    const syncAggregateHeader = (aggregate) => {
-      if (!aggregate?.itemId) return;
-      const patch = {
-        args: { categoryOrder: aggregate.categoryOrder.slice() },
-        count: aggregate.calls.size,
-        completedCount: [...aggregate.calls.values()].filter((r) => r.resolved || r.completedEarly).length,
-        categories: Object.fromEntries(aggregate.categories),
-      };
-      if (aggregate.pushed) {
-        patchItem(aggregate.itemId, patch);
-        return;
-      }
-      // Not yet visible: keep the latest header spec current. The deferred entry
-      // (armed at creation) pushes pendingSpec when its timer fires or a result
-      // forces it visible, preserving call order via flushDeferredUpTo.
-      aggregate.pendingSpec = {
-        kind: 'tool',
-        id: aggregate.itemId,
-        name: '__aggregate__',
-        ...patch,
-        aggregate: true,
-        result: null,
-        rawResult: null,
-        isError: false,
-        expanded: false,
-        headerFinalized: false,
-        startedAt: aggregate.startedAt || Date.now(),
-      };
-    };
-
-    const ensureAssistant = (initialText = '') => {
-      if (!currentAssistantId) {
-        currentAssistantId = nextId();
-        // Do NOT reset currentAssistantText here. The first onTextDelta has
-        // already accumulated the opening chunk before this batched flush runs;
-        // wiping it dropped the leading characters and forced a later set() to
-        // re-add them. Segment resets are owned by closeAssistantSegment().
-        // 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 });
-      }
-      return currentAssistantId;
-    };
-
-    const closeAssistantSegment = () => {
-      currentAssistantId = null;
-      currentAssistantText = '';
-      // Reset incremental-flush state so the next segment rescans from scratch.
-      _streamScanLen = 0;
-      _lastNewlineIdx = -1;
-      _emittedNewlineIdx = -2;
-      _emittedVisibleText = '';
-      _cachedAssistantIndex = -1;
-    };
-
-    const commitAssistantSegment = ({ sealToolBlock = false } = {}) => {
-      const text = currentAssistantText || '';
-      if (!text.trim()) {
-        closeAssistantSegment();
-        return false;
-      }
-      if (sealToolBlock) clearAggregateContinuation();
-      const id = currentAssistantId || ensureAssistant(text);
-      patchItem(id, { text, streaming: false });
-      closeAssistantSegment();
-      return true;
-    };
-
-    const startThinkingSegment = () => {
-      const now = Date.now();
-      if (!thinkingStartedAt) thinkingStartedAt = now;
-      if (!thinkingSegmentStartedAt) thinkingSegmentStartedAt = now;
-      return now;
-    };
-
-    const closeThinkingSegment = () => {
-      if (!thinkingSegmentStartedAt) return;
-      const now = Date.now();
-      accumulatedThinkingMs += Math.max(0, now - thinkingSegmentStartedAt);
-      thinkingSegmentStartedAt = 0;
-      return now;
-    };
-
-    // --- Streaming-delta batcher ---
-    // onTextDelta and onReasoningDelta fire on every tiny chunk (often <10 chars).
-    // Each call previously called set() → emit() → full React reconcile. We
-    // batch accumulated text and flush at most once per STREAM_BATCH_INTERVAL_MS
-    // (≈16ms / 60fps cap). A forced flush happens before any tool call,
-    // finalization, or error so those code paths see the correct text state.
-    // Flush cadence for streamed text/thinking. 8ms (~120fps) matches the Ink
-    // render maxFps (index.jsx render({ maxFps: 120 })), so a queued batch is
-    // never held back waiting for the next Ink frame. 16ms (~60fps) left every
-    // other Ink frame idle, which made fast provider streams visibly land in
-    // coarse chunks ("10 chars at a time").
-    const STREAM_BATCH_INTERVAL_MS = 16;
-    let _batchTimer = null;
-    let _pendingTextFlush = false;   // true when a text/spinner update is queued
-    let _pendingThinkFlush = false;  // true when a thinking update is queued
-    let _pendingThinkingLastEndedAt = 0;
-    let compactingActive = false;
-    // Incremental streaming-flush state: avoids rescanning the full accumulated
-    // assistant text (lastIndexOf) and re-finding the row index on every flush.
-    let _streamScanLen = 0;        // chars of currentAssistantText already scanned for '\n'
-    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 state.items index of the streaming assistant row
-    // Engine-local streaming scalars. Neither responseLength nor thinkingText is
-    // rendered per-token by any consumer: App reads state.thinking only as a
-    // boolean (App.jsx `!!(state.thinking || liveSpinner?.thinking)`) and the
-    // Spinner takes outputTokens, not responseLength. So we keep these growing
-    // values in engine-local vars and publish to the store only on a visible
-    // transition (thinking on↔off), a completed visible text line, tool/usage
-    // updates, or finalization — not on every 8ms streaming flush.
-    let _publishedThinkingActive = false; // last thinking boolean pushed to store
-    // responseLength is only consumed at finalize as an outputTokens fallback
-    // (Math.round(responseLength/4)); we refresh state.spinner.responseLength on
-    // visible-line flush and finalize so that fallback stays valid.
-
-    const flushStreamBatch = () => {
-      if (_batchTimer !== null) {
-        clearTimeout(_batchTimer);
-        _batchTimer = null;
-      }
-      if (_pendingTextFlush) {
-        _pendingTextFlush = false;
-        // Show only COMPLETED lines while streaming. The in-progress trailing
-        // line stays hidden until its '\n' arrives, so the visible text never
-  // grows a glyph at a time (no "Wh"→pause→"What happened…" partial reveal, no
-        // CJK-width reflow jitter). The final non-streaming patch
-        // (streaming:false) always carries the full text, so the tail line that
-        // never got a newline still lands once at finalize.
-        // Incrementally track the last completed-line '\n' offset instead of
-        // rescanning the whole accumulated text every flush. Each char is
-        // examined once across the stream (amortized O(n) total, not O(n) per
-        // flush); when the newline offset hasn't advanced the visible text is
-        // byte-identical to the last flush, so the slice below is skipped and
-        // reused. Reveal semantics are unchanged: still only completed lines.
-        const textLen = currentAssistantText.length;
-        if (textLen < _streamScanLen) { _streamScanLen = 0; _lastNewlineIdx = -1; }
-        for (let i = _streamScanLen; i < textLen; i++) {
-          if (currentAssistantText.charCodeAt(i) === 10) _lastNewlineIdx = i;
-        }
-        _streamScanLen = textLen;
-        let streamingVisibleText;
-        if (_lastNewlineIdx === _emittedNewlineIdx) {
-          streamingVisibleText = _emittedVisibleText;
-        } else {
-          streamingVisibleText = _lastNewlineIdx >= 0
-            ? currentAssistantText.slice(0, _lastNewlineIdx + 1)
-            : '';
-          _emittedNewlineIdx = _lastNewlineIdx;
-          _emittedVisibleText = streamingVisibleText;
-        }
-        const patch = {};
-        // Do NOT create the assistant row (and scroll the transcript) before
-        // there is a completed line with VISIBLE content to show. Until the
-        // first '\n' the only pending state is the spinner; the row appears
-        // together with its first visible line, so no empty "●-only" row
-        // flashes/scrolls ahead of text. `.trim()` also guards the
-        // whitespace-only case: a response that opens with leading newlines
-        // ("\n\n# …") completes a blank line first, whose estimated height
-        // still reserves rows and scrolls the transcript, but Markdown trims
-        // the body to nothing — so the scroll advances onto an empty band for
-        // a few seconds until a non-blank line lands. Don't create the row
-        // 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 || state.items[index]?.id !== id) {
-            index = state.items.findIndex((it) => it.id === id);
-            _cachedAssistantIndex = index;
-          }
-          if (index >= 0) {
-            const current = state.items[index];
-            if (!Object.is(current.text, streamingVisibleText) || current.streaming !== true) {
-              const items = state.items.slice();
-              items[index] = { ...current, text: streamingVisibleText, streaming: true };
-              patch.items = items;
-            }
-          }
-        }
-        // Only touch the spinner when there is a real reason: a visible-line
-        // change (patch.items set above), a thinking→responding transition, or a
-        // 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 thinkingTransition = _publishedThinkingActive === true; // was thinking, now responding
-        if (state.spinner && (visibleLineChanged || thinkingTransition || _pendingThinkingLastEndedAt)) {
-          patch.spinner = { ...state.spinner, responseLength: responseLengthVal, thinking: false, thinkingLastEndedAt: _pendingThinkingLastEndedAt || state.spinner.thinkingLastEndedAt, mode: compactingActive ? 'compacting' : 'responding' };
-          _publishedThinkingActive = false;
-        }
-        if (Object.keys(patch).length > 0) set(patch);
-        _pendingThinkingLastEndedAt = 0;
-      }
-      if (_pendingThinkFlush) {
-        _pendingThinkFlush = false;
-        // App only consumes state.thinking as a boolean and the Spinner only
-        // reads the thinking flag + timing anchors — none of them render the
-        // growing thinkingText. So publish the thinking boolean only on the
-        // OFF→ON transition (or when compacting toggles the flag), not on every
-        // 8ms reasoning chunk. The full thinkingText stays engine-local and is
-        // emitted at finalize via the normal spinner/thinking teardown.
-        const nextThinkingActive = !compactingActive;
-        // Skip the push when the published thinking boolean is unchanged: neither
-        // the growing thinkingText nor responseLength is rendered per-token, and
-        // the Spinner derives its live elapsed from the (already-published)
-        // thinkingSegmentStartedAt anchor. Applies to both thinking and
-        // compacting steady state.
-        if (nextThinkingActive === _publishedThinkingActive) {
-          // no-op: boolean unchanged
-        } else {
-          const responseLengthVal = assistantText.length + thinkingText.length;
-          const thinkingElapsedMs = accumulatedThinkingMs + (thinkingSegmentStartedAt ? Math.max(0, Date.now() - thinkingSegmentStartedAt) : 0);
-          // state.thinking stays a truthy sentinel while active; consumers read it
-          // as a boolean. Keep the value stable (thinkingText) so a late consumer
-          // still sees real text, but only push on transition.
-          const patch = { thinking: compactingActive ? null : thinkingText };
-          if (state.spinner) {
-            patch.spinner = compactingActive
-              ? { ...state.spinner, responseLength: responseLengthVal, thinking: false, thinkingAccumulatedMs: accumulatedThinkingMs, thinkingElapsedMs, thinkingLastEndedAt: state.spinner.thinkingLastEndedAt || 0, mode: 'compacting' }
-              : { ...state.spinner, responseLength: responseLengthVal, thinking: true, thinkingStartedAt, thinkingSegmentStartedAt, thinkingAccumulatedMs: accumulatedThinkingMs, thinkingElapsedMs, thinkingLastEndedAt: 0, mode: 'thinking' };
-          }
-          set(patch);
-          _publishedThinkingActive = nextThinkingActive;
-        }
-      }
-    };
-
-    const scheduleStreamFlush = () => {
-      if (_batchTimer !== null) return; // already scheduled; do not re-arm
-      _batchTimer = setTimeout(flushStreamBatch, STREAM_BATCH_INTERVAL_MS);
-      if (_batchTimer?.unref) _batchTimer.unref(); // don't prevent process exit
-    };
-
-    // __earlyNotify: show 1-line summary + completedCount immediately; defer
-    // rawResult/expand and resultsDone to the history flush.
-    const markToolCardCompletedState = (callId, message) => {
-      const card = cardByCallId.get(callId);
-      if (!card) return;
-      // Early completion also clears the active-summary entry.
-      markToolCallDone(card.callId);
-      const aggregate = card.aggregate;
-      if (aggregate && card.itemId === aggregate.itemId) {
-        const callRec = aggregate.calls.get(callId);
-        if (!callRec || callRec.resolved || callRec.completedEarly) return;
-        aggregate.ensureVisible?.();
-        const rawText = toolResultText(message?.content);
-        const isError = message?.isError === true || message?.toolKind === 'error' || /^\s*\[?error/i.test(rawText) || isErrorToolStatus(toolResultStatus(rawText));
-        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.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 succeeded = completedCount - errors;
-        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`)
-          : formatAggregateDetail(aggregateSummaries(aggregate));
-        const currentItem = state.items.find((it) => it.id === card.itemId);
-        const visualCompleted = Math.max(
-          completedCount,
-          Math.min(allCalls.length, Number(currentItem?.completedCount || 0)),
-        );
-        const patch = {
-          result: displayDetail,
-          text: displayDetail,
-          isError: errors > 0,
-          errorCount: errors,
-          count: allCalls.length,
-          completedCount: visualCompleted,
-        };
-        if (visualCompleted >= allCalls.length) {
-          patch.completedAt = Number(currentItem?.completedAt) || Date.now();
-        }
-        patchItem(card.itemId, patch);
-        return;
-      }
-      // Non-aggregate eager tools are rare; flipping completedCount without
-      // result changes pending/detail rendering and risks row jitter — wait for
-      // the real history flush (unchanged behavior).
-    };
-
-    const deliverToolResultMessage = (message) => {
-      if (message?.__earlyNotify === true) {
-        const earlyCallId = toolResultCallId(message);
-        if (earlyCallId) markToolCardCompletedState(earlyCallId, message);
-        return;
-      }
-      flushToolResults([message], toolCards, cardByCallId, toolGroups, resultsDone);
-    };
-
-    try {
-      const { result, session } = await runtime.ask(userText, {
-        drainSteering: () => drainPendingSteering(),
-        onSteerMessage: (text) => {
-          // Steering can be injected after a terminal no-tool response has
-          // already streamed but before runTurn finalizes. Seal the current
-          // 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();
-          }
-          assistantText = '';
-          const value = String(text || '').trim();
-          if (value) {
-            // Any non-tool transcript item is a block boundary: seal the
-            // aggregate continuation (not just finalize headers) so a later
-            // same-category tool call opens a fresh card instead of reusing
-            // one whose count would then change ABOVE this steered user item.
-            clearAggregateContinuation();
-            pushUserOrSyntheticItem(value, undefined, 'injected');
-          }
-        },
-        onToolCall: async (_iter, calls) => {
-          markPromptCommitted();
-          // Always flush any buffered mid-turn assistant text before the tool
-          // card appears. Without this, when neither a thinking panel nor a
-          // spinner is active the buffered text was dropped by the following
-          // closeAssistantSegment(), so the message above the tool card vanished.
-          flushStreamBatch();
-          if (thinkingText && state.thinking) {
-            const thinkingLastEndedAt = closeThinkingSegment();
-            set({ thinking: null, spinner: state.spinner ? { ...state.spinner, thinking: false, thinkingAccumulatedMs: accumulatedThinkingMs, thinkingLastEndedAt, mode: 'tool-use' } : state.spinner });
-            _publishedThinkingActive = false;
-          } else if (state.spinner) {
-            set({ spinner: { ...state.spinner, mode: 'tool-use' } });
-          }
-          const batchCalls = (calls || []).filter(Boolean);
-          if (batchCalls.length === 0) return;
-          const committedAssistantSegment = commitAssistantSegment({ sealToolBlock: true });
-          if (committedAssistantSegment) {
-            // Let the pre-tool assistant preamble paint as its own frame before
-            // the tool card reserves/pushes rows. When both enter the transcript
-            // in the same render, the bottom-pinned viewport can appear to jump
-            // upward by the combined height ("preamble + tool card" at once).
-            await yieldToRenderer();
-          }
-
-          const touchedAggregates = new Set();
-          // [jitter fix] Last standalone (Agent) card in this batch to reserve a
-          // row for. Flushed AFTER the syncAggregateHeader loop so any earlier-seq
-          // aggregate it would flush-through already has its pendingSpec built.
-          let standaloneReserve = null;
-          for (let i = 0; i < batchCalls.length; i++) {
-            const c = batchCalls[i];
-            const name = toolCallName(c);
-            const args = toolCallArgs(c);
-            // 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);
-            const callId = toolCallId(c);
-            const callKey = callId || `__tool_${toolCards.length}_${i}`;
-            // The old App scan counted multi-pattern calls via
-            // aggregateToolCategoryEntry(...).count, not a flat 1. Derive the same
-            // count here so the incremental Explore/Search summary matches.
-            const activeCount = Number(aggregateToolCategoryEntry(name, args, category)?.count || 1);
-            // Track Explore/Search calls as active for the incremental prompt-
-            // line summary; cleared when their result lands or the turn ends.
-            markToolCallActive(callKey, category, activeCount, Date.now());
-
-            if (!bucket) {
-              const itemId = nextId();
-              // Defer the visible push: hold the spec and only enter the
-              // transcript when the real header/detail will paint (delay
-              // elapsed) or its result lands first. Avoids reserving blank
-              // placeholder height that scrolls the body ahead of the glyphs.
-              const card = {
-                itemId,
-                callId: callKey,
-                done: false,
-                pushed: false,
-                spec: {
-                  kind: 'tool',
-                  id: itemId,
-                  name,
-                  args,
-                  result: null,
-                  isError: false,
-                  expanded: false,
-                  headerFinalized: false,
-                  count: 1,
-                  completedCount: 0,
-                  startedAt: Date.now(),
-                },
-              };
-              registerDeferredCard(card);
-              if (callId) {
-                cardByCallId.set(callId, card);
-              }
-              toolCards.push(card);
-              // [jitter fix] Immediate row-reserve is deferred to after the
-              // syncAggregateHeader loop below (see standaloneReserve): calling
-              // ensureVisible() here would flushDeferredUpTo() every earlier-seq
-              // entry — including an aggregate whose pendingSpec syncAggregateHeader
-              // hasn't built yet — marking it pushed without inserting (lost/
-              // out-of-order card). Record it and flush once headers exist.
-              standaloneReserve = card;
-              // A standalone card (Agent) breaks the consecutive run too: a
-              // later same-bucket call must open a fresh card BELOW it, not
-              // merge into an aggregate above it.
-              tailAggregate = null;
-              continue;
-            }
-
-            const categoryEntry = aggregateToolCategoryEntry(name, args, category);
-            const aggregateCard = ensureAggregateCard(bucket);
-            if (!aggregateCard.categories.has(categoryEntry.key)) aggregateCard.categoryOrder.push(categoryEntry.key);
-            const prevCategory = aggregateCard.categories.get(categoryEntry.key);
-            aggregateCard.categories.set(categoryEntry.key, {
-              ...categoryEntry,
-              count: Number(prevCategory?.count || 0) + Number(categoryEntry.count || 1),
-            });
-            aggregateCard.calls.set(callKey, { name, args, category, summary: null, summarySeq: null, isError: false, resultText: null, resolved: false, completedEarly: false });
-            touchedAggregates.add(aggregateCard);
-            const card = { itemId: aggregateCard.itemId, callId: callKey, done: false, aggregate: aggregateCard };
-            if (callId) {
-              cardByCallId.set(callId, card);
-            }
-            toolCards.push(card);
-          }
-
-          for (const aggregateCard of touchedAggregates) {
-            syncAggregateHeader(aggregateCard);
-          }
-          // [jitter fix] Now that every touched aggregate has its pendingSpec,
-          // reserve the standalone (Agent) card's row immediately. Its
-          // ensureVisible() flushes earlier-seq entries too, but those aggregates
-          // are now push-ready so none is marked pushed without inserting.
-          standaloneReserve?.ensureVisible?.();
-          if (committedAssistantSegment) {
-            // A pre-tool assistant preamble has already had one render frame to
-            // settle. Do not let the first grouped tool card sit off-screen until
-            // the normal 1s deferred timer: when it later inserts its real 3 rows,
-            // the already-wrapped preamble visibly jumps. Surface the first card
-            // now via the existing deferredDisplayReady path, so the post-
-            // preamble frame contains the intended Running tool card immediately
-            // (no blank placeholder, no delayed row insertion).
-            const firstTouchedAggregate = [...touchedAggregates][0] || null;
-            firstTouchedAggregate?.ensureVisible?.();
-          }
-          for (const [bufferedCallId, bufferedMessage] of earlyResultBuffer) {
-            if (!cardByCallId.has(bufferedCallId)) continue;
-            deliverToolResultMessage(bufferedMessage);
-            earlyResultBuffer.delete(bufferedCallId);
-          }
-          await yieldToRenderer();
-        },
-        onToolResult: (message) => {
-          const callId = toolResultCallId(message);
-          if (callId && !cardByCallId.has(callId) && !resultsDone.has(callId)) {
-            earlyResultBuffer.set(callId, message);
-            return;
-          }
-          deliverToolResultMessage(message);
-        },
-        onToolApproval: async (request) => {
-          markPromptCommitted();
-          flushStreamBatch();
-          if (state.spinner) set({ spinner: { ...state.spinner, mode: 'tool-approval' } });
-          return await requestToolApproval(request);
-        },
-        onCompactEvent: (event) => {
-          flushStreamBatch();
-          // Non-tool transcript item — same block-boundary rule as the
-          // steered user item above: seal any live aggregate first so a
-          // later same-category tool call doesn't reuse a card whose count
-          // would then change above this statusdone item.
-          clearAggregateContinuation();
-          pushItem({
-            kind: 'statusdone',
-            id: nextId(),
-            label: compactEventLabel(event),
-            detail: compactEventDetail(event),
-          });
-        },
-        onStageChange: async (stage) => {
-          if (!state.spinner) return;
-          const value = String(stage || '');
-          if (value === 'compacting') {
-            compactingActive = true;
-            const thinkingLastEndedAt = closeThinkingSegment();
-            _pendingThinkFlush = false;
-            _publishedThinkingActive = false; // compacting cleared the thinking flag
-            set({
-              thinking: null,
-              spinner: {
-                ...state.spinner,
-                thinking: false,
-                thinkingSegmentStartedAt: 0,
-                thinkingAccumulatedMs: accumulatedThinkingMs,
-                thinkingLastEndedAt: thinkingLastEndedAt || state.spinner.thinkingLastEndedAt || 0,
-                mode: 'compacting',
-              },
-            });
-            await yieldToRenderer();
-            return;
-          }
-          if (value === 'requesting' || value === 'streaming') compactingActive = false;
-          const mode = value === 'requesting'
-            ? 'requesting'
-            : value === 'streaming'
-              ? (state.spinner.thinking ? 'thinking' : 'responding')
-              : null;
-          if (!mode || state.spinner.mode === mode) return;
-          set({ spinner: { ...state.spinner, mode } });
-        },
-        onTextDelta: (chunk) => {
-          const textChunk = String(chunk ?? '');
-          if (!textChunk) return;
-          markPromptCommitted();
-          const thinkingLastEndedAt = closeThinkingSegment();
-          // Drop any queued think-flush too: it would otherwise re-publish
-          // spinner.thinking:true from flushStreamBatch and resurrect the
-          // indicator after we cleared it here.
-          _pendingThinkFlush = false;
-          if (state.thinking) { set({ thinking: null }); _publishedThinkingActive = false; } // collapse thinking panel immediately, no batch delay
-          assistantText += textChunk;
-          currentAssistantText += textChunk;
-          // Accumulate text and schedule a batched flush (≤1 render per
-          // STREAM_BATCH_INTERVAL_MS). Without scheduling, mid-turn text only
-          // surfaced via the tool-call/finalize flush, so a text→tool segment
-          // with no spinner/thinking dropped the message above the tool card.
-          _pendingTextFlush = true;
-          if (thinkingLastEndedAt) _pendingThinkingLastEndedAt = thinkingLastEndedAt;
-          scheduleStreamFlush();
-        },
-        onAssistantText: (text) => {
-          // Mid-turn assistant text that precedes a tool call. Providers that
-          // stream via onTextDelta already accumulated it into assistantText;
-          // providers that only return the final response.content (no deltas)
-          // never fired onTextDelta, so without this the preamble shows nothing
-          // before the tool card. De-dup against already-streamed text so the
-          // streaming path is unaffected.
-          const full = String(text ?? '');
-          if (!full.trim()) return;
-          // If the streaming path already produced text for THIS segment,
-          // onTextDelta owns the render — content is the same accumulated text
-          // (or a superset), so skip to avoid double-printing the preamble.
-          // Do not check turn-global assistantText: earlier closed preambles stay
-          // there across tool calls, and would suppress later non-streaming
-          // preambles even though currentAssistantText has been reset.
-          if (currentAssistantText.trim()) return;
-          markPromptCommitted();
-          closeThinkingSegment();
-          _pendingThinkFlush = false; // see onTextDelta: prevent a stale think flush resurrecting the indicator
-          if (state.thinking) { set({ thinking: null }); _publishedThinkingActive = false; }
-          assistantText += full;
-          currentAssistantText += full;
-          _pendingTextFlush = true;
-          flushStreamBatch();
-        },
-        onReasoningDelta: (chunk) => {
-          if (String(chunk ?? '')) markPromptCommitted();
-          startThinkingSegment();
-          thinkingText += String(chunk ?? '');
-          // Accumulate reasoning text; fire at most one render per STREAM_BATCH_INTERVAL_MS.
-          _pendingThinkFlush = true;
-          scheduleStreamFlush();
-        },
-        onUsageDelta: (delta) => {
-          applyUsageDelta(state.stats, delta);
-          syncContextStats({ allowEstimated: true });
-          const currentTurnInput = Math.max(0, state.stats.inputTokens - inputBaseline);
-          const currentTurnOutput = Math.max(0, state.stats.outputTokens - outputBaseline);
-          if (state.spinner) {
-            set({ stats: { ...state.stats }, spinner: { ...state.spinner, inputTokens: currentTurnInput, outputTokens: currentTurnOutput } });
-          } else {
-            set({ stats: { ...state.stats } });
-          }
-        },
-      });
-      askResult = result;
-      markPromptCommitted();
-
-      flushToolResults(session?.messages || [], toolCards, cardByCallId, toolGroups, resultsDone, { finalize: true });
-      finalizeToolHeaders();
-      flushStreamBatch(); // force-flush any batched streaming text before finalization writes
-      syncContextStats({ allowEstimated: true });
-
-      const finalText = result?.content != null ? String(result.content) : '';
-      if (finalText.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 });
-      } else if (currentAssistantId && (currentAssistantText.trim() || assistantText.trim())) {
-        const streamedText = currentAssistantText || assistantText;
-        patchItem(currentAssistantId, { text: streamedText, streaming: false });
-      }
-      turnFinishedNormally = true;
-    } catch (error) {
-      flushStreamBatch(); // ensure any batched text lands before the error notice
-      if (error?.name === 'SessionClosedError') {
-        cancelled = true;
-        if (assistantText.trim() && currentAssistantId) {
-          patchItem(currentAssistantId, { text: currentAssistantText || assistantText, streaming: false });
-        }
-        // Finalize pending tool cards so they don't stay "Running..." forever
-        // after cancellation. Without this, the spinner vanishes and TurnDone
-        // shows "cancelled", but in-flight tool cards remain in a perpetual
-        // pending/blinking state because the normal finalize path (line 992)
-        // was skipped when the error interrupted the try block.
-        flushToolResults([], toolCards, cardByCallId, toolGroups, resultsDone, { finalize: true, cancelled: true });
-        finalizeToolHeaders();
-      } else {
-        finalizeToolHeaders();
-        pushNotice(toolErrorDisplay(error, 'turn'), 'error');
-      }
-    } finally {
-      denyAllToolApprovals(cancelled ? 'turn cancelled' : 'turn finished');
-      // Turn is unwinding normally (or via abort) — cancel the wall-clock
-      // watchdog + its force-release grace so they never fire on a live turn.
-      clearWatchdog();
-      // If the watchdog force-release already fired, a NEWER turn now owns the
-      // shared store (busy, activePromptRestore, turndone, drain). This stale
-      // unwind must NOT write shared state or it corrupts that turn. It still
-      // runs its own turn-local teardown (approvals, deferred cards) below.
-      const isStaleUnwind = leadTurnEpoch !== turnEpoch;
-      // Flush any still-deferred tool cards into the transcript and cancel their
-      // pending push timers so nothing fires (or leaks) after the turn ends. The
-      // finalize path above already patches results onto visible cards; this just
-      // guarantees every registered card is materialized before the turn closes.
-      // Collect (don't emit) the still-deferred cards so the turn-close flush and
-      // the turndone item append in ONE set() below instead of one render bounce
-      // per row. Order/ids are preserved (creation order, then turndone last).
-      let closingItems = [];
-      if (deferredEntries.length) {
-        const last = deferredEntries[deferredEntries.length - 1];
-        closingItems = collectDeferredUpTo(last);
-        clearDeferredTimers();
-      }
-      flushDeferredBeforeImmediatePush = null;
-      const producedTranscriptItem =
-        state.items.length + closingItems.length > itemsAtTurnStart;
-      const reclaimed = cancelled && activePromptRestore?.reclaimed === true;
-      if (!isStaleUnwind) activePromptRestore = null;
-      closeThinkingSegment();
-      const elapsedMs = Date.now() - startedAt;
-      const thinkingElapsedMs = thinkingStartedAt ? accumulatedThinkingMs : 0;
-      // responseLength is engine-local now (not pushed per-token), so compute the
-      // fallback from the live accumulator instead of the possibly-stale
-      // state.spinner.responseLength. Final-only / non-streaming turns never
-      // accumulate `assistantText` (only currentAssistantText is set at the
-      // finalize reconcile above), so take the larger of the two text sources so
-      // a no-usage turn still estimates tokens from the final content.
-      const finalAssistantLen = Math.max(assistantText.length, currentAssistantText.length);
-      const finalResponseLength = finalAssistantLen + thinkingText.length;
-      const finalOutputTokens = Math.max(0, Number(state.spinner?.outputTokens || 0), Math.round(finalResponseLength / 4));
-      const turnStatus = cancelled ? 'cancelled' : 'done';
-      const resultContent = askResult?.content != null ? String(askResult.content).trim() : '';
-      const assistantOutput = (currentAssistantText || assistantText || '').trim();
-      // Suppress only true pending-resume no-ops: no transcript items added and no model output; cancelled/error turns and any visible turn stay marked.
-      const isNoOpTurn = turnFinishedNormally
-        && !cancelled
-        && toolCards.length === 0
-        && !resultContent
-        && !assistantOutput
-        && !producedTranscriptItem;
-      if (isStaleUnwind) {
-        // Preserve prior behavior: a stale unwind still materializes its own
-        // deferred cards (turn-local teardown) but writes no other shared state.
-        if (closingItems.length) appendItemsBatch(closingItems);
-        tuiDebug(`runTurn STALE UNWIND turn=${turnIndex} — force-released; skipping shared-state writes`);
-      } else {
-      if (!isNoOpTurn) {
-        state.stats.turns = (state.stats.turns || 0) + 1;
-      }
-      // Pin the post-think summary into the transcript right after this turn's
-      // output so it scrolls up with the answer and stays in the scrollback,
-      // in scrollback. (Previously TurnDone rendered only in the
-      // bottom-fixed live-status slot and vanished on the next turn.)
-      if (!reclaimed && !isNoOpTurn) {
-        closingItems.push({ kind: 'turndone', id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
-      }
-      // Deferred cards + turndone + status all land in ONE set() (one commit).
-      appendItemsBatch(closingItems, {
-        busy: false,
-        spinner: null,
-        thinking: null,
-        lastTurn: null,
-        stats: { ...state.stats },
-        ...routeState(),
-        toolMode: runtime.toolMode,
-        ...agentStatusState({ force: true }),
-      });
-      flushDeferredExecutionPendingResumeKick();
-      }
-    }
-    // Shared UI state: a stale unwind must not wipe a newer turn's live
-    // tool-summary line (same epoch rule as the shared-state block above).
-    if (leadTurnEpoch === turnEpoch) clearActiveToolSummary();
-    _publishedThinkingActive = false; // turn teardown cleared state.thinking
-    tuiDebug(`runTurn end turn=${turnIndex} status=${cancelled ? 'cancelled' : 'done'} elapsedMs=${Date.now() - startedAt}${watchdogTripped ? ' watchdogTripped=1' : ''} pending=${pending.length}`);
-    return cancelled ? 'cancelled' : 'done';
-  }
-
-  const pending = [];
-  let draining = false;
-  let activePromptRestore = null;
-  // Monotonic per-lead-turn epoch (see runTurn). Bumped on watchdog
-  // force-release so a stale turn's late `finally` can detect it no longer owns
-  // the shared store and skip all shared-state writes.
-  let leadTurnEpoch = 0;
-
-  const leadSessionId = () => runtime.id;
-
-  function shouldMirrorSteeringEntry(entry) {
-    return isQueuedEntryEditable(entry) && !isSlashQueuedEntry(entry);
-  }
-
-  function commitSteeringQueueEntries(entries) {
-    callCommitCallbacks(entries);
-    const mirrored = (Array.isArray(entries) ? entries : []).filter(
-      (entry) => shouldMirrorSteeringEntry(entry) && !entry.steeringPersistRestored,
-    );
-    if (mirrored.length > 0) dropTuiSteeringPersist(leadSessionId(), mirrored);
-  }
-
-  function makeQueueEntry(text, options = {}) {
-    const mode = options.mode || 'prompt';
-    const priority = options.priority || defaultQueuePriority(mode);
-    const displayText = promptDisplayText(text, options);
-    return {
-      id: options.id || nextId(),
-      text: displayText,
-      content: text,
-      pastedImages: options.pastedImages && typeof options.pastedImages === 'object' ? options.pastedImages : null,
-      pastedTexts: options.pastedTexts && typeof options.pastedTexts === 'object' ? options.pastedTexts : null,
-      onCommitted: typeof options.onCommitted === 'function' ? options.onCommitted : null,
-      mode,
-      priority,
-      key: options.key || null,
-      skipSlashCommands: options.skipSlashCommands === true,
-      displayText: mode === 'task-notification' ? notificationDisplayText(displayText) : String(displayText || ''),
-      steeringPersistId: options.steeringPersistId || null,
-      steeringPersistRestored: options.steeringPersistRestored === true,
-    };
-  }
-
-  function removeQueuedEntries(entries) {
-    const ids = new Set(entries.map((entry) => entry.id));
-    const keys = entries.map((entry) => entry.key).filter(Boolean);
-    for (const key of keys) pendingNotificationKeys.delete(key);
-    for (const key of keys) displayedExecutionNotificationKeys.delete(key);
-    const queued = state.queued.filter((q) => !ids.has(q.id));
-    if (queued.length !== state.queued.length) set({ queued });
-  }
-
-  function requeueEntriesFront(entries) {
-    const restored = [];
-    for (const entry of entries || []) {
-      if (!entry || !String(entry.text || '').trim()) continue;
-      const next = {
-        ...entry,
-        displayText: entry.displayText || (entry.mode === 'task-notification' ? notificationDisplayText(entry.text) : String(entry.text || '')),
-      };
-      if (next.mode === 'task-notification' && next.key) {
-        if (pendingNotificationKeys.has(next.key)) continue;
-        pendingNotificationKeys.add(next.key);
-      }
-      restored.push(next);
-    }
-    if (restored.length === 0) return false;
-    pending.unshift(...restored);
-    const visible = restored.filter(isQueuedEntryVisible);
-    if (visible.length > 0) set({ queued: [...visible, ...state.queued] });
-    return true;
-  }
-
-  function dequeueQueueBatch(maxPriority = 'later', options = {}) {
-    if (pending.length === 0) return [];
-    const max = queuePriorityValue(maxPriority);
-    const predicate = typeof options.predicate === 'function' ? options.predicate : () => true;
-    const limit = Math.max(1, Number(options.limit) || Infinity);
-    let bestPriority = Infinity;
-    let targetMode = null;
-    for (const entry of pending) {
-      if (!predicate(entry)) continue;
-      const p = queuePriorityValue(entry.priority);
-      if (p > max) continue;
-      if (p < bestPriority) {
-        bestPriority = p;
-        targetMode = entry.mode || 'prompt';
-      }
-    }
-    if (!targetMode) return [];
-    const batch = [];
-    for (let i = 0; i < pending.length;) {
-      const entry = pending[i];
-      if (predicate(entry) && (entry.mode || 'prompt') === targetMode && queuePriorityValue(entry.priority) === bestPriority) {
-        batch.push(entry);
-        pending.splice(i, 1);
-        if (batch.length >= limit) break;
-      } else {
-        i += 1;
-      }
-    }
-    removeQueuedEntries(batch);
-    return batch;
-  }
-
-  async function drain() {
-    if (draining) return;
-    if (autoClearRunning) return;
-    draining = true;
-    let firstBatch = true;
-    try {
-      while (pending.length > 0) {
-        // Drain one priority/mode bucket at a time (unified command queue):
-        // unified command queue semantics: prompt steering stays editable and
-        // task notifications stay non-editable but model-visible.
-        const batch = dequeueQueueBatch('later', { limit: firstBatch ? 1 : Infinity });
-        firstBatch = false;
-        if (batch.length === 0) break;
-        tuiDebug(`busy-queue drain batch=${batch.length} remaining=${pending.length}`);
-        const ids = new Set(batch.map((e) => e.id));
-        const merged = mergePromptContents(batch);
-        for (const entry of batch) {
-          if (entry.mode === 'pending-resume') continue;
-          pushUserOrSyntheticItem(entry.text, entry.id, isQueuedEntryEditable(entry) ? 'user' : 'injected');
-        }
-        const nonEditable = batch.filter((entry) => !isQueuedEntryEditable(entry));
-        const batchPastedImages = mergePastedImages(batch);
-        const batchPastedTexts = mergePastedTexts(batch);
-        const turnStatus = await runTurn(merged, {
-          displayText: batch.map((entry) => entry.text).filter((text) => String(text || '').trim()).join('\n'),
-          pastedImages: batchPastedImages,
-          pastedTexts: batchPastedTexts,
-          onCommitted: () => commitSteeringQueueEntries(batch),
-          submittedIds: [...ids],
-          restorable: nonEditable.length === 0,
-          requeueOnAbort: nonEditable,
-        });
-        // session_manage tool: the model scheduled a reset during this turn.
-        // Run it now, at the turn boundary — same clear body as auto-clear.
-        // Cancelled/interrupted turns drop the reset (consume + discard): the
-        // user aborted the turn that asked for it, so the destructive clear
-        // must not fire. commandBusy guards against a concurrent session
-        // command (resume/new) racing the async clear.
-        const scheduledReset = runtime.consumePendingSessionReset?.();
-        if ((scheduledReset === 'clear' || scheduledReset === 'compact_clear')
-          && turnStatus !== 'cancelled'
-          && !state.commandBusy) {
-          await performSessionClear({
-            verb: scheduledReset === 'clear' ? 'Clearing conversation' : 'Compacting and clearing conversation',
-            doneLabel: scheduledReset === 'clear' ? 'Session cleared' : 'Session compacted and cleared',
-            skipLabel: 'Session reset skipped',
-            surface: 'session-manage',
-            useCompaction: scheduledReset === 'compact_clear',
-          });
-        }
-        // If the user re-submits the reclaimed prompt while the cancelled turn
-        // is still unwinding, enqueue() cannot start another drain because this
-        // drain loop is still active. Continue when pending work appeared during
-        // cancellation so the fresh submit does not get stuck in queued state.
-        if (turnStatus === 'cancelled' && pending.length === 0) break;
-      }
-    } finally {
-      draining = false;
-      if (pending.length > 0) void drain();
-      else flushDeferredExecutionPendingResumeKick();
-    }
-  }
-  function enqueue(text, options = {}) {
-    const entry = makeQueueEntry(text, options);
-    if (entry.mode === 'task-notification' && entry.key) {
-      if (pendingNotificationKeys.has(entry.key)) return false;
-      pendingNotificationKeys.add(entry.key);
-    }
-    pending.push(entry);
-    if (state.busy && shouldMirrorSteeringEntry(entry)) {
-      appendTuiSteeringPersist(leadSessionId(), entry);
-    }
-    if (isQueuedEntryVisible(entry)) set({ queued: [...state.queued, entry] });
-    if (state.busy) tuiDebug(`busy-queue enqueue mode=${entry.mode} pending=${pending.length}`);
-    void drain();
-    return true;
-  }
-
-  function drainPendingSteering() {
-    // Mid-turn steering drain:
-    // Injects queued user prompts (steering) plus non-editable internal entries
-    // into the CURRENT provider pre-send window so the user can redirect a turn
-    // that is already running. Slash commands are still excluded: they must run
-    // through the normal command processor after the turn, not be sent as plain
-    // text. Consumed entries are spliced out of `pending` here, so the post-turn
-    // drain() loop will not re-execute them.
-    const batch = dequeueQueueBatch('next', { predicate: (entry) => !isSlashQueuedEntry(entry) });
-    if (batch.length === 0) return [];
-    const out = batch
-      .map((entry) => {
-        const content = entry.content;
-        if (typeof content === 'string') return content.trim();
-        return { text: String(entry.text || '').trim(), content };
-      })
-      .filter((entry) => {
-        if (typeof entry === 'string') return entry.length > 0;
-        if (Array.isArray(entry?.content)) return entry.content.length > 0;
-        return String(entry?.content ?? '').trim().length > 0;
-      });
-    commitSteeringQueueEntries(batch);
-    return out;
-  }
-
-  async function restoreLeadSteeringFromDisk() {
-    const rows = await drainTuiSteeringPersist(leadSessionId());
-    if (!rows.length) return;
-    const restored = [];
-    for (const row of rows) {
-      const entry = makeQueueEntry(row.text, {
-        steeringPersistRestored: true,
-        steeringPersistId: row.steeringPersistId || undefined,
-      });
-      pending.push(entry);
-      if (isQueuedEntryVisible(entry)) restored.push(entry);
-    }
-    if (restored.length > 0) set({ queued: [...state.queued, ...restored] });
-    void drain();
-  }
-
-  async function autoClearBeforeSubmit() {
-    const cfg = autoClearState();
-    const now = Date.now();
-    const activityAt = sessionActivityTimestamp(runtime.session, lastUserActivityAt);
-    const idleMs = activityAt ? now - activityAt : 0;
-    if (!cfg.enabled || state.busy || pending.length > 0 || autoClearRunning || idleMs < cfg.idleMs) {
-      if (!activityAt) lastUserActivityAt = now;
-      return false;
-    }
-    const minContextPercent = Number(cfg.minContextPercent ?? 10);
-    if (minContextPercent > 0) {
-      const status = runtime.contextStatus?.() || null;
-      const estimatedTokens = Math.max(0, Number(status?.currentEstimatedTokens ?? status?.usedTokens ?? 0));
-      const usedTokens = Math.max(0, Number(status?.usedTokens ?? estimatedTokens ?? 0));
-      const triggerTokens = Number(
-        status?.compaction?.triggerTokens
-        || status?.compaction?.autoCompactTokenLimit
-        || runtime.session?.autoCompactTokenLimit
-        || 0,
-      );
-      if (!(usedTokens > 0 && triggerTokens > 0)) {
-        if (!activityAt) lastUserActivityAt = now;
-        return false;
-      }
-      const usagePct = (usedTokens / triggerTokens) * 100;
-      if (usagePct < minContextPercent) {
-        if (!activityAt) lastUserActivityAt = now;
-        return false;
-      }
-    }
-    return performSessionClear({
-      verb: 'Auto-clearing idle conversation',
-      doneLabel: 'Auto-clear complete',
-      skipLabel: 'Auto-clear skipped',
-      surface: 'auto-clear',
-      useCompaction: true,
-    });
-  }
-
-  // Shared clear body for idle auto-clear and the session_manage tool.
-  // useCompaction=true mirrors auto-clear (summarize via configured
-  // compactType, context carries forward); false is a plain /clear wipe.
-  async function performSessionClear({ verb, doneLabel, skipLabel, surface, useCompaction }) {
-    autoClearRunning = true;
-    const startedAt = Date.now();
-    // commandBusy blocks concurrent session commands (resume/newSession/
-    // setModel) AND new submits for the duration of the async clear — the
-    // clear swaps the live session object, so racing commands could act on
-    // the wrong session.
-    set({ commandBusy: true, commandStatus: { active: true, verb, startedAt, mode: 'auto-clear' } });
-    try {
-      // Give Ink one event-loop turn to paint the auto-clear status before the
-      // clear/compact path starts doing synchronous session/transcript work.
-      // Without this, long idle clears can look like a frozen prompt followed by
-      // an already-complete status row.
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      let compactType = null;
-      if (useCompaction) {
-        const compaction = runtime.getCompactionSettings();
-        compactType = compaction.compactType || compaction.type || null;
-      }
-      await runtime.clear(compactType
-        ? { compactType, requireCompactSuccess: true }
-        : {});
-      resetStats();
-      clearUiActivityBeforeContextSync();
-      syncContextStats({ allowEstimated: true });
-      set({
-        items: replaceItems([]),
-        toasts: [],
-        queued: [],
-        thinking: null,
-        spinner: null,
-        lastTurn: null,
-        ...routeState(),
-        stats: { ...state.stats },
-      });
-      pushItem({
-        kind: 'statusdone',
-        id: nextId(),
-        label: doneLabel,
-      });
-      return true;
-    } catch (error) {
-      const message = presentErrorText(error, { surface });
-      pushItem({
-        kind: 'statusdone',
-        id: nextId(),
-        label: skipLabel,
-        detail: `conversation kept · ${message}`,
-      });
-      pushNotice(`${surface} skipped: ${message}`, 'error');
-      return false;
-    } finally {
-      lastUserActivityAt = Date.now();
-      autoClearRunning = false;
-      set({ commandBusy: false, commandStatus: null });
-      void drain();
-    }
-  }
-
-  function restoreQueued(currentText = '') {
-    const queued = [];
-    for (let i = 0; i < pending.length;) {
-      const entry = pending[i];
-      if (isQueuedEntryEditable(entry)) {
-        queued.push(entry);
-        pending.splice(i, 1);
-      } else {
-        i += 1;
-      }
-    }
-    removeQueuedEntries(queued);
-    const queuedText = queued.map((item) => item.text).filter((text) => String(text || '').trim()).join('\n');
-    const combinedText = [queuedText, String(currentText || '')].filter((text) => text.trim()).join('\n');
-    return { count: queued.length, text: combinedText, pastedImages: mergePastedImages(queued), pastedTexts: mergePastedTexts(queued) };
-  }
-
-  const resetStats = () => {
-    state.stats = createSessionStats();
-    return state.stats;
-  };
-  const clearUiActivityBeforeContextSync = () => {
-    state.items = replaceItems([]);
-    state.toasts = [];
-    state.queued = [];
-    state.thinking = null;
-    state.spinner = null;
-    state.lastTurn = null;
-    state.busy = false;
-    pendingNotificationKeys.clear();
-    displayedExecutionNotificationKeys.clear();
-  };
-  const resetTuiForPendingSessionReset = () => {
-    pendingSessionReset = true;
-    clearUiActivityBeforeContextSync();
-    resetStats();
-    state.stats.currentContextTokens = 0;
-    state.stats.currentEstimatedContextTokens = 0;
-    state.stats.currentContextSource = null;
-    state.stats.currentContextUpdatedAt = Date.now();
-    state.displayContextWindow = 0;
-    state.compactBoundaryTokens = 0;
-    state.autoCompactTokenLimit = 0;
-  };
-  const snapshotTuiBeforeSessionReset = () => ({
-    items: state.items.slice(),
-    toasts: state.toasts.slice(),
-    queued: state.queued.slice(),
-    thinking: state.thinking,
-    spinner: state.spinner,
-    lastTurn: state.lastTurn,
-    busy: state.busy,
-    stats: { ...state.stats },
-    sessionId: state.sessionId,
+  Object.assign(bag, {
+    runtime, nextId, tuiDebug, LEAD_TURN_TIMEOUT_MS,
+    flags, lifecycle, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, listeners, itemIndexById,
+    getState: () => state, set,
+    pushItem, patchItem, replaceItems, pushToast, pushNotice, removeNotice, setProgressHint,
+    pushUserOrSyntheticItem, upsertSyntheticToolItem,
+    markToolCallActive, markToolCallDone, clearActiveToolSummary, clearToastTimers,
+    autoClearState, agentStatusState, baseRouteState, routeState, syncContextStats,
+    presentNextToolApproval, finishToolApproval, denyAllToolApprovals, requestToolApproval,
+    patchToolCardResult, flushToolResults,
+    kickExecutionPendingResume, flushDeferredExecutionPendingResumeKick, scheduleExecutionPendingResumeKick, updateAgentJobCard, subscribeRuntimeNotifications,
   });
-  const restoreTuiAfterFailedSessionReset = (snapshot) => {
-    if (!snapshot) return;
-    pendingSessionReset = false;
-    state.items = replaceItems(snapshot.items);
-    state.toasts = snapshot.toasts.slice();
-    state.queued = snapshot.queued.slice();
-    state.thinking = snapshot.thinking;
-    state.spinner = snapshot.spinner;
-    state.lastTurn = snapshot.lastTurn;
-    state.busy = snapshot.busy;
-    state.stats = { ...snapshot.stats };
-    syncContextStats({ allowEstimated: true });
-    set({
-      items: state.items,
-      toasts: state.toasts,
-      queued: state.queued,
-      thinking: state.thinking,
-      spinner: state.spinner,
-      lastTurn: state.lastTurn,
-      busy: state.busy,
-      ...routeState(),
-      stats: { ...state.stats },
-      ...agentStatusState(),
-    });
-  };
-  const resetStatsAndSyncContext = () => {
-    resetStats();
-    syncContextStats({ allowEstimated: true });
-    return state.stats;
-  };
-
-  void restoreLeadSteeringFromDisk();
-
-  return {
-    getState: () => state,
-    patchItem,
-    subscribe: (listener) => {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    submit: (text, options = {}) => {
-      const t = promptDisplayText(text, options).trim();
-      if (!t) return false;
-      const mode = options.mode || 'prompt';
-     // Prompt input queued while a turn is active keeps the
-     // default `next` priority, so it is injected at the next tool/model
-     // boundary. Explicit options.priority still wins.
-     const priority = options.priority;
-      const queueOptions = {
-        ...options,
-        mode,
-        displayText: promptDisplayText(text, options),
-        priority,
-      };
-      // A running clear (idle auto-clear or session_manage) sets commandBusy;
-      // queue the prompt instead of dropping it — it drains after the clear.
-      if (autoClearRunning) {
-        enqueue(text, queueOptions);
-        return true;
-      }
-      if (state.commandBusy) return false;
-      if (state.busy) {
-        enqueue(text, queueOptions);
-        return true;
-      }
-      void autoClearBeforeSubmit().then(() => enqueue(text, queueOptions));
-      return true;
-    },
-    restoreQueued,
-    setModel: async (m) => {
-      if (state.commandBusy) return false;
-      set({ commandBusy: true });
-      try {
-        // Model changes apply to the NEXT session only (default setRoute
-        // behavior) — never rewrite the live session's provider/model, which
-        // would force a full prompt-cache rewrite mid-conversation.
-        await runtime.setRoute({ model: m });
-        set({ ...routeState(), stats: { ...state.stats } });
-        return true;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    setEffort: async (value) => {
-      if (state.commandBusy) return false;
-      set({ commandBusy: true });
-      try {
-        await runtime.setEffort(value);
-        set({ ...routeState() });
-        return runtime.effort || 'auto';
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    setFast: async (value) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const enabled = await runtime.setFast(value);
-        set({ ...routeState() });
-        return enabled;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    toggleFast: async () => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const enabled = await runtime.toggleFast();
-        set({ ...routeState() });
-        return enabled;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    setToolMode: (m) => {
-      void runtime.setToolMode(m)
-        .then(() => {
-          resetStatsAndSyncContext();
-          set({ ...routeState(), toolMode: runtime.toolMode, stats: { ...state.stats } });
-        })
-        .catch((error) => pushNotice(toolErrorDisplay(error, 'tool'), 'error'));
-    },
-    getAutoClear: () => autoClearState(),
-    setAutoClear: (input = {}) => {
-      const next = runtime.setAutoClear?.(input) || autoClearState();
-      set({ autoClear: next });
-      return next;
-    },
-    getUpdateSettings: () => runtime.getUpdateSettings?.() || null,
-    setAutoUpdate: (enabled) => runtime.setAutoUpdate?.(enabled),
-    checkForUpdate: (input = {}) => runtime.checkForUpdate?.(input),
-    runUpdateNow: () => runtime.runUpdateNow?.(),
-    getUpdateStatus: () => runtime.getUpdateStatus?.() || { phase: 'idle' },
-    getProfile: () => runtime.getProfile?.() || { title: '', language: 'system', languages: [] },
-    setProfile: (input = {}) => {
-      const next = runtime.setProfile?.(input) || runtime.getProfile?.() || null;
-      return next;
-    },
-    getCompactionSettings: () => {
-      return runtime.getCompactionSettings?.() || {};
-    },
-    setCompactionSettings: async (input = {}) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const next = runtime.setCompactionSettings?.(input) || {};
-        set({ ...routeState(), stats: { ...state.stats } });
-        // Context-stats recompute (transcript scan + per-message JSON
-        // stringify) is the secondary hitch source on this toggle; defer it
-        // off the key-handler tick so Ink repaints the setting change first.
-        // Stats become eventually consistent on the next tick/repaint.
-        setTimeout(() => {
-          syncContextStats({ allowEstimated: true });
-          set({ stats: { ...state.stats } });
-        }, 0);
-        return next;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    getMemorySettings: () => {
-      return runtime.getMemorySettings?.() || { enabled: true };
-    },
-    setMemoryEnabled: async (enabled) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const next = await runtime.setMemoryEnabled?.(enabled);
-        set({ ...routeState(), stats: { ...state.stats } });
-        // Deferred for the same reason as setCompactionSettings above: keep
-        // the recompute off the key-handler tick so the toggle repaints
-        // immediately; stats catch up right after.
-        setTimeout(() => {
-          syncContextStats({ allowEstimated: true });
-          set({ stats: { ...state.stats } });
-        }, 0);
-        return next;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    getChannelSettings: (options = {}) => {
-      return runtime.getChannelSettings?.(options) || {
-        enabled: true,
-        ...(options?.includeStatus === false ? {} : { status: runtime.getChannelWorkerStatus?.() }),
-      };
-    },
-    setChannelsEnabled: async (enabled) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const next = await runtime.setChannelsEnabled?.(enabled);
-        set({ ...routeState(), stats: { ...state.stats } });
-        return next;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    agentControl: async (args = {}) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.agentControl(args);
-        const text = String(result ?? '').trim();
-        const itemId = nextId();
-        pushItem({
-          kind: 'tool',
-          id: itemId,
-          name: 'agent',
-          args,
-          result: null,
-          isError: false,
-          expanded: false,
-          count: 1,
-          completedCount: 0,
-          startedAt: Date.now(),
-        });
-        updateAgentJobCard(itemId, text, /^error:/i.test(text));
-        set(agentStatusState({ force: true }));
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    toolsStatus: (query = '') => {
-      return runtime.toolsStatus?.(query) || { mode: state.toolMode, count: 0, activeCount: 0, tools: [] };
-    },
-    selectTools: (names) => {
-      const result = runtime.selectTools?.(names) || { added: [], already: [], blocked: [], missing: [] };
-      const added = result.added?.length ? `added ${result.added.join(', ')}` : '';
-      const already = result.already?.length ? `already ${result.already.join(', ')}` : '';
-      const blocked = result.blocked?.length ? `blocked ${result.blocked.map((row) => row.name).join(', ')}` : '';
-      const missing = result.missing?.length ? `missing ${result.missing.join(', ')}` : '';
-      pushNotice(
-        [added, already, blocked, missing].filter(Boolean).join(' - ') || 'no tool changes',
-        result.blocked?.length || result.missing?.length ? 'warn' : 'info',
-      );
-      return result;
-    },
-    setCwd: (path, options = {}) => {
-      const next = runtime.setCwd(path);
-      set({ cwd: next });
-      if (options?.notice !== false) {
-        pushNotice(options?.message || `Project set: ${projectNameFromPath(next)}`, 'info');
-      }
-      return next;
-    },
-    getSystemShell: () => {
-      return runtime.getSystemShell?.() || runtime.systemShell || { source: 'auto', command: '', effective: '' };
-    },
-    setSystemShell: (command) => {
-      const next = runtime.setSystemShell?.(command) || { source: 'auto', command: '', effective: '' };
-      set({ ...routeState(), systemShell: next });
-      pushNotice(`system shell -> ${next.effective || 'auto'}`, 'info');
-      return next;
-    },
-    mcpStatus: () => {
-      return runtime.mcpStatus?.() || { servers: [], configuredCount: 0, connectedCount: 0, failedCount: 0 };
-    },
-    reconnectMcp: async () => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const status = await runtime.reconnectMcp?.();
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice(
-          `mcp reconnect: ${status?.connectedCount || 0}/${status?.configuredCount || 0} connected${status?.failedCount ? ` - ${status.failedCount} failed` : ''}`,
-          status?.failedCount ? 'warn' : 'info',
-        );
-        return status;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    addMcpServer: async (input) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.addMcpServer?.(input);
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice(`mcp added: ${result?.name || input?.name || 'server'}`, 'info');
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    removeMcpServer: async (name) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const status = await runtime.removeMcpServer?.(name);
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice(`mcp removed: ${name}`, 'info');
-        return status;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    setMcpServerEnabled: async (name, enabled) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const status = await runtime.setMcpServerEnabled?.(name, enabled);
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice(`mcp ${enabled ? 'enabled' : 'disabled'}: ${name}`, 'info');
-        return status;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    getDisabledSkills: () => runtime.getDisabledSkills?.() || { disabled: [] },
-    setDisabledSkills: (disabled) => runtime.setDisabledSkills?.(disabled) || { disabled: [] },
-    skillsStatus: () => {
-      return runtime.skillsStatus?.() || { cwd: state.cwd, count: 0, skills: [] };
-    },
-    skillContent: (name) => {
-      return runtime.skillContent?.(name);
-    },
-    addSkill: async (input) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.addSkill?.(input);
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice(`skill added: ${result?.skill?.name || input?.name || 'skill'}`, 'info');
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    reloadSkills: async () => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const status = await runtime.reloadSkills?.();
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice(`skills reload: ${status?.count || 0} available`, 'info');
-        return status;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    pluginsStatus: () => {
-      return runtime.pluginsStatus?.() || { count: 0, plugins: [] };
-    },
-    reloadPlugins: async () => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const status = await runtime.reloadPlugins?.();
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice(`plugins reload: ${status?.count || 0} detected`, 'info');
-        return status;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    addPlugin: async (source) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.addPlugin?.(source);
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice(`plugin added: ${result?.plugin?.title || result?.plugin?.name || source}`, 'info');
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    updatePlugin: async (plugin) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.updatePlugin?.(plugin);
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice(`plugin updated: ${result?.plugin?.title || result?.plugin?.name || plugin?.name || plugin}`, 'info');
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    removePlugin: async (plugin) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.removePlugin?.(plugin);
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice(`plugin uninstalled: ${result?.plugin?.title || result?.plugin?.name || plugin?.name || plugin}`, 'info');
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    enablePluginMcp: async (plugin) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.enablePluginMcp?.(plugin);
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice(`plugin MCP enabled: ${result?.serverName || plugin?.name || 'plugin'}`, 'info');
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    hooksStatus: () => {
-      return runtime.hooksStatus?.() || { enabled: false, events: [], recent: [] };
-    },
-    contextStatus: () => {
-      return runtime.contextStatus?.() || null;
-    },
-    addHookRule: (rule) => {
-      const rules = runtime.addHookRule?.(rule) || [];
-      pushNotice(`hook rule added (${rules.length} total)`, 'info');
-      return rules;
-    },
-    setHookRuleEnabled: (index, enabled) => {
-      const rules = runtime.setHookRuleEnabled?.(index, enabled) || [];
-      pushNotice(`hook rule ${index + 1} ${enabled ? 'enabled' : 'disabled'}`, 'info');
-      return rules;
-    },
-    deleteHookRule: (index) => {
-      const rules = runtime.deleteHookRule?.(index) || [];
-      pushNotice(`hook rule ${index + 1} deleted`, 'info');
-      return rules;
-    },
-    memoryControl: async (args = {}, options = {}) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.memoryControl(args);
-        const text = String(result || '').trim() || '(empty memory result)';
-        if (!options.silent) pushNotice(text, 'info');
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    recall: async (query, args = {}) => {
-      if (state.commandBusy) return null;
-      const startedAt = Date.now();
-      set({ commandBusy: true, commandStatus: { active: true, verb: 'Recalling memory', startedAt, mode: 'recalling' } });
-      try {
-        const result = await runtime.recall(query, args);
-        pushNotice(String(result || '').trim() || '(empty recall result)', 'info');
-        return result;
-      } finally {
-        set({ commandBusy: false, commandStatus: null });
-      }
-    },
-    compact: async () => {
-      if (state.commandBusy) return null;
-      if (state.busy) {
-        pushNotice('Compact skipped: turn in progress', 'info');
-        return { changed: false, reason: 'compact skipped: turn in progress' };
-      }
-      const startedAt = Date.now();
-      set({ commandBusy: true, commandStatus: { active: true, verb: 'Compacting conversation', startedAt, mode: 'compacting' } });
-      try {
-        // Give Ink one event-loop turn to paint the compacting spinner before
-        // runtime.compact() starts synchronous session/transcript work (same
-        // yield as the auto-clear path; without it /compact looks frozen with
-        // no spinner until the compact already finished).
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        const result = await runtime.compact({ recoverAgent: true });
-        syncContextStats({ allowEstimated: true });
-        set({ ...routeState(), stats: { ...state.stats } });
-        if (result) {
-          pushItem({
-            kind: 'statusdone',
-            id: nextId(),
-            label: result.error ? 'Compact failed' : (result.changed === false ? 'Compact checked' : 'Compact complete'),
-            detail: compactEventDetail({
-              stage: 'manual',
-              trigger: 'manual',
-              status: result.error ? 'failed' : (result.changed === false ? 'no_change' : 'compacted'),
-              compactType: result.compactType,
-              beforeTokens: result.beforeTokens,
-              afterTokens: result.afterTokens,
-              beforeMessages: result.beforeMessages,
-              afterMessages: result.afterMessages,
-              semantic: result.semanticCompact,
-              recallFastTrack: result.recallFastTrack,
-              durationMs: Date.now() - startedAt,
-              error: result.error,
-            }),
-          });
-        } else {
-          // null = session missing/closed: still surface a done row so
-          // /compact never ends silently without a completion marker.
-          pushItem({
-            kind: 'statusdone',
-            id: nextId(),
-            label: 'Compact failed',
-            detail: 'no active session',
-          });
-        }
-        return result;
-      } finally {
-        set({ commandBusy: false, commandStatus: null });
-      }
-    },
-    abort: () => {
-      if (!state.busy) return false;
-      denyAllToolApprovals('interrupted by user');
-      const restoreState = activePromptRestore;
-      // A queued steering prompt means the user already redirected the turn:
-      // interrupting should just cancel the running turn and let the steering
-      // prompt run next, NOT resurrect the in-flight prompt back into the draft.
-      const hasPendingSteering = pending.some((entry) => isQueuedEntryEditable(entry));
-      const canRestore = restoreState?.restorable && !hasPendingSteering;
-      const restoreText = canRestore ? restoreState.text : '';
-      const restorePastedImages = canRestore && restoreState?.pastedImages ? restoreState.pastedImages : null;
-      const restorePastedTexts = canRestore && restoreState?.pastedTexts ? restoreState.pastedTexts : null;
-      // When steering suppresses the restore, the interrupted prompt's pasted
-      // images never get committed (onCommitted won't fire) nor re-installed into
-      // the draft, so hand them back for cleanup to avoid a stale `[Image #id]`
-      // lingering in the paste snapshot.
-      const discardPastedImages = restoreState?.restorable && hasPendingSteering && restoreState?.pastedImages
-        ? restoreState.pastedImages
-        : null;
-      const discardPastedTexts = restoreState?.restorable && hasPendingSteering && restoreState?.pastedTexts
-        ? restoreState.pastedTexts
-        : null;
-      const requeueEntries = restoreState && !restoreState.committed && Array.isArray(restoreState.requeueEntries)
-        ? restoreState.requeueEntries.slice()
-        : [];
-      const aborted = runtime.abort('cli-react-abort');
-      if (restoreState) {
-        if ((restoreText || requeueEntries.length > 0) && aborted !== false) {
-          restoreState.reclaimed = true;
-          const idSet = new Set((restoreState.submittedIds || []).filter((id) => id != null));
-          const patch = { spinner: null, thinking: null, lastTurn: null };
-          if (idSet.size > 0) {
-            const items = state.items.filter((item) => !idSet.has(item?.id));
-            if (items.length !== state.items.length) {
-              patch.items = replaceItems(items);
-            }
-          }
-          set(patch);
-          if (requeueEntries.length > 0) requeueEntriesFront(requeueEntries);
-        }
-        restoreState.restorable = false;
-        restoreState.requeueEntries = [];
-      }
-      return { aborted, restoreText, pastedImages: restorePastedImages, discardPastedImages, pastedTexts: restorePastedTexts, discardPastedTexts };
-    },
-    resolveToolApproval: (id, decision = {}) => {
-      const approved = decision === true || decision?.approved === true;
-      return finishToolApproval(id, approved, decision?.reason || (approved ? 'approved by user' : 'denied by user'));
-    },
-    listPresets: () => {
-      return runtime.listPresets();
-    },
-    listProviderModels: (options = {}) => {
-      return runtime.listProviderModels(options);
-    },
-    getSearchRoute: () => {
-      return runtime.getSearchRoute?.() || runtime.searchRoute || null;
-    },
-    listSearchModels: (options = {}) => {
-      return runtime.listSearchModels?.(options) || [];
-    },
-    setSearchRoute: async (opts) => {
-      if (state.commandBusy) return null;
-      const beforeRouteState = routeState();
-      const optimisticSearchRoute = opts?.provider && opts?.model
-        ? {
-            provider: String(opts.provider).trim(),
-            model: String(opts.model).trim(),
-            ...(opts.effort ? { effort: opts.effort } : {}),
-            ...(opts.fast === true ? { fast: true } : {}),
-            ...(opts.toolType ? { toolType: opts.toolType } : {}),
-          }
-        : null;
-      set({ commandBusy: true });
-      try {
-        if (optimisticSearchRoute?.provider && optimisticSearchRoute.model) {
-          set({ searchRoute: optimisticSearchRoute });
-        }
-        const result = await runtime.setSearchRoute?.(opts);
-        set({ ...routeState(), stats: { ...state.stats } });
-        return result;
-      } catch (e) {
-        set({ searchRoute: beforeRouteState.searchRoute || null });
-        throw e;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    listAgents: () => {
-      return runtime.listAgents?.() || [];
-    },
-    listWorkflows: () => {
-      return runtime.listWorkflows?.() || [];
-    },
-    getOutputStyle: () => {
-      return runtime.getOutputStyle?.() || runtime.listOutputStyles?.() || null;
-    },
-    listOutputStyles: () => {
-      return runtime.listOutputStyles?.() || runtime.getOutputStyle?.() || { styles: [], current: null, configured: 'default' };
-    },
-    setOutputStyle: async (styleId) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.setOutputStyle?.(styleId);
-        resetStats();
-        set({ ...routeState(), stats: { ...state.stats } });
-        // Defer the context recompute (transcript scan) off this tick so
-        // the style change repaints immediately; stats settle right after.
-        setTimeout(() => {
-          syncContextStats({ allowEstimated: true });
-          set({ stats: { ...state.stats } });
-        }, 0);
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    setWorkflow: async (workflowId) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.setWorkflow?.(workflowId);
-        set({ ...routeState(), stats: { ...state.stats } });
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    // Toggle Discord remote mode for this session. Flips the runtime's
-    // remoteEnabled flag (booting/stopping the channel worker) and returns the
-    // NEW enabled state so the caller can render an ON/OFF notice.
-    toggleRemote: () => {
-      const enabled = runtime.isRemoteEnabled?.() === true;
-      if (enabled) runtime.stopRemote?.();
-      else runtime.startRemote?.();
-      const next = runtime.isRemoteEnabled?.() === true;
-      set({ remoteEnabled: next });
-      return next;
-    },
-    // Force-claim remote for this session (single-holder, last-wins). Always
-    // turns remote ON here and steals the bridge seat; the previous holder is
-    // superseded and flips itself OFF via onRemoteStateChange. Used by the
-    // `/remote` slash command — repeated /remote just re-claims (idempotent).
-    claimRemote: () => {
-      runtime.startRemote?.();
-      const next = runtime.isRemoteEnabled?.() === true;
-      set({ remoteEnabled: next });
-      return next;
-    },
-    isRemoteEnabled: () => runtime.isRemoteEnabled?.() === true,
-    // Theme is a TUI-local concern (no runtime round-trip). listThemes returns
-    // picker metadata; getTheme reports the active id; setTheme applies the
-    // palette in-place + persists ui.theme and bumps a themeEpoch so the React
-    // tree re-renders (markdown/status/spinner colorizers re-resolve).
-    listThemes: () => listThemes(),
-    getTheme: () => getThemeSetting(),
-    setTheme: (id, options = {}) => {
-      const applied = setThemeSetting(id, options);
-      set({ themeEpoch: (state.themeEpoch || 0) + 1 });
-      return applied;
-    },
-    setAgentRoute: async (agentId, opts) => {
-      return await runtime.setAgentRoute?.(agentId, opts);
-    },
-    setDefaultProvider: async (provider) => {
-      return await runtime.setDefaultProvider?.(provider);
-    },
-    listProviders: () => {
-      return runtime.listProviders();
-    },
-    getProviderSetup: () => {
-      return runtime.getProviderSetup();
-    },
-    getUsageDashboard: async (options = {}) => {
-      return await runtime.getUsageDashboard?.(options);
-    },
-    getOnboardingStatus: () => {
-      return runtime.getOnboardingStatus?.() || { completed: true, workflowRoutes: {} };
-    },
-    skipOnboarding: () => {
-      // Completed-marking only; no route/agent/provider writes.
-      return runtime.skipOnboarding?.() || null;
-    },
-    completeOnboarding: async (payload = {}) => {
-      if (state.commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.completeOnboarding?.(payload);
-        resetStatsAndSyncContext();
-        set({ ...routeState(), stats: { ...state.stats } });
-        pushNotice('first-run setup saved', 'info');
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    loginOAuthProvider: async (provider) => {
-      if (state.commandBusy) return false;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.loginOAuthProvider(provider);
-        pushNotice(`provider oauth ok: ${result.provider}`, 'info');
-        return true;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    beginOAuthProviderLogin: async (provider) => {
-      if (state.commandBusy) throw new Error('command busy');
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.beginOAuthProviderLogin(provider);
-        pushNotice(`provider oauth started: ${result.provider}`, 'info');
-        return result;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    saveProviderApiKey: (provider, secret) => {
-      const result = runtime.saveProviderApiKey(provider, secret);
-      pushNotice(`provider api key saved: ${result.provider}`, 'info');
-      return true;
-    },
-    saveOpenCodeGoUsageAuth: (opts) => {
-      const result = runtime.saveOpenCodeGoUsageAuth(opts);
-      pushNotice(result.workspaceId
-        ? `OpenCode Go usage auth saved: ${result.workspaceId}`
-        : 'OpenCode Go usage auth saved',
-        'info');
-      return true;
-    },
-    loginOpenCodeGoUsage: async () => {
-      if (state.commandBusy) throw new Error('command busy');
-      set({ commandBusy: true });
-      try {
-        return await runtime.loginOpenCodeGoUsage();
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    saveOpenAIUsageSessionKey: (secret) => {
-      runtime.saveOpenAIUsageSessionKey(secret);
-      pushNotice('OpenAI usage auth saved', 'info');
-      return true;
-    },
-    setLocalProvider: (provider, opts) => {
-      const result = runtime.setLocalProvider(provider, opts);
-      pushNotice(`local provider ${result.enabled ? 'enabled' : 'disabled'}: ${result.provider}`, 'info');
-      return true;
-    },
-    authenticateProvider: async (provider, secret) => {
-      if (state.commandBusy) return false;
-      set({ commandBusy: true });
-      try {
-        const result = await runtime.authenticateProvider(provider, secret);
-        pushNotice(`provider auth ok: ${result.provider} (${result.type})`, 'info');
-        return true;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    forgetProviderAuth: (provider) => {
-      const result = runtime.forgetProviderAuth(provider);
-      pushNotice(`provider auth forgotten: ${result.provider}`, 'info');
-      return true;
-    },
-    getChannelSetup: () => {
-      return runtime.getChannelSetup();
-    },
-    getChannelWorkerStatus: () => runtime.getChannelWorkerStatus?.(),
-    setBackend: (name) => runtime.setBackend?.(name),
-    saveDiscordToken: (token) => {
-      const result = runtime.saveDiscordToken(token);
-      pushNotice('discord token saved', 'info');
-      return result;
-    },
-    forgetDiscordToken: () => {
-      const result = runtime.forgetDiscordToken();
-      pushNotice('discord token forgotten', 'info');
-      return result;
-    },
-    saveTelegramToken: (token) => {
-      const result = runtime.saveTelegramToken?.(token);
-      pushNotice('telegram token saved', 'info');
-      return result;
-    },
-    forgetTelegramToken: () => {
-      const result = runtime.forgetTelegramToken?.();
-      pushNotice('telegram token forgotten', 'info');
-      return result;
-    },
-    saveWebhookAuthtoken: (token) => {
-      const result = runtime.saveWebhookAuthtoken(token);
-      pushNotice('webhook/ngrok authtoken saved', 'info');
-      return result;
-    },
-    forgetWebhookAuthtoken: () => {
-      const result = runtime.forgetWebhookAuthtoken();
-      pushNotice('webhook/ngrok authtoken forgotten', 'info');
-      return result;
-    },
-    setChannel: (entry) => {
-      const result = runtime.setChannel(entry);
-      pushNotice('channel saved', 'info');
-      return result;
-    },
-    setWebhookConfig: (patch) => {
-      const result = runtime.setWebhookConfig(patch);
-      pushNotice('webhook config updated', 'info');
-      return result;
-    },
-    saveSchedule: (entry) => {
-      const result = runtime.saveSchedule(entry);
-      pushNotice(`schedule saved: ${result.name}`, 'info');
-      return result;
-    },
-    deleteSchedule: (name) => {
-      const result = runtime.deleteSchedule(name);
-      pushNotice(`schedule deleted: ${name}`, 'info');
-      return result;
-    },
-    setScheduleEnabled: (name, enabled) => {
-      const result = runtime.setScheduleEnabled(name, enabled);
-      pushNotice(`schedule ${enabled ? 'enabled' : 'disabled'}: ${name}`, 'info');
-      return result;
-    },
-    saveWebhook: (entry) => {
-      const result = runtime.saveWebhook(entry);
-      pushNotice(`webhook saved: ${result.name}`, 'info');
-      return result;
-    },
-    deleteWebhook: (name) => {
-      const result = runtime.deleteWebhook(name);
-      pushNotice(`webhook deleted: ${name}`, 'info');
-      return result;
-    },
-    setWebhookEnabled: (name, enabled) => {
-      const result = runtime.setWebhookEnabled(name, enabled);
-      pushNotice(`webhook ${enabled ? 'enabled' : 'disabled'}: ${name}`, 'info');
-      return result;
-    },
-    setRoute: async (opts) => {
-      if (state.commandBusy) return false;
-      set({ commandBusy: true });
-      try {
-        const routeOpts = opts && typeof opts === 'object' ? opts : {};
-        // Default: apply to the NEXT session only. Only an explicit
-        // `applyToCurrentSession: true` rewrites the live session in place.
-        const applyToCurrentSession = routeOpts.applyToCurrentSession === true;
-        const { applyToCurrentSession: _drop, ...nextRoute } = routeOpts;
-        await runtime.setRoute(nextRoute, { applyToCurrentSession });
-        if (applyToCurrentSession) syncContextStats({ allowEstimated: true });
-        set({ ...routeState(), stats: { ...state.stats } });
-        return true;
-      } finally {
-        set({ commandBusy: false });
-      }
-    },
-    pushNotice,
-    removeNotice,
-    setProgressHint,
-    clear: async () => {
-      if (state.commandBusy) return false;
-      set({ commandBusy: true });
-      clearToastTimers();
-      resetAllStreamingMarkdownStablePrefixes();
-      const rollbackSnapshot = snapshotTuiBeforeSessionReset();
-      resetTuiForPendingSessionReset();
-      set({
-        items: state.items,
-        toasts: state.toasts,
-        queued: state.queued,
-        thinking: null,
-        spinner: null,
-        lastTurn: null,
-        sessionId: null,
-        stats: { ...state.stats },
-      });
-      try {
-        await runtime.clear({ recoverAgent: true });
-        clearUiActivityBeforeContextSync();
-        pendingSessionReset = false;
-        resetStatsAndSyncContext();
-        set({ items: replaceItems([]), toasts: [], queued: [], thinking: null, spinner: null, lastTurn: null, ...routeState(), stats: { ...state.stats } });
-        lastUserActivityAt = Date.now();
-        return true;
-      } catch (error) {
-        restoreTuiAfterFailedSessionReset(rollbackSnapshot);
-        throw error;
-      } finally {
-        pendingSessionReset = false;
-        set({ commandBusy: false });
-      }
-    },
-    listSessions: () => {
-      return runtime.listSessions();
-    },
-    newSession: async () => {
-      if (state.commandBusy) return false;
-      set({ commandBusy: true });
-      clearToastTimers();
-      resetAllStreamingMarkdownStablePrefixes();
-      const rollbackSnapshot = snapshotTuiBeforeSessionReset();
-      resetTuiForPendingSessionReset();
-      set({
-        items: state.items,
-        toasts: state.toasts,
-        queued: state.queued,
-        thinking: null,
-        spinner: null,
-        lastTurn: null,
-        sessionId: null,
-        stats: { ...state.stats },
-      });
-      try {
-        await runtime.newSession();
-        clearUiActivityBeforeContextSync();
-        pendingSessionReset = false;
-        resetStatsAndSyncContext();
-        set({ items: replaceItems([]), toasts: [], queued: [], thinking: null, spinner: null, lastTurn: null, ...routeState(), stats: { ...state.stats } });
-        return true;
-      } catch (error) {
-        restoreTuiAfterFailedSessionReset(rollbackSnapshot);
-        throw error;
-      } finally {
-        pendingSessionReset = false;
-        set({ commandBusy: false });
-      }
-    },
-    resume: async (id) => {
-      if (state.commandBusy) return false;
-      set({ commandBusy: true, commandStatus: { active: true, verb: 'Resuming conversation', startedAt: Date.now(), mode: 'resuming' } });
-      clearToastTimers();
-      try {
-        const r = await runtime.resume(id);
-        if (!r) return false;
-        resetStatsAndSyncContext();
-        const items = [];
-        for (const m of r.messages || []) {
-          if (m.role === 'user') {
-            // content may be a string OR an array of parts (text/tool-call
-            // interleaving) — toolResultText coerces both to readable text so
-            // array-content messages aren't silently dropped.
-            const text = (typeof m.content === 'string' ? m.content : toolResultText(m.content)).trim();
-            if (text) {
-              const synthetic = parseSyntheticAgentMessage(text);
-              if (synthetic) {
-                const label = synthetic.label || 'notification';
-                items.push({
-                  kind: 'tool',
-                  id: nextId(),
-                  name: synthetic.name || 'agent',
-                  args: synthetic.args || {
-                    type: label,
-                    task_id: synthetic.taskId || undefined,
-                    description: synthetic.summary || 'agent notification',
-                  },
-                  result: synthetic.result,
-                  rawResult: synthetic.rawResult ?? text,
-                  isError: synthetic.isError ?? /^(failed|error|killed|cancelled)$/i.test(label),
-                  expanded: false,
-                  count: 1,
-                  completedCount: 1,
-                  startedAt: Date.now(),
-                  completedAt: Date.now(),
-                });
-              } else {
-                items.push({ kind: 'user', id: nextId(), text });
-              }
-            }
-          } else if (m.role === 'assistant') {
-            const text = (typeof m.content === 'string' ? m.content : toolResultText(m.content)).trim();
-            if (text) items.push({ kind: 'assistant', id: nextId(), text });
-          }
-        }
-        set({
-          items: replaceItems(items),
-          toasts: [],
-          queued: [],
-          thinking: null,
-          spinner: null,
-          lastTurn: null,
-          ...routeState(),
-          stats: { ...state.stats },
-        });
-        void restoreLeadSteeringFromDisk();
-        return true;
-      } finally {
-        set({ commandBusy: false, commandStatus: null });
-      }
-    },
-
-    dispose: async (reason = 'cli-react-exit', options = {}) => {
-      if (disposed) return;
-      disposed = true;
-      clearToastTimers();
-      try { clearInterval(runtimePulseTimer); } catch {}
-      try { unsubscribeRuntimeNotifications?.(); } catch {}
-      unsubscribeRuntimeNotifications = null;
-      try { unsubscribeRemoteState?.(); } catch {}
-      unsubscribeRemoteState = null;
-      denyAllToolApprovals('runtime closing');
-      await flushTuiSteeringPersist();
-      await runtime.close(reason, options);
-      listeners.clear();
-    },
-  };
+  Object.assign(bag, createSessionFlow(bag));
+  bag.runTurn = createRunTurn(bag);
+  void bag.restoreLeadSteeringFromDisk();
+  return createEngineApi(bag);
 }