mixdog 0.9.96 → 0.9.97

package/src/runtime/agent/orchestrator/session/eager-dispatch.mjs

@@ -1,11 +1,19 @@
 // Eager tool-dispatch controller, extracted from agent-loop.mjs. Owns the
 // per-turn pending promise map, the intra-turn in-flight signature set, and
-// the mutation epoch. Every valid call may start while the provider is still
-// streaming, including apply_patch and shell in the same batch. Tool-local
-// conflict guards own safety; results are collected later in call order.
+// the mutation epoch. Every valid call dispatches while the provider is still
+// streaming. Calls execute in parallel except that shell after apply_patch
+// waits for every earlier patch in the turn; results are collected later in
+// call order.
 import { normalizeToolEnvelope } from './tool-envelope.mjs';
 import { isInvalidToolArgsMarker } from '../providers/openai-compat-stream.mjs';
-import { _intraTurnSig, _isReadTool, _isScopedCacheableTool, _stripMcpPrefix } from './loop/tool-classify.mjs';
+import {
+    _intraTurnSig,
+    _isMutationTool,
+    _isReadTool,
+    _isScopedCacheableTool,
+    _isShellTool,
+    _stripMcpPrefix,
+} from './loop/tool-classify.mjs';
 import { tryReadCached, tryScopedToolCached } from './read-dedup.mjs';
 import { preDispatchDenyForSession } from './loop/pre-dispatch-deny.mjs';
 import { executeTool } from './loop/tool-exec.mjs';
@@ -18,6 +26,10 @@ export function createEagerDispatcher({
     executeToolFn = executeTool,
 }) {
         const pending = new Map();
+        // Cumulative settlement barrier for patches already emitted in this
+        // assistant turn. Patches remain path-parallel with each other; only a
+        // later shell waits, so validation cannot observe pre-patch files.
+        let patchBarrier = Promise.resolve();
         // Streaming-time intra-turn dedup. When the LLM emits two
         // tool_use blocks with identical (name, args) signatures in
         // sequence, the provider's onToolCall fires for both BEFORE
@@ -90,9 +102,11 @@ export function createEagerDispatcher({
             // this call there, never start it eagerly here.
             if (preDispatchDenyForSession(sessionRef, call, toolKind) !== null) return null;
             const entry = { startedAt: Date.now(), endedAt: null, mutationEpoch: epoch.mutation };
+            const precedingPatches = _isShellTool(call.name) ? patchBarrier : null;
             if (_dedupEligible) _eagerInFlightSigs.set(_sig, call.id);
             entry.promise = (async () => {
                 try {
+                    if (precedingPatches) await precedingPatches;
                     await opts.beforeToolExecution?.();
                     return { ok: true, value: await executeToolFn(call.name, call.arguments, cwd, sessionId, sessionRef, { toolCallId: call.id, signal, notifyFn: opts.notifyFn, toolApprovalHook: opts.onToolApproval, iteration: getNextIteration(), deferShellCwdCommit: true }) };
                 } catch (error) {
@@ -152,6 +166,10 @@ export function createEagerDispatcher({
                     return settled;
                 });
             pending.set(call.id, entry);
+            if (_isMutationTool(call.name)) {
+                const currentPatch = entry.promise;
+                patchBarrier = Promise.allSettled([patchBarrier, currentPatch]).then(() => undefined);
+            }
             return entry;
         };
         const startEagerRun = (calls, startIndex, dupSet) => {

package/src/runtime/agent/orchestrator/session/loop/tool-exec.mjs

@@ -23,6 +23,7 @@ import {
 } from './tool-helpers.mjs';
 import { isOnDeferredToolSurface, prepareDeferredToolCallThrough } from './deferred-call-through.mjs';
 import { preDispatchDenyForSession, routeWebFetchCall } from './pre-dispatch-deny.mjs';
+import { runWithToolExecutionOwner } from '../../../../shared/tool-execution-owner.mjs';
 
 let codeGraphRuntimePromise = null;
 async function executeCodeGraphToolLazy(name, args, cwd, signal = null, options = {}) {
@@ -32,6 +33,11 @@ async function executeCodeGraphToolLazy(name, args, cwd, signal = null, options
     return mod.executeCodeGraphTool(name, args, cwd, signal, options);
 }
 
+export function resolveLiveToolCwd(cwd, sessionRef) {
+    const liveCwd = typeof sessionRef?.cwd === 'string' ? sessionRef.cwd : '';
+    return liveCwd || cwd;
+}
+
 export function _scopedCacheOutcomeForCall(sessionRef, toolCallId, toolName, callerSessionId, executeOpts = {}) {
     if (executeOpts.scopedCacheOutcome) {
         if (sessionRef && toolCallId) {
@@ -51,7 +57,16 @@ export function _scopedCacheOutcomeForCall(sessionRef, toolCallId, toolName, cal
     return outcome;
 }
 
-export async function executeTool(name, args, cwd, callerSessionId, sessionRef, executeOpts = {}) {
+export function executeTool(name, args, cwd, callerSessionId, sessionRef, executeOpts = {}) {
+    return runWithToolExecutionOwner(callerSessionId, () =>
+        executeToolOwned(name, args, cwd, callerSessionId, sessionRef, executeOpts));
+}
+
+async function executeToolOwned(name, args, cwd, callerSessionId, sessionRef, executeOpts = {}) {
+    // cwd is captured when the turn starts. The deferred cwd tool updates
+    // sessionRef.cwd in place, so every later tool call must re-read that live
+    // value instead of continuing to use the stale turn snapshot.
+    cwd = resolveLiveToolCwd(cwd, sessionRef);
     const scopedCacheOutcome = _scopedCacheOutcomeForCall(
         sessionRef,
         executeOpts.toolCallId,
@@ -174,7 +189,10 @@ export async function executeTool(name, args, cwd, callerSessionId, sessionRef,
             && mcpToolHasField(name, 'cwd')
             && (args == null || args.cwd == null);
         const finalArgs = needsCwdInjection ? { ...(args || {}), cwd } : args;
-        return executeMcpTool(name, finalArgs);
+        return executeMcpTool(name, finalArgs, {
+            signal: executeOpts.signal || null,
+            ownerKey: callerSessionId,
+        });
     }
     if (name === 'code_graph') {
         // cwd chain: args.cwd (caller-explicit) → session cwd → undefined (handler throws)

package/src/runtime/agent/orchestrator/session/loop/tool-helpers.mjs

@@ -40,9 +40,10 @@ export function isEagerDispatchable(name, tools) {
     return set.has(name);
 }
 
-// Full-parallel dispatch policy: EVERY valid tool call in an assistant turn
-// starts immediately. Mutations rely on their own conflict scope (apply_patch
-// uses per-path locks), so disjoint writes never wait behind a global barrier.
+// Full dispatch policy: EVERY valid tool call in an assistant turn is queued
+// immediately. Mutations rely on their own conflict scope (apply_patch uses
+// per-path locks); the eager dispatcher adds only the apply_patch -> shell
+// execution barrier required for same-turn validation.
 // isEagerDispatchable above remains the READ-ONLY classifier used for dedup
 // eligibility, steering, and post-mutation result invalidation.
 export function isParallelDispatchable(name) {

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

@@ -67,6 +67,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 +207,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 +320,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 +481,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`;
@@ -574,7 +586,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 +778,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 +913,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 +1058,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 +1103,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 +1138,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/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/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/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,
     };
 }