mixdog 0.9.39 → 0.9.40

package/src/runtime/agent/orchestrator/session/store.mjs

@@ -289,7 +289,10 @@ function _getOrSpawnWorker() {
         // (the originating call plus any that coalesced onto it before it was
         // posted). A supersede never lands here as a rejection — only a real
         // worker failure does.
-        if (ok) { for (const w of waiters) w.resolve(); }
+        if (ok) {
+            clearSessionSaveError(id);
+            for (const w of waiters) w.resolve();
+        }
         else {
             const e = new Error(`[session-store] worker save failed: ${error}`);
             for (const w of waiters) w.reject(e);
@@ -441,6 +444,7 @@ function _doSaveSync(payload) {
         }
         _renameWithRetrySync(tmp, target);
         _upsertSessionSummary(session);
+        clearSessionSaveError(id);
     } catch (err) {
         try { unlinkSync(tmp); } catch { /* ignore cleanup failure */ }
         throw err;
@@ -580,6 +584,7 @@ async function _doSave(payload) {
         }
         _renameWithRetrySync(tmp, target);
         _upsertSessionSummary(session);
+        clearSessionSaveError(id);
     } catch (err) {
         try { unlinkSync(tmp); } catch { /* ignore cleanup failure */ }
         _savePending.delete(id);
@@ -643,6 +648,7 @@ export function markSessionClosed(id, reason = 'manual') {
         return null;
     }
     _savePending.delete(id);
+    clearSessionSaveError(id);
     _clearLiveSession(id);
     _deleteHeartbeat(id);
     _upsertSessionSummary(tombstone);
@@ -702,6 +708,7 @@ export function bumpSessionGeneration(id, reason = 'detach') {
         return null;
     }
     _savePending.delete(id);
+    clearSessionSaveError(id);
     _clearLiveSession(id);
     _deleteHeartbeat(id);
     _upsertSessionSummary(detached);
@@ -748,6 +755,7 @@ export function deleteSession(id, options = {}) {
         catch { /* fall through to .hb cleanup */ }
     }
     _deleteHeartbeat(id);
+    if (removed || !existsSync(path)) clearSessionSaveError(id);
     // deferSummaryUpdate: bulk callers (tombstone sweep) remove thousands of
     // rows — a per-id _removeSessionSummary would parse+rewrite the multi-MB
     // summary index once PER DELETION. They batch the index update themselves.

package/src/runtime/agent/orchestrator/session/tool-result-offload.mjs

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync } from 'fs';
-import { readdir, rmdir, unlink, writeFile } from 'fs/promises';
+import { readdir, rmdir, stat, unlink, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { getPluginData } from '../config.mjs';
 import { normalizeOutputPath } from '../tools/builtin/path-utils.mjs';
@@ -11,6 +11,7 @@ const TOOL_RESULT_SHELL_THRESHOLD_CHARS = 30_000;
 const TOOL_RESULT_SEARCH_THRESHOLD_CHARS = 50_000;
 const TOOL_RESULT_GREP_THRESHOLD_CHARS = 20_000;
 export const TOOL_RESULT_OFFLOAD_PREFIX = '[tool output offloaded:';
+const OFFLOAD_PRUNE_MIN_AGE_MS = 10 * 60 * 1000;
 
 // Per-tool persistence limits mirror reference per-tool maxResultSizeChars
 // rather than a single global value: Grep persists at 20k (CC GrepTool), Glob
@@ -147,6 +148,47 @@ export async function clearOffloadSession(sessionId) {
     } catch { /* best-effort */ }
 }
 
+// Remove sidecars that no longer occur in the live transcript. A serialized
+// path match is conservative: if messages cannot be serialized, or a path is
+// mentioned anywhere in a message, retain the file rather than risk deleting
+// one that can still be read by the model.
+export async function pruneOffloadSession(sessionId, getMessages) {
+    if (!sessionId || typeof getMessages !== 'function') return;
+    const dir = join(getPluginData(), 'tool-results', safeSessionSegment(sessionId));
+    if (!existsSync(dir)) return;
+    let candidates;
+    try {
+        const entries = await readdir(dir);
+        candidates = (await Promise.all(entries
+            .filter((name) => name.endsWith('.txt'))
+            .map(async (name) => {
+                const filePath = join(dir, name);
+                try {
+                    const fileStat = await stat(filePath);
+                    if (Date.now() - fileStat.mtimeMs < OFFLOAD_PRUNE_MIN_AGE_MS) return null;
+                    return { name, filePath };
+                } catch {
+                    return null;
+                }
+            })
+        )).filter(Boolean);
+    } catch { /* best-effort */ }
+    if (!candidates) return;
+    let serialized;
+    try { serialized = JSON.stringify(getMessages()); } catch { return; }
+    const haystack = process.platform === 'win32' ? serialized.toLowerCase() : serialized;
+    await Promise.all(candidates
+        .filter(({ name, filePath }) => {
+            const normalizedPath = normalizeOutputPath(filePath);
+            const needles = [normalizedPath, name];
+            return !needles.some((needle) => {
+                const value = process.platform === 'win32' ? needle.toLowerCase() : needle;
+                return haystack.includes(value);
+            });
+        })
+        .map(({ filePath }) => unlink(filePath).catch(() => { /* best-effort */ })));
+}
+
 export function isOffloadedToolResultText(text) {
     return typeof text === 'string' && text.startsWith(TOOL_RESULT_OFFLOAD_PREFIX);
 }

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -124,23 +124,31 @@ export function _isBenignSearchExitOne(command, exitCode, signal, stderr) {
 function _combineAbortSignals(sessionSignal, externalSignal) {
     const a = sessionSignal || null;
     const b = externalSignal || null;
-    if (!a && !b) return null;
-    if (!a) return b;
-    if (!b) return a;
-    if (a === b) return a;
+    if (!a && !b) return { signal: null, cleanup() {} };
+    if (!a) return { signal: b, cleanup() {} };
+    if (!b) return { signal: a, cleanup() {} };
+    if (a === b) return { signal: a, cleanup() {} };
     if (typeof AbortSignal !== 'undefined' && typeof AbortSignal.any === 'function') {
-        try { return AbortSignal.any([a, b]); } catch { /* fall through */ }
+        try { return { signal: AbortSignal.any([a, b]), cleanup() {} }; } catch { /* fall through */ }
     }
     const ctl = new AbortController();
     const onAbort = (sig) => {
         if (ctl.signal.aborted) return;
         try { ctl.abort(sig?.reason); } catch { try { ctl.abort(); } catch {} }
     };
-    if (a.aborted) { onAbort(a); return ctl.signal; }
-    if (b.aborted) { onAbort(b); return ctl.signal; }
-    try { a.addEventListener('abort', () => onAbort(a), { once: true }); } catch {}
-    try { b.addEventListener('abort', () => onAbort(b), { once: true }); } catch {}
-    return ctl.signal;
+    if (a.aborted) { onAbort(a); return { signal: ctl.signal, cleanup() {} }; }
+    if (b.aborted) { onAbort(b); return { signal: ctl.signal, cleanup() {} }; }
+    const onAbortA = () => onAbort(a);
+    const onAbortB = () => onAbort(b);
+    try { a.addEventListener('abort', onAbortA, { once: true }); } catch {}
+    try { b.addEventListener('abort', onAbortB, { once: true }); } catch {}
+    return {
+        signal: ctl.signal,
+        cleanup() {
+            try { a.removeEventListener('abort', onAbortA); } catch {}
+            try { b.removeEventListener('abort', onAbortB); } catch {}
+        },
+    };
 }
 
 function _prefixPowerShellUtf8(command) {
@@ -228,7 +236,11 @@ export async function executeBashTool(args, workDir, options = {}) {
         const userProvidedSession = typeof args.session_id === 'string' && args.session_id.trim().length > 0;
         const shouldCreate = args.create === true || !userProvidedSession;
         effectiveArgs = { ...effectiveArgs, create: shouldCreate };
-        return executeBashSessionTool('bash_session', effectiveArgs, bashWorkDir, { abortSignal: combinedPersistAbort, sessionId: options?.sessionId });
+        try {
+            return await executeBashSessionTool('bash_session', effectiveArgs, bashWorkDir, { abortSignal: combinedPersistAbort.signal, sessionId: options?.sessionId });
+        } finally {
+            combinedPersistAbort.cleanup();
+        }
     }
 
     let command = args.command;
@@ -276,6 +288,7 @@ export async function executeBashTool(args, workDir, options = {}) {
     }
 
     let shellEffects;
+    let combinedBashAbort = null;
     try {
         shellEffects = await analyzeShellCommandEffects(command, bashWorkDir);
     } catch (err) {
@@ -423,7 +436,7 @@ export async function executeBashTool(args, workDir, options = {}) {
         let bashAbortSignal = null;
         try { bashAbortSignal = (await getAbortSignalForSession(options?.sessionId)) || null; }
         catch { bashAbortSignal = null; }
-        const combinedBashAbort = _combineAbortSignals(bashAbortSignal, options?.abortSignal || null);
+        combinedBashAbort = _combineAbortSignals(bashAbortSignal, options?.abortSignal || null);
         // Sync path only: chain a trailing cwd probe so the session's final
         // working directory persists to the next shell call. Async jobs run
         // detached and are intentionally excluded (they never reach here). The
@@ -456,7 +469,7 @@ export async function executeBashTool(args, workDir, options = {}) {
             env: spawnEnv,
             cwd: bashWorkDir,
             timeoutMs: timeout,
-            abortSignal: combinedBashAbort,
+            abortSignal: combinedBashAbort.signal,
             autoBackgroundMs,
             // On a foreground timeout, promote the still-running child to a
             // tracked background job (unlimited) instead of killing it.
@@ -592,6 +605,7 @@ export async function executeBashTool(args, workDir, options = {}) {
         return _prependDestructiveWarning(command, warningBlock ? `${warningBlock}\n${payload}` : payload);
     }
     finally {
+        combinedBashAbort?.cleanup?.();
         if (shellEffects.mutationMode === 'paths') {
             invalidateBuiltinResultCache(shellEffects.paths);
             markCodeGraphDirtyPaths(shellEffects.paths);

package/src/runtime/shared/buffered-appender.mjs

@@ -38,6 +38,13 @@ function scheduleFlush(path, q) {
     q.timer.unref?.();
 }
 
+function deleteIfIdle(path, q) {
+    if (!q.timer && !q.flushing && !q.inFlight && q.chunks.length === 0
+        && queues.get(path) === q) {
+        queues.delete(path);
+    }
+}
+
 function _flush(path, q) {
     if (q.flushing) return;
     if (q.chunks.length === 0) return;
@@ -70,7 +77,7 @@ function _flush(path, q) {
             if (q.chunks.length > 0) {
                 if (q.bytes >= BUFFER_FLUSH_BYTES) _flush(path, q);
                 else scheduleFlush(path, q);
-            }
+            } else deleteIfIdle(path, q);
         });
 }
 
@@ -120,7 +127,10 @@ export function drainPathSync(path) {
         }
         q.inFlight = null;
     }
-    if (q.chunks.length === 0) return;
+    if (q.chunks.length === 0) {
+        deleteIfIdle(path, q);
+        return;
+    }
     const data = q.chunks.join('');
     q.chunks = [];
     q.bytes = 0;
@@ -129,6 +139,7 @@ export function drainPathSync(path) {
     } catch {
         // Best-effort exit drain; nothing to recover from here.
     }
+    deleteIfIdle(path, q);
 }
 
 /**

package/src/session-runtime/config-helpers.mjs

@@ -176,16 +176,16 @@ export function autoClearProviderDefaults(providerIdleMs = null) {
 }
 
 // Agent terminal retention is deliberately narrower than Auto Clear's general
-// resolution: only listed provider rows participate. In particular, neither
-// the global idleMs nor the Advanced "default" row can retain a completed
-// agent, because those values do not describe a provider cache lifetime.
-// Null means leave the completed agent alone (no live timer, row expiry, or
-// durable store sweep).
+// resolution: listed providers use their provider cache lifetime. Unlisted
+// providers use the Advanced "default" row, or the built-in default when no
+// override is configured, so completed agents are still eventually reclaimed.
 export function resolveAgentTerminalReapMs(config, provider) {
   const key = clean(provider).toLowerCase();
-  if (!key || key === 'default' || !Object.hasOwn(AUTO_CLEAR_PROVIDER_IDLE_MS, key)) return null;
   const raw = config?.autoClear && typeof config.autoClear === 'object' ? config.autoClear : {};
   const overrides = normalizeAutoClearProviderIdleMs(raw.providerIdleMs);
+  if (!key || key === 'default' || !Object.hasOwn(AUTO_CLEAR_PROVIDER_IDLE_MS, key)) {
+    return overrides.default ?? AUTO_CLEAR_PROVIDER_IDLE_MS.default;
+  }
   return overrides[key] ?? AUTO_CLEAR_PROVIDER_IDLE_MS[key];
 }
 

package/src/session-runtime/lifecycle-api.mjs

@@ -30,6 +30,7 @@ export function createLifecycleApi(deps) {
     invalidateContextStatusCache, invalidatePreSessionToolSurface,
     applyResolvedCwd, resolveRoute, applyDeferredToolSurface, standaloneTools,
     pushTranscriptRebind,
+    notificationListeners, remoteStateListeners,
   } = deps;
   return {
     async close(reason = 'cli-exit', options = {}) {
@@ -132,6 +133,9 @@ export function createLifecycleApi(deps) {
         ok = mgr.closeSession(session.id, reason, { tombstone });
         setSession(null);
       }
+      invalidateContextStatusCache();
+      notificationListeners?.clear?.();
+      remoteStateListeners?.clear?.();
       const shellJobsStop = globalThis.__mixdogShellJobsRuntimeLoaded === true
         ? import('../runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs')
           .then((mod) => mod?.shutdownShellJobs?.(reason, { sync: !detach }))

package/src/session-runtime/runtime-core.mjs

@@ -2259,6 +2259,7 @@ export async function createMixdogSessionRuntime({
     resolveCwdPath,
     agentStatusState,
     notificationListeners,
+    remoteStateListeners,
     awaitInitialMcpConnect,
   });
 

package/src/session-runtime/session-turn-api.mjs

@@ -33,6 +33,18 @@ export function createSessionTurnApi(deps) {
     awaitInitialMcpConnect,
   } = deps;
   return {
+    getTurnLiveness() {
+      const sessionId = getSession()?.id;
+      if (!sessionId || typeof mgr.getSessionProgressSnapshot !== 'function') return null;
+      const snapshot = mgr.getSessionProgressSnapshot(sessionId);
+      if (!snapshot) return null;
+      return {
+        stage: snapshot.stage,
+        lastProgressAt: snapshot.lastProgressAt,
+        toolStartedAt: snapshot.toolStartedAt,
+        toolSelfDeadlineMs: snapshot.toolSelfDeadlineMs,
+      };
+    },
     async ask(prompt, options = {}) {
       setActiveTurnCount(getActiveTurnCount() + 1);
       // Lazy code-graph prewarm: kick off the build ONCE, on the first real

package/src/standalone/agent-tool.mjs

@@ -509,7 +509,11 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     for (const [tag, sessionId] of [...tags.entries()]) {
       if (indexedKeys.has(`${tag}\0${sessionId}`)) continue;
       const session = getLiveSession(sessionId);
-      if (!session || session.closed) tags.delete(tag);
+      if (!session || session.closed) {
+        tags.delete(tag);
+        tagAgents.delete(tag);
+        tagCwds.delete(tag);
+      }
     }
     if (!scanSessions) return;
     for (const session of mgr.listSessions({ includeClosed: false }) || []) {
@@ -1514,6 +1518,9 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     }
     for (const timer of reapTimers.values()) clearTimeout(timer);
     reapTimers.clear();
+    tags.clear();
+    tagAgents.clear();
+    tagCwds.clear();
     flushWorkerIndexMutations();
     writeWorkerRows((byKey) => byKey.clear());
     return { closed, failed };

package/src/tui/App.jsx

@@ -107,7 +107,6 @@ import {
   transcriptItemVariantKey,
   transcriptMeasuredRowsCache,
   buildTranscriptRowIndex,
-  transcriptStructureSignature,
   transcriptRenderWindow,
 } from './app/transcript-window.mjs';
 import {
@@ -2951,6 +2950,8 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     transcriptMeasureRef,
   } = useTranscriptWindow({
     items: state.items,
+    structureRevision: state.structureRevision,
+    streamingTail: state.streamingTail,
     themeEpoch: state.themeEpoch,
     frameColumns,
     toolOutputExpanded,

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

@@ -832,7 +832,7 @@ export function buildTranscriptRowIndexIncremental(items, {
   suppressMeasuredRowHeights = false,
   measuredRowsVersion = 0,
   cacheRef = null,
-  prefixSig = null,
+  prefixRevision = null,
 } = {}) {
   const allItems = Array.isArray(items) ? items : [];
   const tail = trailingStreamingItem(allItems);
@@ -850,11 +850,10 @@ export function buildTranscriptRowIndexIncremental(items, {
   }
   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/
+  // Prefix identity is carried by the engine's monotonic structure revision.
+  // Every settled-item mutation, including same-length middle tool-card patches,
+  // bumps it without requiring a render-time walk over the transcript.
+  // Fast path: same prefix length + tail id + revision, and columns/expanded/
   // suppress/version all match. Only the tail row can differ → recompute + append.
   if (cache
     && cache.columns === columns
@@ -862,10 +861,10 @@ export function buildTranscriptRowIndexIncremental(items, {
     && cache.suppress === suppressMeasuredRowHeights
     && cache.version === measuredRowsVersion
     && cache.prefixLen === prefixLen
-    && prefixSig != null
-    && cache.prefixSig === prefixSig
+    && prefixRevision != null
+    && cache.prefixRevision === prefixRevision
     && cache.tailId === tail.id) {
-    // prefixSig matches → prefix rows provably unchanged; NO prefix walk / no
+    // revision matches → prefix rows provably unchanged; NO prefix walk / no
     // re-estimation. Only the tail row can differ, recompute it.
     {
       const tailMeasured = suppressMeasuredRowHeights
@@ -894,7 +893,7 @@ export function buildTranscriptRowIndexIncremental(items, {
     suppress: suppressMeasuredRowHeights,
     version: measuredRowsVersion,
     prefixLen,
-    prefixSig,
+    prefixRevision,
     tailId: tail.id,
     prefixRowsArr: full.rows.slice(0, prefixLen),
     prefixPrefixRows: full.prefixRows.slice(0, prefixLen + 1),

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

@@ -18,7 +18,6 @@ import {
   hasStreamingRowStateToPrune,
   transcriptItemVariantKey,
   buildTranscriptRowIndexIncremental,
-  transcriptStructureSignature,
   estimateTranscriptItemRowsCached,
   setStreamingBottomPinned,
   transcriptRenderWindow,
@@ -32,7 +31,9 @@ import {
 import { shouldSuppressFullyFailedToolItem } from '../transcript-tool-failures.mjs';
 
 export function useTranscriptWindow({
-  items,
+  items: settledItems,
+  structureRevision,
+  streamingTail,
   themeEpoch,
   frameColumns,
   toolOutputExpanded,
@@ -129,42 +130,12 @@ export function useTranscriptWindow({
     return fn;
   }, []);
 
-  // Key the heavy O(n) row-index + windowing memos on a STRUCTURE signature
-  // instead of the `items` array identity. The engine swaps `items`
-  // for a new array on every streaming flush (~8ms) while only the final
-  // assistant item's text grows; depending on array identity re-ran both memos
-  // each delta frame and visibly throttled the stream. The signature changes
-  // only when transcript structure or the streaming item's estimated height
-  // changes, so steady per-character growth keeps both memos warm.
-  //
-  // The signature itself is memoized on `items` identity (+columns/
-  // expanded) so re-renders that DO NOT touch items — drag motion, scroll,
-  // 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.
-  // 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],
-  );
+  // The settled array no longer changes during streaming. Geometry is keyed by
+  // the engine revision plus the live tail's resolved height, so same-height
+  // text flushes do not copy/walk the settled prefix or rerun heavy memos.
+  const streamingTailItem = streamingTail?.kind === 'assistant' && streamingTail.streaming
+    ? streamingTail
+    : null;
   const scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
   const transcriptPinnedForStreaming = followingRef.current
     || scrolledUpRowsForPin <= transcriptBottomSlackRows;
@@ -173,13 +144,18 @@ export function useTranscriptWindow({
   // 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 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 transcriptStructureSig = `${revision}#${tailSig}`;
+  const transcriptStreamingActive = !!streamingTailItem;
   const scrolledUpForStreamingMeasure = scrolledUpRowsForPin > transcriptBottomSlackRows;
   const prevEstimateGeometry = transcriptGeomRef.current?.suppressMeasuredRowHeights === true;
   const hasStreamingReadingAnchor = !!transcriptAnchorRef.current
@@ -199,15 +175,15 @@ export function useTranscriptWindow({
   // 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, {
+  const transcriptRowIndex = useMemo(() => buildTranscriptRowIndexIncremental(transcriptItems, {
     columns: frameColumns,
     toolOutputExpanded,
     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]);
+    prefixRevision: revision,
+  // 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]);
   // ── 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
@@ -243,7 +219,7 @@ export function useTranscriptWindow({
   if (anchorLockActive) {
     const locked = resolveAnchorScrollOffset({
       anchor: transcriptAnchorRef.current,
-      items: items,
+      items: transcriptItems,
       curPrefix: curPrefixForLock,
       totalRows: lockTotalRows,
       viewRows: lockViewRows,
@@ -288,7 +264,7 @@ export function useTranscriptWindow({
         const captured = { id: anchorItem.id, offset: Math.max(0, prevTopRow - (prevPrefix[idx] || 0)) };
         const locked = resolveAnchorScrollOffset({
           anchor: captured,
-          items: items,
+          items: transcriptItems,
           curPrefix: curPrefixForLock,
           totalRows: lockTotalRows,
           viewRows: lockViewRows,
@@ -343,7 +319,7 @@ export function useTranscriptWindow({
         const captured = { id: anchorItem.id, offset: Math.max(0, prevTopRow - (prevPrefix[idx] || 0)) };
         const locked = resolveAnchorScrollOffset({
           anchor: captured,
-          items: items,
+          items: transcriptItems,
           curPrefix: curPrefixForLock,
           totalRows: lockTotalRows,
           viewRows: lockViewRows,
@@ -376,7 +352,7 @@ export function useTranscriptWindow({
   // measuredRowsVersion bumps, the row index absorbs the growth (idEntry.rows ==
   // the new measured height) and the live estimate matches it, so delta → 0.
   if (scrolledUp && !followingRef.current) {
-    const growth = streamingTailMountedGrowth(items, frameColumns, toolOutputExpanded);
+    const growth = streamingTailMountedGrowth(transcriptItems, frameColumns, toolOutputExpanded);
     // Only compensate when the tail is actually mounted in the rendered slice
     // (viewport + overscan). Off-slice it is represented by a row-index-sized
     // bottom spacer that does NOT physically grow this frame, so shifting the
@@ -394,7 +370,7 @@ export function useTranscriptWindow({
       }
     }
   }
-  const transcriptWindow = useMemo(() => transcriptRenderWindow(items, {
+  const transcriptWindow = useMemo(() => transcriptRenderWindow(transcriptItems, {
     scrollOffset: renderScrollOffset,
     viewportHeight: transcriptContentHeight,
     columns: frameColumns,
@@ -451,7 +427,7 @@ export function useTranscriptWindow({
     prefixRows: transcriptRowIndex?.prefixRows || null,
     totalRows: Math.max(0, Number(transcriptWindow.totalRows) || 0),
     viewRows: Math.max(1, Number(transcriptContentHeight) || 1),
-    items: items || null,
+    items: transcriptItems || null,
     // The offset THIS frame actually rendered with. The same-frame anchor
     // CAPTURE for a missing/dirty anchor (above) reads this from the PREVIOUS
     // frame to reconstruct the exact top-edge row that was on screen, so the
@@ -469,10 +445,16 @@ export function useTranscriptWindow({
   // height changes. Re-slice the live `items` over the memo's stable
   // [startIndex, endIndex) bounds so the on-screen text is always current
   // while the expensive indexing/windowing stays warm.
-  const transcriptVisibleItems = (items || []).slice(
+  const transcriptVisibleItems = (transcriptItems || []).slice(
     transcriptWindow.startIndex,
     transcriptWindow.endIndex,
   );
+  if (streamingTailItem && transcriptVisibleItems.length > 0) {
+    const last = transcriptVisibleItems.length - 1;
+    if (transcriptVisibleItems[last]?.id === streamingTailItem.id) {
+      transcriptVisibleItems[last] = streamingTailItem;
+    }
+  }
   // The bottom meta band is spinner-only, so nothing is pulled out of the
   // transcript for it. A finished turn's done row (turndone/statusdone) renders
   // inline in scrollback like any other item — no filtering, no double-paint.
@@ -703,7 +685,7 @@ export function useTranscriptWindow({
     // move the item's prefix start and are absorbed the same way. No deltas, no
     // fallback, no drift.
     const viewRows = Math.max(1, Number(transcriptContentHeight) || 1);
-    const itemList = items || [];
+    const itemList = transcriptItems || [];
     let anchor = transcriptAnchorRef.current;
     // (Re)capture the anchor from the current viewport-top edge when missing or
     // invalidated by a manual scroll. anchorRow = absolute row at the top edge.