mixdog 0.9.16 → 0.9.18

package/src/session-runtime/provider-models.mjs

@@ -11,6 +11,10 @@ import { fastCapableFor, fastPreferenceFor } from './model-capabilities.mjs';
 import { modelSettingsFor } from './config-helpers.mjs';
 import { isSelectableLlmModel } from './model-recency.mjs';
 
+const PROVIDER_MODELS_PROFILE_ENABLED = /^(1|true|yes|on)$/i.test(String(
+  process.env.MIXDOG_PROVIDER_MODELS_PROFILE || process.env.MIXDOG_BOOT_PROFILE || '',
+));
+
 export function createProviderModels({
   caches,
   modelMetaByRoute,
@@ -32,6 +36,10 @@ export function createProviderModels({
   const config = () => getConfig();
   const route = () => getRoute();
   const reg = () => getReg();
+  function profile(event, fields = {}) {
+    if (!PROVIDER_MODELS_PROFILE_ENABLED) return;
+    bootProfile(`provider-models:${event}`, fields);
+  }
 
   function modelMetaKey(providerId, modelId) {
     return `${clean(providerId)}\n${clean(modelId)}`;
@@ -152,12 +160,17 @@ export function createProviderModels({
     return results;
   }
 
-  async function loadProviderModelsFresh({ forceRefresh = false } = {}) {
-    ensureFullConfig();
+  async function loadProviderModelsFresh({ forceRefresh = false, loadSecrets = true } = {}) {
+    const startedAt = performance.now();
+    profile('load:start', { forceRefresh, loadSecrets });
+    if (loadSecrets) ensureFullConfig();
+    const providersStartedAt = performance.now();
     await ensureProvidersReady(config().providers || {});
+    profile('providers-ready', { ms: (performance.now() - providersStartedAt).toFixed(1) });
     const allProviders = [...reg().getAllProviders()];
     const providerResults = await Promise.all(allProviders.map(async ([name, provider]) => {
       if (typeof provider?.listModels !== 'function') return [];
+      const providerStartedAt = performance.now();
       try {
         let models = null;
         if (forceRefresh && typeof provider._refreshModelCache === 'function') {
@@ -173,8 +186,19 @@ export function createProviderModels({
           if (!isSelectableLlmModel(m)) continue;
           rows.push(providerModelCacheRow(name, m));
         }
+        profile('provider:done', {
+          provider: name,
+          ms: (performance.now() - providerStartedAt).toFixed(1),
+          models: models.length,
+          rows: rows.length,
+        });
         return rows;
-      } catch {
+      } catch (error) {
+        profile('provider:failed', {
+          provider: name,
+          ms: (performance.now() - providerStartedAt).toFixed(1),
+          error: error?.message || String(error),
+        });
         // Ignore per-provider catalog failures so one bad credential or
         // transient /models error does not hide other authenticated models.
         return [];
@@ -189,9 +213,21 @@ export function createProviderModels({
       results.push(row);
       modelMetaByRoute.set(modelMetaKey(row.provider, row.id), row);
     }
+    profile('load:done', { ms: (performance.now() - startedAt).toFixed(1), providers: allProviders.length, rows: results.length });
     return results;
   }
 
+  function shouldAdoptProviderModelCache(models, { loadSecrets = true } = {}) {
+    // Background warmup deliberately avoids ensureFullConfig() so it cannot
+    // block the TUI on keychain/config reload. That no-secrets path is only a
+    // best-effort provider-internal prefetch. Its result may be a partial
+    // catalog (for example local/env providers listed while keychain-backed
+    // providers failed), so never let it become the authoritative picker cache.
+    // Foreground/forced loads still adopt empty lists because they loaded the
+    // authoritative config.
+    return loadSecrets;
+  }
+
   async function collectSearchProviderModels({ force = false } = {}) {
     if (!force && Array.isArray(caches.searchProviderModelsCache.models)) {
       return providerModelsFromCacheRows(quickHelpers.searchRowsWithDefault(caches.searchProviderModelsCache.models));
@@ -223,15 +259,15 @@ export function createProviderModels({
     }
     if (force) {
       const seq = ++caches.providerModelsLoadSeq;
-      const models = await loadProviderModelsFresh({ forceRefresh: true });
+      const models = await loadProviderModelsFresh({ forceRefresh: true, loadSecrets: true });
       if (seq === caches.providerModelsLoadSeq) caches.providerModelsCache = { models, at: Date.now() };
       return providerModelsFromCacheRows(models);
     }
     if (!caches.providerModelsPromise) {
       const seq = ++caches.providerModelsLoadSeq;
-      caches.providerModelsPromise = loadProviderModelsFresh()
+      caches.providerModelsPromise = loadProviderModelsFresh({ loadSecrets: true })
         .then((models) => {
-          if (seq === caches.providerModelsLoadSeq) caches.providerModelsCache = { models, at: Date.now() };
+          if (seq === caches.providerModelsLoadSeq && shouldAdoptProviderModelCache(models, { loadSecrets: true })) caches.providerModelsCache = { models, at: Date.now() };
           return models;
         })
         .finally(() => {
@@ -243,10 +279,13 @@ export function createProviderModels({
 
   function warmProviderModelCache() {
     if (Array.isArray(caches.providerModelsCache.models) || caches.providerModelsPromise) return caches.providerModelsPromise;
+    profile('warm:start');
     const seq = ++caches.providerModelsLoadSeq;
-    caches.providerModelsPromise = loadProviderModelsFresh()
+    caches.providerModelsPromise = loadProviderModelsFresh({ loadSecrets: false })
       .then((models) => {
-        if (seq === caches.providerModelsLoadSeq) caches.providerModelsCache = { models, at: Date.now() };
+        if (seq === caches.providerModelsLoadSeq && shouldAdoptProviderModelCache(models, { loadSecrets: false })) {
+          caches.providerModelsCache = { models, at: Date.now() };
+        }
         bootProfile('provider-models:warm-ready', { count: models.length });
         return models;
       })

package/src/standalone/channel-worker.mjs

@@ -75,6 +75,8 @@ export function createStandaloneChannelWorker({
   let readyResolve = null;
   let readyReject = null;
   let stopPromise = null;
+  let stopRequested = false;
+  let bootGeneration = 0;
   let inProcessMod = null;
   let inProcessStartPromise = null;
   let nextCallId = 1;
@@ -153,6 +155,7 @@ export function createStandaloneChannelWorker({
       return stopPromise.then(() => start());
     }
     if (child && child.exitCode == null && !child.killed) return readyPromise || Promise.resolve(status());
+    stopRequested = false;
     readyPromise = new Promise((resolve, reject) => {
       readyResolve = resolve;
       readyReject = reject;
@@ -181,6 +184,9 @@ export function createStandaloneChannelWorker({
       windowsHide: true,
     });
     const spawnedPid = child.pid;
+    // Per-boot generation: a later start()/respawn bumps this, so a stale old
+    // child's late exit is ignored instead of respawning/rejecting the current one.
+    const myGeneration = ++bootGeneration;
     startChildGuardian({ childPid: spawnedPid, label: 'channel-worker', orphanGraceMs: 8000, forceGraceMs: 3000 });
     if (spawnedPid) ownedChildPids.add(spawnedPid);
     installParentExitHook();
@@ -215,13 +221,17 @@ export function createStandaloneChannelWorker({
     });
 
     child.on('exit', (code, signal) => {
+      if (myGeneration !== bootGeneration) return;
       if (spawnedPid) ownedChildPids.delete(spawnedPid);
       const error = new Error(`channels runtime exited (${signal || (code ?? 'unknown')})`);
-      if (!becameReady && readyReject && !stopPromise && attempt < WORKER_BOOT_MAX_ATTEMPTS) {
+      // Exit code 2 = terminal (non-transient) worker start failure: reject, never respawn.
+      // A requested stop (stopRequested) also suppresses respawn even if stopPromise's
+      // settle timer already cleared it before the child exited.
+      if (!becameReady && readyReject && !stopPromise && !stopRequested && code !== 2 && attempt < WORKER_BOOT_MAX_ATTEMPTS) {
         logLine(logPath, `worker exited before ready (${signal || (code ?? 'unknown')}), attempt ${attempt}/${WORKER_BOOT_MAX_ATTEMPTS}; retrying in ${WORKER_BOOT_RETRY_DELAY_MS}ms`);
         child = null;
         setTimeout(() => {
-          if (stopPromise || !readyReject) return;
+          if (stopPromise || stopRequested || !readyReject) return;
           spawnWorkerChild(attempt + 1);
         }, WORKER_BOOT_RETRY_DELAY_MS);
         return;
@@ -235,6 +245,7 @@ export function createStandaloneChannelWorker({
     });
 
     child.on('error', (error) => {
+      if (myGeneration !== bootGeneration) return;
       logLine(logPath, `runtime error: ${error?.message || error}`);
       if (readyReject) readyReject(error);
       readyResolve = null;
@@ -347,6 +358,7 @@ export function createStandaloneChannelWorker({
 
   function stop(reason = 'standalone shutdown', options = {}) {
     const waitForExit = options?.waitForExit !== false;
+    stopRequested = true;
     stopClientHeartbeat();
     if (stopPromise) return stopPromise;
     if (!useProcessWorker) {

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

@@ -562,6 +562,17 @@ export function measuredTranscriptRows(item, columns, toolOutputExpanded) {
 
 const STREAMING_ROW_QUANTUM = 1;
 
+// Bottom-pinned flag for the streaming-tail row estimate. Set once per hook
+// render (use-transcript-window.mjs) BEFORE any tail resolution so every path
+// that resolves the streaming tail height (tailSig, buildTranscriptRowIndex,
+// incremental tail, transcriptStructureSignature) reads the same value and
+// cannot diverge. Bottom-pinned → fold the live estimate in (geometry right on
+// the first commit); away from bottom → d19cad1e defer-growth.
+let streamingBottomPinned = false;
+export function setStreamingBottomPinned(pinned) {
+  streamingBottomPinned = !!pinned;
+}
+
 function assistantTextForStreamingRowEstimate(text) {
   return streamingLayoutText(text);
 }
@@ -573,20 +584,42 @@ 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);
+      if (streamingBottomPinned) {
+        // Bottom-pinned: the view follows the tail, so its geometry must be
+        // correct on the FIRST commit. Fold the freshly-grown live estimate in
+        // — max(measuredFloor, liveEstimate) — so totalRows/scrollOffset are
+        // right this frame instead of committing the stale measured floor and
+        // growing a frame later when the harvest bumps measuredRowsVersion
+        // (the judder). The measured floor still guards against an estimate
+        // that undercounts the real wrap. Away from bottom the defer-growth
+        // path below is kept (its anchor-stability / perf intent).
+        return Math.max(idEntry.rows, streamingEstimateRows(item, columns, toolOutputExpanded));
+      }
+      // 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 +665,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,10 @@ import {
   streamingMeasuredRowsById,
   pruneStreamingMeasuredRowsById,
   transcriptItemVariantKey,
-  buildTranscriptRowIndex,
+  buildTranscriptRowIndexIncremental,
   transcriptStructureSignature,
+  estimateTranscriptItemRowsCached,
+  setStreamingBottomPinned,
   transcriptRenderWindow,
   resolveAnchorScrollOffset,
   upperBound,
@@ -55,6 +57,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,16 +126,44 @@ 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],
-  );
-  const transcriptStreamingActive = (items || []).some(
-    (item) => item?.kind === 'assistant' && item?.streaming,
+  // 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 scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
   const transcriptPinnedForStreaming = followingRef.current
     || scrolledUpRowsForPin <= transcriptBottomSlackRows;
+  // Publish the pinned state to the streaming-tail estimator BEFORE resolving
+  // tailSig / the row-index memo this render, so max(measuredFloor, liveEstimate)
+  // applies while bottom-pinned (right geometry on first commit, no judder) and
+  // every tail-resolving path reads the same height (no sig/geometry divergence).
+  setStreamingBottomPinned(transcriptPinnedForStreaming);
+  const tailSig = streamingTailItem
+    ? `a${streamingTailItem.id}:${estimateTranscriptItemRowsCached(streamingTailItem, frameColumns, toolOutputExpanded)}`
+    : '_';
+  const transcriptStructureSig = `${prefixSig}#${tailSig}`;
+  const transcriptStreamingActive = (items || []).some(
+    (item) => item?.kind === 'assistant' && item?.streaming,
+  );
   const scrolledUpForStreamingMeasure = scrolledUpRowsForPin > transcriptBottomSlackRows;
   const prevEstimateGeometry = transcriptGeomRef.current?.suppressMeasuredRowHeights === true;
   const hasStreamingReadingAnchor = !!transcriptAnchorRef.current
@@ -140,12 +174,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 +458,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) {