mixdog 0.9.96 → 0.9.99

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

@@ -9,6 +9,7 @@ import { readStreamOutcome } from '../../providers/lib/stream-outcome.mjs';
 import { normalizeCompactType, DEFAULT_COMPACT_TYPE } from '../compact.mjs';
 import { loadSession, saveSession, saveSessionAsync, saveSessionAsyncDeferred, readSessionLifecycleFromDisk } from '../store.mjs';
 import { createAbortController } from '../../../../shared/abort-controller.mjs';
+import { estimateJsonBytes } from '../../../../shared/json-metrics.mjs';
 import { logLlmCall } from '../../../../shared/llm/usage-log.mjs';
 import { appendAgentTrace } from '../../agent-trace.mjs';
 import { recordStandaloneStatusTelemetry } from './status-telemetry.mjs';
@@ -67,6 +68,17 @@ import {
 import { _getAgentLoop } from './runtime-loaders.mjs';
 import { getAgentRuntimeSync } from './agent-runtime-singleton.mjs';
 import { recordProviderContextBaseline } from '../loop/compact-policy.mjs';
+import { runAbortable, settleWithin, throwIfAborted } from '../../../../shared/abort-race.mjs';
+
+export const DEFAULT_ASK_CLEANUP_SETTLE_MS = 2_000;
+
+export async function settleAskCleanup(promise, { timeoutMs } = {}) {
+    const configured = Number(process.env.MIXDOG_ASK_CLEANUP_SETTLE_MS);
+    const budget = Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0
+        ? Number(timeoutMs)
+        : (Number.isFinite(configured) && configured > 0 ? configured : DEFAULT_ASK_CLEANUP_SETTLE_MS);
+    return await settleWithin(promise, budget);
+}
 
 export function persistedAssistantTranscriptMetadata(value, fallbackAt = Date.now()) {
     if (!value || typeof value !== 'object') return null;
@@ -196,7 +208,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
     if (process.env.MIXDOG_DEBUG_AGENT) {
         process.stderr.write(`[agent-trace] t0-ask-start sessionHash=${createHash('sha256').update(String(sessionId)).digest('hex').slice(0, 8)} role=? iteration=0 promptSrc=${_promptSrc} prefetchFiles=${_prefetchFiles} callers=${_prefetchCallers} references=${_prefetchRefs}\n`);
     }
-    const unlock = await acquireSessionLock(sessionId);
+    const unlock = await acquireSessionLock(sessionId, askOpts?.signal);
     // Start crash-spool hydration without delaying the user turn. A completed
     // background hydration joins the id-deduped memory drain below.
     const takeoverHydration = hydratePendingMessages(sessionId);
@@ -309,9 +321,10 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         // computation would run detached. Capture the linked signal, install the
         // fresh controller, then re-cascade it — aborting the new controller
         // immediately when the parent already fired, or re-arming the listener.
-        const _linkedParentSignal = runtime.parentAbortLink?.signal;
+        const _linkedParentSignal = askOpts?.signal || runtime.parentAbortLink?.signal;
         // Fresh controller per ask — the previous ask's controller may have aborted.
         runtime.controller = createAbortController();
+        const turnSignal = runtime.controller.signal;
         runtime.generation = askGeneration;
         runtime.closed = false;
         runtime.session = preSession;
@@ -469,7 +482,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // even to the real task. Single-turn structure with a labelled
             // `# Task` block forces the model to treat the brief as the work
             // unit, not as another piece of context to ack.
-            const explicitPrefetchResult = await _tryBridgeExplicitPrefetch(session, explicitPrefetch);
+            const explicitPrefetchResult = await _tryBridgeExplicitPrefetch(session, explicitPrefetch, turnSignal);
             let _contextBlock = '';
             if (context) {
                 _contextBlock += `# Additional context\n${_capCtx(context)}\n\n`;
@@ -556,7 +569,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 const _prefetchBytes = Buffer.byteLength(explicitPrefetchResult || '', 'utf8');
                 const _promptBytes = promptContentBytes(prompt);
                 const _userTurnBytes = promptContentBytes(_userTurnContent);
-                const _messagesBytes = Buffer.byteLength(JSON.stringify(historyMessages || []), 'utf8');
+                const _messagesBytes = estimateJsonBytes(historyMessages || []);
                 const _totalBytes = _userTurnBytes + _messagesBytes;
                 appendAgentTrace({
                     kind: 'context',
@@ -574,7 +587,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     },
                 });
             } catch { /* trace must never break the ask path */ }
-            const agentLoop = await _getAgentLoop();
+            const agentLoop = await runAbortable(turnSignal, () => _getAgentLoop());
             const _trackTextDelta = (chunk) => {
                 _turnInterruption.recordTextDelta(chunk);
                 _scheduleTurnCheckpoint();
@@ -766,6 +779,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     session.toolApprovalHook = priorToolApprovalHook;
                 }
             }
