mixdog 0.9.95 → 0.9.97

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/runtime-loaders.mjs

@@ -17,6 +17,10 @@ export async function _getAgentLoop() {
     if (typeof mod.agentLoop !== 'function') throw new Error('agent loop runtime is not available');
     return mod.agentLoop;
 }
+export async function prewarmAgentLoop() {
+    await _getAgentLoop();
+    return true;
+}
 export function _closeBashSessionLazy(sessionId, reason) {
     if (!sessionId) return;
     _bashSessionRuntimePromise ??= import('../../tools/bash-session.mjs');

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

@@ -6,7 +6,7 @@ import { loadSession, saveSessionAsync, setLiveSession, evictLiveSession, listSt
 import { estimateMessagesTokens, estimateTranscriptContextUsage } from '../context-utils.mjs';
 import { normalizeCompactType, DEFAULT_COMPACT_TYPE, SUMMARY_PREFIX } from '../compact.mjs';
 import { runSessionCompaction } from './compaction-runner.mjs';
-import { hasUserConversationMessage } from './prompt-utils.mjs';
+import { hasUserConversationMessage, promptContentText } from './prompt-utils.mjs';
 import { getProvider } from '../../providers/registry.mjs';
 import { isSessionCompactionBlocked, getSessionAbortSignal, _runtimeEntries } from './runtime-liveness.mjs';
 import { mintSessionId } from './session-id.mjs';
@@ -314,3 +314,33 @@ export async function updateSessionStatus(id, status) {
     await saveSessionAsync(session, { expectedGeneration: session.generation });
     return true;
 }
+
+// --- Rewind to a previous user message (message selector) ---
+// Claude Code's "restore conversation": the selected prompt and everything
+// after it leave the model history so the user can edit and resubmit it.
+// Earlier turns — including any compaction rewrite that precedes them — stay
+// exactly as they are. Idle-only; the caller interrupts a live turn first.
+export async function rewindSessionMessagesTo(sessionId, options = {}) {
+    const session = loadSession(sessionId);
+    if (!session || session.closed === true) return null;
+    const target = String(options?.text ?? '').trim();
+    if (!target) return null;
+    const messages = Array.isArray(session.messages) ? session.messages : [];
+    let start = -1;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.role !== 'user') continue;
+        if (promptContentText(message.content).trim() !== target) continue;
+        start = index;
+        break;
+    }
+    if (start < 0) return null;
+    const removed = messages.length - start;
+    session.messages = messages.slice(0, start);
+    // The provider cache is keyed on the exact prefix we just truncated.
+    session.providerState = undefined;
+    session.updatedAt = Date.now();
+    session.lastUsedAt = Date.now();
+    await saveSessionAsync(session, { expectedGeneration: session.generation });
+    return { removed, remaining: session.messages.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/manager/turn-interruption.mjs

@@ -41,18 +41,25 @@ function assistantToolCallIds(message) {
     return ids;
 }
 
-function rewindProvisionalUserTurn(messages, currentUserContent) {
+function provisionalUserTurnIndex(messages, currentUserContent) {
     const currentText = promptContentText(currentUserContent);
     for (let i = messages.length - 1; i >= 0; i -= 1) {
         const message = messages[i];
         if (message?.role !== 'user') continue;
         if (message.content === currentUserContent
             || promptContentText(message.content) === currentText) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+function rewindProvisionalUserTurn(messages, currentUserContent) {
+    const index = provisionalUserTurnIndex(messages, currentUserContent);
+    if (index >= 0) {
             // Remove the provisional user turn plus pre-send hooks appended
             // after it, while retaining any compaction rewrite before it.
-            messages.splice(i);
-            break;
-        }
+        messages.splice(index);
     }
     return messages;
 }
@@ -69,13 +76,26 @@ function finalizeInterruptedTurn({
     abortReason,
 }) {
     const messages = filterModelVisibleSessionMessages(turnOutgoing).slice();
+    // Null/unknown reasons keep the legacy rewind (status quo for wrapped
+    // aborts without a closeReason enum); named non-user reasons preserve.
+    const userCancelled = abortReason == null
+        || USER_CANCEL_ABORT_REASONS.has(abortReason);
+    // Claude Code parity: a turn cancelled while the model was only THINKING
+    // produced no model-visible message, so the provisional user turn is
+    // rewound and the prompt goes back to the input box. Anything the model
+    // actually said or did — committed messages from this turn, buffered text,
+    // tool calls/results — keeps the turn (reasoning alone does not).
+    const producedOutput = String(partialAssistantContent || '').trim() !== ''
+        || observedToolCalls.size > 0
+        || observedToolResults.size > 0
+        || (() => {
+            const index = provisionalUserTurnIndex(messages, currentUserContent);
+            return index >= 0 && index < messages.length - 1;
+        })();
     const preserveResponse = responseStarted
-        && !isInternalRuntimeNotificationText(currentUserContent);
+        && !isInternalRuntimeNotificationText(currentUserContent)
+        && (producedOutput || !userCancelled);
     if (!preserveResponse) {
-        // Null/unknown reasons keep the legacy rewind (status quo for wrapped
-        // aborts without a closeReason enum); named non-user reasons preserve.
-        const userCancelled = abortReason == null
-            || USER_CANCEL_ABORT_REASONS.has(abortReason);
         if (!userCancelled) {
             return {
                 messages,

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

@@ -101,6 +101,7 @@ export {
 // ── Session lifecycle / ask / crud / close / cleanup ──────────────────────
 export { SessionClosedError } from './manager/session-errors.mjs';
 export { setAgentRuntime } from './manager/agent-runtime-singleton.mjs';
+export { prewarmAgentLoop } from './manager/runtime-loaders.mjs';
 export {
     createSession,
     updateSessionRoute,
@@ -120,6 +121,7 @@ export {
     listSessions,
     findSessionByScopeKey,
     clearSessionMessages,
+    rewindSessionMessagesTo,
     compactSessionMessages,
     updateSessionStatus,
     updateSessionGeneratedTitle,

package/src/runtime/agent/orchestrator/session/result-classification.mjs

@@ -96,3 +96,68 @@ export function isInformationalShellExitOne(result) {
     if (payload.startsWith('[stderr') || payload.includes('\n[stderr')) return false;
     return true;
 }
+
+/**
+ * Shell-result outcome test. The shell tool reports failure through its OWN
+ * status markers (bash-tool.mjs `_shellFailureStatus`): `Error:
+ * [shell-run-failed] …`, `Error: [shell-tool-failed] …`, or a bare
+ * `[exit code: N]` / `[timeout: …]` / `[signal: …]` marker — optionally behind
+ * ⚠️ destructive-warning lines, which are prepended AFTER the error prefix is
+ * composed. A generic leading `Error:` is NOT a shell failure: it is just as
+ * likely the command's own stdout, which is why classifyResultKind (correct
+ * for tools that own the `Error:` convention) over-reports on shell output.
+ *
+ * @param {unknown} result
+ * @returns {boolean}
+ */
+export function isShellFailureResult(result) {
+    if (typeof result !== 'string') return false;
+    const body = result.replace(/^(?:\s*⚠️[^\n]*\n)+/, '').trimStart();
+    if (/^error:\s*\[shell-(?:run|tool)-failed\]/i.test(body)) return true;
+    return /^\[(?:exit code:|timeout:|signal:)/i.test(body);
+}
+
+// Evidence that a command's OUTPUT reports a real failure. Used to separate a
+// legitimate non-zero exit (a probe or report that prints its result and ends
+// with 1) from a genuine failure that happens to write only to stdout — test
+// runners, compilers and package managers all announce themselves in the text.
+// Deliberately literal: only well-known failure banners count, so an unknown
+// tool's report is never mislabelled a failure.
+const SHELL_OUTPUT_FAILURE_EVIDENCE = [
+    /^not ok \d/m,
+    /^# fail [1-9]/m,
+    /\bAssertionError\b/,
+    /\bTraceback \(most recent call last\)/,
+    /^npm ERR!/m,
+    /\berror TS\d+\b/,
+    // Indented banners count too: runners print "  FAIL <case>" under a header.
+    /^\s*FAIL(?:ED|URE)?\b/mi,
+    /\bFAILED[:!]/,
+    /^\s*✗/m,
+    /\b\d+ (?:tests? )?failed\b/i,
+    /^fatal:/m,
+    /^error:/mi,
+    /\bSyntaxError\b|\bReferenceError\b|\bTypeError\b/,
+    /\bCannot find module\b/,
+];
+export function shellOutputReportsFailure(text) {
+    const body = String(text ?? '');
+    if (!body.trim()) return false;
+    return SHELL_OUTPUT_FAILURE_EVIDENCE.some((pattern) => pattern.test(body));
+}
+
+/**
+ * Classify a non-zero shell exit as a real failure or a legitimate report.
+ * Legitimate: exit code 1 exactly, no signal, NOTHING on stderr, real output
+ * on stdout, and no failure banner in that output. Everything else — any other
+ * exit code, a signal, any stderr, an empty capture, or a failure banner —
+ * stays a failure.
+ */
+export function isLegitimateShellExit({ exitCode, signal, stdout, stderr } = {}) {
+    if (signal) return false;
+    if (exitCode !== 1) return false;
+    if (String(stderr ?? '').trim()) return false;
+    const out = String(stdout ?? '').trim();
+    if (!out || out === '(no output)') return false;
+    return !shellOutputReportsFailure(out);
+}

package/src/runtime/agent/orchestrator/session/send-with-recovery.mjs

@@ -5,13 +5,19 @@
 // pass), and unrecoverable errors throw. Behavior identical to the inline
 // try/catch it replaced.
 import { appendAgentTrace } from '../agent-trace.mjs';
-import { classifyError, isContextOverflowError } from '../providers/retry-classifier.mjs';
+import {
+    classifyError,
+    isContextOverflowError,
+    isNonTerminalStreamClose,
+    jitterDelayMs,
+} from '../providers/retry-classifier.mjs';
 import { setTimeout as sleepMs } from 'timers/promises';
 import { readStreamOutcome } from '../providers/lib/stream-outcome.mjs';
 import { resolveWorkerCompactPolicy } from './loop/compact-policy.mjs';
 import { agentContextOverflowError } from './loop/context-overflow.mjs';
 import { estimateMessagesTokensSafe } from './loop/compact-debug.mjs';
 import { isOutputLimitStopReason } from './loop/termination.mjs';
+import { isVisibleStreamProgress } from '../../../shared/stream-progress.mjs';
 
 function normalizedIncompleteUsage(raw) {
     if (!raw || typeof raw !== 'object') return undefined;
@@ -45,9 +51,35 @@ function normalizedIncompleteUsage(raw) {
 // the identical request is side-effect-free, so wait out the blip and retry
 // the send at the loop level. Two attempts, 5s/15s — combined with the
 // provider envelope this covers ~50s outages before failing honestly.
-const TRANSPORT_RETRY_BACKOFF_MS = Object.freeze([5_000, 15_000]);
+// Env-overridable (comma-separated ms) so tests can drive the ladder without
+// real waits and an operator can widen the window for a flaky uplink; the
+// LENGTH of the list is the retry budget, exactly like codex's
+// stream_max_retries + backoff table.
+const TRANSPORT_RETRY_BACKOFF_MS = Object.freeze((() => {
+    const raw = process.env.MIXDOG_TRANSPORT_RETRY_BACKOFF_MS;
+    if (typeof raw === 'string' && raw.trim()) {
+        const parsed = raw.split(',')
+            .map((value) => Number(value.trim()))
+            .filter((value) => Number.isFinite(value) && value >= 0);
+        if (parsed.length) return parsed;
+    }
+    // Three steps (~50s of outage) instead of two: the provider envelope
+    // already covers short blips, so this ladder exists for the long ones.
+    // codex allows 5 stream reconnects and cc 10 request retries.
+    return [5_000, 15_000, 30_000];
+})());
 export const TRANSPORT_RETRY_MAX = TRANSPORT_RETRY_BACKOFF_MS.length;
 
+// codex jitters every backoff by 0.9–1.1 so parallel workers that lose the
+// same uplink do not resume in lockstep; our provider layers already jitter
+// (10% WS / 20% shared), this brings the loop ladder in line.
+const TRANSPORT_RETRY_JITTER_RATIO = 0.1;
+
+function transportRetryWaitMs(attemptIndex) {
+    const base = TRANSPORT_RETRY_BACKOFF_MS[attemptIndex];
+    return jitterDelayMs(base, TRANSPORT_RETRY_JITTER_RATIO);
+}
+
 export async function sendWithRecovery(ctx) {
     const {
         provider, messages, model, sendTools, tools, opts,
@@ -56,7 +88,8 @@ export async function sendWithRecovery(ctx) {
     } = ctx;
     let response;
     // Bench-only turn timing (MIXDOG_TURN_TIMING=1): one stderr line per
-    // provider request — TTFT (first stream delta) and total stream time.
+    // provider request — TTFT (first visible model progress) and total stream
+    // time. Transport/header and response-created acknowledgements do not count.
     // Inert unless the env flag is set; used to profile harness vs model
     // latency in Terminal-Bench runs.
     const turnT0 = process.env.MIXDOG_TURN_TIMING === '1' ? Date.now() : 0;
@@ -67,7 +100,7 @@ export async function sendWithRecovery(ctx) {
         timedOpts = {
             ...(opts || {}),
             onStreamDelta: (kind) => {
-                if (!turnFirstDelta) turnFirstDelta = Date.now();
+                if (!turnFirstDelta && isVisibleStreamProgress(kind)) turnFirstDelta = Date.now();
                 if (prevDelta) prevDelta(kind);
             },
         };
@@ -92,6 +125,22 @@ export async function sendWithRecovery(ctx) {
     // overflow-retry branch intentionally clears opts.onToolCall, and that
     // clear must survive the restore.
     const relayWitness = { textEmitted: false, toolCallsDispatched: 0 };
+    // Caller-visible reconnect progress for LOOP-level replays, mirroring the
+    // transports' own emitReconnectProgress (openai-oauth-ws). Without it the
+    // 5s/15s wait rendered as a frozen turn with no explanation, while codex
+    // surfaces "Reconnecting... n/max" through notify_stream_error and cc
+    // yields a SystemAPIErrorMessage for the same situation.
+    const emitLoopReconnectProgress = (attempt, waitMs, classifier) => {
+        try {
+            opts?.onStageChange?.('reconnecting', {
+                attempt,
+                max: TRANSPORT_RETRY_MAX,
+                classifier: classifier || null,
+                waitMs,
+                message: `Reconnecting... ${attempt}/${TRANSPORT_RETRY_MAX}`,
+            });
+        } catch { /* progress reporting must never break recovery */ }
+    };
     const prevOnTextDelta = typeof opts?.onTextDelta === 'function' ? opts.onTextDelta : null;
     const prevOnToolCall = typeof opts?.onToolCall === 'function' ? opts.onToolCall : null;
     const witnessedOnTextDelta = prevOnTextDelta
@@ -116,7 +165,15 @@ export async function sendWithRecovery(ctx) {
     }
     try {
         try {
-            response = await provider.send(messages, model, sendTools.length ? sendTools : undefined, timedOpts);
+            const admittedOpts = timedOpts?.admissionOwner
+                ? timedOpts
+                : { ...(timedOpts || {}), admissionOwner: sessionId };
+            response = await provider.send(
+                messages,
+                model,
+                sendTools.length ? sendTools : undefined,
+                admittedOpts,
+            );
             logTurnTiming('ok');
         } catch (sendErr) {
             logTurnTiming(`err:${sendErr?.code || sendErr?.name || 'unknown'}`);
@@ -220,7 +277,7 @@ export async function sendWithRecovery(ctx) {
                     transportRetriesUsed < TRANSPORT_RETRY_MAX
                     && await retractExposedTextForReplay()
                 ) {
-                    const waitMs = TRANSPORT_RETRY_BACKOFF_MS[transportRetriesUsed];
+                    const waitMs = transportRetryWaitMs(transportRetriesUsed);
                     try {
                         process.stderr.write(
                             `[loop] exposed-text stall retracted (sess=${sessionId || 'unknown'} `
@@ -238,6 +295,11 @@ export async function sendWithRecovery(ctx) {
                             partialContentLen: sendErr.partialContent.length,
                         });
                     } catch { /* best-effort */ }
+                    emitLoopReconnectProgress(
+                        transportRetriesUsed + 1,
+                        waitMs,
+                        outcome.stallObserved ? 'stream_stalled' : 'stream_closed',
+                    );
                     await sleepMs(waitMs, undefined, signal ? { signal } : undefined);
                     return { action: 'retry_transport' };
                 }
@@ -332,12 +394,23 @@ export async function sendWithRecovery(ctx) {
                 && (
                     (outcome.replaySafe === true && classifyError(sendErr) === 'transient')
                     || (
-                        (classifyError(sendErr) === 'transient' || outcome.stallObserved === true)
+                        // classifyError reports 'permanent' the moment anything
+                        // was exposed, so an exposed disconnect could never
+                        // reach the retraction path: name the transport
+                        // symptoms directly (stall OR non-terminal close).
+                        (classifyError(sendErr) === 'transient'
+                            || outcome.stallObserved === true
+                            // Same inversion for the truncated-stream class
+                            // (anthropic message_start-without-message_stop,
+                            // gemini/compat EOF): classifyError calls it
+                            // 'transient' only while nothing was exposed.
+                            || outcome.truncatedStream === true
+                            || isNonTerminalStreamClose(sendErr))
                         && await retractExposedTextForReplay()
                     )
                 )
             ) {
-                const waitMs = TRANSPORT_RETRY_BACKOFF_MS[transportRetriesUsed];
+                const waitMs = transportRetryWaitMs(transportRetriesUsed);
                 try {
                     process.stderr.write(
                         `[loop] transient send failure with no observed output (sess=${sessionId || 'unknown'} `
@@ -356,6 +429,11 @@ export async function sendWithRecovery(ctx) {
                         status: sendErr?.status ?? null,
                     });
                 } catch { /* best-effort */ }
+                emitLoopReconnectProgress(
+                    transportRetriesUsed + 1,
+                    waitMs,
+                    sendErr?.retryClassifier || sendErr?.midstreamClassifier || sendErr?.code || null,
+                );
                 await sleepMs(waitMs, undefined, signal ? { signal } : undefined);
                 return { action: 'retry_transport' };
             } else

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,
     };
 }