mixdog 0.9.53 → 0.9.55

package/src/tui/dist/index.mjs

@@ -194,8 +194,8 @@ var require_mixdog_debug = __commonJS({
 import React21 from "react";
 import { render } from "../../../vendor/ink/build/index.js";
 import { closeSync as closeSync2, constants as fsConstants, createWriteStream, mkdirSync as mkdirSync7, openSync as openSync2, readSync } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname9, join as join10 } from "node:path";
+import { tmpdir as tmpdir3 } from "node:os";
+import { dirname as dirname9, join as join11 } from "node:path";
 import { performance as performance3 } from "node:perf_hooks";
 import { format } from "node:util";
 
@@ -4671,14 +4671,32 @@ function offsetAtCell(text, row, col, width) {
 }
 function boundaryPositions(text, width) {
   const value = String(text || "");
-  const offsets = [0];
-  for (const unit of graphemeUnits(value)) offsets.push(unit.end);
-  const seen = /* @__PURE__ */ new Set();
-  const positions = offsets.filter((offset) => {
-    if (seen.has(offset)) return false;
-    seen.add(offset);
-    return true;
-  }).map((offset) => ({ offset, ...caretPosition(value, offset, width) }));
+  const w = safeWidth(width);
+  const units = graphemeUnits(value);
+  const positions = [{ offset: 0, row: 0, col: 0 }];
+  let row = 0;
+  let col = 0;
+  for (let i = 0; i < units.length; i += 1) {
+    const { end, segment } = units[i];
+    if (segment === "\n") {
+      row += 1;
+      col = 0;
+    } else {
+      const segmentWidth = displayWidth(segment);
+      if (segmentWidth > 0) {
+        if (col > 0 && col + segmentWidth > w) {
+          row += 1;
+          col = 0;
+        }
+        col += segmentWidth;
+        if (col === w && i < units.length - 1) {
+          row += 1;
+          col = 0;
+        }
+      }
+    }
+    positions.push({ offset: end, row, col });
+  }
   return positions;
 }
 function verticalOffset(text, offset, width, direction, preferredColumn = null) {
@@ -4919,11 +4937,14 @@ function PromptInput({
   const commitDraft = (next, options = {}) => {
     const sameDraft = draftStateEqual(draftRef.current, next);
     if (!options.keepPreferredColumn) preferredColumnRef.current = null;
-    if (sameDraft) return;
+    if (sameDraft) {
+      if (options.immediateSettle) scheduleImmediateFlush();
+      return;
+    }
     if (!options.skipHistory) recordUndoSnapshot(draftRef.current, next, options);
     draftRef.current = next;
     setDraft(next);
-    scheduleImmediateFlush();
+    if (!options.throttledRender) scheduleImmediateFlush();
     if (next.value !== lastReportedValueRef.current) {
       lastReportedValueRef.current = next.value;
       onDraftChange?.(next.value);
@@ -5024,13 +5045,13 @@ function PromptInput({
   const queueMouseExtendCommit = (next, immediate = false) => {
     if (immediate) {
       cancelMouseExtendCoalesce();
-      commitDraft(next);
+      commitDraft(next, { immediateSettle: true });
       mouseExtendCoalesceRef.current.t = Date.now();
       return;
     }
     if (draftStateEqual(draftRef.current, next)) {
       cancelMouseExtendCoalesce();
-      commitDraft(next);
+      commitDraft(next, { throttledRender: true });
       return;
     }
     const state = mouseExtendCoalesceRef.current;
@@ -5040,7 +5061,7 @@ function PromptInput({
     if (elapsed >= MOUSE_EXTEND_COALESCE_MS) {
       cancelMouseExtendCoalesce();
       state.t = now;
-      commitDraft(next);
+      commitDraft(next, { throttledRender: true });
       return;
     }
     if (state.timer) return;
@@ -5050,7 +5071,7 @@ function PromptInput({
       current.timer = null;
       current.pendingNext = null;
       current.t = Date.now();
-      if (pending) commitDraft(pending);
+      if (pending) commitDraft(pending, { throttledRender: true });
     }, Math.max(1, MOUSE_EXTEND_COALESCE_MS - elapsed));
     state.timer.unref?.();
   };
@@ -6630,6 +6651,7 @@ import stringWidth6 from "string-width";
 // src/tui/app/text-layout.mjs
 import wrapAnsi from "wrap-ansi";
 var graphemeSegmenter3 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+var promptRowsCache = null;
 function wrappedTextRows(value, width) {
   const w = Math.max(1, Math.floor(Number(width) || 1));
   let row = 0;
@@ -6657,7 +6679,14 @@ function wrappedTextRows(value, width) {
   return row + 1;
 }
 function promptContentRows(value, contentColumns) {
-  return wrappedTextRows(`${String(value ?? "")} `, contentColumns);
+  const text = String(value ?? "");
+  const width = Math.max(1, Math.floor(Number(contentColumns) || 1));
+  if (promptRowsCache?.text === text && promptRowsCache.width === width) {
+    return promptRowsCache.rows;
+  }
+  const rows = wrappedTextRows(`${text} `, width);
+  promptRowsCache = { text, width, rows };
+  return rows;
 }
 function wrappedDetailRows(text, width) {
   const value = String(text ?? "").trim();
@@ -9539,6 +9568,18 @@ function resolveStreamingMarkdownParts(text, streamKey) {
 }
 
 // src/tui/markdown/measure-rendered-rows.mjs
+var streamingRowsByKey = /* @__PURE__ */ new Map();
+var STREAMING_ROWS_LRU_MAX = 32;
+function cacheStreamingRows(key, entry) {
+  if (!key) return;
+  if (streamingRowsByKey.has(key)) streamingRowsByKey.delete(key);
+  streamingRowsByKey.set(key, entry);
+  while (streamingRowsByKey.size > STREAMING_ROWS_LRU_MAX) {
+    const oldest = streamingRowsByKey.keys().next().value;
+    if (oldest === void 0) break;
+    streamingRowsByKey.delete(oldest);
+  }
+}
 function wrappedLineRows(line, width) {
   const text = String(line);
   const full = displayWidth(text);
@@ -9600,15 +9641,55 @@ function measureMarkdownRenderedRows(text, columns, { trimPartialFences = false
 }
 function measureStreamingMarkdownRenderedRows(text, columns, streamKey) {
   const value = String(text ?? "");
-  if (!value) return 1;
+  const key = streamKey == null || streamKey === "" ? null : String(streamKey);
+  const cached = key ? streamingRowsByKey.get(key) : null;
+  if (cached && cached.text === value && cached.columns === columns) {
+    cacheStreamingRows(key, cached);
+    return cached.rows;
+  }
+  if (!value) {
+    cacheStreamingRows(key, {
+      text: value,
+      columns,
+      mode: "empty",
+      rows: 1
+    });
+    return 1;
+  }
   const parts = resolveStreamingMarkdownParts(value, streamKey);
   if (parts.plain) {
-    return estimateWrappedRowsFallback(parts.unstableForRender, columns, 3);
+    const plain = parts.unstableForRender;
+    const width = Math.max(8, Number(columns || 80) - 3);
+    const lastBreak = plain.lastIndexOf("\n");
+    const stablePrefix = lastBreak >= 0 ? plain.substring(0, lastBreak + 1) : "";
+    let stableRows2 = 0;
+    if (cached && cached.mode === "plain" && cached.columns === columns && stablePrefix.startsWith(cached.stablePrefix)) {
+      const addedComplete = plain.substring(cached.stablePrefix.length, Math.max(cached.stablePrefix.length, lastBreak));
+      stableRows2 = cached.stableRows;
+      if (addedComplete) {
+        stableRows2 += addedComplete.split("\n").reduce((sum, line) => sum + wrappedLineRows(line, width), 0);
+      }
+    } else if (lastBreak >= 0) {
+      stableRows2 = plain.substring(0, lastBreak).split("\n").reduce((sum, line) => sum + wrappedLineRows(line, width), 0);
+    }
+    const finalLine = lastBreak >= 0 ? plain.substring(lastBreak + 1) : plain;
+    const rows2 = Math.max(1, stableRows2 + wrappedLineRows(finalLine, width));
+    cacheStreamingRows(key, {
+      text: value,
+      columns,
+      mode: "plain",
+      stablePrefix,
+      stableRows: stableRows2,
+      rows: rows2
+    });
+    return rows2;
   }
   let rows = 0;
   let childCount = 0;
+  let stableRows = 0;
   if (parts.stablePrefix) {
-    rows += measureMarkdownRenderedRows(parts.stablePrefix, columns, { trimPartialFences: false });
+    stableRows = cached && cached.mode === "markdown" && cached.columns === columns && cached.stablePrefix === parts.stablePrefix ? cached.stableRows : measureMarkdownRenderedRows(parts.stablePrefix, columns, { trimPartialFences: false });
+    rows += stableRows;
     childCount += 1;
   }
   if (parts.unstableSuffix) {
@@ -9616,8 +9697,16 @@ function measureStreamingMarkdownRenderedRows(text, columns, streamKey) {
     childCount += 1;
   }
   if (childCount === 2) rows += 1;
-  if (childCount === 0) return 1;
-  return Math.max(1, rows);
+  const measuredRows = childCount === 0 ? 1 : Math.max(1, rows);
+  cacheStreamingRows(key, {
+    text: value,
+    columns,
+    mode: "markdown",
+    stablePrefix: parts.stablePrefix,
+    stableRows,
+    rows: measuredRows
+  });
+  return measuredRows;
 }
 
 // src/runtime/shared/err-text.mjs
@@ -10573,7 +10662,7 @@ function lowerBound(values, target) {
   let hi = values.length;
   while (lo < hi) {
     const mid = Math.floor((lo + hi) / 2);
-    if (values[mid] < target) lo = mid + 1;
+    if (transcriptRowAt(values, mid) < target) lo = mid + 1;
     else hi = mid;
   }
   return lo;
@@ -10583,14 +10672,14 @@ function upperBound(values, target) {
   let hi = values.length;
   while (lo < hi) {
     const mid = Math.floor((lo + hi) / 2);
-    if (values[mid] <= target) lo = mid + 1;
+    if (transcriptRowAt(values, mid) <= target) lo = mid + 1;
     else hi = mid;
   }
   return lo;
 }
 function resolveAnchorScrollOffset({ anchor, items, curPrefix, totalRows, viewRows, maxRows }) {
   if (!anchor || anchor.id == null) return null;
-  if (!Array.isArray(curPrefix) || curPrefix.length <= 1) return null;
+  if (!curPrefix || curPrefix.length <= 1) return null;
   const list = Array.isArray(items) ? items : [];
   let idx = -1;
   for (let i = list.length - 1; i >= 0; i--) {
@@ -10600,9 +10689,9 @@ function resolveAnchorScrollOffset({ anchor, items, curPrefix, totalRows, viewRo
     }
   }
   if (idx < 0 || idx > curPrefix.length - 2) return null;
-  const itemHeight = Math.max(0, (curPrefix[idx + 1] || 0) - (curPrefix[idx] || 0));
+  const itemHeight = Math.max(0, transcriptRowAt(curPrefix, idx + 1) - transcriptRowAt(curPrefix, idx));
   const clampedOffset = Math.max(0, Math.min(Number(anchor.offset) || 0, itemHeight));
-  const anchorRowCur = (curPrefix[idx] || 0) + clampedOffset;
+  const anchorRowCur = transcriptRowAt(curPrefix, idx) + clampedOffset;
   return Math.max(0, Math.min(maxRows, totalRows - viewRows - anchorRowCur));
 }
 function fnv1a32(str) {
@@ -10662,8 +10751,21 @@ var transcriptRowsCache = /* @__PURE__ */ new WeakMap();
 var transcriptMeasuredRowsCache = /* @__PURE__ */ new WeakMap();
 var streamingMeasuredRowsById = /* @__PURE__ */ new Map();
 var streamingEstimateHighWaterById = /* @__PURE__ */ new Map();
+var streamingTailEstimateById = /* @__PURE__ */ new Map();
+var STREAMING_TAIL_ESTIMATE_LRU_MAX = 8;
+function cacheStreamingTailEstimate(id, entry) {
+  if (id == null) return;
+  if (streamingTailEstimateById.has(id)) streamingTailEstimateById.delete(id);
+  streamingTailEstimateById.set(id, entry);
+  while (streamingTailEstimateById.size > STREAMING_TAIL_ESTIMATE_LRU_MAX) {
+    const oldest = streamingTailEstimateById.keys().next().value;
+    if (oldest === void 0) break;
+    streamingTailEstimateById.delete(oldest);
+    streamingEstimateHighWaterById.delete(oldest);
+  }
+}
 function hasStreamingRowStateToPrune() {
-  return streamingMeasuredRowsById.size > 0 || streamingEstimateHighWaterById.size > 0;
+  return streamingMeasuredRowsById.size > 0 || streamingEstimateHighWaterById.size > 0 || streamingTailEstimateById.size > 0;
 }
 function pruneStreamingMeasuredRowsById(liveIds) {
   if (!liveIds) return;
@@ -10677,6 +10779,11 @@ function pruneStreamingMeasuredRowsById(liveIds) {
       if (!liveIds.has(id)) streamingEstimateHighWaterById.delete(id);
     }
   }
+  if (streamingTailEstimateById.size > 0) {
+    for (const id of streamingTailEstimateById.keys()) {
+      if (!liveIds.has(id)) streamingTailEstimateById.delete(id);
+    }
+  }
 }
 function carryTranscriptMeasuredRowsCache(prevItem, nextItem) {
   if (!TRANSCRIPT_MEASURED_ROWS || !prevItem || !nextItem || prevItem === nextItem) return;
@@ -10707,20 +10814,42 @@ function assistantTextForStreamingRowEstimate(text) {
   return streamingLayoutText(text);
 }
 function streamingEstimateRows(item, columns, toolOutputExpanded) {
+  const id = item?.id;
+  const exactText = String(item?.text ?? "");
+  const toolExpanded = toolOutputExpanded ? 1 : 0;
+  const renderMode = item?.kind === "assistant" && item?.streaming ? "assistant-streaming-markdown" : "other";
+  const cached = id == null ? null : streamingTailEstimateById.get(id);
+  if (cached && cached.text === exactText && cached.columns === columns && cached.toolExpanded === toolExpanded && cached.renderMode === renderMode) {
+    cacheStreamingTailEstimate(id, cached);
+    return cached.rows;
+  }
   const trimmedText = assistantTextForStreamingRowEstimate(item.text);
   const estimateItem = trimmedText === item.text ? item : { ...item, text: trimmedText };
   const raw = Math.max(1, Math.ceil(estimateTranscriptItemRows(estimateItem, columns, toolOutputExpanded)));
   const quantized = Math.ceil(raw / STREAMING_ROW_QUANTUM) * STREAMING_ROW_QUANTUM;
-  const id = item?.id;
   if (id == null) return quantized;
-  const toolExpanded = toolOutputExpanded ? 1 : 0;
   const prev = streamingEstimateHighWaterById.get(id);
-  if (!prev || prev.columns !== columns || prev.toolExpanded !== toolExpanded) {
-    streamingEstimateHighWaterById.set(id, { rows: quantized, columns, toolExpanded });
-    return quantized;
+  let rows;
+  if (!prev || prev.columns !== columns || prev.toolExpanded !== toolExpanded || prev.renderMode !== renderMode) {
+    streamingEstimateHighWaterById.set(id, {
+      rows: quantized,
+      columns,
+      toolExpanded,
+      renderMode
+    });
+    rows = quantized;
+  } else {
+    if (quantized > prev.rows) prev.rows = quantized;
+    rows = prev.rows;
   }
-  if (quantized > prev.rows) prev.rows = quantized;
-  return prev.rows;
+  cacheStreamingTailEstimate(id, {
+    text: exactText,
+    columns,
+    toolExpanded,
+    renderMode,
+    rows
+  });
+  return rows;
 }
 function streamingTailMountedGrowth(items, columns, toolOutputExpanded) {
   const list = Array.isArray(items) ? items : [];
@@ -10752,12 +10881,14 @@ function estimateTranscriptItemRowsCached(item, columns, toolOutputExpanded) {
     if (idEntry) {
       streamingMeasuredRowsById.delete(item.id);
       streamingEstimateHighWaterById.delete(item.id);
+      streamingTailEstimateById.delete(item.id);
     }
     return streamingEstimateRows(item, columns, toolOutputExpanded);
   }
   if (item.kind === "assistant") {
     if (streamingMeasuredRowsById.has(item.id)) streamingMeasuredRowsById.delete(item.id);
     if (streamingEstimateHighWaterById.has(item.id)) streamingEstimateHighWaterById.delete(item.id);
+    if (streamingTailEstimateById.has(item.id)) streamingTailEstimateById.delete(item.id);
   }
   const variantKey = transcriptItemVariantKey(item);
   const toolExpanded = toolOutputExpanded ? 1 : 0;
@@ -10772,14 +10903,15 @@ function estimateTranscriptItemRowsCached(item, columns, toolOutputExpanded) {
 function buildTranscriptRowIndex(items, {
   columns = 80,
   toolOutputExpanded = false,
-  suppressMeasuredRowHeights = false
+  suppressMeasuredRowHeights = false,
+  streamingTailItem = null
 } = {}) {
   const allItems = Array.isArray(items) ? items : [];
   const rows = new Array(allItems.length);
   const prefixRows = new Array(allItems.length + 1);
   prefixRows[0] = 0;
   for (let i = 0; i < allItems.length; i++) {
-    const item = allItems[i];
+    const item = streamingTailItem && i === allItems.length - 1 ? streamingTailItem : allItems[i];
     const measured = suppressMeasuredRowHeights ? null : measuredTranscriptRows(item, columns, toolOutputExpanded);
     const rowCount = measured != null ? measured : estimateTranscriptItemRowsCached(item, columns, toolOutputExpanded);
     rows[i] = rowCount;
@@ -10797,17 +10929,19 @@ function buildTranscriptRowIndexIncremental(items, {
   suppressMeasuredRowHeights = false,
   measuredRowsVersion = 0,
   cacheRef = null,
-  prefixRevision = null
+  prefixRevision = null,
+  streamingTailItem = null
 } = {}) {
   const allItems = Array.isArray(items) ? items : [];
-  const tail = trailingStreamingItem(allItems);
+  const tail = streamingTailItem || trailingStreamingItem(allItems);
   const holder = cacheRef || { current: null };
   if (!tail) {
     holder.current = null;
     return buildTranscriptRowIndex(allItems, {
       columns,
       toolOutputExpanded,
-      suppressMeasuredRowHeights
+      suppressMeasuredRowHeights,
+      streamingTailItem
     });
   }
   const prefixLen = allItems.length - 1;
@@ -10816,17 +10950,19 @@ function buildTranscriptRowIndexIncremental(items, {
     {
       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 totalRows = cache.prefixTotal + tailRows;
+      return {
+        rows: appendTranscriptRow(cache.prefixRowsArr, tailRows),
+        prefixRows: appendTranscriptRow(cache.prefixPrefixRows, totalRows),
+        totalRows
+      };
     }
   }
   const full = buildTranscriptRowIndex(allItems, {
     columns,
     toolOutputExpanded,
-    suppressMeasuredRowHeights
+    suppressMeasuredRowHeights,
+    streamingTailItem
   });
   holder.current = {
     columns,
@@ -10842,6 +10978,42 @@ function buildTranscriptRowIndexIncremental(items, {
   };
   return full;
 }
+function transcriptStructureSignature(items, columns, toolOutputExpanded, prefixRevision = 0, streamingTailItem = null) {
+  const list = Array.isArray(items) ? items : [];
+  const tail = streamingTailItem || trailingStreamingItem(list);
+  const tailRows = tail ? estimateTranscriptItemRowsCached(tail, columns, toolOutputExpanded) : 0;
+  return `${Math.max(0, Number(prefixRevision) || 0)}|${list.length}|${columns}|${toolOutputExpanded ? 1 : 0}|${tail?.id ?? "_"}:${tailRows}`;
+}
+function transcriptRowAt(values, index) {
+  if (!values || index < 0 || index >= values.length) return 0;
+  return typeof values.atIndex === "function" ? values.atIndex(index) : Number(values[index]) || 0;
+}
+function appendTranscriptRow(prefix, tailValue) {
+  return Object.freeze({
+    length: prefix.length + 1,
+    atIndex: (index) => index === prefix.length ? tailValue : Number(prefix[index]) || 0,
+    slice: (start = 0, end = prefix.length + 1) => {
+      const values = [];
+      const lo = Math.max(0, start < 0 ? prefix.length + 1 + start : start);
+      const hi = Math.min(prefix.length + 1, end < 0 ? prefix.length + 1 + end : end);
+      for (let index = lo; index < hi; index++) {
+        values.push(index === prefix.length ? tailValue : prefix[index]);
+      }
+      return values;
+    }
+  });
+}
+function transcriptItemsWithStableTail(settledItems, streamingTailItem, cacheRef) {
+  const settled = Array.isArray(settledItems) ? settledItems : [];
+  if (!streamingTailItem) return settled;
+  const previous = cacheRef?.current;
+  if (previous && previous.settled === settled && previous.tailId === streamingTailItem.id) {
+    return previous.items;
+  }
+  const items = [...settled, streamingTailItem];
+  if (cacheRef) cacheRef.current = { settled, tailId: streamingTailItem.id, items };
+  return items;
+}
 function transcriptRenderWindow(items, { scrollOffset = 0, viewportHeight = 24, columns = 80, toolOutputExpanded = false, rowIndex = null } = {}) {
   const allItems = Array.isArray(items) ? items : [];
   const itemCount = allItems.length;
@@ -10878,7 +11050,7 @@ function transcriptRenderWindow(items, { scrollOffset = 0, viewportHeight = 24,
     endIndex = Math.min(itemCount, Math.max(visibleEndIndex, startIndex + effectiveMaxItems));
     if (endIndex - startIndex > effectiveMaxItems) startIndex = Math.max(0, endIndex - effectiveMaxItems);
   }
-  const bottomSpacerRows = Math.max(0, totalRows - (prefixRows[endIndex] || totalRows));
+  const bottomSpacerRows = Math.max(0, totalRows - (transcriptRowAt(prefixRows, endIndex) || totalRows));
   return {
     startIndex,
     endIndex,
@@ -11016,6 +11188,9 @@ function useMouseInput({
       promptMouseSelectionRef.current?.clear?.();
       applySelectionRect(null);
     };
+    const finishWindowsMouseGesture = () => {
+      if (IS_WINDOWS_TERMINAL) store.forceRenderRepaint?.();
+    };
     const EDGE_AUTOSCROLL_INTERVAL_MS = 50;
     const stopEdgeAutoscroll = () => {
       const st = edgeAutoscrollRef.current;
@@ -11089,6 +11264,7 @@ function useMouseInput({
           if (dragRef.current.active) {
             const last = dragRef.current.last || {};
             finalizeActiveDrag(Number(last.x) || 0, Number(last.y) || 0);
+            finishWindowsMouseGesture();
           } else {
             stopEdgeAutoscroll();
           }
@@ -11123,9 +11299,6 @@ function useMouseInput({
         const shiftHeld = (button & MOUSE_SHIFT_MASK) !== 0;
         const ctrlHeld = (button & MOUSE_CTRL_MASK) !== 0;
         if (IS_WINDOWS_TERMINAL && shiftHeld) return;
-        if (IS_WINDOWS_TERMINAL && press && !isMotion) {
-          store.forceRenderRepaint?.();
-        }
         const extendHeld = shiftHeld || ctrlHeld;
         const isRightPress = baseButton === 2 && press && !isMotion;
         if (isRightPress) {
@@ -11138,6 +11311,7 @@ function useMouseInput({
               dragRef.current = { anchor: { x, y }, anchorScroll: 0, last: { x, y }, active: false, rect: null, region: "prompt", anchorSpan: null };
               if (offset != null) ctl.extendTo?.(offset, true);
               lastClickRef.current = { x: -1, y: -1, t: 0 };
+              finishWindowsMouseGesture();
             }
             return;
           }
@@ -11155,6 +11329,7 @@ function useMouseInput({
             dragRef.current = { ...dragRef.current, last: { x, y: selectionY }, active: false, region: regionR };
             applySelectionRect(rect);
             lastClickRef.current = { x, y, t: nowR, count: 1 };
+            finishWindowsMouseGesture();
             return;
           }
           if (dragRef.current.region === regionR && !dragRef.current.anchorSpan && dragRef.current.anchor && dragRef.current.rect && !(dragRef.current.rect.x1 === dragRef.current.rect.x2 && dragRef.current.rect.y1 === dragRef.current.rect.y2)) {
@@ -11166,6 +11341,7 @@ function useMouseInput({
             dragRef.current = { ...dragRef.current, last: { x, y: selectionY }, active: false, region: regionR };
             applySelectionRect(rect);
             lastClickRef.current = { x, y, t: nowR, count: 1 };
+            finishWindowsMouseGesture();
             return;
           }
           return;
@@ -11208,6 +11384,7 @@ function useMouseInput({
             dragRef.current.region = null;
             dragRef.current.anchorSpan = null;
             clearAllSelections();
+            finishWindowsMouseGesture();
             return;
           }
           const region = inTranscript ? "transcript" : "status";
@@ -11317,6 +11494,7 @@ function useMouseInput({
           }
         } else if (!press && baseButton === 0 && dragRef.current.active) {
           finalizeActiveDrag(x, y);
+          finishWindowsMouseGesture();
         }
       }
     };
@@ -11330,6 +11508,73 @@ function useMouseInput({
 
 // src/tui/app/use-transcript-scroll.mjs
 import { useCallback as useCallback3, useEffect as useEffect8, useRef as useRef8 } from "react";
+
+// src/tui/engine/render-timing.mjs
+var RENDER_ACK_HANG_GUARD_MS = 250;
+var RENDER_SETTLE_IDLE_MS = 64;
+var pendingRenderAcks = [];
+var renderAckSeq = 0;
+var scheduleRenderFrameAck = () => {
+  const seq = ++renderAckSeq;
+  setImmediate(() => notifyRenderFrame(seq));
+};
+var notifyRenderFrame = (seq = ++renderAckSeq) => {
+  if (pendingRenderAcks.length === 0) return;
+  const acks = pendingRenderAcks;
+  pendingRenderAcks = [];
+  for (const ack of acks) ack(seq);
+};
+var yieldToRenderer = ({ frames = 1 } = {}) => new Promise((resolve5) => {
+  const minSeq = renderAckSeq;
+  let remainingFrames = Math.max(1, Math.floor(Number(frames) || 1));
+  let settled = false;
+  let sawRealFrame = false;
+  let timer2 = null;
+  const finish = () => {
+    if (settled) return;
+    settled = true;
+    if (timer2) clearTimeout(timer2);
+    const idx = pendingRenderAcks.indexOf(onFrame);
+    if (idx !== -1) pendingRenderAcks.splice(idx, 1);
+    resolve5();
+  };
+  const onTimeout = () => {
+    if (settled) return;
+    if (!sawRealFrame && renderAckSeq > minSeq) {
+      setImmediate(() => {
+        if (!settled && !sawRealFrame) finish();
+      });
+      return;
+    }
+    finish();
+  };
+  const armWait = () => {
+    if (settled) return;
+    if (!pendingRenderAcks.includes(onFrame)) pendingRenderAcks.push(onFrame);
+    if (timer2) clearTimeout(timer2);
+    timer2 = setTimeout(onTimeout, sawRealFrame ? RENDER_SETTLE_IDLE_MS : RENDER_ACK_HANG_GUARD_MS);
+  };
+  const onFrame = (seq = 0) => {
+    if (settled) return;
+    if (seq <= minSeq) {
+      if (!pendingRenderAcks.includes(onFrame)) pendingRenderAcks.push(onFrame);
+      return;
+    }
+    sawRealFrame = true;
+    if (timer2) {
+      clearTimeout(timer2);
+      timer2 = null;
+    }
+    const idx = pendingRenderAcks.indexOf(onFrame);
+    if (idx !== -1) pendingRenderAcks.splice(idx, 1);
+    remainingFrames -= 1;
+    if (remainingFrames <= 0) finish();
+    else armWait();
+  };
+  armWait();
+});
+
+// src/tui/app/use-transcript-scroll.mjs
 function useTranscriptScroll({
   store,
   frameColumns,
@@ -11352,7 +11597,7 @@ function useTranscriptScroll({
   const scrollAnimationRef = useRef8(null);
   const selectionPaintRef = useRef8({ t: 0, rect: null, pending: null, timer: null });
   const scrollCoalesceRef = useRef8({ pendingRows: 0, timer: null });
-  const selectionTextTimerRef = useRef8(null);
+  const selectionTextCaptureRef = useRef8(0);
   const stitchBufferRef = useRef8(/* @__PURE__ */ new Map());
   const stitchHarvestTimerRef = useRef8(null);
   const stitchHarvestScrollRef = useRef8(0);
@@ -11465,12 +11710,12 @@ function useTranscriptScroll({
     stopSmoothScroll();
   }, [stopSmoothScroll]);
   const rememberSelectionTextSoon = useCallback3(() => {
-    if (selectionTextTimerRef.current) return;
-    selectionTextTimerRef.current = setTimeout(() => {
-      selectionTextTimerRef.current = null;
+    const capture = ++selectionTextCaptureRef.current;
+    void yieldToRenderer().then(() => {
+      if (capture !== selectionTextCaptureRef.current) return;
       const text = store.getRenderSelectionText?.();
       if (text && text.trim()) selectionTextRef.current = text;
-    }, 0);
+    });
   }, [store]);
   const selectionClip = useCallback3(() => {
     if (dragRef.current.region === "status") {
@@ -11496,22 +11741,20 @@ function useTranscriptScroll({
     if (options.captureText === false) clipped.captureText = false;
     return clipped;
   }, [selectionClip]);
-  const paintSelectionRect = useCallback3((clippedRect, { rememberText = true, immediate = false } = {}) => {
+  const paintSelectionRect = useCallback3((clippedRect, { rememberText = true } = {}) => {
     const nextRect = clippedRect || null;
     const state = selectionPaintRef.current;
     if (selectionRectsEqual(state.rect, nextRect)) {
       const needsCapture = nextRect && rememberText && nextRect.captureText !== false;
-      if (!immediate && !needsCapture) return false;
-      if (immediate || needsCapture) {
-        store.setRenderSelection?.(nextRect, { immediate: true });
-      }
+      if (!needsCapture) return false;
+      store.setRenderSelection?.(nextRect);
       if (needsCapture) rememberSelectionTextSoon();
       if (nextRect) harvestStitchRowsSoon();
       return true;
     }
     state.rect = nextRect;
     state.t = Date.now();
-    store.setRenderSelection?.(nextRect, immediate ? { immediate: true } : void 0);
+    store.setRenderSelection?.(nextRect);
     if (nextRect && rememberText && nextRect.captureText !== false) rememberSelectionTextSoon();
     if (nextRect) harvestStitchRowsSoon();
     return true;
@@ -11533,17 +11776,18 @@ function useTranscriptScroll({
       state.timer = null;
     }
     state.pending = null;
-    if (pending) paintSelectionRect(pending, { rememberText: false, immediate: true });
+    if (pending) paintSelectionRect(pending, { rememberText: false });
   }, [paintSelectionRect]);
   const applySelectionRect = useCallback3((rect) => {
     const clippedRect = withSelectionClip(rect);
     dragRef.current.rect = clippedRect || null;
     if (!clippedRect) {
+      selectionTextCaptureRef.current += 1;
       selectionTextRef.current = "";
       clearStitchBuffer();
     }
     cancelPendingSelectionPaint();
-    paintSelectionRect(clippedRect, { rememberText: true, immediate: true });
+    paintSelectionRect(clippedRect, { rememberText: true });
   }, [paintSelectionRect, withSelectionClip, clearStitchBuffer, cancelPendingSelectionPaint]);
   const applySelectionRectThrottled = useCallback3((rect) => {
     const clippedRect = withSelectionClip(rect, { captureText: false });
@@ -11634,8 +11878,7 @@ function useTranscriptScroll({
     if (paintState.timer) clearTimeout(paintState.timer);
     paintState.timer = null;
     paintState.pending = null;
-    if (selectionTextTimerRef.current) clearTimeout(selectionTextTimerRef.current);
-    selectionTextTimerRef.current = null;
+    selectionTextCaptureRef.current += 1;
     if (stitchHarvestTimerRef.current) clearTimeout(stitchHarvestTimerRef.current);
     stitchHarvestTimerRef.current = null;
     const coalesceState = scrollCoalesceRef.current;
@@ -11645,6 +11888,44 @@ function useTranscriptScroll({
   }, []);
   const scrollTranscriptRows = useCallback3((deltaRows, options = {}) => {
     const maxTarget = Math.max(0, Number(maxScrollRowsRef.current) || 0);
+    const historyState = store.getState?.() || {};
+    const captureRestoreAnchor = () => {
+      const geom = transcriptGeomRef.current || {};
+      const prefixRows = geom.prefixRows;
+      if (!prefixRows || prefixRows.length <= 1) return;
+      const total = Math.max(0, Number(geom.totalRows) || 0);
+      const view = Math.max(1, Number(geom.viewRows) || 1);
+      const target2 = Math.max(0, Number(scrollTargetRef.current) || 0);
+      const row = Math.max(0, Math.min(total, total - target2 - view));
+      let index = upperBound(prefixRows, row) - 1;
+      index = Math.max(0, Math.min(prefixRows.length - 2, index));
+      const item = geom.items?.[index];
+      if (item?.id != null) {
+        transcriptAnchorRef.current = {
+          id: item.id,
+          offset: Math.max(0, row - transcriptRowAt(prefixRows, index))
+        };
+        transcriptAnchorDirtyRef.current = false;
+      }
+    };
+    if (deltaRows > 0 && scrollTargetRef.current >= maxTarget && historyState.transcriptHistoryBefore) {
+      captureRestoreAnchor();
+      if (!store.restoreOlderTranscript?.()) return;
+      stopSmoothScroll();
+      cancelTranscriptFollow();
+      return;
+    }
+    if (deltaRows < 0 && scrollTargetRef.current <= 0 && historyState.transcriptHistoryAfter) {
+      captureRestoreAnchor();
+      if (!store.restoreNewerTranscript?.()) return;
+      stopSmoothScroll();
+      cancelTranscriptFollow();
+      const anchoredTarget = Math.max(1, maxTarget);
+      scrollTargetRef.current = anchoredTarget;
+      scrollPositionRef.current = anchoredTarget;
+      setScrollOffset(anchoredTarget);
+      return;
+    }
     const target = Math.max(0, Math.min(maxTarget, scrollTargetRef.current + deltaRows));
     const appliedDelta = target - scrollTargetRef.current;
     if (appliedDelta !== 0 && dragRef.current.region === "transcript" && dragRef.current.rect) {
@@ -11660,7 +11941,7 @@ function useTranscriptScroll({
       } else {
         const geom = transcriptGeomRef.current || {};
         const prefixRows = geom.prefixRows;
-        if (Array.isArray(prefixRows) && prefixRows.length > 1) {
+        if (prefixRows && prefixRows.length > 1) {
           const gTotal = Math.max(0, Number(geom.totalRows) || 0);
           const gView = Math.max(1, Number(geom.viewRows) || 1);
           const anchorRow = Math.max(0, Math.min(gTotal, gTotal - target - gView));
@@ -11670,7 +11951,7 @@ function useTranscriptScroll({
           const items = geom.items || [];
           const anchorItem = items[idx];
           if (anchorItem && anchorItem.id != null) {
-            transcriptAnchorRef.current = { id: anchorItem.id, offset: Math.max(0, anchorRow - (prefixRows[idx] || 0)) };
+            transcriptAnchorRef.current = { id: anchorItem.id, offset: Math.max(0, anchorRow - transcriptRowAt(prefixRows, idx)) };
             transcriptAnchorDirtyRef.current = false;
           } else {
             transcriptAnchorDirtyRef.current = true;
@@ -11867,6 +12148,7 @@ function useTranscriptWindow({
   const transcriptTotalRowsRef = useRef9(0);
   const committedMaxScrollRowsRef = useRef9(0);
   const incrementalRowIndexCacheRef = useRef9(null);
+  const transcriptItemsCacheRef = useRef9(null);
   const prevViewportGeomRef = useRef9({ contentHeight: 0, floatingPanelRows: 0 });
   const transcriptItemElsRef = useRef9(/* @__PURE__ */ new Map());
   const transcriptMeasureRefCache = useRef9(/* @__PURE__ */ new Map());
@@ -11901,12 +12183,18 @@ function useTranscriptWindow({
   const tailRows = streamingTailItem ? estimateTranscriptItemRowsCached(streamingTailItem, frameColumns, toolOutputExpanded) : 0;
   const tailSig = streamingTailItem ? `${streamingTailItem.id}:${tailRows}` : "_";
   const revision = Math.max(0, Number(structureRevision) || 0);
-  const transcriptItems = useMemo(
-    () => streamingTailItem ? [...settledItems || [], streamingTailItem] : settledItems || [],
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- tail text at the same resolved height is injected into the bounded visible slice below
-    [settledItems, revision, streamingTailItem?.id, tailRows]
+  const transcriptItems = transcriptItemsWithStableTail(
+    settledItems,
+    streamingTailItem,
+    transcriptItemsCacheRef
+  );
+  const transcriptStructureSig = transcriptStructureSignature(
+    transcriptItems,
+    frameColumns,
+    toolOutputExpanded,
+    revision,
+    streamingTailItem
   );
-  const transcriptStructureSig = `${revision}#${tailSig}`;
   const transcriptStreamingActive = !!streamingTailItem;
   const scrolledUpForStreamingMeasure = scrolledUpRowsForPin > 0;
   const prevEstimateGeometry = transcriptGeomRef.current?.suppressMeasuredRowHeights === true;
@@ -11919,7 +12207,8 @@ function useTranscriptWindow({
     suppressMeasuredRowHeights,
     measuredRowsVersion,
     cacheRef: incrementalRowIndexCacheRef,
-    prefixRevision: revision
+    prefixRevision: revision,
+    streamingTailItem
     // eslint-disable-next-line react-hooks/exhaustive-deps -- revision/tail height capture structural geometry; measuredRowsVersion folds in measured corrections
   }), [revision, tailSig, frameColumns, toolOutputExpanded, measuredRowsVersion, suppressMeasuredRowHeights]);
   const hasReadingAnchor = !!transcriptAnchorRef.current && !transcriptAnchorDirtyRef.current;
@@ -11946,7 +12235,7 @@ function useTranscriptWindow({
   } else if (!followingRef.current && !nearBottomWithoutAnchor && scrolledUp) {
     const geom = transcriptGeomRef.current || {};
     const prevPrefix = geom.prefixRows;
-    if (Array.isArray(prevPrefix) && prevPrefix.length > 1) {
+    if (prevPrefix && prevPrefix.length > 1) {
       const prevTotal = Math.max(0, Number(geom.totalRows) || 0);
       const prevView = Math.max(1, Number(geom.viewRows) || 1);
       const prevOffset = Math.max(0, Number(geom.renderOffset) || 0);
@@ -11957,7 +12246,7 @@ function useTranscriptWindow({
       if (idx > prevPrefix.length - 2) idx = prevPrefix.length - 2;
       const anchorItem = prevItems[idx];
       if (anchorItem && anchorItem.id != null) {
-        const captured = { id: anchorItem.id, offset: Math.max(0, prevTopRow - (prevPrefix[idx] || 0)) };
+        const captured = { id: anchorItem.id, offset: Math.max(0, prevTopRow - transcriptRowAt(prevPrefix, idx)) };
         const locked = resolveAnchorScrollOffset({
           anchor: captured,
           items: transcriptItems,
@@ -11979,7 +12268,7 @@ function useTranscriptWindow({
   if (viewportOnlyChanged && !anchorLockActive && !followingRef.current && !nearBottomWithoutAnchor && scrolledUp) {
     const geom = transcriptGeomRef.current || {};
     const prevPrefix = geom.prefixRows;
-    if (Array.isArray(prevPrefix) && prevPrefix.length > 1) {
+    if (prevPrefix && prevPrefix.length > 1) {
       const prevTotal = Math.max(0, Number(geom.totalRows) || 0);
       const prevView = Math.max(1, Number(prevViewport.contentHeight) || Number(geom.viewRows) || 1);
       const prevOffset = Math.max(0, Number(geom.renderOffset) || 0);
@@ -11990,7 +12279,7 @@ function useTranscriptWindow({
       if (idx > prevPrefix.length - 2) idx = prevPrefix.length - 2;
       const anchorItem = prevItems[idx];
       if (anchorItem && anchorItem.id != null) {
-        const captured = { id: anchorItem.id, offset: Math.max(0, prevTopRow - (prevPrefix[idx] || 0)) };
+        const captured = { id: anchorItem.id, offset: Math.max(0, prevTopRow - transcriptRowAt(prevPrefix, idx)) };
         const locked = resolveAnchorScrollOffset({
           anchor: captured,
           items: transcriptItems,
@@ -12212,7 +12501,7 @@ function useTranscriptWindow({
         if (idx > itemList.length - 1) idx = itemList.length - 1;
         const anchorItem = itemList[idx];
         if (anchorItem && anchorItem.id != null) {
-          anchor = { id: anchorItem.id, offset: Math.max(0, anchorRow - (curPrefix[idx] || 0)) };
+          anchor = { id: anchorItem.id, offset: Math.max(0, anchorRow - transcriptRowAt(curPrefix, idx)) };
           transcriptAnchorRef.current = anchor;
         }
       }
@@ -21657,9 +21946,11 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
     overlayHintFallbackRow,
     transcriptMeasureRef
   } = useTranscriptWindow({
-    items: state.items,
-    structureRevision: state.structureRevision,
-    streamingTail: state.streamingTail,
+    items: state.transcriptViewItems || state.items,
+    structureRevision: state.transcriptViewItems ? state.transcriptViewRevision : state.structureRevision,
+    // Historical pages are contiguous settled windows. Keep the independently
+    // growing live tail hidden until paging forward reaches the live window.
+    streamingTail: state.transcriptViewItems ? null : state.streamingTail,
     themeEpoch: state.themeEpoch,
     frameColumns,
     toolOutputExpanded,
@@ -21812,7 +22103,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
                       Item,
                       {
                         item,
-                        prevKind: i > 0 ? arr[i - 1].kind : state.items[transcriptWindow.startIndex - 1]?.kind ?? null,
+                        prevKind: i > 0 ? arr[i - 1].kind : (state.transcriptViewItems || state.items)[transcriptWindow.startIndex - 1]?.kind ?? null,
                         columns: frameColumns,
                         toolOutputExpanded,
                         rightMessage: attachOverlayHint ? inputHint : "",
@@ -22094,6 +22385,11 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
 
 // src/tui/engine.mjs
 import { performance as performance2 } from "node:perf_hooks";
+import { mkdtempSync, readFileSync as readFileSync8, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join10 } from "node:path";
+import { Worker } from "node:worker_threads";
 
 // src/runtime/shared/tool-execution-contract.mjs
 function clean2(value) {
@@ -23027,71 +23323,6 @@ function resolveTuiRuntimeNotificationDelivery(event, text) {
   };
 }
 
-// src/tui/engine/render-timing.mjs
-var RENDER_ACK_HANG_GUARD_MS = 250;
-var RENDER_SETTLE_IDLE_MS = 64;
-var pendingRenderAcks = [];
-var renderAckSeq = 0;
-var scheduleRenderFrameAck = () => {
-  const seq = ++renderAckSeq;
-  setImmediate(() => notifyRenderFrame(seq));
-};
-var notifyRenderFrame = (seq = ++renderAckSeq) => {
-  if (pendingRenderAcks.length === 0) return;
-  const acks = pendingRenderAcks;
-  pendingRenderAcks = [];
-  for (const ack of acks) ack(seq);
-};
-var yieldToRenderer = ({ frames = 1 } = {}) => new Promise((resolve5) => {
-  const minSeq = renderAckSeq;
-  let remainingFrames = Math.max(1, Math.floor(Number(frames) || 1));
-  let settled = false;
-  let sawRealFrame = false;
-  let timer2 = null;
-  const finish = () => {
-    if (settled) return;
-    settled = true;
-    if (timer2) clearTimeout(timer2);
-    const idx = pendingRenderAcks.indexOf(onFrame);
-    if (idx !== -1) pendingRenderAcks.splice(idx, 1);
-    resolve5();
-  };
-  const onTimeout = () => {
-    if (settled) return;
-    if (!sawRealFrame && renderAckSeq > minSeq) {
-      setImmediate(() => {
-        if (!settled && !sawRealFrame) finish();
-      });
-      return;
-    }
-    finish();
-  };
-  const armWait = () => {
-    if (settled) return;
-    if (!pendingRenderAcks.includes(onFrame)) pendingRenderAcks.push(onFrame);
-    if (timer2) clearTimeout(timer2);
-    timer2 = setTimeout(onTimeout, sawRealFrame ? RENDER_SETTLE_IDLE_MS : RENDER_ACK_HANG_GUARD_MS);
-  };
-  const onFrame = (seq = 0) => {
-    if (settled) return;
-    if (seq <= minSeq) {
-      if (!pendingRenderAcks.includes(onFrame)) pendingRenderAcks.push(onFrame);
-      return;
-    }
-    sawRealFrame = true;
-    if (timer2) {
-      clearTimeout(timer2);
-      timer2 = null;
-    }
-    const idx = pendingRenderAcks.indexOf(onFrame);
-    if (idx !== -1) pendingRenderAcks.splice(idx, 1);
-    remainingFrames -= 1;
-    if (remainingFrames <= 0) finish();
-    else armWait();
-  };
-  armWait();
-});
-
 // src/tui/engine/tool-result-status.mjs
 var CANCELLED_RESULT_STATUS_LINE = "[status: cancelled]";
 function shellCommandExitCode(text) {
@@ -24151,7 +24382,7 @@ function drainTuiSteeringPersist(leadSessionId) {
 }
 
 // src/tui/engine/context-state.mjs
-function createContextState({ runtime, getState, getPendingSessionReset }) {
+function createContextState({ runtime, getState, updateState, getPendingSessionReset }) {
   const autoClearState = () => runtime.getAutoClear?.() || runtime.autoClear || { enabled: true, idleMs: 60 * 60 * 1e3, custom: false, providerDefault: 60 * 60 * 1e3, provider: null, minContextPercent: 10 };
   const AGENT_STATUS_CACHE_MS = 250;
   let agentStatusCache = null;
@@ -24201,15 +24432,16 @@ function createContextState({ runtime, getState, getPendingSessionReset }) {
   function syncContextDisplayFields(ctx = null) {
     const status = ctx || runtime.contextStatus?.() || null;
     if (!status) return;
-    const state = getState();
     const displayWindow = Number(status.contextWindow || 0);
     const compactBoundary = Number(status.compaction?.boundaryTokens || 0);
     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 patch = {};
+    if (displayWindow > 0) patch.displayContextWindow = displayWindow;
+    if (compactBoundary > 0) patch.compactBoundaryTokens = compactBoundary;
+    if (autoCompact > 0) patch.autoCompactTokenLimit = autoCompact;
+    if (Object.keys(patch).length > 0) updateState(patch);
   }
   const syncContextStats = ({ allowEstimated = false } = {}) => {
     if (getPendingSessionReset()) return null;
@@ -24217,15 +24449,17 @@ function createContextState({ runtime, getState, getPendingSessionReset }) {
     if (!ctx) return null;
     syncContextDisplayFields(ctx);
     const state = getState();
-    const hasProviderUsage = Number(state.stats.latestPromptTokens || state.stats.latestInputTokens || state.stats.inputTokens || 0) > 0;
+    const stats = { ...state.stats };
+    const hasProviderUsage = Number(stats.latestPromptTokens || stats.latestInputTokens || 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();
+      stats.currentEstimatedContextTokens = 0;
+      stats.currentContextTokens = 0;
+      stats.currentContextSource = null;
+      stats.currentContextUpdatedAt = Date.now();
+      updateState({ stats });
       return ctx;
     }
     const estimatedTokens = Math.max(0, Number(ctx.currentEstimatedTokens ?? ctx.usedTokens ?? 0));
@@ -24234,32 +24468,33 @@ function createContextState({ runtime, getState, getPendingSessionReset }) {
     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;
+      stats.currentEstimatedContextTokens = estimatedTokens;
+      stats.currentContextSource = "estimated";
+      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();
+      stats.currentEstimatedContextTokens = estimatedTokens;
+      stats.currentContextSource = usedSource || (estimatedTokens > 0 ? "estimated" : null);
+      const publishedSource = String(stats.currentContextSource || "").toLowerCase();
       if (publishedSource === "last_api_request") {
         const apiUsed = Math.max(0, Number(ctx.lastApiRequestTokens ?? usedTokens ?? 0));
-        state.stats.currentContextTokens = apiUsed;
+        stats.currentContextTokens = apiUsed;
       } else if (publishedSource === "estimated") {
-        state.stats.currentContextTokens = 0;
+        stats.currentContextTokens = 0;
       } else {
-        state.stats.currentContextTokens = usedTokens > 0 ? usedTokens : 0;
+        stats.currentContextTokens = usedTokens > 0 ? usedTokens : 0;
       }
     } else {
-      state.stats.currentEstimatedContextTokens = 0;
+      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";
+        stats.currentContextTokens = Math.max(0, Number(ctx.lastApiRequestTokens ?? usedTokens ?? 0));
+        stats.currentContextSource = "last_api_request";
       } else {
-        state.stats.currentContextTokens = 0;
-        state.stats.currentContextSource = null;
+        stats.currentContextTokens = 0;
+        stats.currentContextSource = null;
       }
     }
-    state.stats.currentContextUpdatedAt = Date.now();
+    stats.currentContextUpdatedAt = Date.now();
+    updateState({ stats });
     return ctx;
   };
   return {
@@ -24305,6 +24540,7 @@ function createSessionFlow(bag) {
     clearToastTimers,
     getState,
     set,
+    flushEmitImmediate,
     pushItem,
     replaceItems,
     pushNotice,
@@ -24313,7 +24549,10 @@ function createSessionFlow(bag) {
     agentStatusState,
     routeState,
     syncContextStats,
-    flushDeferredExecutionPendingResumeKick
+    flushDeferredExecutionPendingResumeKick,
+    snapshotTranscriptSpill,
+    restoreTranscriptSpill,
+    releaseTranscriptSpill
   } = bag;
   const AUTO_CLEAR_COMPACT_TIMEOUT_MS = 6e4;
   const leadSessionId = () => runtime.id;
@@ -24516,7 +24755,10 @@ function createSessionFlow(bag) {
     if (getState().busy && shouldMirrorSteeringEntry(entry)) {
       appendTuiSteeringPersist(leadSessionId(), entry);
     }
-    if (isQueuedEntryVisible(entry)) set({ queued: [...getState().queued, entry] });
+    if (isQueuedEntryVisible(entry)) {
+      set({ queued: [...getState().queued, entry] });
+      if (isQueuedEntryEditable(entry)) flushEmitImmediate?.();
+    }
     if (getState().busy) tuiDebug2(`busy-queue enqueue mode=${entry.mode} pending=${pending.length}`);
     void drain();
     return true;
@@ -24698,19 +24940,23 @@ function createSessionFlow(bag) {
     return { count: queued.length, text: combinedText, pastedImages: mergePastedImages(queued), pastedTexts: mergePastedTexts(queued) };
   }
   const resetStats = () => {
-    getState().stats = createSessionStats();
-    return getState().stats;
+    const stats = createSessionStats();
+    set({ stats });
+    return stats;
   };
   const clearUiActivityBeforeContextSync = () => {
     clearToastTimers();
     resetAllStreamingMarkdownStablePrefixes();
-    getState().items = replaceItems([]);
-    getState().toasts = [];
-    getState().queued = [];
-    getState().thinking = null;
-    getState().spinner = null;
-    getState().lastTurn = null;
-    getState().busy = false;
+    const items = replaceItems([]);
+    set({
+      items,
+      toasts: [],
+      queued: [],
+      thinking: null,
+      spinner: null,
+      lastTurn: null,
+      busy: false
+    });
     pendingNotificationKeys.clear();
     displayedExecutionNotificationKeys.clear();
     clearExecutionDedupState?.();
@@ -24743,16 +24989,24 @@ function createSessionFlow(bag) {
     flags.pendingSessionReset = true;
     clearUiActivityBeforeContextSync();
     resetStats();
-    getState().stats.currentContextTokens = 0;
-    getState().stats.currentEstimatedContextTokens = 0;
-    getState().stats.currentContextSource = null;
-    getState().stats.currentContextUpdatedAt = Date.now();
-    getState().displayContextWindow = 0;
-    getState().compactBoundaryTokens = 0;
-    getState().autoCompactTokenLimit = 0;
+    set({
+      stats: {
+        ...getState().stats,
+        currentContextTokens: 0,
+        currentEstimatedContextTokens: 0,
+        currentContextSource: null,
+        currentContextUpdatedAt: Date.now()
+      },
+      displayContextWindow: 0,
+      compactBoundaryTokens: 0,
+      autoCompactTokenLimit: 0
+    });
   };
   const snapshotTuiBeforeSessionReset = () => ({
     items: getState().items.slice(),
+    transcriptViewItems: Array.isArray(getState().transcriptViewItems) ? getState().transcriptViewItems.slice() : null,
+    transcriptViewRevision: getState().transcriptViewRevision,
+    transcriptSpill: snapshotTranscriptSpill?.() || null,
     toasts: getState().toasts.slice(),
     queued: getState().queued.slice(),
     thinking: getState().thinking,
@@ -24765,14 +25019,20 @@ function createSessionFlow(bag) {
   const restoreTuiAfterFailedSessionReset = (snapshot) => {
     if (!snapshot) return;
     flags.pendingSessionReset = false;
-    getState().items = replaceItems(snapshot.items);
-    getState().toasts = snapshot.toasts.slice();
-    getState().queued = snapshot.queued.slice();
-    getState().thinking = snapshot.thinking;
-    getState().spinner = snapshot.spinner;
-    getState().lastTurn = snapshot.lastTurn;
-    getState().busy = snapshot.busy;
-    getState().stats = { ...snapshot.stats };
+    restoreTranscriptSpill?.(snapshot.transcriptSpill);
+    const items = replaceItems(snapshot.items, { preserveSpill: true });
+    set({
+      items,
+      transcriptViewItems: snapshot.transcriptViewItems,
+      transcriptViewRevision: snapshot.transcriptViewRevision,
+      toasts: snapshot.toasts.slice(),
+      queued: snapshot.queued.slice(),
+      thinking: snapshot.thinking,
+      spinner: snapshot.spinner,
+      lastTurn: snapshot.lastTurn,
+      busy: snapshot.busy,
+      stats: { ...snapshot.stats }
+    });
     syncContextStats({ allowEstimated: true });
     set({
       items: getState().items,
@@ -24787,12 +25047,15 @@ function createSessionFlow(bag) {
       ...agentStatusState()
     });
   };
+  const commitTuiSessionReset = (snapshot) => {
+    releaseTranscriptSpill?.(snapshot?.transcriptSpill);
+  };
   const resetStatsAndSyncContext = () => {
     resetStats();
     syncContextStats({ allowEstimated: true });
     return getState().stats;
   };
-  return { leadSessionId, shouldMirrorSteeringEntry, commitSteeringQueueEntries, makeQueueEntry, removeQueuedEntries, requeueEntriesFront, dequeueQueueBatch, drain, enqueue, drainPendingSteering, restoreLeadSteeringFromDisk, autoClearBeforeSubmit, performSessionClear, restoreQueued, resetStats, clearUiActivityBeforeContextSync, resetTuiForPendingSessionReset, snapshotTuiBeforeSessionReset, restoreTuiAfterFailedSessionReset, resetStatsAndSyncContext };
+  return { leadSessionId, shouldMirrorSteeringEntry, commitSteeringQueueEntries, makeQueueEntry, removeQueuedEntries, requeueEntriesFront, dequeueQueueBatch, drain, enqueue, drainPendingSteering, restoreLeadSteeringFromDisk, autoClearBeforeSubmit, performSessionClear, restoreQueued, resetStats, clearUiActivityBeforeContextSync, resetTuiForPendingSessionReset, snapshotTuiBeforeSessionReset, restoreTuiAfterFailedSessionReset, commitTuiSessionReset, resetStatsAndSyncContext };
 }
 
 // src/tui/engine/turn.mjs
@@ -24807,7 +25070,10 @@ function createRunTurn(bag) {
     itemIndexById,
     getState,
     set,
+    flushEmit,
+    flushEmitImmediate,
     pushItem,
+    appendItems,
     patchItem,
     replaceItems,
     updateStreamingTail: updateStreamingTailFromStore,
@@ -24976,6 +25242,7 @@ function createRunTurn(bag) {
           if (flags.draining) flags.draining = false;
           if (pending.length > 0) void drain();
           flushDeferredExecutionPendingResumeKick();
+          flushEmitImmediate?.();
         }, 5e3);
         watchdogGraceTimer.unref?.();
       }, delay);
@@ -25128,6 +25395,10 @@ function createRunTurn(bag) {
         set(extra);
         return;
       }
+      if (appendItems) {
+        appendItems(newItems, extra);
+        return;
+      }
       const base = getState().items.length;
       const items = [...getState().items, ...newItems];
       for (let i = 0; i < newItems.length; i++) {
@@ -25637,6 +25908,37 @@ function createRunTurn(bag) {
           if (thinkingLastEndedAt) _pendingThinkingLastEndedAt = thinkingLastEndedAt;
           scheduleStreamFlush();
         },
+        onTextReset: ({ chars } = {}) => {
+          if (!isCurrentTurn()) return false;
+          const count = Math.max(0, Number(chars) || 0);
+          if (!count) return false;
+          flushStreamBatch();
+          assistantText = assistantText.slice(0, Math.max(0, assistantText.length - count));
+          currentAssistantText = currentAssistantText.slice(
+            0,
+            Math.max(0, currentAssistantText.length - count)
+          );
+          _streamScanLen = 0;
+          _lastNewlineIdx = -1;
+          _emittedNewlineIdx = -2;
+          _emittedVisibleText = "";
+          if (currentAssistantId) {
+            if (currentAssistantText) {
+              set({
+                streamingTail: {
+                  kind: "assistant",
+                  id: currentAssistantId,
+                  text: currentAssistantText,
+                  streaming: true
+                }
+              });
+            } else {
+              clearStreamingTail(currentAssistantId);
+              currentAssistantId = null;
+            }
+          }
+          return true;
+        },
         onAssistantText: (text) => {
           const full = String(text ?? "");
           if (!full.trim()) return;
@@ -25667,7 +25969,9 @@ function createRunTurn(bag) {
         },
         onUsageDelta: (delta) => {
           if (!markTurnProgress("usage-delta")) return;
-          applyUsageDelta(getState().stats, delta);
+          const stats = { ...getState().stats };
+          applyUsageDelta(stats, delta);
+          set({ stats });
           syncContextStats({ allowEstimated: true });
           const currentTurnInput = Math.max(0, getState().stats.inputTokens - inputBaseline);
           const currentTurnOutput = Math.max(0, getState().stats.outputTokens - outputBaseline);
@@ -25770,7 +26074,7 @@ function createRunTurn(bag) {
         const assistantOutput = (currentAssistantText || assistantText || "").trim();
         const isNoOpTurn = turnFinishedNormally && !cancelled && toolCards.length === 0 && !resultContent && !assistantOutput && !producedTranscriptItem;
         if (!isNoOpTurn) {
-          getState().stats.turns = (getState().stats.turns || 0) + 1;
+          set({ stats: { ...getState().stats, turns: (getState().stats.turns || 0) + 1 } });
         }
         if (!reclaimed && !isNoOpTurn) {
           closingItems.push({ kind: "turndone", id: nextId2(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
@@ -25789,6 +26093,7 @@ function createRunTurn(bag) {
       }
     }
     if (flags.leadTurnEpoch === turnEpoch) clearActiveToolSummary();
+    flushEmit?.();
     _publishedThinkingActive = false;
     const finalStatus = cancelled ? "cancelled" : failed ? "failed" : "done";
     tuiDebug2(`runTurn end turn=${turnIndex} status=${finalStatus} elapsedMs=${Date.now() - startedAt}${watchdogTripped ? " watchdogTripped=1" : ""} pending=${pending.length}`);
@@ -25807,11 +26112,13 @@ function createEngineApiB(bag) {
     listeners,
     getState,
     set,
+    disposeEmit,
     replaceItems,
     pushNotice,
     removeNotice,
     setProgressHint,
     clearToastTimers,
+    disposeTranscriptSpill,
     routeState,
     syncContextStats,
     finishToolApproval,
@@ -25822,6 +26129,7 @@ function createEngineApiB(bag) {
     resetTuiForPendingSessionReset,
     snapshotTuiBeforeSessionReset,
     restoreTuiAfterFailedSessionReset,
+    commitTuiSessionReset,
     resetStatsAndSyncContext
   } = bag;
   return {
@@ -26166,6 +26474,7 @@ function createEngineApiB(bag) {
         flags.pendingSessionReset = false;
         resetStatsAndSyncContext();
         set({ items: replaceItems([]), toasts: [], queued: [], thinking: null, spinner: null, lastTurn: null, ...routeState(), stats: { ...getState().stats } });
+        commitTuiSessionReset(rollbackSnapshot);
         flags.lastUserActivityAt = Date.now();
         return true;
       } catch (error) {
@@ -26203,6 +26512,7 @@ function createEngineApiB(bag) {
           ...routeState(),
           stats: { ...getState().stats }
         });
+        commitTuiSessionReset(rollbackSnapshot);
         return true;
       } catch (error) {
         restoreTuiAfterFailedSessionReset(rollbackSnapshot);
@@ -26235,6 +26545,7 @@ function createEngineApiB(bag) {
         flags.pendingSessionReset = false;
         resetStatsAndSyncContext();
         set({ items: replaceItems([]), toasts: [], queued: [], thinking: null, spinner: null, lastTurn: null, ...routeState(), stats: { ...getState().stats } });
+        commitTuiSessionReset(rollbackSnapshot);
         return true;
       } catch (error) {
         restoreTuiAfterFailedSessionReset(rollbackSnapshot);
@@ -26305,8 +26616,10 @@ function createEngineApiB(bag) {
     },
     dispose: async (reason = "cli-react-exit", options = {}) => {
       if (flags.disposed) return;
+      disposeEmit?.();
       flags.disposed = true;
       clearToastTimers();
+      disposeTranscriptSpill?.();
       try {
         clearInterval(lifecycle.runtimePulseTimer);
       } catch {
@@ -26531,10 +26844,14 @@ function createEngineApiA(bag) {
     pending,
     listeners,
     getState,
+    getPublishedState = getState,
     set,
+    flushEmitImmediate,
     pushItem,
     patchItem,
     replaceItems,
+    restoreOlderTranscript,
+    restoreNewerTranscript,
     settleStreamingTail,
     clearStreamingTail,
     pushNotice,
@@ -26554,8 +26871,10 @@ function createEngineApiA(bag) {
     discardExecutionPendingResume
   } = bag;
   return {
-    getState: () => getState(),
+    getState: () => getPublishedState(),
     patchItem,
+    restoreOlderTranscript,
+    restoreNewerTranscript,
     subscribe: (listener) => {
       listeners.add(listener);
       return () => listeners.delete(listener);
@@ -27063,7 +27382,10 @@ function createEngineApiA(bag) {
           if (idSet.size > 0) {
             const items = getState().items.filter((item) => !idSet.has(item?.id));
             if (items.length !== getState().items.length) {
-              patch.items = replaceItems(items);
+              patch.items = replaceItems(items, {
+                preserveSpill: true,
+                preserveTranscriptView: true
+              });
             }
           }
           set(patch);
@@ -27091,6 +27413,7 @@ function createEngineApiA(bag) {
         flags.drainEpoch = (Number(flags.drainEpoch) || 0) + 1;
         if (flags.draining) flags.draining = false;
         pushNotice("Interrupt did not settle \u2014 input restored.", "warn", { transcript: true });
+        flushEmitImmediate?.();
         if (pending.length > 0 && typeof drain === "function") void drain();
         if (typeof flushDeferredExecutionPendingResumeKick === "function") flushDeferredExecutionPendingResumeKick();
       }, recoveryMs);
@@ -27100,6 +27423,68 @@ function createEngineApiA(bag) {
   };
 }
 
+// src/tui/engine/frame-batched-store.mjs
+function createFrameBatchedStorePublisher({
+  getState,
+  publishState,
+  listeners,
+  isDisposed = () => false,
+  frameMs = 16,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+  enqueueMicrotask = queueMicrotask
+}) {
+  let timer2 = null;
+  let emitPending = false;
+  let structureChangePending = false;
+  let immediatePending = false;
+  const flush = () => {
+    if (timer2 !== null) {
+      clearTimer(timer2);
+      timer2 = null;
+    }
+    immediatePending = false;
+    if (!emitPending || isDisposed()) return false;
+    emitPending = false;
+    const current = getState();
+    let next = current;
+    if (structureChangePending) {
+      structureChangePending = false;
+      next = {
+        ...current,
+        structureRevision: (Number(current.structureRevision) || 0) + 1
+      };
+    }
+    publishState(next);
+    for (const listener of listeners) listener();
+    return true;
+  };
+  const emit = () => {
+    emitPending = true;
+    if (timer2 !== null || isDisposed()) return;
+    timer2 = setTimer(flush, frameMs);
+    timer2?.unref?.();
+  };
+  const markStructureChange = () => {
+    structureChangePending = true;
+  };
+  const flushImmediate = () => {
+    if (!emitPending || immediatePending || isDisposed()) return false;
+    immediatePending = true;
+    enqueueMicrotask(flush);
+    return true;
+  };
+  const dispose = () => {
+    if (emitPending && !isDisposed()) flush();
+    else if (timer2 !== null) clearTimer(timer2);
+    timer2 = null;
+    emitPending = false;
+    structureChangePending = false;
+    immediatePending = false;
+  };
+  return { emit, flush, flushImmediate, markStructureChange, dispose };
+}
+
 // src/tui/engine.mjs
 var SESSION_RUNTIME_MODULE = import.meta.url.replace(/\\/g, "/").includes("/tui/dist/") ? "../../mixdog-session-runtime.mjs" : "../mixdog-session-runtime.mjs";
 var TOOL_APPROVAL_TIMEOUT_MS = (() => {
@@ -27121,6 +27506,377 @@ var tuiDebug = (msg) => {
 };
 var _idSeq = 0;
 var nextId = () => `it_${++_idSeq}`;
+var TRANSCRIPT_LIVE_ITEM_CAP = 512;
+var TRANSCRIPT_SPILL_CHUNK_ITEMS = 128;
+var TRANSCRIPT_RESTORE_OVERLAP_ITEMS = 64;
+var TRANSCRIPT_SPILL_STALE_MS = 24 * 60 * 60 * 1e3;
+var TRANSCRIPT_SPILL_HEARTBEAT_MS = 1e4;
+var TRANSCRIPT_PROCESS_NONCE = randomUUID();
+function cleanupStaleTranscriptSpillDirs({
+  root = tmpdir2(),
+  now = Date.now(),
+  staleMs = TRANSCRIPT_SPILL_STALE_MS
+} = {}) {
+  try {
+    for (const entry of readdirSync2(root, { withFileTypes: true })) {
+      if (!entry.isDirectory() || !entry.name.startsWith("mixdog-transcript-")) continue;
+      const path2 = join10(root, entry.name);
+      try {
+        const ownerPid = Number(/^mixdog-transcript-(\d+)-/.exec(entry.name)?.[1]);
+        let pidAlive = false;
+        if (ownerPid > 0) {
+          try {
+            process.kill(ownerPid, 0);
+            pidAlive = true;
+          } catch {
+          }
+        }
+        if (!pidAlive) {
+          rmSync2(path2, { recursive: true, force: true });
+          continue;
+        }
+        let heartbeatAge;
+        try {
+          heartbeatAge = now - statSync5(join10(path2, "heartbeat")).mtimeMs;
+        } catch {
+          heartbeatAge = now - statSync5(path2).mtimeMs;
+        }
+        if (heartbeatAge <= staleMs) continue;
+        rmSync2(path2, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function createTranscriptSpillBuffer({
+  cap = TRANSCRIPT_LIVE_ITEM_CAP,
+  chunkSize = TRANSCRIPT_SPILL_CHUNK_ITEMS,
+  workerFactory = (source) => new Worker(source, { eval: true }),
+  onWarning = (message) => tuiDebug(message),
+  writeTimeoutMs = 5e3
+} = {}) {
+  try {
+    writeFileSync6(
+      join10(tmpdir2(), `mixdog-transcript-owner-${process.pid}.json`),
+      JSON.stringify({ pid: process.pid, nonce: TRANSCRIPT_PROCESS_NONCE }),
+      "utf8"
+    );
+  } catch {
+  }
+  cleanupStaleTranscriptSpillDirs();
+  const pages = [];
+  let cursor = null;
+  let spillDir = null;
+  let pageSequence = 0;
+  let spillWorker = null;
+  let workerSpawnCount = 0;
+  let activeWrite = null;
+  let activeWriteTimer = null;
+  let warningEmitted = false;
+  let spillDisabled = false;
+  const writeQueue = [];
+  const heartbeatTimers = /* @__PURE__ */ new Map();
+  const snapshots = /* @__PURE__ */ new Set();
+  const cleanupRecords = (records, directory) => {
+    for (const record of records) {
+      record.cancelled = true;
+    }
+    if (directory) {
+      const timer2 = heartbeatTimers.get(directory);
+      if (timer2) clearInterval(timer2);
+      heartbeatTimers.delete(directory);
+      try {
+        rmSync2(directory, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+  const ensureSpillDir = () => {
+    if (spillDir) return spillDir;
+    const root = tmpdir2();
+    writeFileSync6(
+      join10(root, `mixdog-transcript-owner-${process.pid}.json`),
+      JSON.stringify({ pid: process.pid, nonce: TRANSCRIPT_PROCESS_NONCE }),
+      "utf8"
+    );
+    spillDir = mkdtempSync(join10(root, `mixdog-transcript-${process.pid}-${TRANSCRIPT_PROCESS_NONCE}-`));
+    writeFileSync6(
+      join10(spillDir, "owner.json"),
+      JSON.stringify({ pid: process.pid, nonce: TRANSCRIPT_PROCESS_NONCE }),
+      "utf8"
+    );
+    const heartbeat = join10(spillDir, "heartbeat");
+    writeFileSync6(heartbeat, String(Date.now()), "utf8");
+    const heartbeatTimer = setInterval(() => {
+      try {
+        writeFileSync6(heartbeat, String(Date.now()), "utf8");
+      } catch {
+      }
+    }, TRANSCRIPT_SPILL_HEARTBEAT_MS);
+    heartbeatTimer.unref?.();
+    heartbeatTimers.set(spillDir, heartbeatTimer);
+    return spillDir;
+  };
+  const workerSource = `
+    const { parentPort } = require('node:worker_threads');
+    const { renameSync, writeFileSync } = require('node:fs');
+    parentPort.on('message', ({ id, targetPath, tempPath, items }) => {
+      try {
+        writeFileSync(tempPath, JSON.stringify(items), 'utf8');
+        renameSync(tempPath, targetPath);
+        parentPort.postMessage({ id, ok: true });
+      } catch (error) {
+        parentPort.postMessage({ id, ok: false, error: String(error && error.message || error) });
+      }
+    });`;
+  const ensureWorker = () => {
+    if (spillWorker) return spillWorker;
+    try {
+      const worker = workerFactory(workerSource);
+      spillWorker = worker;
+      workerSpawnCount += 1;
+      worker.on("message", (result) => {
+        if (spillWorker !== worker || result?.id !== activeWrite?.id) return;
+        finishWrite(result?.ok === true, result?.error);
+      });
+      const failWorker = (error) => {
+        if (spillWorker !== worker) return;
+        if (activeWriteTimer) clearTimeout(activeWriteTimer);
+        activeWriteTimer = null;
+        const failed = activeWrite;
+        activeWrite = null;
+        spillWorker = null;
+        try {
+          worker.terminate?.();
+        } catch {
+        }
+        if (failed) retryOrPin(failed, error?.message);
+        pumpWrites();
+      };
+      worker.on("error", failWorker);
+      worker.on("exit", (code) => {
+        failWorker(new Error(`spill worker exited (${code})`));
+      });
+      worker.unref?.();
+    } catch (error) {
+      spillWorker = null;
+      if (activeWrite) {
+        const failed = activeWrite;
+        activeWrite = null;
+        retryOrPin(failed, error?.message);
+      }
+    }
+    return spillWorker;
+  };
+  const retryOrPin = (record, error) => {
+    if (record.cancelled) return;
+    record.attempts += 1;
+    if (record.attempts <= 2) {
+      writeQueue.unshift(record);
+      return;
+    }
+    record.pinned = true;
+    spillDisabled = true;
+    for (const queued of writeQueue.splice(0)) {
+      if (!queued.cancelled) queued.pinned = true;
+    }
+    if (!warningEmitted) {
+      warningEmitted = true;
+      try {
+        onWarning(`transcript spill write failed; history pinned in memory (${error || "unknown error"})`);
+      } catch {
+      }
+    }
+  };
+  const finishWrite = (ok, error) => {
+    if (activeWriteTimer) clearTimeout(activeWriteTimer);
+    activeWriteTimer = null;
+    const record = activeWrite;
+    activeWrite = null;
+    if (record && !record.cancelled) {
+      if (ok) record.pendingItems = null;
+      else retryOrPin(record, error);
+    }
+    pumpWrites();
+  };
+  const pumpWrites = () => {
+    if (activeWrite) return;
+    while (writeQueue.length && writeQueue[0].cancelled) writeQueue.shift();
+    if (!writeQueue.length) return;
+    activeWrite = writeQueue.shift();
+    const worker = ensureWorker();
+    if (!worker) {
+      if (activeWrite) {
+        const failed = activeWrite;
+        activeWrite = null;
+        retryOrPin(failed, "worker unavailable");
+      }
+      queueMicrotask(pumpWrites);
+      return;
+    }
+    const tempPath = `${activeWrite.path}.attempt-${activeWrite.attempts}-${randomUUID()}.tmp`;
+    worker.postMessage({
+      id: activeWrite.id,
+      targetPath: activeWrite.path,
+      tempPath,
+      items: activeWrite.pendingItems
+    });
+    activeWriteTimer = setTimeout(() => {
+      if (!activeWrite || spillWorker !== worker) return;
+      const failed = activeWrite;
+      activeWrite = null;
+      activeWriteTimer = null;
+      spillWorker = null;
+      try {
+        worker.terminate?.();
+      } catch {
+      }
+      retryOrPin(failed, `write timed out after ${writeTimeoutMs}ms`);
+      pumpWrites();
+    }, Math.max(1, Number(writeTimeoutMs) || 5e3));
+    activeWriteTimer.unref?.();
+  };
+  const encode = (items) => {
+    const page = join10(ensureSpillDir(), `${++pageSequence}.json`);
+    const record = {
+      id: pageSequence,
+      path: page,
+      pendingItems: items,
+      cancelled: false,
+      attempts: 0,
+      pinned: false
+    };
+    writeQueue.push(record);
+    pumpWrites();
+    return record;
+  };
+  const decode = (record) => record.pendingItems || JSON.parse(readFileSync8(record.path, "utf8"));
+  return {
+    get hasOlder() {
+      return cursor == null ? pages.length > 0 : cursor > 0;
+    },
+    get hasNewer() {
+      return cursor != null;
+    },
+    reset() {
+      const retained = [...snapshots].some((snapshot) => snapshot.spillDir === spillDir);
+      const oldPages = pages.splice(0);
+      const oldDir = spillDir;
+      pages.length = 0;
+      cursor = null;
+      spillDir = null;
+      pageSequence = 0;
+      spillDisabled = false;
+      warningEmitted = false;
+      if (!retained) cleanupRecords(oldPages, oldDir);
+    },
+    snapshot() {
+      const snapshot = {
+        pages: pages.slice(),
+        cursor,
+        spillDir,
+        pageSequence,
+        spillDisabled,
+        warningEmitted
+      };
+      snapshots.add(snapshot);
+      return snapshot;
+    },
+    restoreSnapshot(snapshot) {
+      if (!snapshot || !snapshots.has(snapshot)) return false;
+      if (snapshot.spillDir === spillDir) {
+        cursor = snapshot.cursor;
+        snapshots.delete(snapshot);
+        return true;
+      }
+      cleanupRecords(pages, spillDir);
+      pages.splice(0, pages.length, ...snapshot.pages);
+      cursor = snapshot.cursor;
+      spillDir = snapshot.spillDir;
+      pageSequence = snapshot.pageSequence;
+      spillDisabled = snapshot.spillDisabled === true;
+      warningEmitted = snapshot.warningEmitted === true;
+      snapshots.delete(snapshot);
+      return true;
+    },
+    releaseSnapshot(snapshot) {
+      if (!snapshot || !snapshots.delete(snapshot)) return false;
+      if (snapshot.spillDir !== spillDir) cleanupRecords(snapshot.pages, snapshot.spillDir);
+      return true;
+    },
+    dispose() {
+      cleanupRecords(pages, spillDir);
+      for (const snapshot of snapshots) {
+        if (snapshot.spillDir !== spillDir) cleanupRecords(snapshot.pages, snapshot.spillDir);
+      }
+      pages.length = 0;
+      snapshots.clear();
+      cursor = null;
+      spillDir = null;
+      for (const timer2 of heartbeatTimers.values()) clearInterval(timer2);
+      heartbeatTimers.clear();
+      writeQueue.length = 0;
+      activeWrite = null;
+      if (activeWriteTimer) clearTimeout(activeWriteTimer);
+      activeWriteTimer = null;
+      try {
+        spillWorker?.terminate();
+      } catch {
+      }
+      spillWorker = null;
+    },
+    get workerCount() {
+      return workerSpawnCount;
+    },
+    get pendingWriteCount() {
+      return writeQueue.length + (activeWrite ? 1 : 0);
+    },
+    get pinnedPageCount() {
+      return pages.filter((page) => page.pinned).length;
+    },
+    get disabled() {
+      return spillDisabled;
+    },
+    capLive(items) {
+      let live = Array.isArray(items) ? items : [];
+      if (spillDisabled) return live;
+      while (live.length > cap) {
+        pages.push(encode(live.slice(0, chunkSize)));
+        live = live.slice(chunkSize);
+      }
+      return live;
+    },
+    restoreOlder(liveItems) {
+      const nextCursor = cursor == null ? pages.length - 1 : cursor - 1;
+      if (nextCursor < 0) return null;
+      cursor = nextCursor;
+      const restored = decode(pages[cursor]);
+      const following = cursor + 1 < pages.length ? decode(pages[cursor + 1]) : Array.isArray(liveItems) ? liveItems : [];
+      return [...restored, ...following.slice(0, TRANSCRIPT_RESTORE_OVERLAP_ITEMS)];
+    },
+    restoreNewer(liveItems) {
+      if (cursor == null) return null;
+      const nextCursor = cursor + 1;
+      if (nextCursor >= pages.length) {
+        cursor = null;
+        return { items: null, atLive: true };
+      }
+      cursor = nextCursor;
+      const restored = decode(pages[cursor]);
+      const following = cursor + 1 < pages.length ? decode(pages[cursor + 1]) : Array.isArray(liveItems) ? liveItems : [];
+      return [...restored, ...following.slice(0, TRANSCRIPT_RESTORE_OVERLAP_ITEMS)];
+    }
+  };
+}
+function refillTranscriptViewOverlap(viewItems, previousLiveItems, nextLiveItems) {
+  const view = Array.isArray(viewItems) ? viewItems : null;
+  if (!view) return null;
+  const previousIds = new Set((previousLiveItems || []).map((item) => item?.id).filter((id) => id != null));
+  if (!view.some((item) => previousIds.has(item?.id))) return view;
+  const historical = view.filter((item) => !previousIds.has(item?.id));
+  return [...historical, ...(nextLiveItems || []).slice(0, TRANSCRIPT_RESTORE_OVERLAP_ITEMS)];
+}
 function replaceEngineItemsState({
   state,
   items,
@@ -27142,7 +27898,13 @@ function replaceEngineItemsState({
     streamingTail: preserveStreamingTail ? state.streamingTail : null
   };
 }
-function createEngineItemMutators({ getState, set, itemIndexById }) {
+function createEngineItemMutators({
+  getState,
+  set,
+  itemIndexById,
+  normalizeItems = (items) => items,
+  itemStateExtra = () => ({})
+}) {
   const patchItem = (id, patch) => {
     const state = getState();
     let index = itemIndexById.get(id);
@@ -27182,15 +27944,21 @@ function createEngineItemMutators({ getState, set, itemIndexById }) {
       streaming: false
     };
     const index = state.items.length;
-    const items = [...state.items, item];
-    itemIndexById.set(id, index);
+    const items = normalizeItems([...state.items, item]);
+    itemIndexById.clear();
+    for (let i = 0; i < items.length; i++) {
+      const itemId = items[i]?.id;
+      if (itemId != null) itemIndexById.set(itemId, i);
+    }
+    const settledIndex = items.findIndex((entry) => entry?.id === id);
     set({
       items,
       structureRevision: (Number(state.structureRevision) || 0) + 1,
       streamingTail: null,
+      ...itemStateExtra(),
       ...extra
     });
-    return true;
+    return settledIndex >= 0;
   };
   return { patchItem, settleStreamingTail };
 }
@@ -27239,6 +28007,7 @@ async function createEngineSession({
   const pendingNotificationKeys = /* @__PURE__ */ new Set();
   const displayedExecutionNotificationKeys = /* @__PURE__ */ new Set();
   const bag = {};
+  let state;
   const {
     autoClearState,
     agentStatusState,
@@ -27248,6 +28017,9 @@ async function createEngineSession({
   } = createContextState({
     runtime,
     getState: () => state,
+    updateState: (patch) => {
+      state = { ...state, ...patch };
+    },
     getPendingSessionReset: () => flags.pendingSessionReset
   });
   const initialAgentState = {
@@ -27255,8 +28027,12 @@ async function createEngineSession({
     agentJobs: [],
     agentScope: null
   };
-  let state = {
+  state = {
     items: [],
+    transcriptViewItems: null,
+    transcriptViewRevision: 0,
+    transcriptHistoryBefore: false,
+    transcriptHistoryAfter: false,
     structureRevision: 0,
     streamingTail: null,
     toasts: [],
@@ -27295,50 +28071,109 @@ async function createEngineSession({
   syncContextStats({ allowEstimated: true });
   bootProfile("engine:context-ready", { ms: (performance2.now() - contextStartedAt).toFixed(1) });
   const listeners = /* @__PURE__ */ new Set();
-  let emitScheduled = false;
-  const flushEmit = () => {
-    emitScheduled = false;
-    for (const l of listeners) l();
-  };
-  const emit = () => {
-    if (emitScheduled) return;
-    emitScheduled = true;
-    queueMicrotask(flushEmit);
-  };
+  let publishedState = process.env.NODE_ENV === "production" ? state : Object.freeze(state);
+  state = { ...state, stats: { ...state.stats } };
+  const publisher = createFrameBatchedStorePublisher({
+    getState: () => state,
+    publishState: (next) => {
+      publishedState = process.env.NODE_ENV === "production" ? next : Object.freeze(next);
+      state = { ...next, stats: { ...next.stats } };
+    },
+    listeners,
+    isDisposed: () => flags.disposed
+  });
+  const emit = publisher.emit;
+  const flushEmit = publisher.flush;
+  const flushEmitImmediate = publisher.flushImmediate;
   const set = (patch) => {
     if (!patch || typeof patch !== "object") return false;
+    const requestsStructureChange = Object.prototype.hasOwnProperty.call(patch, "structureRevision") && !Object.is(patch.structureRevision, state.structureRevision);
+    const effectivePatch = requestsStructureChange ? Object.fromEntries(Object.entries(patch).filter(([key]) => key !== "structureRevision")) : patch;
     let changed = false;
-    for (const [key, value] of Object.entries(patch)) {
+    for (const [key, value] of Object.entries(effectivePatch)) {
       if (!Object.is(state[key], value)) {
         changed = true;
         break;
       }
     }
-    if (!changed) return false;
+    if (!changed && !requestsStructureChange) return false;
     const commandBusyReleased = state.commandBusy === true && Object.prototype.hasOwnProperty.call(patch, "commandBusy") && patch.commandBusy === false;
-    state = { ...state, ...patch };
+    state = { ...state, ...effectivePatch };
+    if (requestsStructureChange) publisher.markStructureChange();
     emit();
+    if (effectivePatch.commandStatus || effectivePatch.toolApproval) {
+      flushEmitImmediate();
+    }
     if (commandBusyReleased) queueMicrotask(() => {
       void bag.drain?.();
     });
     return true;
   };
   const itemIndexById = /* @__PURE__ */ new Map();
-  const replaceItems = (items, { preserveStreamingTail = false } = {}) => {
+  const transcriptSpill = createTranscriptSpillBuffer();
+  const reindexLiveItems = (items) => {
+    itemIndexById.clear();
+    for (let i = 0; i < items.length; i++) {
+      const id = items[i]?.id;
+      if (id != null) itemIndexById.set(id, i);
+    }
+  };
+  const transcriptHistoryFlags = () => ({
+    transcriptHistoryBefore: transcriptSpill.hasOlder,
+    transcriptHistoryAfter: transcriptSpill.hasNewer
+  });
+  const restoreOlderTranscript = () => {
+    const transcriptViewItems = transcriptSpill.restoreOlder(state.items);
+    if (!transcriptViewItems) return false;
+    set({
+      transcriptViewItems,
+      transcriptViewRevision: state.transcriptViewRevision + 1,
+      ...transcriptHistoryFlags()
+    });
+    flushEmitImmediate();
+    return true;
+  };
+  const restoreNewerTranscript = () => {
+    const restored = transcriptSpill.restoreNewer(state.items);
+    if (!restored) return false;
+    set({
+      transcriptViewItems: restored.atLive ? null : restored,
+      transcriptViewRevision: state.transcriptViewRevision + 1,
+      ...transcriptHistoryFlags()
+    });
+    flushEmitImmediate();
+    return true;
+  };
+  const replaceItems = (items, {
+    preserveStreamingTail = false,
+    preserveSpill = false,
+    preserveTranscriptView = false
+  } = {}) => {
     const nextItems = Array.isArray(items) ? items : [];
+    if (!preserveSpill) transcriptSpill.reset();
+    const liveItems = transcriptSpill.capLive(nextItems);
+    const previousTranscriptView = state.transcriptViewItems;
+    const nextTranscriptView = preserveTranscriptView && previousTranscriptView ? refillTranscriptViewOverlap(previousTranscriptView, state.items, liveItems) : null;
+    const transcriptViewChanged = nextTranscriptView !== previousTranscriptView;
     activeToolCalls.clear();
+    const structureRevision = state.structureRevision;
     state = replaceEngineItemsState({
       state,
-      items: nextItems,
+      items: liveItems,
       itemIndexById,
       preserveStreamingTail,
       extra: {
-        promptHistoryList: buildMergedPromptHistory(recomputePromptHistory(nextItems), loadPromptHistory(state.cwd)),
-        activeToolSummary: null
+        promptHistoryList: preserveSpill ? state.promptHistoryList : buildMergedPromptHistory(recomputePromptHistory(nextItems), loadPromptHistory(state.cwd)),
+        activeToolSummary: null,
+        transcriptViewItems: nextTranscriptView,
+        transcriptViewRevision: preserveTranscriptView ? state.transcriptViewRevision + (transcriptViewChanged ? 1 : 0) : state.transcriptViewRevision + 1,
+        ...transcriptHistoryFlags()
       }
     });
+    state = { ...state, structureRevision };
+    publisher.markStructureChange();
     emit();
-    return nextItems;
+    return liveItems;
   };
   const activeToolCalls = /* @__PURE__ */ new Map();
   const recomputeActiveToolSummary = () => {
@@ -27378,16 +28213,30 @@ async function createEngineSession({
     if (!flags.pushingFromDeferredEntry && flags.flushDeferredBeforeImmediatePush) {
       flags.flushDeferredBeforeImmediatePush();
     }
-    const index = state.items.length;
-    const items = [...state.items, item];
+    const uncappedItems = [...state.items, item];
+    const items = transcriptSpill.capLive(uncappedItems);
+    if (items !== uncappedItems) reindexLiveItems(items);
+    const index = items.length - 1;
     if (item?.id != null) itemIndexById.set(item.id, index);
     if (item?.kind === "user") {
       const promptHistoryList = buildMergedPromptHistory(recomputePromptHistory(items), loadPromptHistory(state.cwd));
-      set({ items, structureRevision: state.structureRevision + 1, promptHistoryList });
+      set({ items, structureRevision: state.structureRevision + 1, promptHistoryList, ...transcriptHistoryFlags() });
+      flushEmitImmediate();
     } else {
-      set({ items, structureRevision: state.structureRevision + 1 });
+      set({ items, structureRevision: state.structureRevision + 1, ...transcriptHistoryFlags() });
     }
   };
+  const appendItems = (newItems, extra = {}) => {
+    if (!Array.isArray(newItems) || newItems.length === 0) return set(extra);
+    const items = transcriptSpill.capLive([...state.items, ...newItems]);
+    reindexLiveItems(items);
+    return set({
+      items,
+      structureRevision: state.structureRevision + 1,
+      ...transcriptHistoryFlags(),
+      ...extra
+    });
+  };
   const updateStreamingTail = (id, patch = {}, extra = {}) => {
     if (id == null) return false;
     const current = state.streamingTail?.id === id ? state.streamingTail : { kind: "assistant", id, text: "", streaming: true };
@@ -27412,7 +28261,9 @@ async function createEngineSession({
   const { patchItem, settleStreamingTail } = createEngineItemMutators({
     getState: () => state,
     set,
-    itemIndexById
+    itemIndexById,
+    normalizeItems: (items) => transcriptSpill.capLive(items),
+    itemStateExtra: transcriptHistoryFlags
   });
   const upsertSyntheticToolItem = (text, id = nextId(), parsed = null) => {
     const synthetic = parseSyntheticAgentMessage(text);
@@ -27626,10 +28477,17 @@ async function createEngineSession({
     listeners,
     itemIndexById,
     getState: () => state,
+    getPublishedState: () => publishedState,
     set,
+    flushEmit,
+    flushEmitImmediate,
+    disposeEmit: publisher.dispose,
     pushItem,
+    appendItems,
     patchItem,
     replaceItems,
+    restoreOlderTranscript,
+    restoreNewerTranscript,
     updateStreamingTail,
     settleStreamingTail,
     clearStreamingTail,
@@ -27649,6 +28507,10 @@ async function createEngineSession({
     baseRouteState,
     routeState,
     syncContextStats,
+    disposeTranscriptSpill: () => transcriptSpill.dispose(),
+    snapshotTranscriptSpill: () => transcriptSpill.snapshot(),
+    restoreTranscriptSpill: (snapshot) => transcriptSpill.restoreSnapshot(snapshot),
+    releaseTranscriptSpill: (snapshot) => transcriptSpill.releaseSnapshot(snapshot),
     presentNextToolApproval,
     finishToolApproval,
     denyAllToolApprovals,
@@ -27891,7 +28753,7 @@ function scheduleHardExit(code = 0) {
   timer2.unref?.();
 }
 function resolveTuiStderrLogPath() {
-  return process.env.MIXDOG_TUI_STDERR_LOG || join10(process.env.MIXDOG_RUNTIME_ROOT || join10(tmpdir2(), "mixdog"), "mixdog-tui.stderr.log");
+  return process.env.MIXDOG_TUI_STDERR_LOG || join11(process.env.MIXDOG_RUNTIME_ROOT || join11(tmpdir3(), "mixdog"), "mixdog-tui.stderr.log");
 }
 function ansiFg(rgb) {
   const m = /rgb\((\d+),\s*(\d+),\s*(\d+)\)/.exec(String(rgb || ""));