+            throwIfAborted(turnSignal);
             // Post-loop validation: if closeSession() landed while we were awaiting,
             // drop the save so the tombstone on disk isn't overwritten.
             const currentRuntime = _getRuntimeEntry(sessionId);
@@ -900,7 +914,10 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 // Unified total-prompt field. Anthropic = input+cache_read+cache_write
                 // (additive); OpenAI OAuth/API/Gemini = input_tokens already includes the
                 // cached portion (inclusive), so the fallback must not double-count.
-                const { isInclusiveProvider, computeCostUsd } = await import('../../../../shared/llm/cost.mjs');
+                const { isInclusiveProvider, computeCostUsd } = await runAbortable(
+                    turnSignal,
+                    () => import('../../../../shared/llm/cost.mjs'),
+                );
                 const inclusive = isInclusiveProvider(session.provider);
                 const promptTokens = typeof result.usage.promptTokens === 'number'
                     ? result.usage.promptTokens
@@ -1042,15 +1059,14 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                         }
                         try {
                             const durableSave = saveSessionAsync(activeSession, { expectedGeneration: askGeneration });
-                            if (finalized.responsePreserved) {
-                                await finalizePendingMessageDelivery(
+                            const cleanup = finalized.responsePreserved
+                                ? finalizePendingMessageDelivery(
                                     activeSession, _turnPendingEntries, durableSave,
                                     () => saveSessionAsync(activeSession, { expectedGeneration: askGeneration }),
-                                );
-                            } else {
-                                await durableSave;
-                            }
-                            clearTurnCheckpoint(sessionId, _turnCheckpointToken);
+                                )
+                                : durableSave;
+                            const cleanupResult = await settleAskCleanup(cleanup);
+                            if (cleanupResult.settled) clearTurnCheckpoint(sessionId, _turnCheckpointToken);
                         } catch { /* cancellation cleanup is best-effort */ }
                         if (currentRuntime) currentRuntime.session = activeSession;
                     } else releasePendingMessages(sessionId, _turnPendingEntries);
