mixdog 0.9.16 → 0.9.18

package/src/tui/dist/index.mjs

@@ -3516,7 +3516,7 @@ function hasActiveStatuslineTools(activeTools = null) {
   return e || s;
 }
 function hasActiveStatuslineWork(line, agentWorkers = [], agentJobs = [], activeTools = null) {
-  return hasRunningStatuslineWorkers(agentWorkers, agentJobs) || hasActiveStatuslineTools(activeTools) || /\bRunning \d+ (?:Agents?|Shells?)\b/.test(stripAnsi(line)) || /\b(?:Exploring|Searching)\b/.test(stripAnsi(line));
+  return hasRunningStatuslineWorkers(agentWorkers, agentJobs) || hasActiveStatuslineTools(activeTools) || /\bRunning \d+ (?:Agents?|Shells?)\b/.test(stripAnsi(line)) || /\b(?:Exploring|Searching|Memory)\b/.test(stripAnsi(line));
 }
 function bootFullRenderEligible(mountAtMs, line, agentWorkers = [], agentJobs = [], activeTools = null) {
   const elapsed = Date.now() - mountAtMs;
@@ -7538,6 +7538,12 @@ function withFileLockSync(lockPath, fn, opts = {}) {
     } catch (err) {
       lastErr = err;
       if (!LOCK_WAIT_CODES.has(err?.code)) throw err;
+      if (timeoutMs <= 0) {
+        const contErr = new Error(`atomic lock contended (try-once): ${lockPath}`);
+        contErr.code = "ELOCKCONTENDED";
+        contErr.cause = err;
+        throw contErr;
+      }
       try {
         const st = statSync3(lockPath);
         if (Date.now() - st.mtimeMs > staleMs) {
@@ -7694,6 +7700,91 @@ function _releaseReclaimGuard(reclaim) {
     }
   }
 }
+function _asyncSleep(ms) {
+  return new Promise((resolve5) => {
+    setTimeout(resolve5, Math.max(1, Number(ms) || 1));
+  });
+}
+async function withFileLock(lockPath, fn, opts = {}) {
+  const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : DEFAULT_LOCK_TIMEOUT_MS;
+  const staleMs = Number.isFinite(opts.staleMs) ? opts.staleMs : 3e4;
+  const deadline = Date.now() + timeoutMs;
+  mkdirSync2(dirname3(lockPath), { recursive: true });
+  let attempt = 0;
+  let lastErr = null;
+  while (true) {
+    let fd;
+    try {
+      fd = openSync(lockPath, "wx");
+    } catch (err) {
+      lastErr = err;
+      if (!LOCK_WAIT_CODES.has(err?.code)) throw err;
+      if (timeoutMs <= 0) {
+        const contErr = new Error(`atomic lock contended (try-once): ${lockPath}`);
+        contErr.code = "ELOCKCONTENDED";
+        contErr.cause = err;
+        throw contErr;
+      }
+      try {
+        const st = statSync3(lockPath);
+        if (Date.now() - st.mtimeMs > staleMs) {
+          const deadPid = _readLockOwnerPid(lockPath);
+          if (deadPid !== null && _pidIsDead(deadPid)) {
+            const reclaim = _tryAcquireReclaimGuard(lockPath, staleMs);
+            if (reclaim !== null) {
+              let reclaimed = false;
+              try {
+                const currentSt = statSync3(lockPath);
+                if (Date.now() - currentSt.mtimeMs > staleMs) {
+                  const currentPid = _readLockOwnerPid(lockPath);
+                  if (currentPid === deadPid && _pidIsDead(currentPid)) {
+                    try {
+                      unlinkSync2(lockPath);
+                      reclaimed = true;
+                    } catch {
+                    }
+                  }
+                }
+              } finally {
+                _releaseReclaimGuard(reclaim);
+              }
+              if (reclaimed) continue;
+            }
+          }
+        }
+      } catch {
+      }
+      if (Date.now() >= deadline) break;
+      const base = DEFAULT_BACKOFFS_MS[Math.min(attempt, DEFAULT_BACKOFFS_MS.length - 1)];
+      const jitter = Math.floor(Math.random() * Math.min(75, Math.max(1, base)));
+      await _asyncSleep(Math.min(Math.max(1, deadline - Date.now()), base + jitter));
+      attempt += 1;
+      continue;
+    }
+    try {
+      writeFileSync2(fd, `${process.pid} ${Date.now()}
+`, "utf8");
+    } catch {
+    }
+    try {
+      if (opts.secret === true) _enforceOwnerOnlyAclWin32(lockPath);
+      return await fn();
+    } finally {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+      try {
+        if (_lockOwnedByPid(lockPath, process.pid)) unlinkSync2(lockPath);
+      } catch {
+      }
+    }
+  }
+  const timeoutErr = new Error(`atomic lock timeout after ${timeoutMs}ms: ${lockPath}`);
+  timeoutErr.code = "ELOCKTIMEOUT";
+  timeoutErr.cause = lastErr;
+  throw timeoutErr;
+}
 var _cachedUserSid = null;
 function _resolveCurrentUserPrincipal() {
   const systemRoot = process.env.SystemRoot || process.env.windir;
@@ -7854,6 +7945,21 @@ function updateJsonAtomicSync(filePath, mutator, opts = {}) {
     return next;
   }, opts);
 }
+async function updateJsonAtomic(filePath, mutator, opts = {}) {
+  const { lock: _lock, ...writeOpts } = opts;
+  return withFileLock(`${filePath}.lock`, () => {
+    let cur = null;
+    try {
+      cur = JSON.parse(readFileSync3(filePath, "utf8"));
+    } catch {
+      cur = null;
+    }
+    const next = mutator(cur);
+    if (next === void 0) return cur;
+    writeJsonAtomicSync(filePath, next, { ...writeOpts, lock: false });
+    return next;
+  }, opts);
+}
 
 // src/runtime/shared/user-data-guard.mjs
 import {
@@ -10994,6 +11100,10 @@ function measuredTranscriptRows(item, columns, toolOutputExpanded) {
   return entry.rows;
 }
 var STREAMING_ROW_QUANTUM = 1;
+var streamingBottomPinned = false;
+function setStreamingBottomPinned(pinned) {
+  streamingBottomPinned = !!pinned;
+}
 function assistantTextForStreamingRowEstimate(text) {
   return streamingLayoutText(text);
 }
@@ -11007,14 +11117,16 @@ function estimateTranscriptItemRowsCached(item, columns, toolOutputExpanded) {
   if (!item) return Math.max(1, Math.ceil(estimateTranscriptItemRows(item, columns, toolOutputExpanded)));
   if (shouldSuppressFullyFailedToolItem(item)) return 0;
   if (item.kind === "assistant" && item.streaming) {
-    const estimate = streamingEstimateRows(item, columns, toolOutputExpanded);
     const toolExpanded2 = toolOutputExpanded ? 1 : 0;
     const idEntry = streamingMeasuredRowsById.get(item.id);
     if (idEntry && idEntry.rows > 0 && idEntry.columns === columns && idEntry.toolExpanded === toolExpanded2) {
-      return Math.max(idEntry.rows, estimate);
+      if (streamingBottomPinned) {
+        return Math.max(idEntry.rows, streamingEstimateRows(item, columns, toolOutputExpanded));
+      }
+      return idEntry.rows;
     }
     if (idEntry) streamingMeasuredRowsById.delete(item.id);
-    return estimate;
+    return streamingEstimateRows(item, columns, toolOutputExpanded);
   }
   if (item.kind === "assistant" && streamingMeasuredRowsById.has(item.id)) {
     streamingMeasuredRowsById.delete(item.id);
@@ -11047,6 +11159,61 @@ function buildTranscriptRowIndex(items, {
   }
   return { rows, prefixRows, totalRows: prefixRows[allItems.length] || 0 };
 }
+function trailingStreamingItem(allItems) {
+  const last = allItems.length > 0 ? allItems[allItems.length - 1] : null;
+  return last && last.kind === "assistant" && last.streaming ? last : null;
+}
+function buildTranscriptRowIndexIncremental(items, {
+  columns = 80,
+  toolOutputExpanded = false,
+  suppressMeasuredRowHeights = false,
+  measuredRowsVersion = 0,
+  cacheRef = null,
+  prefixSig = null
+} = {}) {
+  const allItems = Array.isArray(items) ? items : [];
+  const tail = trailingStreamingItem(allItems);
+  const holder = cacheRef || { current: null };
+  if (!tail) {
+    holder.current = null;
+    return buildTranscriptRowIndex(allItems, {
+      columns,
+      toolOutputExpanded,
+      suppressMeasuredRowHeights
+    });
+  }
+  const prefixLen = allItems.length - 1;
+  const cache = holder.current;
+  if (cache && cache.columns === columns && cache.toolExpanded === (toolOutputExpanded ? 1 : 0) && cache.suppress === suppressMeasuredRowHeights && cache.version === measuredRowsVersion && cache.prefixLen === prefixLen && prefixSig != null && cache.prefixSig === prefixSig && cache.tailId === tail.id) {
+    {
+      const tailMeasured = suppressMeasuredRowHeights ? null : measuredTranscriptRows(tail, columns, toolOutputExpanded);
+      const tailRows = tailMeasured != null ? tailMeasured : estimateTranscriptItemRowsCached(tail, columns, toolOutputExpanded);
+      const rows = cache.prefixRowsArr.slice();
+      rows.push(tailRows);
+      const prefixRows = cache.prefixPrefixRows.slice();
+      prefixRows.push(cache.prefixTotal + tailRows);
+      return { rows, prefixRows, totalRows: prefixRows[allItems.length] || 0 };
+    }
+  }
+  const full = buildTranscriptRowIndex(allItems, {
+    columns,
+    toolOutputExpanded,
+    suppressMeasuredRowHeights
+  });
+  holder.current = {
+    columns,
+    toolExpanded: toolOutputExpanded ? 1 : 0,
+    suppress: suppressMeasuredRowHeights,
+    version: measuredRowsVersion,
+    prefixLen,
+    prefixSig,
+    tailId: tail.id,
+    prefixRowsArr: full.rows.slice(0, prefixLen),
+    prefixPrefixRows: full.prefixRows.slice(0, prefixLen + 1),
+    prefixTotal: full.prefixRows[prefixLen] || 0
+  };
+  return full;
+}
 var transcriptSigPartCache = /* @__PURE__ */ new WeakMap();
 function transcriptStructureSignature(items, columns, toolOutputExpanded) {
   const list = Array.isArray(items) ? items : [];
@@ -11880,6 +12047,7 @@ function useTranscriptWindow({
 }) {
   const transcriptTotalRowsRef = useRef8(0);
   const preservedScrollDeltaRef = useRef8(0);
+  const incrementalRowIndexCacheRef = useRef8(null);
   const prevViewportGeomRef = useRef8({ contentHeight: 0, floatingPanelRows: 0 });
   const transcriptItemElsRef = useRef8(/* @__PURE__ */ new Map());
   const transcriptMeasureRefCache = useRef8(/* @__PURE__ */ new Map());
@@ -11907,26 +12075,41 @@ function useTranscriptWindow({
     }
     return fn;
   }, []);
-  const transcriptStructureSig = useMemo(
-    () => transcriptStructureSignature(items, frameColumns, toolOutputExpanded),
-    [items, frameColumns, toolOutputExpanded]
+  const streamingTailItem = useMemo(() => {
+    const last = (items || []).length > 0 ? items[items.length - 1] : null;
+    return last && last.kind === "assistant" && last.streaming ? last : null;
+  }, [items]);
+  const prefixLen = streamingTailItem ? (items || []).length - 1 : (items || []).length;
+  const prefixSig = useMemo(
+    () => transcriptStructureSignature(
+      streamingTailItem ? (items || []).slice(0, prefixLen) : items || [],
+      frameColumns,
+      toolOutputExpanded
+    ),
+    [items, streamingTailItem, prefixLen, frameColumns, toolOutputExpanded]
   );
+  const scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
+  const transcriptPinnedForStreaming = followingRef.current || scrolledUpRowsForPin <= transcriptBottomSlackRows;
+  setStreamingBottomPinned(transcriptPinnedForStreaming);
+  const tailSig = streamingTailItem ? `a${streamingTailItem.id}:${estimateTranscriptItemRowsCached(streamingTailItem, frameColumns, toolOutputExpanded)}` : "_";
+  const transcriptStructureSig = `${prefixSig}#${tailSig}`;
   const transcriptStreamingActive = (items || []).some(
     (item) => item?.kind === "assistant" && item?.streaming
   );
-  const scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
-  const transcriptPinnedForStreaming = followingRef.current || scrolledUpRowsForPin <= transcriptBottomSlackRows;
   const scrolledUpForStreamingMeasure = scrolledUpRowsForPin > transcriptBottomSlackRows;
   const prevEstimateGeometry = transcriptGeomRef.current?.suppressMeasuredRowHeights === true;
   const hasStreamingReadingAnchor = !!transcriptAnchorRef.current || transcriptAnchorDirtyRef.current;
   const bottomPinnedForMeasure = transcriptPinnedForStreaming;
   const suppressMeasuredRowHeights = bottomPinnedForMeasure || transcriptStreamingActive && (scrolledUpForStreamingMeasure && hasStreamingReadingAnchor || scrolledUpForStreamingMeasure && prevEstimateGeometry && !transcriptPinnedForStreaming);
-  const transcriptRowIndex = useMemo(() => buildTranscriptRowIndex(items, {
+  const transcriptRowIndex = useMemo(() => buildTranscriptRowIndexIncremental(items, {
     columns: frameColumns,
     toolOutputExpanded,
-    suppressMeasuredRowHeights
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- intentional: sig captures the relevant item changes; measuredRowsVersion folds in app-level measured height corrections
-  }), [transcriptStructureSig, measuredRowsVersion, suppressMeasuredRowHeights]);
+    suppressMeasuredRowHeights,
+    measuredRowsVersion,
+    cacheRef: incrementalRowIndexCacheRef,
+    prefixSig
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- intentional: prefixSig/tailSig capture the relevant item changes (raw `items` dropped so a tail-only flush never re-enters the builder via array identity); measuredRowsVersion folds in app-level measured height corrections
+  }), [prefixSig, tailSig, measuredRowsVersion, suppressMeasuredRowHeights]);
   const hasReadingAnchor = !!transcriptAnchorRef.current && !transcriptAnchorDirtyRef.current;
   const scrolledUpRows = Math.max(0, Number(scrollTargetRef.current) || 0);
   const scrolledUp = scrolledUpRows > transcriptBottomSlackRows;
@@ -22149,6 +22332,13 @@ import { randomBytes as randomBytes3 } from "crypto";
 import { join as join7 } from "path";
 var PENDING_MESSAGES_FILE = "session-pending-messages.json";
 var PENDING_MESSAGES_MODE = 384;
+var _persistChain = Promise.resolve();
+function _serialize(task) {
+  const run = _persistChain.then(task, task);
+  _persistChain = run.catch(() => {
+  });
+  return run;
+}
 function pendingMessagesPath() {
   return join7(resolvePluginData(), PENDING_MESSAGES_FILE);
 }
@@ -22216,59 +22406,67 @@ function removePersistRow(q, entry) {
 }
 function appendTuiSteeringPersist(leadSessionId, entry) {
   const text = entryPersistText(entry);
-  if (!text) return;
+  if (!text) return Promise.resolve();
   const key = tuiSteeringSessionKey(leadSessionId);
-  if (!key) return;
+  if (!key) return Promise.resolve();
   if (!entry.steeringPersistId) entry.steeringPersistId = newSteeringPersistId();
   const record = { id: entry.steeringPersistId, text };
-  try {
-    updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
-      const next = normalizePendingStore(raw);
-      const q = Array.isArray(next.sessions[key]) ? next.sessions[key] : [];
-      q.push(record);
-      next.sessions[key] = q;
-      const now = Date.now();
-      next.updatedAt = now;
-      touchPendingSessionEntry(next, key, now);
-      return next;
-    }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
-  } catch (err) {
+  return _serialize(async () => {
     try {
-      process.stderr.write(`[tui] steering-queue append failed sessionId=${leadSessionId}: ${err?.message || err}
+      await updateJsonAtomic(pendingMessagesPath(), (raw) => {
+        const next = normalizePendingStore(raw);
+        const q = Array.isArray(next.sessions[key]) ? next.sessions[key] : [];
+        q.push(record);
+        next.sessions[key] = q;
+        const now = Date.now();
+        next.updatedAt = now;
+        touchPendingSessionEntry(next, key, now);
+        return next;
+      }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
+    } catch (err) {
+      try {
+        process.stderr.write(`[tui] steering-queue append failed sessionId=${leadSessionId}: ${err?.message || err}
 `);
-    } catch {
+      } catch {
+      }
     }
-  }
+  });
 }
 function dropTuiSteeringPersist(leadSessionId, entries) {
   const key = tuiSteeringSessionKey(leadSessionId);
-  if (!key) return;
+  if (!key) return Promise.resolve();
   const batch = Array.isArray(entries) ? entries : [];
-  if (batch.length === 0) return;
-  try {
-    updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
-      const next = normalizePendingStore(raw);
-      const q = Array.isArray(next.sessions[key]) ? next.sessions[key].slice() : [];
-      if (q.length === 0) return void 0;
-      for (const entry of batch) {
-        removePersistRow(q, entry);
-      }
-      if (q.length === 0) {
-        delete next.sessions[key];
-        if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
-      } else {
-        next.sessions[key] = q;
-      }
-      next.updatedAt = Date.now();
-      return next;
-    }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
-  } catch (err) {
+  if (batch.length === 0) return Promise.resolve();
+  return _serialize(async () => {
     try {
-      process.stderr.write(`[tui] steering-queue drop failed sessionId=${leadSessionId}: ${err?.message || err}
+      await updateJsonAtomic(pendingMessagesPath(), (raw) => {
+        const next = normalizePendingStore(raw);
+        const q = Array.isArray(next.sessions[key]) ? next.sessions[key].slice() : [];
+        if (q.length === 0) return void 0;
+        for (const entry of batch) {
+          removePersistRow(q, entry);
+        }
+        if (q.length === 0) {
+          delete next.sessions[key];
+          if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
+        } else {
+          next.sessions[key] = q;
+        }
+        next.updatedAt = Date.now();
+        return next;
+      }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
+    } catch (err) {
+      try {
+        process.stderr.write(`[tui] steering-queue drop failed sessionId=${leadSessionId}: ${err?.message || err}
 `);
-    } catch {
+      } catch {
+      }
     }
-  }
+  });
+}
+function flushTuiSteeringPersist() {
+  return _persistChain.catch(() => {
+  });
 }
 function drainedRowToRestore(row) {
   if (typeof row === "string") {
@@ -22281,27 +22479,29 @@ function drainedRowToRestore(row) {
 }
 function drainTuiSteeringPersist(leadSessionId) {
   const key = tuiSteeringSessionKey(leadSessionId);
-  if (!key) return [];
-  let drained = [];
-  try {
-    updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
-      const next = normalizePendingStore(raw);
-      const q = Array.isArray(next.sessions[key]) ? next.sessions[key] : [];
-      drained = q.map(drainedRowToRestore).filter(Boolean);
-      if (drained.length === 0) return void 0;
-      delete next.sessions[key];
-      if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
-      next.updatedAt = Date.now();
-      return next;
-    }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
-  } catch (err) {
+  if (!key) return Promise.resolve([]);
+  return _serialize(async () => {
+    let drained = [];
     try {
-      process.stderr.write(`[tui] steering-queue drain failed sessionId=${leadSessionId}: ${err?.message || err}
+      await updateJsonAtomic(pendingMessagesPath(), (raw) => {
+        const next = normalizePendingStore(raw);
+        const q = Array.isArray(next.sessions[key]) ? next.sessions[key] : [];
+        drained = q.map(drainedRowToRestore).filter(Boolean);
+        if (drained.length === 0) return void 0;
+        delete next.sessions[key];
+        if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
+        next.updatedAt = Date.now();
+        return next;
+      }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
+    } catch (err) {
+      try {
+        process.stderr.write(`[tui] steering-queue drain failed sessionId=${leadSessionId}: ${err?.message || err}
 `);
-    } catch {
+      } catch {
+      }
     }
-  }
-  return drained;
+    return drained;
+  });
 }
 
 // src/tui/engine.mjs
@@ -22862,13 +23062,20 @@ async function createEngineSession({
         seq: deferredSeqCounter++,
         pushed: false,
         timer: null,
-        push: () => {
+        // 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;
+          if (!card.spec) return null;
           card.spec.deferredDisplayReady = true;
+          return card.spec;
+        },
+        push: () => {
+          const spec = entry.materialize();
+          if (!spec) return;
           pushingFromDeferredEntry = true;
           try {
-            pushItem(card.spec);
+            pushItem(spec);
           } finally {
             pushingFromDeferredEntry = false;
           }
@@ -22889,13 +23096,18 @@ async function createEngineSession({
         seq: deferredSeqCounter++,
         pushed: false,
         timer: null,
-        push: () => {
+        materialize: () => {
           aggregate.pushed = true;
-          if (!aggregate.pendingSpec) return;
+          if (!aggregate.pendingSpec) return null;
           aggregate.pendingSpec.deferredDisplayReady = true;
+          return aggregate.pendingSpec;
+        },
+        push: () => {
+          const spec = entry.materialize();
+          if (!spec) return;
           pushingFromDeferredEntry = true;
           try {
-            pushItem(aggregate.pendingSpec);
+            pushItem(spec);
           } finally {
             pushingFromDeferredEntry = false;
           }
@@ -22919,6 +23131,35 @@ async function createEngineSession({
         }
       }
     };
+    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;
+    };
+    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") {
@@ -23421,13 +23662,14 @@ async function createEngineSession({
       denyAllToolApprovals(cancelled ? "turn cancelled" : "turn finished");
       clearWatchdog();
       const isStaleUnwind = leadTurnEpoch !== turnEpoch;
+      let closingItems = [];
       if (deferredEntries.length) {
         const last = deferredEntries[deferredEntries.length - 1];
-        if (last) flushDeferredUpTo(last);
+        closingItems = collectDeferredUpTo(last);
         clearDeferredTimers();
       }
       flushDeferredBeforeImmediatePush = null;
-      const producedTranscriptItem = state.items.length > itemsAtTurnStart;
+      const producedTranscriptItem = state.items.length + closingItems.length > itemsAtTurnStart;
       const reclaimed = cancelled && activePromptRestore?.reclaimed === true;
       if (!isStaleUnwind) activePromptRestore = null;
       closeThinkingSegment();
@@ -23441,15 +23683,16 @@ async function createEngineSession({
       const assistantOutput = (currentAssistantText || assistantText || "").trim();
       const isNoOpTurn = turnFinishedNormally && !cancelled && toolCards.length === 0 && !resultContent && !assistantOutput && !producedTranscriptItem;
       if (isStaleUnwind) {
+        if (closingItems.length) appendItemsBatch(closingItems);
         tuiDebug(`runTurn STALE UNWIND turn=${turnIndex} \u2014 force-released; skipping shared-state writes`);
       } else {
         if (!isNoOpTurn) {
           state.stats.turns = (state.stats.turns || 0) + 1;
         }
         if (!reclaimed && !isNoOpTurn) {
-          pushItem({ kind: "turndone", id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
+          closingItems.push({ kind: "turndone", id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
         }
-        set({
+        appendItemsBatch(closingItems, {
           busy: false,
           spinner: null,
           thinking: null,
@@ -23638,8 +23881,8 @@ async function createEngineSession({
     commitSteeringQueueEntries(batch);
     return out;
   }
-  function restoreLeadSteeringFromDisk() {
-    const rows = drainTuiSteeringPersist(leadSessionId());
+  async function restoreLeadSteeringFromDisk() {
+    const rows = await drainTuiSteeringPersist(leadSessionId());
     if (!rows.length) return;
     const restored = [];
     for (const row of rows) {
@@ -23820,7 +24063,7 @@ async function createEngineSession({
     syncContextStats({ allowEstimated: true });
     return state.stats;
   };
-  restoreLeadSteeringFromDisk();
+  void restoreLeadSteeringFromDisk();
   return {
     getState: () => state,
     patchItem,
@@ -24743,7 +24986,7 @@ async function createEngineSession({
           ...routeState(),
           stats: { ...state.stats }
         });
-        restoreLeadSteeringFromDisk();
+        void restoreLeadSteeringFromDisk();
         return true;
       } finally {
         set({ commandBusy: false, commandStatus: null });
@@ -24768,6 +25011,7 @@ async function createEngineSession({
       }
       unsubscribeRemoteState = null;
       denyAllToolApprovals("runtime closing");
+      await flushTuiSteeringPersist();
       await runtime.close(reason, options);
       listeners.clear();
     }
@@ -24953,7 +25197,7 @@ function touchUiHeartbeat(instanceId) {
       if (!curRaw) return void 0;
       if (instanceId && curRaw.instanceId !== instanceId) return void 0;
       return { ...curRaw, ui_heartbeat_at: Date.now(), updatedAt: Date.now() };
-    }, { compact: true, fsync: false, fsyncDir: false, renameFallback: "truncate" });
+    }, { compact: true, fsync: false, fsyncDir: false, renameFallback: "truncate", timeoutMs: 0 });
   } catch {
   }
 }
@@ -24975,36 +25219,129 @@ var EXIT_HARD_DELAY_MS = positiveIntEnv2("MIXDOG_TUI_HARD_EXIT_DELAY_MS", 500);
 var EXIT_HARD_ENABLED = !/^(0|false|no|off)$/i.test(String(process.env.MIXDOG_TUI_HARD_EXIT || "1"));
 var EXIT_DEBUG_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_TUI_EXIT_DEBUG || ""));
 var PERF_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_TUI_PERF || ""));
+var LOOP_PROBE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_TUI_LOOP_PROBE || ""));
+var LOOP_PROBE_INTERVAL_MS = 1e3;
+var LOOP_PROBE_DRIFT_THRESHOLD_MS = 200;
 function positiveIntEnv2(name, fallback) {
   const value = Number(process.env[name]);
   return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
 }
+function installTuiLoopProbe() {
+  if (!LOOP_PROBE_ENABLED) return () => {
+  };
+  let last = performance3.now();
+  const timer = setInterval(() => {
+    const now = performance3.now();
+    const drift = now - last - LOOP_PROBE_INTERVAL_MS;
+    last = now;
+    if (drift > LOOP_PROBE_DRIFT_THRESHOLD_MS) {
+      try {
+        process.stderr.write(`[mixdog-loop] stall=${drift.toFixed(0)}ms
+`);
+      } catch {
+      }
+    }
+  }, LOOP_PROBE_INTERVAL_MS);
+  timer.unref?.();
+  return () => {
+    try {
+      clearInterval(timer);
+    } catch {
+    }
+  };
+}
 var PERF_REPORT_EVERY = positiveIntEnv2("MIXDOG_TUI_PERF_EVERY", 60);
+var PERF_STALL_INTERVAL_MS = positiveIntEnv2("MIXDOG_TUI_PERF_STALL_INTERVAL_MS", 100);
+var PERF_STALL_THRESHOLD_MS = positiveIntEnv2("MIXDOG_TUI_PERF_STALL_MS", 80);
+var PERF_RENDER_GAP_MS = positiveIntEnv2("MIXDOG_TUI_PERF_RENDER_GAP_MS", 120);
+function perfLog(event, fields = {}) {
+  if (!PERF_ENABLED) return;
+  const elapsedMs = performance3.now() - BOOT_PROFILE_START2;
+  const parts = [`[mixdog-perf] +${elapsedMs.toFixed(1)}ms`, event];
+  for (const [key, value] of Object.entries(fields || {})) {
+    if (value === void 0 || value === null || value === "") continue;
+    parts.push(`${key}=${String(value).replace(/\s+/g, "_")}`);
+  }
+  try {
+    process.stderr.write(`${parts.join(" ")}
+`);
+  } catch {
+  }
+}
+function installTuiPerfProbe() {
+  if (!PERF_ENABLED) return () => {
+  };
+  let last = performance3.now();
+  let lastCpu = process.cpuUsage();
+  perfLog("probe:start", {
+    intervalMs: PERF_STALL_INTERVAL_MS,
+    stallMs: PERF_STALL_THRESHOLD_MS,
+    renderGapMs: PERF_RENDER_GAP_MS
+  });
+  const timer = setInterval(() => {
+    const now = performance3.now();
+    const elapsed = now - last;
+    const lagMs = elapsed - PERF_STALL_INTERVAL_MS;
+    const cpu = process.cpuUsage(lastCpu);
+    last = now;
+    lastCpu = process.cpuUsage();
+    if (lagMs < PERF_STALL_THRESHOLD_MS) return;
+    const mem = process.memoryUsage();
+    perfLog("event-loop-stall", {
+      lagMs: lagMs.toFixed(1),
+      elapsedMs: elapsed.toFixed(1),
+      cpuUserMs: (cpu.user / 1e3).toFixed(1),
+      cpuSystemMs: (cpu.system / 1e3).toFixed(1),
+      rssMb: (mem.rss / 1048576).toFixed(1),
+      heapMb: (mem.heapUsed / 1048576).toFixed(1)
+    });
+  }, PERF_STALL_INTERVAL_MS);
+  timer.unref?.();
+  return () => {
+    try {
+      clearInterval(timer);
+    } catch {
+    }
+  };
+}
 function makeRenderProfiler() {
   if (!PERF_ENABLED) return void 0;
   let count = 0;
   let sum = 0;
   let max = 0;
   let slow = 0;
+  let maxGap = 0;
+  let lastFrameAt = 0;
   return ({ renderTime } = {}) => {
+    const now = performance3.now();
     const ms = Number(renderTime) || 0;
+    const gap = lastFrameAt ? now - lastFrameAt : 0;
+    lastFrameAt = now;
     count += 1;
     sum += ms;
     if (ms > max) max = ms;
+    if (gap > maxGap) maxGap = gap;
     if (ms >= 16) slow += 1;
+    if (gap >= PERF_RENDER_GAP_MS) {
+      perfLog("render-gap", {
+        gapMs: gap.toFixed(1),
+        renderMs: ms.toFixed(2)
+      });
+    }
     if (count >= PERF_REPORT_EVERY) {
       const avg = sum / count;
-      try {
-        process.stderr.write(
-          `[mixdog-perf] frames=${count} avg=${avg.toFixed(2)}ms max=${max.toFixed(2)}ms slow16+=${slow}
-`
-        );
-      } catch {
-      }
+      perfLog("render-summary", {
+        frames: count,
+        avgMs: avg.toFixed(2),
+        maxMs: max.toFixed(2),
+        maxGapMs: maxGap.toFixed(1),
+        slow16: slow
+      });
       count = 0;
       sum = 0;
       max = 0;
       slow = 0;
+      maxGap = 0;
     }
   };
 }
@@ -25219,6 +25556,8 @@ async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {
     return 1;
   }
   const restoreStderr = installTuiStderrGuard();
+  const stopPerfProbe = installTuiPerfProbe();
+  const stopLoopProbe = installTuiLoopProbe();
   const restorePrimedInput = () => drainStdin(process.stdin);
   let restored = false;
   const restoreTerminal = () => {
@@ -25250,6 +25589,8 @@ async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {
     bootProfile2("store:ready", { ms: (performance3.now() - startedAt).toFixed(1) });
   } catch (error) {
     splash.stop();
+    stopPerfProbe();
+    stopLoopProbe();
     restoreTerminal();
     try {
       process.off("exit", restoreTerminal);
@@ -25334,6 +25675,8 @@ async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {
     }
     await waitUntilExit();
   } finally {
+    stopPerfProbe();
+    stopLoopProbe();
     clearInterval(uiHeartbeatTimer);
     for (const [stream, event, handler] of stdioDeathListeners.splice(0)) {
       try {