mixdog 0.9.65 → 0.9.66

package/src/tui/dist/index.mjs

@@ -2588,7 +2588,7 @@ import { render } from "../../../vendor/ink/build/index.js";
 import { closeSync as closeSync3, constants as fsConstants, createWriteStream as createWriteStream2, mkdirSync as mkdirSync9, openSync as openSync3, readSync } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { dirname as dirname12, join as join15 } from "node:path";
-import { performance as performance3 } from "node:perf_hooks";
+import { performance as performance4 } from "node:perf_hooks";
 import { format } from "node:util";
 
 // src/tui/App.jsx
@@ -7274,6 +7274,7 @@ function PromptInput({
   if (valueRef) valueRef.current = draftRef.current.value;
   const { isRawModeSupported } = useStdin();
   const boxRef = useRef4(null);
+  const inkRootRef = useRef4(null);
   const cursorEnabledRef = useRef4(false);
   const contentWidthRef = useRef4(80);
   const preferredColumnRef = useRef4(null);
@@ -7288,9 +7289,15 @@ function PromptInput({
   }
   const flushThrottleRef = useRef4({ lastAt: 0, timer: null });
   const flushImmediate = () => {
+    const cachedRoot = inkRootRef.current;
+    if (typeof cachedRoot?.onImmediateRender === "function") {
+      cachedRoot.onImmediateRender();
+      return;
+    }
     let node = boxRef.current;
     for (let i = 0; node && i < 64; i++) {
       if (node.nodeName === "ink-root") {
+        inkRootRef.current = node;
         if (typeof node.onImmediateRender === "function") node.onImmediateRender();
         return;
       }
@@ -11289,18 +11296,22 @@ function trimPartialClosingFences(tokens) {
 }
 var OPEN_FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
 var CLOSE_FENCE_RE = /^ {0,3}([`~]+)[ \t]*$/;
+var OPEN_FENCE_SCAN_LRU_MAX = 32;
+var openFenceScanByStreamKey = /* @__PURE__ */ new Map();
 function isClosingFence(line, char, openLen) {
   const m = CLOSE_FENCE_RE.exec(line);
   if (!m) return false;
   const run = m[1];
   return run.startsWith(char.repeat(openLen));
 }
-function findOpenFenceStart(text) {
-  const value = String(text ?? "");
-  let open = null;
-  let start = 0;
-  for (let i = 0; i <= value.length; i++) {
+function scanOpenFence(value, startAt = 0, initialOpen = null) {
+  let open = initialOpen;
+  let start = startAt;
+  const checkpointIndex = value.lastIndexOf("\n") + 1;
+  let openBeforeCheckpoint = start === checkpointIndex ? open : null;
+  for (let i = startAt; i <= value.length; i++) {
     if (i !== value.length && value[i] !== "\n") continue;
+    if (start === checkpointIndex) openBeforeCheckpoint = open;
     const line = value.slice(start, i);
     if (!open) {
       const m = OPEN_FENCE_RE.exec(line);
@@ -11316,13 +11327,42 @@ function findOpenFenceStart(text) {
     }
     start = i + 1;
   }
-  if (!open || open.indent !== 0) return null;
-  return { index: open.index, lang: open.lang };
+  return { open, checkpointIndex, openBeforeCheckpoint };
+}
+function touchOpenFenceScan(key, entry) {
+  if (openFenceScanByStreamKey.has(key)) openFenceScanByStreamKey.delete(key);
+  openFenceScanByStreamKey.set(key, entry);
+  while (openFenceScanByStreamKey.size > OPEN_FENCE_SCAN_LRU_MAX) {
+    const oldest = openFenceScanByStreamKey.keys().next().value;
+    if (oldest === void 0) break;
+    openFenceScanByStreamKey.delete(oldest);
+  }
+}
+function resetOpenFenceScan(streamKey) {
+  if (streamKey == null || streamKey === "") return;
+  openFenceScanByStreamKey.delete(String(streamKey));
+}
+function resetAllOpenFenceScans() {
+  openFenceScanByStreamKey.clear();
+}
+function findOpenFenceStart(text, streamKey = null) {
+  const value = String(text ?? "");
+  const key = streamKey == null || streamKey === "" ? null : String(streamKey);
+  const cached = key ? openFenceScanByStreamKey.get(key) : null;
+  if (cached?.text === value) return cached.result;
+  const scanned = cached && value.startsWith(cached.text) ? scanOpenFence(value, cached.checkpointIndex, cached.openBeforeCheckpoint) : scanOpenFence(value);
+  const result = !scanned.open || scanned.open.indent !== 0 ? null : { index: scanned.open.index, lang: scanned.open.lang };
+  if (key) touchOpenFenceScan(key, { text: value, ...scanned, result });
+  return result;
 }
 
 // src/tui/markdown/render-ansi.mjs
 var TOKEN_CACHE_MAX = 500;
 var tokenCache = /* @__PURE__ */ new Map();
+var renderedSegmentCache = [];
+var RENDERED_SEGMENT_CACHE_MAX = 12;
+var RENDERED_SEGMENT_CACHE_MAX_CHARS = 256 * 1024;
+var renderedSegmentCacheChars = 0;
 var MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|^\d+\. |\n\d+\. /;
 var _configured = false;
 function configureMarked() {
@@ -11384,8 +11424,19 @@ function lexMarkdown(content, { trimPartialFences = false } = {}) {
   return tokens;
 }
 function renderTokenAnsiSegments(content, opts = {}) {
-  const tokens = lexMarkdown(content, opts);
+  const text = String(content ?? "");
   const width = Number(opts.width) || 0;
+  const trimPartialFences = opts.trimPartialFences === true;
+  const themeVersion = getThemeVersion();
+  for (let index = renderedSegmentCache.length - 1; index >= 0; index -= 1) {
+    const entry = renderedSegmentCache[index];
+    if (entry.text === text && entry.width === width && entry.trimPartialFences === trimPartialFences && entry.themeVersion === themeVersion) {
+      renderedSegmentCache.splice(index, 1);
+      renderedSegmentCache.push(entry);
+      return entry.segments;
+    }
+  }
+  const tokens = lexMarkdown(text, opts);
   const segments = [];
   for (const token of tokens) {
     if (token.type === "table") {
@@ -11398,55 +11449,104 @@ function renderTokenAnsiSegments(content, opts = {}) {
       segments.push({ type: "ansi", ansi, token });
     }
   }
+  if (text.length <= RENDERED_SEGMENT_CACHE_MAX_CHARS) {
+    const entry = { text, width, trimPartialFences, themeVersion, segments };
+    renderedSegmentCache.push(entry);
+    renderedSegmentCacheChars += text.length;
+    while (renderedSegmentCache.length > RENDERED_SEGMENT_CACHE_MAX || renderedSegmentCacheChars > RENDERED_SEGMENT_CACHE_MAX_CHARS) {
+      const removed = renderedSegmentCache.shift();
+      renderedSegmentCacheChars -= removed?.text.length || 0;
+    }
+  }
   return segments;
 }
 
 // src/tui/markdown/streaming-markdown.mjs
 import { marked as marked2 } from "marked";
 var stablePrefixByStreamKey = /* @__PURE__ */ new Map();
+var markdownSyntaxByStreamKey = /* @__PURE__ */ new Map();
+var plainWindowSyntaxByStreamKey = /* @__PURE__ */ new Map();
 var resolvedPartsByStreamKey = /* @__PURE__ */ new Map();
 var STABLE_PREFIX_LRU_MAX = 32;
 function streamingLayoutText(text) {
   return String(text ?? "").replace(/^\n+|\n+$/g, "");
 }
-function windowPlainStreamingText(text, columns, maxRows) {
+function windowPlainStreamingText(text, columns, maxRows, streamKey = null) {
   const value = streamingLayoutText(text);
   const rowBudget = Math.max(0, Math.floor(Number(maxRows) || 0));
-  if (!value || rowBudget <= 0 || hasMarkdownSyntax(value)) return value;
-  const lines = value.split("\n");
+  const key = streamKey == null || streamKey === "" ? null : String(streamKey);
+  if (!value || rowBudget <= 0 || cachedStreamingHasMarkdownSyntax(
+    plainWindowSyntaxByStreamKey,
+    value,
+    key
+  )) return value;
   const width = Math.max(1, Math.floor(Number(columns) || 80));
   let rows = 0;
-  let start = lines.length;
-  while (start > 0) {
-    const line = lines[start - 1];
+  let end = value.length;
+  let start = end;
+  while (end >= 0) {
+    const newline = value.lastIndexOf("\n", end - 1);
+    const lineStart2 = newline + 1;
+    const line = value.slice(lineStart2, end);
     const lineRows = Math.max(1, Math.ceil(displayWidth(line) / width));
     if (rows > 0 && rows + lineRows > rowBudget) break;
     rows += lineRows;
-    start -= 1;
-    if (rows >= rowBudget) break;
+    start = lineStart2;
+    if (rows >= rowBudget || newline < 0) break;
+    end = newline;
   }
-  return start > 0 ? lines.slice(start).join("\n") : value;
+  return start > 0 ? value.slice(start) : value;
 }
 function isWhitespaceOnlyText(text) {
   return !String(text ?? "").trim();
 }
-function touchStablePrefixKey(key, value) {
+function touchLruKey(cache, key, value) {
   if (!key) return;
-  if (stablePrefixByStreamKey.has(key)) stablePrefixByStreamKey.delete(key);
-  stablePrefixByStreamKey.set(key, value);
-  while (stablePrefixByStreamKey.size > STABLE_PREFIX_LRU_MAX) {
-    const oldest = stablePrefixByStreamKey.keys().next().value;
+  if (cache.has(key)) cache.delete(key);
+  cache.set(key, value);
+  while (cache.size > STABLE_PREFIX_LRU_MAX) {
+    const oldest = cache.keys().next().value;
     if (oldest === void 0) break;
-    stablePrefixByStreamKey.delete(oldest);
+    cache.delete(oldest);
   }
 }
+function touchStablePrefixKey(key, value) {
+  touchLruKey(stablePrefixByStreamKey, key, value);
+}
 function getStablePrefixKey(key) {
-  if (!key || !stablePrefixByStreamKey.has(key)) return "";
+  if (!key || !stablePrefixByStreamKey.has(key)) return { text: "", chunks: [] };
   const value = stablePrefixByStreamKey.get(key);
-  stablePrefixByStreamKey.delete(key);
-  stablePrefixByStreamKey.set(key, value);
+  touchStablePrefixKey(key, value);
+  return value;
+}
+function stableStateForText(text, previous) {
+  if (!text) return { text: "", chunks: [] };
+  if (text.startsWith(previous.text)) {
+    const appended = text.substring(previous.text.length);
+    return appended ? { text, chunks: [...previous.chunks, appended] } : previous;
+  }
+  return { text, chunks: [text] };
+}
+function cachedStreamingHasMarkdownSyntax(cache, text, key) {
+  if (!key) return hasMarkdownSyntax(text);
+  const previous = cache.get(key);
+  let value;
+  if (previous && text.startsWith(previous.text)) {
+    if (previous.value) {
+      value = true;
+    } else {
+      const lineStart2 = previous.text.lastIndexOf("\n") + 1;
+      value = hasMarkdownSyntax(text.substring(Math.max(0, lineStart2 - 1)));
+    }
+  } else {
+    value = hasMarkdownSyntax(text);
+  }
+  touchLruKey(cache, key, { text, value });
   return value;
 }
+function streamingHasMarkdownSyntax(text, key) {
+  return cachedStreamingHasMarkdownSyntax(markdownSyntaxByStreamKey, text, key);
+}
 function getResolvedPartsKey(key, text) {
   if (!key) return null;
   const entry = resolvedPartsByStreamKey.get(key);
@@ -11518,11 +11618,17 @@ function resetStreamingMarkdownStablePrefix(streamKey) {
   if (streamKey == null || streamKey === "") return;
   const key = String(streamKey);
   stablePrefixByStreamKey.delete(key);
+  markdownSyntaxByStreamKey.delete(key);
+  plainWindowSyntaxByStreamKey.delete(key);
   resolvedPartsByStreamKey.delete(key);
+  resetOpenFenceScan(key);
 }
 function resetAllStreamingMarkdownStablePrefixes() {
   stablePrefixByStreamKey.clear();
+  markdownSyntaxByStreamKey.clear();
+  plainWindowSyntaxByStreamKey.clear();
   resolvedPartsByStreamKey.clear();
+  resetAllOpenFenceScans();
 }
 function resolveStreamingMarkdownParts(text, streamKey) {
   const t = streamingLayoutText(text);
@@ -11534,34 +11640,39 @@ function resolveStreamingMarkdownParts(text, streamKey) {
     return cacheResolvedPartsKey(key, t, {
       plain: true,
       stablePrefix: "",
+      stableChunks: [],
       unstableSuffix: "",
       unstableForRender: ""
     });
   }
-  if (!hasMarkdownSyntax(t)) {
+  if (!streamingHasMarkdownSyntax(t, key)) {
     if (key) stablePrefixByStreamKey.delete(key);
     return cacheResolvedPartsKey(key, t, {
       plain: true,
       stablePrefix: "",
+      stableChunks: [],
       unstableSuffix: t,
       unstableForRender: t
     });
   }
-  let stablePrefix = key ? getStablePrefixKey(key) : "";
-  if (!t.startsWith(stablePrefix)) {
-    stablePrefix = "";
+  let stableState = key ? getStablePrefixKey(key) : { text: "", chunks: [] };
+  if (!t.startsWith(stableState.text)) {
+    stableState = { text: "", chunks: [] };
   }
-  const open = findOpenFenceStart(t);
+  let stablePrefix = stableState.text;
+  const open = findOpenFenceStart(t, key);
   if (open) {
     let openPrefix = t.substring(0, open.index);
     if (isWhitespaceOnlyText(openPrefix)) openPrefix = "";
-    if (key && openPrefix) touchStablePrefixKey(key, openPrefix);
+    stableState = stableStateForText(openPrefix, stableState);
+    if (key && openPrefix) touchStablePrefixKey(key, stableState);
     else if (key) stablePrefixByStreamKey.delete(key);
     const unstableSuffix2 = t.substring(openPrefix.length);
     return cacheResolvedPartsKey(key, t, {
       plain: false,
       openFence: true,
       stablePrefix: openPrefix,
+      stableChunks: stableState.chunks,
       unstableSuffix: unstableSuffix2,
       unstableForRender: unstableSuffix2
     });
@@ -11584,18 +11695,24 @@ function resolveStreamingMarkdownParts(text, streamKey) {
     if (advance > 0) {
       stablePrefix = t.substring(0, boundary + advance);
       if (isWhitespaceOnlyText(stablePrefix)) stablePrefix = "";
-      if (key && stablePrefix) touchStablePrefixKey(key, stablePrefix);
+      stableState = stableStateForText(stablePrefix, stableState);
+      if (key && stablePrefix) touchStablePrefixKey(key, stableState);
       else if (key && !stablePrefix) stablePrefixByStreamKey.delete(key);
     }
   } catch {
     stablePrefix = "";
+    stableState = { text: "", chunks: [] };
     if (key) stablePrefixByStreamKey.delete(key);
   }
-  if (isWhitespaceOnlyText(stablePrefix)) stablePrefix = "";
+  if (isWhitespaceOnlyText(stablePrefix)) {
+    stablePrefix = "";
+    stableState = { text: "", chunks: [] };
+  }
   const unstableSuffix = t.substring(stablePrefix.length);
   return cacheResolvedPartsKey(key, t, {
     plain: false,
     stablePrefix,
+    stableChunks: stableState.chunks,
     unstableSuffix,
     unstableForRender: balanceStreamingMarkdown(unstableSuffix)
   });
@@ -11721,22 +11838,31 @@ function measureStreamingMarkdownRenderedRows(text, columns, streamKey) {
   let rows = 0;
   let childCount = 0;
   let stableRows = 0;
-  if (parts.stablePrefix) {
-    stableRows = cached && cached.mode === "markdown" && cached.columns === columns && cached.stablePrefix === parts.stablePrefix ? cached.stableRows : measureMarkdownRenderedRows(parts.stablePrefix, columns, { trimPartialFences: false });
-    rows += stableRows;
-    childCount += 1;
-  }
+  const stableChunks = parts.stableChunks?.length ? parts.stableChunks : parts.stablePrefix ? [parts.stablePrefix] : [];
+  const reusableChunks = cached && cached.mode === "markdown" && cached.columns === columns && Array.isArray(cached.stableChunks) && cached.stableChunks.length <= stableChunks.length && cached.stableChunks.every((chunk, index) => chunk === stableChunks[index]);
+  let measuredStableChunks = 0;
+  if (reusableChunks) {
+    stableRows = cached.stableRows;
+    measuredStableChunks = cached.stableChunks.length;
+  }
+  for (let index = measuredStableChunks; index < stableChunks.length; index += 1) {
+    if (index > 0) stableRows += 1;
+    stableRows += measureMarkdownRenderedRows(stableChunks[index], columns, { trimPartialFences: false });
+  }
+  rows += stableRows;
+  childCount = stableChunks.length;
   if (parts.unstableSuffix) {
+    if (childCount > 0) rows += 1;
     rows += measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
     childCount += 1;
   }
-  if (childCount === 2) rows += 1;
   const measuredRows = childCount === 0 ? 1 : Math.max(1, rows);
   cacheStreamingRows(key, {
     text: value,
     columns,
     mode: "markdown",
     stablePrefix: parts.stablePrefix,
+    stableChunks: stableChunks.slice(),
     stableRows,
     rows: measuredRows
   });
@@ -12818,6 +12944,9 @@ function cacheStreamingTailEstimate(id, entry) {
 function hasStreamingRowStateToPrune() {
   return streamingMeasuredRowsById.size > 0 || streamingEstimateHighWaterById.size > 0 || streamingTailEstimateById.size > 0;
 }
+function transcriptHarvestInputsEqual(left, right) {
+  return !!left && !!right && left.revision === right.revision && left.settledItems === right.settledItems && left.streamingTailItem === right.streamingTailItem && left.startIndex === right.startIndex && left.endIndex === right.endIndex && left.frameColumns === right.frameColumns && left.toolOutputExpanded === right.toolOutputExpanded && left.transcriptContentHeight === right.transcriptContentHeight && left.floatingPanelRows === right.floatingPanelRows && left.overlayHintRequested === right.overlayHintRequested && left.transcriptGuardRows === right.transcriptGuardRows && left.themeEpoch === right.themeEpoch;
+}
 function pruneStreamingMeasuredRowsById(liveIds) {
   if (!liveIds) return;
   if (streamingMeasuredRowsById.size > 0) {
@@ -13632,13 +13761,30 @@ import { useCallback as useCallback3, useEffect as useEffect8, useRef as useRef8
 // src/tui/engine/render-timing.mjs
 var RENDER_ACK_HANG_GUARD_MS = 250;
 var RENDER_SETTLE_IDLE_MS = 64;
+var TUI_RENDER_FPS = 60;
+var TUI_FRAME_MS = Math.ceil(1e3 / TUI_RENDER_FPS);
 var pendingRenderAcks = [];
 var renderAckSeq = 0;
+var lastRenderFrameAt = 0;
+var renderFrameDelay = (lastFrameAt, currentTime, frameMs = TUI_FRAME_MS) => {
+  if (!(lastFrameAt > 0)) return frameMs;
+  return Math.max(0, frameMs - Math.max(0, currentTime - lastFrameAt));
+};
+var scheduleRenderAlignedStoreFlush = (callback, frameMs = TUI_FRAME_MS) => {
+  const timer2 = setTimeout(
+    callback,
+    renderFrameDelay(lastRenderFrameAt, performance.now(), frameMs)
+  );
+  timer2.unref?.();
+  return timer2;
+};
+var cancelRenderAlignedStoreFlush = (timer2) => clearTimeout(timer2);
 var scheduleRenderFrameAck = () => {
   const seq = ++renderAckSeq;
   setImmediate(() => notifyRenderFrame(seq));
 };
 var notifyRenderFrame = (seq = ++renderAckSeq) => {
+  lastRenderFrameAt = performance.now();
   if (pendingRenderAcks.length === 0) return;
   const acks = pendingRenderAcks;
   pendingRenderAcks = [];
@@ -14285,6 +14431,11 @@ function useTranscriptWindow({
   const prevViewportGeomRef = useRef9({ contentHeight: 0, floatingPanelRows: 0 });
   const transcriptItemElsRef = useRef9(/* @__PURE__ */ new Map());
   const transcriptMeasureRefCache = useRef9(/* @__PURE__ */ new Map());
+  const harvestGateRef = useRef9({
+    inputs: null,
+    skippedForDrag: false,
+    forceNext: false
+  });
   const transcriptMeasureItemsRef = useRef9(/* @__PURE__ */ new Map());
   const transcriptMeasureRef = useCallback4((item) => {
     if (!TRANSCRIPT_MEASURED_ROWS || !item || item.id == null) return void 0;
@@ -14516,11 +14667,33 @@ function useTranscriptWindow({
   const transcriptTailPinned = Math.max(0, Number(transcriptWindow.effectiveScrollOffset) || 0) === 0;
   const overlayHintOnLastItem = overlayHintRequested && floatingPanelRows <= 0 && transcriptWindow.bottomSpacerRows === 0 && transcriptTailPinned && overlayHintAttachItemIndex >= 0;
   const overlayHintFallbackRow = overlayHintRequested && floatingPanelRows <= 0 && transcriptGuardRows > 0 && !overlayHintOnLastItem;
+  const harvestInputs = {
+    revision,
+    settledItems,
+    streamingTailItem,
+    startIndex: transcriptWindow.startIndex,
+    endIndex: transcriptWindow.endIndex,
+    frameColumns,
+    toolOutputExpanded,
+    transcriptContentHeight,
+    floatingPanelRows,
+    overlayHintRequested,
+    transcriptGuardRows,
+    themeEpoch
+  };
   useLayoutEffect3(() => {
     if (!TRANSCRIPT_MEASURED_ROWS) return;
-    if (dragRef.current.active) return;
+    const gate = harvestGateRef.current;
+    if (dragRef.current.active) {
+      gate.skippedForDrag = true;
+      return;
+    }
+    if (!gate.skippedForDrag && !gate.forceNext && transcriptHarvestInputsEqual(gate.inputs, harvestInputs)) return;
     const els = transcriptItemElsRef.current;
     if (!els || els.size === 0) return;
+    gate.inputs = harvestInputs;
+    gate.skippedForDrag = false;
+    gate.forceNext = false;
     const liveItems = transcriptMeasureItemsRef.current;
     const toolExpandedFlag = toolOutputExpanded ? 1 : 0;
     let changed = false;
@@ -14595,6 +14768,7 @@ function useTranscriptWindow({
           }, 0);
           if (typeof streak.timer?.unref === "function") streak.timer.unref();
         }
+        gate.forceNext = true;
         setMeasuredRowsVersion((v) => (v + 1) % 1e6);
       }
     }
@@ -20156,13 +20330,29 @@ function Markdown({ children, themeEpoch = 0, trimPartialFences = false, columns
   }, [children, themeEpoch, trimPartialFences, columns]);
   return /* @__PURE__ */ jsx13(Box11, { flexDirection: "column", gap: 1, children: elements });
 }
+var StableMarkdownChunk = React13.memo(function StableMarkdownChunk2({
+  text,
+  themeEpoch,
+  columns
+}) {
+  return /* @__PURE__ */ jsx13(Markdown, { themeEpoch, columns, children: text });
+});
 function StreamingMarkdown({ children, themeEpoch = 0, columns, streamKey }) {
   const parts = resolveStreamingMarkdownParts(children, streamKey);
   if (parts.plain) {
     return /* @__PURE__ */ jsx13(Text13, { color: theme.text, wrap: "wrap", children: parts.unstableForRender });
   }
+  const stableChunks = parts.stableChunks?.length ? parts.stableChunks : parts.stablePrefix ? [parts.stablePrefix] : [];
   return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", gap: 1, children: [
-    parts.stablePrefix ? /* @__PURE__ */ jsx13(Markdown, { themeEpoch, columns, children: parts.stablePrefix }) : null,
+    stableChunks.map((text, index) => /* @__PURE__ */ jsx13(
+      StableMarkdownChunk,
+      {
+        text,
+        themeEpoch,
+        columns
+      },
+      `stable-${index}`
+    )),
     parts.unstableSuffix ? /* @__PURE__ */ jsx13(Markdown, { themeEpoch, columns, trimPartialFences: true, children: parts.unstableForRender }) : null
   ] });
 }
@@ -20181,7 +20371,7 @@ var AssistantMessage = React14.memo(function AssistantMessage2({
     if (!streaming && assistantId) resetStreamingMarkdownStablePrefix(assistantId);
   }, [streaming, assistantId]);
   const bodyWidth = assistantBodyWidth(columns);
-  const renderText = streaming && streamingWindowRows > 0 ? windowPlainStreamingText(text, bodyWidth, streamingWindowRows) : text;
+  const renderText = streaming && streamingWindowRows > 0 ? windowPlainStreamingText(text, bodyWidth, streamingWindowRows, assistantId) : text;
   return /* @__PURE__ */ jsxs10(Box12, { flexDirection: "row", marginTop: 1, children: [
     /* @__PURE__ */ jsx14(Box12, { flexShrink: 0, minWidth: 2, children: /* @__PURE__ */ jsx14(Text14, { color: theme.text, children: TURN_MARKER }) }),
     /* @__PURE__ */ jsx14(Box12, { flexDirection: "column", flexShrink: 0, width: bodyWidth, children: streaming ? /* @__PURE__ */ jsx14(StreamingMarkdown, { themeEpoch, columns: bodyWidth, streamKey: assistantId, children: renderText }) : /* @__PURE__ */ jsx14(Markdown, { themeEpoch, columns: bodyWidth, children: text }) })
@@ -23633,7 +23823,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
 }
 
 // src/tui/engine.mjs
-import { performance as performance2 } from "node:perf_hooks";
+import { performance as performance3 } from "node:perf_hooks";
 import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync11, readdirSync as readdirSync5, rmSync as rmSync4, statSync as statSync7, watch as watch2, writeFileSync as writeFileSync8 } from "node:fs";
 import { basename as basename7, dirname as dirname11, join as join14 } from "node:path";
 
@@ -23916,12 +24106,12 @@ function sessionPath(id) {
 }
 
 // src/tui/engine/boot-profile.mjs
-import { performance } from "node:perf_hooks";
+import { performance as performance2 } from "node:perf_hooks";
 var BOOT_PROFILE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_BOOT_PROFILE || ""));
-var BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance.now());
+var BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance2.now());
 function bootProfile(event, fields = {}) {
   if (!BOOT_PROFILE_ENABLED) return;
-  const elapsedMs = performance.now() - BOOT_PROFILE_START;
+  const elapsedMs = performance2.now() - BOOT_PROFILE_START;
   const parts = [`[mixdog-boot] +${elapsedMs.toFixed(1)}ms`, `tui:${event}`];
   for (const [key, value] of Object.entries(fields || {})) {
     if (value === void 0 || value === null || value === "") continue;
@@ -25611,6 +25801,7 @@ import { randomBytes as randomBytes3 } from "crypto";
 import { join as join10 } from "path";
 var PENDING_MESSAGES_FILE = "session-pending-messages.json";
 var PENDING_MESSAGES_MODE = 384;
+var STALE_STEERING_RESTORE_TTL_MS = 30 * 60 * 1e3;
 var _persistChain = Promise.resolve();
 function _serialize(task) {
   const run = _persistChain.then(task, task);
@@ -25637,7 +25828,9 @@ function normalizeTuiSteeringQueueEntry(entry) {
   if (typeof entry.text === "string" && entry.text.trim()) {
     const text = entry.text.trim();
     const id = typeof entry.id === "string" && entry.id.trim() ? entry.id.trim() : null;
-    return id ? { id, text } : text;
+    if (!id) return text;
+    const at = Number(entry.at);
+    return Number.isFinite(at) && at > 0 ? { id, text, at } : { id, text };
   }
   return null;
 }
@@ -25689,7 +25882,7 @@ function appendTuiSteeringPersist(leadSessionId, entry) {
   const key = tuiSteeringSessionKey(leadSessionId);
   if (!key) return Promise.resolve();
   if (!entry.steeringPersistId) entry.steeringPersistId = newSteeringPersistId();
-  const record = { id: entry.steeringPersistId, text };
+  const record = { id: entry.steeringPersistId, text, at: Date.now() };
   return _serialize(async () => {
     try {
       await updateJsonAtomic(pendingMessagesPath(), (raw) => {
@@ -25761,12 +25954,21 @@ function drainTuiSteeringPersist(leadSessionId) {
   if (!key) return Promise.resolve([]);
   return _serialize(async () => {
     let drained = [];
+    let droppedStale = 0;
     try {
       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;
+        const now = Date.now();
+        const touchedAt = Number(next.sessionTouchedAt?.[key]) || 0;
+        const fresh = q.filter((row) => {
+          const at = Number(row?.at) || touchedAt;
+          const stale = at > 0 && now - at > STALE_STEERING_RESTORE_TTL_MS;
+          if (stale) droppedStale += 1;
+          return !stale;
+        });
+        drained = fresh.map(drainedRowToRestore).filter(Boolean);
+        if (drained.length === 0 && droppedStale === 0) return void 0;
         delete next.sessions[key];
         if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
         next.updatedAt = Date.now();
@@ -25775,6 +25977,13 @@ function drainTuiSteeringPersist(leadSessionId) {
     } catch (err) {
       try {
         process.stderr.write(`[tui] steering-queue drain failed sessionId=${leadSessionId}: ${err?.message || err}
+`);
+      } catch {
+      }
+    }
+    if (droppedStale > 0) {
+      try {
+        process.stderr.write(`[tui] dropped ${droppedStale} stale steering row(s) sessionId=${leadSessionId}
 `);
       } catch {
       }
@@ -28276,6 +28485,17 @@ function createEngineApiB(bag) {
     listSessions: (options) => {
       return runtime.listSessions(options);
     },
+    // Desktop sidebar watcher hook: EngineHost fs.watches this directory so
+    // heartbeat sidecar create/delete pushes instant working/dot updates.
+    // Without it the watcher silently no-ops and the sidebar falls back to
+    // the 60s safety poll (user: spinner kept spinning after the turn ended).
+    sessionStoreDir: () => {
+      try {
+        return runtime.sessionStoreDir?.() || null;
+      } catch {
+        return null;
+      }
+    },
     deleteSession: async (id) => {
       if (getState().commandBusy) return false;
       const deletingCurrent = String(runtime.session?.id || getState().sessionId || "") === String(id || "");
@@ -29247,7 +29467,9 @@ function createFrameBatchedStorePublisher({
   frameMs = 16,
   setTimer = setTimeout,
   clearTimer = clearTimeout,
-  enqueueMicrotask = queueMicrotask
+  enqueueMicrotask = queueMicrotask,
+  scheduleFrame = (callback, delay2) => setTimer(callback, delay2),
+  cancelFrame = (handle) => clearTimer(handle)
 }) {
   let timer2 = null;
   let emitPending = false;
@@ -29255,7 +29477,7 @@ function createFrameBatchedStorePublisher({
   let immediatePending = false;
   const flush = () => {
     if (timer2 !== null) {
-      clearTimer(timer2);
+      cancelFrame(timer2);
       timer2 = null;
     }
     immediatePending = false;
@@ -29277,7 +29499,7 @@ function createFrameBatchedStorePublisher({
   const emit = () => {
     emitPending = true;
     if (timer2 !== null || isDisposed()) return;
-    timer2 = setTimer(flush, frameMs);
+    timer2 = scheduleFrame(flush, frameMs);
     timer2?.unref?.();
   };
   const markStructureChange = () => {
@@ -29291,7 +29513,7 @@ function createFrameBatchedStorePublisher({
   };
   const dispose = () => {
     if (emitPending && !isDisposed()) flush();
-    else if (timer2 !== null) clearTimer(timer2);
+    else if (timer2 !== null) cancelFrame(timer2);
     timer2 = null;
     emitPending = false;
     structureChangePending = false;
@@ -30313,16 +30535,16 @@ async function createEngineSession({
   cwd,
   desktopSession
 } = {}) {
-  const startedAt = performance2.now();
+  const startedAt = performance3.now();
   bootProfile("engine:create:start", { provider: providerName, model, toolMode, remote });
   process.env.MIXDOG_QUIET_PROVIDER_LOG = "1";
   process.env.MIXDOG_QUIET_SESSION_LOG = "1";
   process.env.MIXDOG_QUIET_MCP_LOG = "1";
   process.env.MIXDOG_QUIET_MEMORY_LOG = "1";
   process.env.MIXDOG_PATCH_NATIVE_PREWARM ??= "0";
-  const importStartedAt = performance2.now();
+  const importStartedAt = performance3.now();
   const { createMixdogSessionRuntime } = await import(SESSION_RUNTIME_MODULE);
-  bootProfile("session-runtime:imported", { ms: (performance2.now() - importStartedAt).toFixed(1) });
+  bootProfile("session-runtime:imported", { ms: (performance3.now() - importStartedAt).toFixed(1) });
   const runtime = await createMixdogSessionRuntime({
     provider: providerName,
     model,
@@ -30331,9 +30553,9 @@ async function createEngineSession({
     ...cwd ? { cwd } : {},
     ...desktopSession ? { desktopSession } : {}
   });
-  bootProfile("engine:create:runtime-ready", { ms: (performance2.now() - startedAt).toFixed(1) });
+  bootProfile("engine:create:runtime-ready", { ms: (performance3.now() - startedAt).toFixed(1) });
   const runtimeCwd = runtime.cwd || process.cwd();
-  const stateStartedAt = performance2.now();
+  const stateStartedAt = performance3.now();
   const flags = {
     disposed: false,
     draining: false,
@@ -30409,11 +30631,11 @@ async function createEngineSession({
     cwd: runtimeCwd,
     themeEpoch: 0
   };
-  bootProfile("engine:route-state-ready", { ms: (performance2.now() - stateStartedAt).toFixed(1) });
-  bootProfile("engine:state-ready", { ms: (performance2.now() - stateStartedAt).toFixed(1) });
-  const contextStartedAt = performance2.now();
+  bootProfile("engine:route-state-ready", { ms: (performance3.now() - stateStartedAt).toFixed(1) });
+  bootProfile("engine:state-ready", { ms: (performance3.now() - stateStartedAt).toFixed(1) });
+  const contextStartedAt = performance3.now();
   syncContextStats({ allowEstimated: true });
-  bootProfile("engine:context-ready", { ms: (performance2.now() - contextStartedAt).toFixed(1) });
+  bootProfile("engine:context-ready", { ms: (performance3.now() - contextStartedAt).toFixed(1) });
   const listeners = /* @__PURE__ */ new Set();
   let publishedState = process.env.NODE_ENV === "production" ? state : Object.freeze(state);
   state = { ...state, stats: { ...state.stats } };
@@ -30424,7 +30646,10 @@ async function createEngineSession({
       state = { ...next, stats: { ...next.stats } };
     },
     listeners,
-    isDisposed: () => flags.disposed
+    isDisposed: () => flags.disposed,
+    frameMs: TUI_FRAME_MS,
+    scheduleFrame: scheduleRenderAlignedStoreFlush,
+    cancelFrame: cancelRenderAlignedStoreFlush
   });
   const emit = publisher.emit;
   const flushEmit = publisher.flush;
@@ -31100,7 +31325,7 @@ var XTSHIFTESCAPE_ON = process.env.WT_SESSION ? "" : "\x1B[>1s";
 var MOUSE_TRACKING_ON2 = `\x1B[?1000h\x1B[?1002h\x1B[?1006h\x1B[?1007l${XTSHIFTESCAPE_ON}`;
 var ALT_SCROLL_RESTORE = "\x1B[?1007h";
 var BOOT_PROFILE_ENABLED2 = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_BOOT_PROFILE || ""));
-var BOOT_PROFILE_START2 = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance3.now());
+var BOOT_PROFILE_START2 = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance4.now());
 var EXIT_WAIT_TIMEOUT_MS = positiveIntEnv2("MIXDOG_TUI_EXIT_WAIT_MS", 2500);
 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"));
@@ -31116,9 +31341,9 @@ function positiveIntEnv2(name, fallback) {
 function installTuiLoopProbe() {
   if (!LOOP_PROBE_ENABLED) return () => {
   };
-  let last = performance3.now();
+  let last = performance4.now();
   const timer2 = setInterval(() => {
-    const now = performance3.now();
+    const now = performance4.now();
     const drift = now - last - LOOP_PROBE_INTERVAL_MS;
     last = now;
     if (drift > LOOP_PROBE_DRIFT_THRESHOLD_MS) {
@@ -31143,7 +31368,7 @@ 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 elapsedMs = performance4.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;
@@ -31158,7 +31383,7 @@ function perfLog(event, fields = {}) {
 function installTuiPerfProbe() {
   if (!PERF_ENABLED) return () => {
   };
-  let last = performance3.now();
+  let last = performance4.now();
   let lastCpu = process.cpuUsage();
   perfLog("probe:start", {
     intervalMs: PERF_STALL_INTERVAL_MS,
@@ -31166,7 +31391,7 @@ function installTuiPerfProbe() {
     renderGapMs: PERF_RENDER_GAP_MS
   });
   const timer2 = setInterval(() => {
-    const now = performance3.now();
+    const now = performance4.now();
     const elapsed = now - last;
     const lagMs = elapsed - PERF_STALL_INTERVAL_MS;
     const cpu = process.cpuUsage(lastCpu);
@@ -31204,7 +31429,7 @@ function makeRenderProfiler() {
   let lastFrameAt = 0;
   return ({ renderTime } = {}) => {
     ackRenderedFrame();
-    const now = performance3.now();
+    const now = performance4.now();
     const ms = Number(renderTime) || 0;
     const gap = lastFrameAt ? now - lastFrameAt : 0;
     lastFrameAt = now;
@@ -31238,7 +31463,7 @@ function makeRenderProfiler() {
 }
 function bootProfile2(event, fields = {}) {
   if (!BOOT_PROFILE_ENABLED2) return;
-  const elapsedMs = performance3.now() - BOOT_PROFILE_START2;
+  const elapsedMs = performance4.now() - BOOT_PROFILE_START2;
   const parts = [`[mixdog-boot] +${elapsedMs.toFixed(1)}ms`, `tui:${event}`];
   for (const [key, value] of Object.entries(fields || {})) {
     if (value === void 0 || value === null || value === "") continue;
@@ -31456,7 +31681,7 @@ function installTuiConsoleGuard() {
   };
 }
 async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {}) {
-  const startedAt = performance3.now();
+  const startedAt = performance4.now();
   bootProfile2("run:start", { provider, model, toolMode, remote });
   if (!process.stdin.isTTY) {
     process.stderr.write(
@@ -31487,6 +31712,7 @@ async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {
   process.stdout.write(`${TERMINAL_MODE_RESET_HIDDEN_CURSOR}\x1B[?1049h${TERMINAL_MODE_RESET_HIDDEN_CURSOR}\x1B[2J\x1B[H`);
   process.stdout.write("\x1B[5 q");
   process.on("exit", restoreTerminal);
+  const storeOutcomePromise = createEngineSession({ provider, model, toolMode, remote }).then((store2) => ({ store: store2, error: null }), (error) => ({ store: null, error }));
   try {
     await loadThemeSettingFromConfig();
   } catch {
@@ -31496,8 +31722,10 @@ async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {
   } };
   let store;
   try {
-    store = await createEngineSession({ provider, model, toolMode, remote });
-    bootProfile2("store:ready", { ms: (performance3.now() - startedAt).toFixed(1) });
+    const outcome = await storeOutcomePromise;
+    if (outcome.error) throw outcome.error;
+    store = outcome.store;
+    bootProfile2("store:ready", { ms: (performance4.now() - startedAt).toFixed(1) });
   } catch (error) {
     splash.stop();
     stopPerfProbe();
@@ -31562,8 +31790,8 @@ async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {
   registerStdioDeath(process.stderr, "error", { requireCode: true });
   registerStdioDeath(process.stderr, "close");
   try {
-    const instance = render(/* @__PURE__ */ jsx21(App, { store, forceOnboarding: forceOnboarding === true }), { exitOnCtrlC: false, maxFps: 60, incrementalRendering: true, patchConsole: false, onRender: makeRenderProfiler() });
-    bootProfile2("render:mounted", { ms: (performance3.now() - startedAt).toFixed(1) });
+    const instance = render(/* @__PURE__ */ jsx21(App, { store, forceOnboarding: forceOnboarding === true }), { exitOnCtrlC: false, maxFps: TUI_RENDER_FPS, incrementalRendering: true, patchConsole: false, onRender: makeRenderProfiler() });
+    bootProfile2("render:mounted", { ms: (performance4.now() - startedAt).toFixed(1) });
     const { waitUntilExit } = instance;
     if (mouseTracking && typeof instance.setSelection === "function") {
       store.setRenderSelection = instance.setSelection;