@@ -1088,35 +1104,34 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 else releasePendingMessages(sessionId, _turnPendingEntries);
                 try {
                     const durableSave = saveSessionAsync(activeSession, { expectedGeneration: askGeneration });
-                    if (finalized.responsePreserved) {
-                        await finalizePendingMessageDelivery(
+                    const cleanup = finalized.responsePreserved
+                        ? finalizePendingMessageDelivery(
                             activeSession, _turnPendingEntries, durableSave,
                             () => saveSessionAsync(activeSession, { expectedGeneration: askGeneration }),
-                        );
-                    } else {
-                        await durableSave;
-                    }
-                    _errorStateDurable = true;
+                        )
+                        : durableSave;
+                    _errorStateDurable = (await settleAskCleanup(cleanup)).settled;
                 } catch { /* provider-failure history persistence is best-effort */ }
                 const currentRuntime = _getRuntimeEntry(sessionId);
                 if (currentRuntime) currentRuntime.session = activeSession;
             } else {
-                const promptPersisted = await persistCompactedOutgoingAfterAskFailure({
+                const compactPersist = await settleAskCleanup(persistCompactedOutgoingAfterAskFailure({
                     sessionId,
                     activeSession,
                     askGeneration,
                     turnOutgoing: _turnOutgoing,
                     error: err,
-                });
+                }));
+                const promptPersisted = compactPersist.settled && compactPersist.value === true;
                 if (promptPersisted) {
                     recordPendingMessageDelivery(activeSession, _turnPendingEntries);
                     try {
                         const durableSave = saveSessionAsync(activeSession, { expectedGeneration: askGeneration });
-                        await finalizePendingMessageDelivery(
+                        const cleanup = finalizePendingMessageDelivery(
                             activeSession, _turnPendingEntries, durableSave,
                             () => saveSessionAsync(activeSession, { expectedGeneration: askGeneration }),
                         );
-                        _errorStateDurable = true;
+                        _errorStateDurable = (await settleAskCleanup(cleanup)).settled;
                     } catch {}
                 } else {
                     releasePendingMessages(sessionId, _turnPendingEntries);
@@ -1124,8 +1139,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             }
             if (!_errorStateDurable && activeSession) {
                 try {
-                    await saveSessionAsync(activeSession, { expectedGeneration: askGeneration });
-                    _errorStateDurable = true;
+                    _errorStateDurable = (await settleAskCleanup(
+                        saveSessionAsync(activeSession, { expectedGeneration: askGeneration }),
+                    )).settled;
                 } catch { /* retain checkpoint when canonical persistence fails */ }
             }
             if (_errorStateDurable) clearTurnCheckpoint(sessionId, _turnCheckpointToken);

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -77,8 +77,7 @@ function addCompactUsageToSession(session, usage) {
     session.totalUncachedInputTokens = (session.totalUncachedInputTokens || 0) + uncachedInputTokens;
     session.tokensCumulative = (session.tokensCumulative || 0) + inputTokens + outputTokens;
 }
-// A dead/unreachable memory runtime makes each proxy RPC wait ~30s (waitForPort)
-// and retry once (memory-runtime-proxy.mjs) — that must NEVER wedge the
+// A stalled memory call must NEVER wedge the
 // compact//clear path. Bound every recall-fasttrack memory call with a short
 // local timeout: on timeout we abort (best-effort cancel via a chained signal)
 // and treat it exactly like an RPC failure, so compaction proceeds WITHOUT
@@ -93,7 +92,7 @@ function recallMemoryTimeoutMs(session) {
     // misconfigured tiny value can't turn the bound into a busy no-wait.
     return Math.max(250, configured || RECALL_MEMORY_CALL_TIMEOUT_MS);
 }
-// Cold-start allowance (clear/manual path only): a booting memory daemon can
+// Cold-start allowance (clear/manual path only): a booting memory runtime can
 // miss the tight first bound (waitForPort + first-RPC warmup ~2-10s). On a
 // timeout we retry ONCE with a longer bound before honoring the bail-to-
 // semantic contract, so a rebooting runtime succeeds instead of instantly

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

@@ -355,6 +355,9 @@ function normalizePendingMessageEntry(entry) {
         id: pendingMessageId(entry),
         enqueuedAt: Number(entry.enqueuedAt) || Date.now(),
     };
+    const entryOptions = entry.options && typeof entry.options === 'object'
+        ? { options: entry.options }
+        : {};
     const marker = entry.notificationKind === COMPLETION_NOTIFICATION_KIND
         ? { notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: Number(entry.enqueuedAt) || Date.now() }
         : null;
@@ -366,13 +369,13 @@ function normalizePendingMessageEntry(entry) {
     if (content == null) return null;
     const text = typeof entry.text === 'string' ? entry.text.trim() : promptContentText(content).trim();
     let out = null;
-    if (Array.isArray(content)) out = content.length > 0 ? { content, text } : null;
+    if (Array.isArray(content)) out = content.length > 0 ? { content, text, ...entryOptions } : null;
     else if (typeof content === 'string') {
         const value = content.trim();
-        out = value ? { content: value, text: text || value } : null;
+        out = value ? { content: value, text: text || value, ...entryOptions } : null;
     } else {
         const fallback = promptContentText(content).trim();
-        out = fallback ? { content: fallback, text: text || fallback } : null;
+        out = fallback ? { content: fallback, text: text || fallback, ...entryOptions } : null;
     }
     if (!out) return null;
     // The lifecycle token rides along every derived copy (see carryLifecycleToken).
@@ -394,7 +397,12 @@ function pendingMessageQueueEntry(entry) {
     const marker = isCompletionNotificationEntry(normalized)
         ? { notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: normalized.enqueuedAt }
         : null;
-    const base = { ...identity, content: normalized.content, text: normalized.text || promptContentText(normalized.content).trim() };
+    const base = {
+        ...identity,
+        content: normalized.content,
+        text: normalized.text || promptContentText(normalized.content).trim(),
+        ...(normalized.options ? { options: normalized.options } : {}),
+    };
     return carryLifecycleToken(marker ? { ...base, ...marker } : base, entry);
 }
 
@@ -427,6 +435,20 @@ function normalizePersistedEntry(entry, options = {}) {
         const message = entry.message.trim();
         return message ? { id, message, enqueuedAt } : null;
     }
+    if (Object.prototype.hasOwnProperty.call(entry, 'content')) {
+        const normalized = normalizePendingMessageEntry(entry);
+        if (!normalized) return null;
+        if (typeof normalized.content === 'string' && !normalized.options) {
+            return { id, message: normalized.text || normalized.content, enqueuedAt };
+        }
+        return {
+            id,
+            content: normalized.content,
+            text: normalized.text,
+            ...(normalized.options ? { options: normalized.options } : {}),
+            enqueuedAt,
+        };
+    }
     const t = pendingMessageText(entry);
     return t ? { id, message: t, enqueuedAt } : null;
 }
@@ -1195,10 +1217,26 @@ async function _flushForeignDrainBatch() {
                         && !isCompletionNotificationEntry(entry)
                         && !isLegacyUnmarkedCompletionNotification(text)
                         && text && !isInternalRuntimeNotificationText(text);
+                    const normalized = normalizePendingMessageEntry(entry);
+                    const structured = Array.isArray(normalized?.content) || Boolean(normalized?.options);
                     if (foreignUser && isStaleUserInjection(entry)) {
-                        taken.push({ text: lateDeliveryText(text, entry), id });
+                        const lateText = lateDeliveryText(text, entry);
+                        const content = Array.isArray(normalized?.content)
+                            ? [{ type: 'text', text: `${lateText.slice(0, lateText.length - text.length)}` }, ...normalized.content]
+                            : lateText;
+                        taken.push({
+                            ...(structured ? { content } : {}),
+                            text: lateText,
+                            id,
+                            ...(normalized?.options ? { options: normalized.options } : {}),
+                        });
                     } else if (foreignUser) {
-                        taken.push({ text, id });
+                        taken.push({
+                            ...(structured ? { content: normalized?.content ?? text } : {}),
+                            text,
+                            id,
+                            ...(normalized?.options ? { options: normalized.options } : {}),
+                        });
                     } else {
                         kept.push(entry);
                     }

package/src/runtime/agent/orchestrator/session/manager/prefetch-bridge.mjs

@@ -6,8 +6,10 @@ import { executeInternalTool } from '../../internal-tools.mjs';
 import { classifyResultKind } from '../result-classification.mjs';
 import { tryPrefetchCached, setPrefetchCached } from '../read-dedup.mjs';
 import { _executeCodeGraphToolLazy } from './runtime-loaders.mjs';
+import { runAbortable, throwIfAborted } from '../../../../shared/abort-race.mjs';
 
-export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
+export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch, signal = null) {
+    throwIfAborted(signal);
     if (!explicitPrefetch || typeof explicitPrefetch !== 'object') return null;
     if (!isAgentOwner(session)) return null;
     const parts = [];
@@ -52,7 +54,10 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
         totalEntries.push(...files);
         // R20: per-file prefetch cache (cross-dispatch, process-local).
         // Try each file from cache first; batch misses into one disk read.
-        const { resolve: _pfResolve, isAbsolute: _pfIsAbs, normalize: _pfNorm } = await import('path');
+        const { resolve: _pfResolve, isAbsolute: _pfIsAbs, normalize: _pfNorm } = await runAbortable(
+            signal,
+            () => import('path'),
+        );
         const _pfCwd = session.cwd || null;
         function _pfAbsPath(f) {
             const abs = _pfIsAbs(f) ? f : _pfResolve(_pfCwd || process.cwd(), f);
@@ -79,7 +84,7 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
         if (missFiles.length > 0) {
             // Read each miss file individually so we can cache per-file.
             // The files list is small (typically 2-5), so N awaits is fine.
-            await Promise.all(missFiles.map(async (f) => {
+            await runAbortable(signal, () => Promise.all(missFiles.map(async (f) => {
                 const opts = _readOptsByFile.get(f) || {};
                 const readArgs = { path: f };
                 if (opts.mode === 'full') {
@@ -95,7 +100,7 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
                 if (out !== null) {
                     missResults[f] = String(out);
                 }
-            }));
+            })));
             // Cache successful miss results.
             for (const { file, abs } of fileMisses) {
                 const content = missResults[file];
@@ -157,7 +162,7 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
                     return { symbol, out: null };
                 });
         });
-        const callerResults = await Promise.allSettled(callerTasks);
+        const callerResults = await runAbortable(signal, () => Promise.allSettled(callerTasks));
         for (const r of callerResults) {
             const { symbol, out } = r.status === 'fulfilled' ? r.value : { symbol: '?', out: null };
             if (out && classifyResultKind(String(out)) !== 'error') {
@@ -182,7 +187,7 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
                     return { symbol, out: null };
                 });
         });
-        const refResults = await Promise.allSettled(refTasks);
+        const refResults = await runAbortable(signal, () => Promise.allSettled(refTasks));
         for (const r of refResults) {
             const { symbol, out } = r.status === 'fulfilled' ? r.value : { symbol: '?', out: null };
             if (out && classifyResultKind(String(out)) !== 'error') {
@@ -192,6 +197,7 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
             }
         }
     }
