mixdog 0.9.65 → 0.9.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.65",
+  "version": "0.9.67",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/app.mjs

@@ -39,8 +39,8 @@ export { parseHeadlessRoleCommand };
  * tools, and the canonical Ink TUI. Vendored reference code is not executable
  * from this entry point.
  */
-export async function run(argv = []) {
-  const invocation = classifyCliInvocation(argv);
+export async function run(argv = [], classifiedInvocation = null) {
+  const invocation = classifiedInvocation ?? classifyCliInvocation(argv);
   // Headless commands establish their own audited environment after route
   // validation; do not let an inherited MIXDOG_BOOT_PROFILE affect that path.
   if (invocation.kind !== 'headless' && invocation.skipHostPrelude !== true) {

package/src/cli.mjs

@@ -57,7 +57,7 @@ async function main() {
     } catch { /* fall through to in-place run */ }
   }
   const { run } = await import('./app.mjs');
-  return await run(argv);
+  return await run(argv, invocation);
 }
 
 main().then(async (code) => {

package/src/repl.mjs

@@ -14,7 +14,8 @@
  *   Live token streaming via onTextDelta conflicts with post-hoc markdown
  *   rendering (you can't style a heading until you've seen the whole line).
  *   We choose: stream raw tokens live so the turn FEELS alive, then on turn
- *   end clear the streamed raw block and re-print the markdown-rendered text.
+ *   end replace only changed rows with markdown-rendered text, falling back to
+ *   a full block redraw when wrapping or row structure makes patching unsafe.
  *   Rationale: the alternative (buffer silently, render once) loses all live
  *   feedback on slow turns, which is the worse UX. The re-render is cheap and
  *   only runs when stdout is a TTY (so piped/non-TTY output stays clean and is
@@ -27,12 +28,14 @@ import { basename } from 'node:path';
 import { bold, dim, cyan, green, red, yellow, colorEnabled } from './ui/ansi.mjs';
 import { printHelp } from './help.mjs';
 import { createSessionStats, applyUsageDelta } from './ui/session-stats.mjs';
+import { buildStreamFinalPatch } from './ui/stream-finalize.mjs';
 
 let runtimeModulePromise = null;
 let markdownModulePromise = null;
 let toolCardModulePromise = null;
 let statuslineModulePromise = null;
 let shutdownModulePromise = null;
+const STREAM_WRITE_BATCH_MS = 8;
 
 function loadRuntimeModule() {
   runtimeModulePromise ??= import('./mixdog-session-runtime.mjs');
@@ -159,6 +162,15 @@ export async function runRepl({ provider: providerName, model, toolMode = 'full'
       stdout.write('\n');
 
       let streamedText = '';
+      let streamedChunks = [];
+      let streamedTextDirty = false;
+      const currentStreamedText = () => {
+        if (!streamedTextDirty) return streamedText;
+        streamedText = streamedChunks.join('');
+        streamedChunks = streamedText ? [streamedText] : [];
+        streamedTextDirty = false;
+        return streamedText;
+      };
       let printedAny = false;
       let printedToolCard = false;
       // After the blank line emitted above, the cursor sits at a fresh line
@@ -166,6 +178,38 @@ export async function runRepl({ provider: providerName, model, toolMode = 'full'
       // a leading newline is only needed to break away from un-terminated
       // streamed text, never between consecutive cards.
       let atLineStart = true;
+      let pendingStreamChunks = [];
+      let streamFlushTimer = null;
+      let streamWriteError = null;
+      const flushStream = () => {
+        if (streamFlushTimer) {
+          clearTimeout(streamFlushTimer);
+          streamFlushTimer = null;
+        }
+        if (streamWriteError) {
+          const error = streamWriteError;
+          streamWriteError = null;
+          throw error;
+        }
+        if (pendingStreamChunks.length === 0) return;
+        const text = pendingStreamChunks.join('');
+        pendingStreamChunks = [];
+        stdout.write(text);
+      };
+      const queueStreamChunk = (chunk) => {
+        if (streamWriteError) throw streamWriteError;
+        pendingStreamChunks.push(chunk);
+        if (streamFlushTimer) return;
+        streamFlushTimer = setTimeout(() => {
+          streamFlushTimer = null;
+          try {
+            flushStream();
+          } catch (error) {
+            streamWriteError = error;
+          }
+        }, STREAM_WRITE_BATCH_MS);
+        streamFlushTimer.unref?.();
+      };
       try {
         const runtime = await ensureRuntime();
         const { result } = await runtime.ask(
@@ -173,6 +217,7 @@ export async function runRepl({ provider: providerName, model, toolMode = 'full'
           {
             onToolCall: async (_iter, calls) => {
               for (const c of calls || []) {
+                flushStream();
                 printedToolCard = true;
                 const lead = atLineStart ? '' : '\n';
                 stdout.write(lead + (await renderToolCardLazy(c)) + '\n');
@@ -181,16 +226,21 @@ export async function runRepl({ provider: providerName, model, toolMode = 'full'
           },
             onTextDelta: (chunk) => {
               printedAny = true;
-              streamedText += chunk;
-              stdout.write(chunk);
+              streamedChunks.push(chunk);
+              streamedTextDirty = true;
+              queueStreamChunk(chunk);
               atLineStart = chunk.endsWith('\n');
             },
             onTextReset: ({ chars } = {}) => {
               const count = Math.max(0, Number(chars) || 0);
               if (!count || !colorEnabled() || printedToolCard) return false;
+              flushStream();
+              streamedText = currentStreamedText();
               const remaining = streamedText.slice(0, Math.max(0, streamedText.length - count));
               eraseStreamedBlock(streamedText);
               streamedText = remaining;
+              streamedChunks = remaining ? [remaining] : [];
+              streamedTextDirty = false;
               if (remaining) stdout.write(remaining);
               printedAny = !!remaining;
               atLineStart = !remaining || remaining.endsWith('\n');
@@ -199,7 +249,9 @@ export async function runRepl({ provider: providerName, model, toolMode = 'full'
             onUsageDelta: (delta) => applyUsageDelta(stats, delta),
           },
         );
+        flushStream();
 
+        streamedText = currentStreamedText();
         const finalText = (result?.content != null && String(result.content)) || streamedText;
 
         // Approach (a): clear the raw streamed block and re-print as markdown.
@@ -208,8 +260,16 @@ export async function runRepl({ provider: providerName, model, toolMode = 'full'
         // into a pipe).
         if (finalText) {
           if (printedAny && colorEnabled() && !printedToolCard) {
-            eraseStreamedBlock(streamedText);
-            stdout.write(await renderMarkdownLazy(finalText) + '\n');
+            const rendered = await renderMarkdownLazy(finalText);
+            const patch = buildStreamFinalPatch(streamedText, rendered, {
+              columns: stdout.columns || 80,
+            });
+            if (patch) stdout.write(patch.output);
+            else {
+              eraseStreamedBlock(streamedText);
+              stdout.write(rendered);
+            }
+            stdout.write('\n');
           } else if (!printedAny) {
             // Nothing streamed live (provider without onTextDelta) — render once.
             stdout.write(await renderMarkdownLazy(finalText) + '\n');
@@ -235,7 +295,13 @@ export async function runRepl({ provider: providerName, model, toolMode = 'full'
           rawContextWindow: runtime.rawContextWindow,
         })) + '\n');
       } catch (error) {
-        stdout.write('\n' + red(`[error] ${error?.message || error}`) + '\n');
+        let displayError = error;
+        try {
+          flushStream();
+        } catch (flushError) {
+          displayError = flushError;
+        }
+        stdout.write('\n' + red(`[error] ${displayError?.message || displayError}`) + '\n');
       }
 
       stdout.write('\n');

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -1,7 +1,10 @@
 import { isOffloadedToolResultText } from './tool-result-offload.mjs';
 import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
-import { providerNativeToolPrefixCount } from '../../../../session-runtime/provider-request-tools.mjs';
+import {
+    isFinalizedProviderRequestTools,
+    providerNativeToolPrefixCount,
+} from '../../../../session-runtime/provider-request-tools.mjs';
 import { contentFileDescriptors, contentImageDescriptors, contentToText } from '../providers/media-normalization.mjs';
 export {
     DEFAULT_COMPACTION_BUFFER_TOKENS,
@@ -591,9 +594,10 @@ export function summarizeContextMessages(messages) {
     if (!Array.isArray(messages)) return contextSummaryResult(emptyContextSummaryState(), 0);
     let cached = contextTranscriptMemo.get(messages);
     if (!cached || messages.length < cached.count) {
-        cached = { count: 0, contributions: [], state: emptyContextSummaryState(), revision: 0 };
+        cached = { count: 0, contributions: [], state: emptyContextSummaryState(), revision: 0, result: null };
         contextTranscriptMemo.set(messages, cached);
     }
+    let changed = cached.result === null;
     for (let index = 0; index < messages.length; index += 1) {
         const previous = cached.contributions[index];
         const contribution = contextMessageContribution(messages[index]);
@@ -602,10 +606,13 @@ export function summarizeContextMessages(messages) {
         cached.contributions[index] = contribution;
         applyContextMessageContribution(cached.state, contribution, 1);
         cached.revision += 1;
+        changed = true;
     }
     cached.contributions.length = messages.length;
     cached.count = messages.length;
-    return contextSummaryResult(cached.state, messages.length);
+    if (!changed && cached.result) return cached.result;
+    cached.result = contextSummaryResult(cached.state, messages.length);
+    return cached.result;
 }
 
 // A stable warm-cache generation for consumers that cache a derived view of
@@ -617,11 +624,47 @@ export function contextMessagesRevision(messages) {
     return contextTranscriptMemo.get(messages)?.revision || 0;
 }
 
+export function summarizeContextMessagesAtRevision(messages, revision) {
+    if (Array.isArray(messages)) {
+        const cached = contextTranscriptMemo.get(messages);
+        if (cached
+            && cached.count === messages.length
+            && cached.revision === revision
+            && cached.result) return cached.result;
+    }
+    return summarizeContextMessages(messages);
+}
+
 // Hash only estimator/provider-visible projections. In particular, images
 // contribute their visual count but never their raw data-url/base64 bytes.
+const contextMessagesSignatureMemo = new WeakMap();
+const CONTEXT_SIGNATURE_COUNTS_MAX = 4;
+
 export function contextMessagesSignature(messages, count = messages?.length) {
     const list = Array.isArray(messages) ? messages : [];
     const end = Math.max(0, Math.min(list.length, Number.isInteger(count) ? count : list.length));
+    let contributions = null;
+    let signatures = null;
+    if (Array.isArray(messages)) {
+        summarizeContextMessages(messages);
+        contributions = contextTranscriptMemo.get(messages)?.contributions.slice(0, end) || [];
+        signatures = contextMessagesSignatureMemo.get(messages);
+        const previous = signatures?.get(end);
+        if (previous && previous.contributions.length === contributions.length) {
+            let unchanged = true;
+            for (let index = 0; index < contributions.length; index += 1) {
+                if (previous.contributions[index] !== contributions[index]) {
+                    unchanged = false;
+                    break;
+                }
+            }
+            if (unchanged) {
+                signatures.delete(end);
+                signatures.set(end, previous);
+                return previous.signature;
+            }
+        }
+    }
     const hash = createHash('sha256');
     for (let index = 0; index < end; index += 1) {
         const message = list[index];
@@ -634,11 +677,22 @@ export function contextMessagesSignature(messages, count = messages?.length) {
         ]));
         hash.update('\0');
     }
-    return hash.digest('hex');
+    const signature = hash.digest('hex');
+    if (Array.isArray(messages)) {
+        signatures ||= new Map();
+        if (signatures.has(end)) signatures.delete(end);
+        signatures.set(end, { contributions, signature });
+        while (signatures.size > CONTEXT_SIGNATURE_COUNTS_MAX) {
+            const oldest = signatures.keys().next().value;
+            if (oldest === undefined) break;
+            signatures.delete(oldest);
+        }
+        contextMessagesSignatureMemo.set(messages, signatures);
+    }
+    return signature;
 }
 
-const toolSchemaTokenMemo = new WeakMap();
-const requestReserveTokenMemo = new WeakMap();
+const toolSchemaAnalysisMemo = new WeakMap();
 
 function serializeToolSchemas(tools) {
     const list = Array.isArray(tools) ? tools : [];
@@ -661,7 +715,19 @@ function serializeToolSchemas(tools) {
 }
 
 export function toolSchemaSignature(tools) {
-    return createHash('sha256').update(serializeToolSchemas(tools)).digest('hex');
+    return analyzeToolSchemas(tools).signature;
+}
+
+function analyzeToolSchemas(tools) {
+    const list = Array.isArray(tools) ? tools : [];
+    const cached = Array.isArray(tools) ? toolSchemaAnalysisMemo.get(tools) : null;
+    if (cached && isFinalizedProviderRequestTools(tools)) return cached;
+    const text = serializeToolSchemas(list);
+    const signature = createHash('sha256').update(text).digest('hex');
+    if (cached?.signature === signature) return cached;
+    const analysis = { signature, tokens: estimateTokens(text) };
+    if (Array.isArray(tools)) toolSchemaAnalysisMemo.set(tools, analysis);
+    return analysis;
 }
 
 /**
@@ -674,13 +740,7 @@ export function toolSchemaSignature(tools) {
  */
 export function estimateToolSchemaTokens(tools) {
     if (!Array.isArray(tools) || tools.length === 0) return 0;
-    const signature = toolSchemaSignature(tools);
-    const cached = toolSchemaTokenMemo.get(tools);
-    if (cached?.signature === signature) return cached.value;
-    const text = serializeToolSchemas(tools);
-    const tokens = estimateTokens(text);
-    toolSchemaTokenMemo.set(tools, { signature, value: tokens });
-    return tokens;
+    return analyzeToolSchemas(tools).tokens;
 }
 
 /**
@@ -689,13 +749,8 @@ export function estimateToolSchemaTokens(tools) {
  * not expose a stable framing cost, so no synthetic fixed allowance is added.
  */
 export function estimateRequestReserveTokens(tools) {
-    if (!Array.isArray(tools)) return estimateToolSchemaTokens(tools);
-    const signature = toolSchemaSignature(tools);
-    const cached = requestReserveTokenMemo.get(tools);
-    if (cached?.signature === signature) return cached.value;
-    const reserve = estimateToolSchemaTokens(tools);
-    requestReserveTokenMemo.set(tools, { signature, value: reserve });
-    return reserve;
+    if (!Array.isArray(tools) || tools.length === 0) return estimateToolSchemaTokens(tools);
+    return analyzeToolSchemas(tools).tokens;
 }
 
 /**

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -18,6 +18,18 @@ const PENDING_MESSAGES_FILE = 'session-pending-messages.json';
 const PENDING_MESSAGES_MODE = 0o600;
 const PENDING_ORPHAN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const PENDING_ORPHAN_GRACE_MS = 60 * 60 * 1000;
+// Replay window for genuine user/steering entries. A cross-surface submit is
+// meant for a LIVE owner; if nothing picked it up within this window, firing
+// it into a session resumed hours or days later reads as a surprise
+// self-injection (user report: stale spool messages replayed on re-entry).
+// Crash+restart recovery within the window still replays normally.
+const STALE_USER_INJECTION_TTL_MS = 30 * 60 * 1000;
+
+function isStaleUserInjection(entry, now = Date.now()) {
+    if (isCompletionNotificationEntry(entry)) return false;
+    const enqueuedAt = Number(entry?.enqueuedAt) || 0;
+    return enqueuedAt > 0 && (now - enqueuedAt) > STALE_USER_INJECTION_TTL_MS;
+}
 // Marker for deferred agent/tool *completion* notifications. Such entries must
 // never be replayed into a later turn on session resume (out-of-order delivery
 // is worse than loss — owner decision), so drain discards them. Genuine
@@ -155,11 +167,17 @@ function normalizePendingStore(raw) {
     const out = { version: 1, updatedAt: storeUpdatedAt, sessions: {}, sessionTouchedAt: {} };
     for (const [sid, value] of Object.entries(sessions)) {
         if (!isValidPendingSessionId(sid) || !Array.isArray(value)) continue;
+        // Legacy string entries carry no timestamp of their own. Age them from
+        // the session's last real enqueue (sessionTouchedAt), NOT the store's
+        // updatedAt — the store refreshes on every unrelated write, which made
+        // days-old legacy entries look permanently fresh to the stale gate.
+        const touchedAt = Number(touchedRaw[sid]);
+        const legacyEnqueuedAt = Number.isFinite(touchedAt) && touchedAt > 0 ? touchedAt : storeUpdatedAt;
         const q = isTuiSteeringPendingKey(sid)
             ? value.map(normalizeTuiSteeringQueueEntry).filter(Boolean)
             : value.map((entry, index) => normalizePersistedEntry(entry, {
                 legacyId: legacyPendingMessageId(sid, index, typeof entry === 'string' ? entry : JSON.stringify(entry)),
-                fallbackEnqueuedAt: storeUpdatedAt + index,
+                fallbackEnqueuedAt: legacyEnqueuedAt + index,
             })).filter(Boolean);
         if (q.length > 0) {
             out.sessions[sid] = q;
@@ -469,6 +487,7 @@ export function hydratePendingMessages(sessionId, options = {}) {
       let hydrated = [];
       let alreadyDelivered = [];
       let staleLedgerEntries = [];
+      const staleUserEntries = [];
       const ledgerSession = loadSession(sessionId);
       try {
         const deliveredLedger = new Set(ledgerSession?.deliveredPendingMessageIds || []);
@@ -490,7 +509,16 @@ export function hydratePendingMessages(sessionId, options = {}) {
                     alreadyDelivered.push(entry);
                     return false;
                 }
-                return id && !inDelivery.has(id) && !acked.has(id);
+                if (!id || inDelivery.has(id) || acked.has(id)) return false;
+                // Stale genuine user/steering entries must not surprise-inject
+                // into a session resumed long after they were queued (user:
+                // "re-entering the session suddenly injected old messages").
+                // Completion entries keep their own resume-drop policy.
+                if (isStaleUserInjection(entry)) {
+                    staleUserEntries.push(entry);
+                    return false;
+                }
+                return true;
             });
             // Read-only claim: durable data remains until successful delivery
             // acknowledges these exact ids. A crash here therefore redelivers.
@@ -506,6 +534,11 @@ export function hydratePendingMessages(sessionId, options = {}) {
         const cleaned = await acknowledgePendingMessages(sessionId, alreadyDelivered);
         if (cleaned) cleanupConfirmed.push(...alreadyDelivered);
       }
+      if (staleUserEntries.length > 0) {
+        try { process.stderr.write(`[session] dropped ${staleUserEntries.length} stale queued message(s) (older than ${Math.round(STALE_USER_INJECTION_TTL_MS / 60000)}m) sessionId=${sessionId}\n`); } catch {}
+        const cleaned = await acknowledgePendingMessages(sessionId, staleUserEntries);
+        if (cleaned) cleanupConfirmed.push(...staleUserEntries);
+      }
       if (cleanupConfirmed.length > 0) {
         try {
             // One session save prunes both IDs whose replay spool was removed
@@ -710,6 +743,7 @@ export function drainForeignUserInjections(sessionId) {
         }
     } catch { /* ledger unavailable — in-memory sets still guard */ }
     const taken = [];
+    let droppedStale = 0;
     try {
         updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
             const next = normalizePendingStore(raw);
@@ -723,10 +757,14 @@ export function drainForeignUserInjections(sessionId) {
                     && !isCompletionNotificationEntry(entry)
                     && !isLegacyUnmarkedCompletionNotification(text)
                     && text && !isInternalRuntimeNotificationText(text);
-                if (foreignUser) taken.push(text);
+                // Stale foreign submits are removed WITHOUT injecting: they
+                // were aimed at a live owner that no longer exists (user:
+                // stale spool messages fired on session re-entry days later).
+                if (foreignUser && isStaleUserInjection(entry)) droppedStale += 1;
+                else if (foreignUser) taken.push(text);
                 else kept.push(entry);
             }
-            if (taken.length === 0) return undefined;
+            if (taken.length === 0 && droppedStale === 0) return undefined;
             if (kept.length > 0) next.sessions[sessionId] = kept;
             else {
                 delete next.sessions[sessionId];
@@ -739,6 +777,9 @@ export function drainForeignUserInjections(sessionId) {
         try { process.stderr.write(`[session] foreign-injection drain failed sessionId=${sessionId}: ${err?.message || err}\n`); } catch {}
         return [];
     }
+    if (droppedStale > 0) {
+        try { process.stderr.write(`[session] dropped ${droppedStale} stale foreign submit(s) (older than ${Math.round(STALE_USER_INJECTION_TTL_MS / 60000)}m) sessionId=${sessionId}\n`); } catch {}
+    }
     return taken;
 }
 

package/src/runtime/agent/orchestrator/session/manager/session-crud.mjs

@@ -136,7 +136,17 @@ export async function clearSessionMessages(sessionId, options = {}) {
     // fresh id. Skipped for scratch sessions with no real user turn — nothing
     // worth resuming. Best-effort: any failure here must never block the
     // clear itself (mirrors the pre-compact failure handling above).
-    if (hasUserConversationMessage(messages)) {
+    // ALSO skipped when the clear carries a compact summary forward
+    // (compact_clear/auto-clear): the outgoing transcript is just the compact
+    // product whose content the live session retains via the summary, so the
+    // fork duplicated it as a confusing extra Recent row ("Re-attached after
+    // compaction…" — user report). Plain /clear (no summary kept) still forks.
+    const summaryCarriedForward = keep.some((m) => (
+        m?.role === 'user'
+        && typeof m.content === 'string'
+        && m.content.startsWith(SUMMARY_PREFIX)
+    ));
+    if (hasUserConversationMessage(messages) && !summaryCarriedForward) {
         try {
             const forkId = mintSessionId();
             const fork = {

package/src/runtime/agent/orchestrator/session/store/summary-cache.mjs

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { getPluginData } from '../../config.mjs';
 import { getStoreDir } from './paths-heartbeat.mjs';
 import { _storedSessionFromFile } from './serialize.mjs';
-import { _sessionSummary, _normalizeSummaryIndex, _upsertSessionSummary, _removeSessionSummary, _pruneSummaryIndexIds } from '../store-summary-index.mjs';
+import { _sessionSummary, _normalizeSummaryIndex, _upsertSessionSummaryRow, _removeSessionSummary, _pruneSummaryIndexIds } from '../store-summary-index.mjs';
 
 // Listing is much hotter than writing, especially while the desktop session
 // browser is open. Keep the compact sidecar in memory after the first read;
@@ -12,27 +12,31 @@ import { _sessionSummary, _normalizeSummaryIndex, _upsertSessionSummary, _remove
 // path. Pending overlays cover a write that lands before the first listing.
 export let _summaryRowsCache = null;
 const _summaryCacheUpserts = new Map();
+const _summaryCacheLatestRows = new Map();
 export const _summaryCacheRemovals = new Set();
 export const _summaryCacheVersions = new Map();
 let _summaryCacheDataDir = null;
+let _summaryRowsViewCache = null;
+
+function _invalidateSummaryRowsView() {
+    _summaryRowsViewCache = null;
+}
 
 export function _ensureSummaryCacheDataDir() {
     const dataDir = getPluginData();
     if (_summaryCacheDataDir === dataDir) return;
     _summaryCacheDataDir = dataDir;
     _summaryRowsCache = null;
+    _summaryRowsViewCache = null;
     _summaryScanCache.clear();
     _summaryCacheUpserts.clear();
+    _summaryCacheLatestRows.clear();
     _summaryCacheRemovals.clear();
     _summaryCacheVersions.clear();
 }
 
-function _summaryRowsWithLocalMutations(rows, { discardLocalMutations = false } = {}) {
-    if (discardLocalMutations) {
-        _summaryCacheUpserts.clear();
-        _summaryCacheRemovals.clear();
-    }
-    const byId = new Map(_normalizeSummaryIndex({ rows }).rows.map((row) => [row.id, row]));
+function _summaryRowsWithLocalMutations(rows) {
+    const byId = new Map(rows.map((row) => [row.id, row]));
     for (const id of _summaryCacheRemovals) byId.delete(id);
     for (const [id, row] of _summaryCacheUpserts) byId.set(id, row);
     return [...byId.values()].sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
@@ -41,14 +45,19 @@ function _summaryRowsWithLocalMutations(rows, { discardLocalMutations = false }
 export function _setSummaryRowsCache(rows, options) {
     if (options?.discardLocalMutations === true) {
         _summaryCacheUpserts.clear();
+        _summaryCacheLatestRows.clear();
         _summaryCacheRemovals.clear();
     }
     _summaryRowsCache = _normalizeSummaryIndex({ rows }).rows;
-    return _summaryRowsWithLocalMutations(_summaryRowsCache);
+    _invalidateSummaryRowsView();
+    return _cachedSummaryRows();
 }
 
 export function _cachedSummaryRows() {
-    return _summaryRowsCache === null ? null : _summaryRowsWithLocalMutations(_summaryRowsCache);
+    if (_summaryRowsCache === null) return null;
+    if (_summaryRowsViewCache) return _summaryRowsViewCache;
+    _summaryRowsViewCache = _summaryRowsWithLocalMutations(_summaryRowsCache);
+    return _summaryRowsViewCache;
 }
 
 function _setCachedBaseSummary(row) {
@@ -56,21 +65,26 @@ function _setCachedBaseSummary(row) {
     const byId = new Map(_summaryRowsCache.map((existing) => [existing.id, existing]));
     byId.set(row.id, row);
     _summaryRowsCache = [...byId.values()].sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+    _invalidateSummaryRowsView();
 }
 
 function _removeCachedBaseSummary(id) {
     if (_summaryRowsCache === null) return;
     _summaryRowsCache = _summaryRowsCache.filter((row) => row.id !== id);
+    _invalidateSummaryRowsView();
 }
 
 export function _cacheSessionSummary(session) {
     _ensureSummaryCacheDataDir();
     const row = _sessionSummary(session);
     if (!row) return;
-    _summaryCacheVersions.set(row.id, (_summaryCacheVersions.get(row.id) || 0) + 1);
+    const version = (_summaryCacheVersions.get(row.id) || 0) + 1;
+    _summaryCacheVersions.set(row.id, version);
     _summaryCacheRemovals.delete(row.id);
     _summaryCacheUpserts.set(row.id, row);
-    return _summaryCacheVersions.get(row.id);
+    _summaryCacheLatestRows.set(row.id, { version, row });
+    _invalidateSummaryRowsView();
+    return version;
 }
 
 export function _uncacheSessionSummary(id) {
@@ -78,24 +92,33 @@ export function _uncacheSessionSummary(id) {
     if (!id) return;
     _summaryCacheVersions.set(id, (_summaryCacheVersions.get(id) || 0) + 1);
     _summaryCacheUpserts.delete(id);
+    _summaryCacheLatestRows.delete(id);
     _summaryCacheRemovals.add(id);
+    _invalidateSummaryRowsView();
     _removeCachedBaseSummary(id);
 }
 
 export function _rollbackCachedSessionSummary(id, version) {
     if ((_summaryCacheVersions.get(id) || 0) !== version) return;
     _summaryCacheUpserts.delete(id);
+    _summaryCacheLatestRows.delete(id);
+    _invalidateSummaryRowsView();
 }
 
 export function _queueSessionSummaryUpsert(session, version = null) {
-    const row = _sessionSummary(session);
+    const latest = version === null ? null : _summaryCacheLatestRows.get(session?.id);
+    const row = latest?.version === version ? latest.row : _sessionSummary(session);
     if (!row) return;
     _setCachedBaseSummary(row);
     if (version === null || (_summaryCacheVersions.get(row.id) || 0) === version) {
         _summaryCacheUpserts.delete(row.id);
+        if (_summaryCacheLatestRows.get(row.id)?.version === version) {
+            _summaryCacheLatestRows.delete(row.id);
+        }
         _summaryCacheRemovals.delete(row.id);
+        _invalidateSummaryRowsView();
     }
-    _upsertSessionSummary(session);
+    _upsertSessionSummaryRow(row);
 }
 
 export function _queueSessionSummaryRemoval(id) {