mixdog 0.9.16 → 0.9.17

package/src/tui/app/transcript-window.mjs

@@ -573,20 +573,31 @@ function streamingEstimateRows(item, columns, toolOutputExpanded) {
   return Math.ceil(raw / STREAMING_ROW_QUANTUM) * STREAMING_ROW_QUANTUM;
 }
 
-function estimateTranscriptItemRowsCached(item, columns, toolOutputExpanded) {
+export function estimateTranscriptItemRowsCached(item, columns, toolOutputExpanded) {
   if (!item) return Math.max(1, Math.ceil(estimateTranscriptItemRows(item, columns, toolOutputExpanded)));
   if (shouldSuppressFullyFailedToolItem(item)) return 0;
   if (item.kind === 'assistant' && item.streaming) {
-    const estimate = streamingEstimateRows(item, columns, toolOutputExpanded);
     const toolExpanded = toolOutputExpanded ? 1 : 0;
     const idEntry = streamingMeasuredRowsById.get(item.id);
     if (idEntry && idEntry.rows > 0 && idEntry.columns === columns && idEntry.toolExpanded === toolExpanded) {
-      // Streaming text only ever grows, so the last real measured height is a
-      // valid floor even after the item object (and its text) has moved on.
-      return Math.max(idEntry.rows, estimate);
+      // Defer-growth: while a confirmed (post-commit Yoga) measurement exists
+      // for this streaming id, THIS render keeps that value instead of
+      // folding in the freshly-grown estimate. Combining
+      // max(measuredFloor, liveEstimate) let per-flush row growth reach
+      // totalRows/scrollOffset a full frame BEFORE Yoga confirmed the real
+      // wrap — the estimate could over/undercount vs the real layout, and
+      // the next commit's harvest then corrected it, bouncing an anchored or
+      // bottom-pinned offset by the mismatch. Freezing at the last confirmed
+      // height means growth only reaches the row index on the SAME frame the
+      // harvest (use-transcript-window.mjs) writes the new measured value and
+      // bumps measuredRowsVersion — the "measured frame" consumes it, not the
+      // estimate frame.
+      return idEntry.rows;
     }
     if (idEntry) streamingMeasuredRowsById.delete(item.id);
-    return estimate;
+    // No confirmed measurement yet for this id (item just started streaming):
+    // nothing to defer against, so the first frame falls back to the estimate.
+    return streamingEstimateRows(item, columns, toolOutputExpanded);
   }
   if (item.kind === 'assistant' && streamingMeasuredRowsById.has(item.id)) {
     // Item settled (no longer streaming): the id-keyed floor is no longer
@@ -632,6 +643,104 @@ export function buildTranscriptRowIndex(items, {
   return { rows, prefixRows, totalRows: prefixRows[allItems.length] || 0 };
 }
 
+// ── Incremental streaming-tail row-index cache ─────────────────────────────
+// On a streaming flush the engine swaps `items` for a fresh array in which
+// ONLY the trailing assistant item's text has grown; every settled item ahead
+// of it is byte-identical geometry. buildTranscriptRowIndex re-walks all N
+// items each flush (O(n) per ~16ms frame) even though only the last row's
+// height can change. This cache holds the SETTLED-PREFIX row-index (all items
+// except the trailing streaming assistant item) keyed on a stable signature of
+// that prefix + columns + expanded + suppress + measuredRowsVersion. When the
+// only difference since last flush is the trailing streaming item, we recompute
+// just that one tail row and append it to the cached prefixRows. Any structural
+// change (item count, non-tail change, columns, expanded, suppress, version)
+// invalidates the cache and falls back to a full buildTranscriptRowIndex.
+// The cache is per-hook-instance now (passed in as `cacheRef`); there is no
+// module-level mutable state to leak across hook instances.
+
+/** True when `items` ends with a streaming assistant item (the growing tail). */
+function trailingStreamingItem(allItems) {
+  const last = allItems.length > 0 ? allItems[allItems.length - 1] : null;
+  return last && last.kind === 'assistant' && last.streaming ? last : null;
+}
+
+export function buildTranscriptRowIndexIncremental(items, {
+  columns = 80,
+  toolOutputExpanded = false,
+  suppressMeasuredRowHeights = false,
+  measuredRowsVersion = 0,
+  cacheRef = null,
+  prefixSig = null,
+} = {}) {
+  const allItems = Array.isArray(items) ? items : [];
+  const tail = trailingStreamingItem(allItems);
+  // Per-hook-instance cache holder (useRef object). Fall back to a throwaway
+  // holder if none supplied so the builder still works in isolation.
+  const holder = cacheRef || { current: null };
+  // No streaming tail → nothing incremental to exploit; drop any stale cache and
+  // do the normal full build. (The memo layer already skips recompute when the
+  // structure signature is unchanged, so a settled transcript pays this once.)
+  if (!tail) {
+    holder.current = null;
+    return buildTranscriptRowIndex(allItems, {
+      columns, toolOutputExpanded, suppressMeasuredRowHeights,
+    });
+  }
+  const prefixLen = allItems.length - 1;
+  const cache = holder.current;
+  // Prefix identity is carried by `prefixSig` (a hash of every prefix item's
+  // WeakMap sigPart, computed once in the hook). String equality catches a
+  // same-length MIDDLE-item replacement (tool-card patch swaps a middle object →
+  // fresh fragment → different sig), which a last-item ref check would miss.
+  // Fast path: same prefix length + tail id + prefixSig, and columns/expanded/
+  // suppress/version all match. Only the tail row can differ → recompute + append.
+  if (cache
+    && cache.columns === columns
+    && cache.toolExpanded === (toolOutputExpanded ? 1 : 0)
+    && cache.suppress === suppressMeasuredRowHeights
+    && cache.version === measuredRowsVersion
+    && cache.prefixLen === prefixLen
+    && prefixSig != null
+    && cache.prefixSig === prefixSig
+    && cache.tailId === tail.id) {
+    // prefixSig matches → prefix rows provably unchanged; NO prefix walk / no
+    // re-estimation. Only the tail row can differ, recompute it.
+    {
+      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 };
+    }
+  }
+  // Cache miss: full build, then repopulate the settled-prefix cache so the NEXT
+  // flush (only the tail grown) takes the fast path. The prefix arrays are the
+  // full-build outputs truncated before the tail row — byte-identical to a
+  // full rebuild's prefix by construction.
+  const full = buildTranscriptRowIndex(allItems, {
+    columns, toolOutputExpanded, suppressMeasuredRowHeights,
+  });
+  holder.current = {
+    columns,
+    toolExpanded: toolOutputExpanded ? 1 : 0,
+    suppress: suppressMeasuredRowHeights,
+    version: measuredRowsVersion,
+    prefixLen,
+    prefixSig,
+    tailId: tail.id,
+    prefixRowsArr: full.rows.slice(0, prefixLen),
+    prefixPrefixRows: full.prefixRows.slice(0, prefixLen + 1),
+    prefixTotal: full.prefixRows[prefixLen] || 0,
+  };
+  return full;
+}
+
 // Stable signature for the transcript row-index / window memos. Changes only
 // when transcript STRUCTURE changes or the streaming item's estimated height
 // changes — not on every character. Per-item sigParts are identity-memoized.

package/src/tui/app/use-transcript-window.mjs

@@ -16,8 +16,9 @@ import {
   streamingMeasuredRowsById,
   pruneStreamingMeasuredRowsById,
   transcriptItemVariantKey,
-  buildTranscriptRowIndex,
+  buildTranscriptRowIndexIncremental,
   transcriptStructureSignature,
+  estimateTranscriptItemRowsCached,
   transcriptRenderWindow,
   resolveAnchorScrollOffset,
   upperBound,
@@ -55,6 +56,10 @@ export function useTranscriptWindow({
 }) {
   const transcriptTotalRowsRef = useRef(0);
   const preservedScrollDeltaRef = useRef(0);
+  // Per-hook-instance settled-prefix row-index cache for the incremental
+  // builder. Was module-level (leaked across hook instances); now local so
+  // each transcript window owns its own tail-flush cache.
+  const incrementalRowIndexCacheRef = useRef(null);
   // Previous frame's viewport-only geometry (content height + floating-panel
   // reservation). A floating panel / view (picker/context/usage/text-entry)
   // open-close changes transcriptContentHeight WITHOUT changing `items`, so the
@@ -120,10 +125,33 @@ export function useTranscriptWindow({
   // input typing — skip the O(n) signature walk entirely. During streaming the
   // engine hands us a fresh `items` array each flush, so this memo
   // recomputes and still tracks the streaming item's height correctly.
-  const transcriptStructureSig = useMemo(
-    () => transcriptStructureSignature(items, frameColumns, toolOutputExpanded),
-    [items, frameColumns, toolOutputExpanded],
+  // Split the structure signature into prefix (all items except the trailing
+  // streaming item) + tail. On a streaming flush only the tail item object is
+  // replaced; every prefix item keeps identity, so the prefix sig is O(1)-
+  const streamingTailItem = useMemo(() => {
+    const last = (items || []).length > 0 ? items[items.length - 1] : null;
+    return last && last.kind === 'assistant' && last.streaming ? last : null;
+  }, [items]);
+  const prefixLen = streamingTailItem ? (items || []).length - 1 : (items || []).length;
+  // Key on `items` identity (engine swaps the array every flush — INCLUDING a
+  // tool-card patch that replaces a MIDDLE item object), so a same-length
+  // middle-item replacement is caught (new object → fresh WeakMap fragment →
+  // different prefixSig string). The walk itself is cheap: transcript-
+  // StructureSignature reads a WeakMap sigPart per item (no re-estimation for
+  // unchanged objects) and joins — O(n) map lookups, not O(n) measurement. The
+  // row-index memo stays keyed on the prefixSig STRING, so a tail-only flush
+  // (identical prefix objects → identical string) still skips the row rebuild.
+  const prefixSig = useMemo(
+    () => transcriptStructureSignature(
+      streamingTailItem ? (items || []).slice(0, prefixLen) : (items || []),
+      frameColumns, toolOutputExpanded,
+    ),
+    [items, streamingTailItem, prefixLen, frameColumns, toolOutputExpanded],
   );
+  const tailSig = streamingTailItem
+    ? `a${streamingTailItem.id}:${estimateTranscriptItemRowsCached(streamingTailItem, frameColumns, toolOutputExpanded)}`
+    : '_';
+  const transcriptStructureSig = `${prefixSig}#${tailSig}`;
   const transcriptStreamingActive = (items || []).some(
     (item) => item?.kind === 'assistant' && item?.streaming,
   );
@@ -140,12 +168,24 @@ export function useTranscriptWindow({
       (scrolledUpForStreamingMeasure && hasStreamingReadingAnchor)
       || (scrolledUpForStreamingMeasure && prevEstimateGeometry && !transcriptPinnedForStreaming)
     ));
-  const transcriptRowIndex = useMemo(() => buildTranscriptRowIndex(items, {
+  // Incremental builder: on a streaming flush where only the trailing assistant
+  // item's text grew, it recomputes just the tail row and appends to a cached
+  // settled-prefix row-index (O(1) prefix) instead of re-walking all N items.
+  // Any structural change (item count, non-tail change, columns, expanded,
+  // suppress, measuredRowsVersion) misses the cache and falls back to a full
+  // buildTranscriptRowIndex — so the prefix table is byte-identical to a full
+  // rebuild for the settled prefix. All those invalidators are folded into the
+  // memo deps below (sig captures item/column/expanded structure; the rest are
+  // listed explicitly), so the memo only recomputes when one of them changes.
+  const transcriptRowIndex = useMemo(() => buildTranscriptRowIndexIncremental(items, {
     columns: frameColumns,
     toolOutputExpanded,
     suppressMeasuredRowHeights,
-  // eslint-disable-next-line react-hooks/exhaustive-deps -- intentional: sig captures the relevant item changes; measuredRowsVersion folds in app-level measured height corrections
-  }), [transcriptStructureSig, measuredRowsVersion, suppressMeasuredRowHeights]);
+    measuredRowsVersion,
+    cacheRef: incrementalRowIndexCacheRef,
+    prefixSig,
+  // eslint-disable-next-line react-hooks/exhaustive-deps -- intentional: prefixSig/tailSig capture the relevant item changes (raw `items` dropped so a tail-only flush never re-enters the builder via array identity); measuredRowsVersion folds in app-level measured height corrections
+  }), [prefixSig, tailSig, measuredRowsVersion, suppressMeasuredRowHeights]);
   // ── Same-frame anchor lock ───────────────────────────────────────────────
   // While the user reads older transcript (anchor captured, not dirty), resolve
   // the scroll offset that keeps the anchored viewport-top row fixed for THIS
@@ -412,6 +452,17 @@ export function useTranscriptWindow({
         const idPrev = streamingMeasuredRowsById.get(item.id);
         if (!idPrev || idPrev.rows !== measured || idPrev.columns !== frameColumns || idPrev.toolExpanded !== toolExpandedFlag) {
           streamingMeasuredRowsById.set(item.id, { rows: measured, columns: frameColumns, toolExpanded: toolExpandedFlag });
+          // ALWAYS bump on a real id-store change, bottom-pinned or not.
+          // estimateTranscriptItemRowsCached (transcript-window.mjs) now
+          // returns ONLY this id-store floor for a streaming item (defer-
+          // growth: no live-estimate blend), so it is the SOLE path that ever
+          // feeds this item's grown height into transcriptStructureSig /
+          // buildTranscriptRowIndex. Skipping the bump while bottom-pinned
+          // used to be safe because the blended estimate kept the signature
+          // moving on its own each flush; with the blend gone, skipping it
+          // here would freeze totalRows/prefixRows for this item until the
+          // stream settles — invisible growth for anything reading rowIndex
+          // (windowing, maxScrollRows, an anchor captured mid-stream).
           changed = true;
         }
       }

package/src/tui/components/StatusLine.jsx

@@ -84,7 +84,7 @@ function hasActiveStatuslineWork(line, agentWorkers = [], agentJobs = [], active
   return hasRunningStatuslineWorkers(agentWorkers, agentJobs)
     || hasActiveStatuslineTools(activeTools)
     || /\bRunning \d+ (?:Agents?|Shells?)\b/.test(stripAnsi(line))
-    || /\b(?:Exploring|Searching)\b/.test(stripAnsi(line));
+    || /\b(?:Exploring|Searching|Memory)\b/.test(stripAnsi(line));
 }
 
 function bootFullRenderEligible(mountAtMs, line, agentWorkers = [], agentJobs = [], activeTools = null) {