+    throwIfAborted(signal);
     if (session && typeof session === 'object' && (callers.length > 0 || references.length > 0)) {
         if (!session.prefetchStats) session.prefetchStats = { files: 0, cached: 0, miss: 0, failed: 0, callers: 0, references: 0 };
         session.prefetchStats.callers = (session.prefetchStats.callers || 0) + callers.length;

package/src/runtime/agent/orchestrator/session/manager/prompt-utils.mjs

@@ -4,13 +4,14 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { isInternalRuntimeNotificationText as contractIsInternalRuntimeNotificationText } from '../../../../shared/tool-execution-contract.mjs';
 import { SUMMARY_PREFIX } from '../compact.mjs';
+import { attachmentTextForPart, isAttachmentReference } from '../../../../attachments/store.mjs';
 
 export function promptContentText(content) {
     if (typeof content === 'string') return content;
     if (Array.isArray(content)) {
         return content.map((part) => {
             if (typeof part === 'string') return part;
-            if (part?.type === 'text') return part.text || '';
+            if (part?.type === 'text') return isAttachmentReference(part) ? attachmentTextForPart(part) : (part.text || '');
             if (part?.type === 'image') return '[Image]';
             return part?.text || '';
         }).filter(Boolean).join('\n');

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

@@ -2,8 +2,10 @@
 // Per-session mutex extracted verbatim from manager.mjs. Queues concurrent
 // askSession calls (and their drained pending-message tail turns) to prevent
 // message loss / interleaving.
+import { abortReason } from '../../../../shared/abort-race.mjs';
+
 const _sessionLocks = new Map();
-export function acquireSessionLock(sessionId) {
+export function acquireSessionLock(sessionId, signal = null) {
     let entry = _sessionLocks.get(sessionId);
     if (!entry) {
         entry = { promise: Promise.resolve(), count: 0 };
@@ -15,9 +17,43 @@ export function acquireSessionLock(sessionId) {
     entry.promise = new Promise(r => { release = r; });
     // Self-heal: if the previous holder rejected, swallow so subsequent
     // queued waiters don't propagate that rejection and brick the lock chain.
-    return prev.catch(() => {}).then(() => () => {
+    const previousReady = prev.catch(() => {});
+    let slotReleased = false;
+    const releaseSlot = () => {
+        if (slotReleased) return;
+        slotReleased = true;
         entry.count--;
         if (entry.count === 0) _sessionLocks.delete(sessionId);
         release();
+    };
+    const unlock = () => releaseSlot();
+    if (!signal) return previousReady.then(() => unlock);
+
+    // A cancelled waiter must reject immediately without opening a hole in the
+    // mutex. Its reserved slot is skipped only after the previous holder exits,
+    // so later waiters still cannot overlap the live owner.
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const removeAbort = () => {
+            try { signal.removeEventListener('abort', onAbort); } catch {}
+        };
+        const onAbort = () => {
+            if (settled) return;
+            settled = true;
+            removeAbort();
+            void previousReady.then(releaseSlot);
+            reject(abortReason(signal, `Session "${sessionId}" lock wait aborted`));
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted) {
+            onAbort();
+            return;
+        }
+        previousReady.then(() => {
+            if (settled) return;
+            settled = true;
+            removeAbort();
+            resolve(unlock);
+        });
     });
 }

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

@@ -4,12 +4,9 @@ import { renameWithRetrySync } from '../../../../shared/atomic-file.mjs';
 import { sanitizeContentForStoredHistory } from '../../providers/media-normalization.mjs';
 import { readTopLevelLifecycleRecord, isLifecycleUnreadable } from '../lifecycle-scan.mjs';
 
-// The live in-memory session (and every model request)
-// retains attached image bytes across turns so multi-turn recognition works.
-// The persisted session JSON, however, replaces image content with a short
-// text placeholder at serialization time — keeping session files small without
-// starving the model of the image mid-conversation. Returns the same object
-// reference when nothing changed (no-image sessions pay only a shallow scan).
+// Inline legacy media is replaced with placeholders on disk. New prompt media
+// already arrives as durable content-addressed refs, so session JSON stays small
+// while provider lowering can still resolve it across turns.
 // Per-message disk projection shared by _sessionForDisk and the save-worker
 // delta path (tail-only projection). Returns the SAME array reference when no
 // message changed. Idempotent: already-sanitized content passes through

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

@@ -121,7 +121,11 @@ export function _queueSessionSummaryUpsert(session, version = null) {
  */
 export function _queueSessionSummaryUpsertRow(row, version = null) {
     if (!row) return;
-    _setCachedBaseSummary(row);
+    const fileProbe = probePath(join(getStoreDir(), `${row.id}.json`));
+    const durableRow = fileProbe.state === PROBE_PRESENT
+        ? { ...row, storageMtimeMs: fileProbe.mtimeMs, storageSize: fileProbe.size }
+        : row;
+    _setCachedBaseSummary(durableRow);
     if (version === null || (_summaryCacheVersions.get(row.id) || 0) === version) {
         _summaryCacheUpserts.delete(row.id);
         if (_summaryCacheLatestRows.get(row.id)?.version === version) {
@@ -130,7 +134,7 @@ export function _queueSessionSummaryUpsertRow(row, version = null) {
         _summaryCacheRemovals.delete(row.id);
         _invalidateSummaryRowsView();
     }
-    _upsertSessionSummaryRow(row);
+    _upsertSessionSummaryRow(durableRow);
 }
 
 export function _queueSessionSummaryRemoval(id) {
@@ -220,7 +224,10 @@ export function _scanStoredSessionSummaryRows() {
             else markInvalid(f);
             continue;
         }
-        const row = session ? _sessionSummary(session) : null;
+        const summary = session ? _sessionSummary(session) : null;
+        const row = summary
+            ? { ...summary, storageMtimeMs: fileProbe.mtimeMs, storageSize: fileProbe.size }
+            : null;
         _summaryScanCache.set(f, { mtimeMs: fileProbe.mtimeMs, size: fileProbe.size, row });
         changed = true;
         if (row) rows.push(row);

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

@@ -154,6 +154,8 @@ export function _sessionSummary(session) {
         preview: messageProjection.preview,
         generation: typeof session.generation === 'number' ? session.generation : 0,
         implicitBashSessionId: session.implicitBashSessionId || null,
+        storageMtimeMs: _positiveNumber(session.storageMtimeMs, 0),
+        storageSize: _positiveNumber(session.storageSize, 0),
         // Lifecycle provenance for catalog filters: resume-machinery scratch
         // forks (detachedReason='cli-resume') must never surface in Recent.
         detachedReason: session.detachedReason || null,
@@ -190,6 +192,8 @@ function _normalizeSummaryRow(row) {
         preview: _cleanPreview(row.preview || ''),
         generation: typeof row.generation === 'number' ? row.generation : 0,
         implicitBashSessionId: row.implicitBashSessionId || null,
+        storageMtimeMs: _positiveNumber(row.storageMtimeMs, 0),
+        storageSize: _positiveNumber(row.storageSize, 0),
         detachedReason: row.detachedReason || null,
     };
 }