@orion-agents/orion-code 0.2.2 → 0.3.1

package/dist/services/session-storage.js

@@ -15,6 +15,8 @@ exports.advanceSessionCompactSourceReceipt = advanceSessionCompactSourceReceipt;
 exports.createSession = createSession;
 exports.saveSessionMeta = saveSessionMeta;
 exports.updateSessionEffort = updateSessionEffort;
+exports.updateSessionModel = updateSessionModel;
+exports.updateSessionThreadReadModel = updateSessionThreadReadModel;
 exports.loadSessionMeta = loadSessionMeta;
 exports.updateSessionStats = updateSessionStats;
 exports.resumeSession = resumeSession;
@@ -32,6 +34,7 @@ exports.loadSessionTranscriptMessages = loadSessionTranscriptMessages;
 exports.endSession = endSession;
 exports.updateSessionSummary = updateSessionSummary;
 exports.getLastSession = getLastSession;
+exports.filterSessionsWithRestorableHistory = filterSessionsWithRestorableHistory;
 exports.appendHistory = appendHistory;
 exports.readHistory = readHistory;
 exports.readProjectHistory = readProjectHistory;
@@ -45,10 +48,12 @@ exports.appendSessionTraceEvent = appendSessionTraceEvent;
 exports.readSessionTraceEvents = readSessionTraceEvents;
 exports.loadSessionHistory = loadSessionHistory;
 exports.loadSessionHistoryWithDiagnostics = loadSessionHistoryWithDiagnostics;
+exports.loadSessionRestoreBundle = loadSessionRestoreBundle;
 exports.listSessions = listSessions;
 exports.listProjectSessions = listProjectSessions;
 exports.findSession = findSession;
 exports.lookupSessionRef = lookupSessionRef;
+exports.lookupSessionRefInSessions = lookupSessionRefInSessions;
 exports.renameSession = renameSession;
 exports.deleteSession = deleteSession;
 const fs_1 = require("fs");
@@ -66,6 +71,9 @@ const goal_storage_1 = require("./goal-storage");
 const fingerprint_1 = require("./compact/fingerprint");
 const token_estimate_1 = require("../utils/token-estimate");
 const thread_session_view_1 = require("../runtime/thread-session-view");
+const legacy_thread_materializer_1 = require("../runtime/legacy-thread-materializer");
+const paths_1 = require("../product/paths");
+const turn_commit_1 = require("../runtime/turn-commit");
 const harness_1 = require("../harness");
 var redaction_2 = require("./redaction");
 Object.defineProperty(exports, "redactTraceText", { enumerable: true, get: function () { return redaction_2.redactTraceText; } });
@@ -304,7 +312,7 @@ function normalizeSessionMeta(session) {
         updatedAt,
         updatedAtIso: session.updatedAtIso ?? new Date(updatedAt).toISOString(),
         messageCount: session.messageCount ?? 0,
-        historySizeBytes: computeSessionHistorySizeBytes({ id: session.id, projectPath }),
+        historySizeBytes: session.historySizeBytes ?? computeSessionHistorySizeBytes({ id: session.id, projectPath }),
         tokenCount: session.tokenCount ?? 0,
         cost: session.cost ?? 0,
         gitBranch: session.gitBranch ?? getGitBranch(projectPath),
@@ -980,28 +988,6 @@ function loadRawSessionMeta(sessionId) {
     const path = findSessionMetaPath(sessionId);
     return path ? readSessionMetaAtPath(path) : null;
 }
-function projectSessionMetaWithThread(session) {
-    try {
-        const threadSummary = (0, thread_session_view_1.loadThreadSessionSummaryV1)(session.projectPath, session.id);
-        if (!threadSummary)
-            return session;
-        const updatedAt = Math.max(session.updatedAt ?? session.startTime, threadSummary.updatedAt);
-        return {
-            ...session,
-            updatedAt,
-            updatedAtIso: new Date(updatedAt).toISOString(),
-            messageCount: threadSummary.messageCount,
-            historySizeBytes: threadSummary.historySizeBytes,
-        };
-    }
-    catch (error) {
-        // A damaged historical Thread must not make every healthy Session in the
-        // project undiscoverable. Its raw metadata remains selectable for an
-        // explicit, isolated recovery attempt.
-        (0, debug_log_1.debugError)('session-storage.projectThreadMeta', error, session.id);
-        return session;
-    }
-}
 /**
  * Serialize a session read-modify-write transaction across Orion processes.
  * The metadata path is rediscovered before each transaction and re-read only
@@ -1036,12 +1022,100 @@ function updateSessionEffort(sessionId, effortPreference) {
         }
     });
 }
+/** Persist the model selected for one Session without replacing unrelated metadata. */
+function updateSessionModel(sessionId, model) {
+    const normalizedModel = model.trim();
+    if (!normalizedModel)
+        throw new Error('Session model must not be empty.');
+    return mutateSessionMeta(sessionId, session => {
+        session.model = normalizedModel;
+        session.updatedAt = Date.now();
+        session.updatedAtIso = new Date(session.updatedAt).toISOString();
+    });
+}
+/**
+ * Persist the bounded Session-list projection derived from an authoritative
+ * v2 Thread. List and picker paths consume this catalog projection directly;
+ * they must never replay every Thread merely to render metadata.
+ */
+function updateSessionThreadReadModel(sessionId, input) {
+    if (!input.threadId.trim())
+        throw new Error('Session Thread id must not be empty.');
+    if (!Number.isSafeInteger(input.cursor) || input.cursor < 0) {
+        throw new Error('Session Thread cursor must be a non-negative safe integer.');
+    }
+    if (!input.projectionDigest.trim()) {
+        throw new Error('Session Thread projection digest must not be empty.');
+    }
+    if (!Number.isSafeInteger(input.cutoverGeneration) || input.cutoverGeneration < 1) {
+        throw new Error('Session Thread cutover generation must be a positive safe integer.');
+    }
+    if (input.lastRecordHash !== null && !/^[a-f0-9]{64}$/i.test(input.lastRecordHash)) {
+        throw new Error('Session Thread last record hash must be a SHA-256 digest or null.');
+    }
+    for (const [name, value] of [
+        ['logDevice', input.logDevice],
+        ['logInode', input.logInode],
+        ['logMtimeNs', input.logMtimeNs],
+        ['logCtimeNs', input.logCtimeNs],
+    ]) {
+        if (!/^\d+$/.test(value))
+            throw new Error(`Session Thread ${name} must be an integer string.`);
+    }
+    if (!Number.isSafeInteger(input.messageCount) || input.messageCount < 0) {
+        throw new Error('Session Thread messageCount must be a non-negative safe integer.');
+    }
+    if (!Number.isSafeInteger(input.historySizeBytes) || input.historySizeBytes < 0) {
+        throw new Error('Session Thread historySizeBytes must be a non-negative safe integer.');
+    }
+    if (!Number.isFinite(input.updatedAt) || input.updatedAt < 0) {
+        throw new Error('Session Thread updatedAt must be a non-negative finite timestamp.');
+    }
+    return withLockedSession(sessionId, session => {
+        const nextUpdatedAt = Math.max(session.updatedAt ?? session.startTime, input.updatedAt);
+        const current = session.threadReadModel;
+        const unchanged = session.messageCount === input.messageCount &&
+            session.historySizeBytes === input.historySizeBytes &&
+            session.updatedAt === nextUpdatedAt &&
+            current?.version === 1 &&
+            current.threadId === input.threadId &&
+            current.cursor === input.cursor &&
+            current.projectionDigest === input.projectionDigest &&
+            current.cutoverGeneration === input.cutoverGeneration &&
+            current.lastRecordHash === input.lastRecordHash &&
+            current.logDevice === input.logDevice &&
+            current.logInode === input.logInode &&
+            current.logMtimeNs === input.logMtimeNs &&
+            current.logCtimeNs === input.logCtimeNs;
+        if (unchanged)
+            return session;
+        session.messageCount = input.messageCount;
+        session.historySizeBytes = input.historySizeBytes;
+        session.threadReadModel = {
+            version: 1,
+            threadId: input.threadId,
+            cursor: input.cursor,
+            projectionDigest: input.projectionDigest,
+            cutoverGeneration: input.cutoverGeneration,
+            lastRecordHash: input.lastRecordHash,
+            logDevice: input.logDevice,
+            logInode: input.logInode,
+            logMtimeNs: input.logMtimeNs,
+            logCtimeNs: input.logCtimeNs,
+        };
+        // Selecting a Session is itself recent activity. A background projection
+        // refresh must not reorder it backwards to the timestamp of its last fact.
+        session.updatedAt = nextUpdatedAt;
+        session.updatedAtIso = new Date(session.updatedAt).toISOString();
+        writeSessionMetaUnlocked(session);
+        return session;
+    });
+}
 /**
  * 加载会话元数据
  */
 function loadSessionMeta(sessionId) {
-    const session = loadRawSessionMeta(sessionId);
-    return session ? projectSessionMetaWithThread(session) : null;
+    return loadRawSessionMeta(sessionId);
 }
 /**
  * 更新会话统计
@@ -1058,13 +1132,20 @@ function updateSessionStats(sessionId, tokens, cost) {
  * Mark a saved session as active again and refresh project metadata.
  */
 function resumeSession(sessionId) {
-    const session = mutateSessionMeta(sessionId, current => {
+    return withLockedSession(sessionId, current => {
+        // Session selection is not new conversation activity. Once a Session is
+        // already open, do not rewrite its metadata/catalog merely because the UI
+        // selected it again. This keeps /resume off the fsync path while preserving
+        // the one durable ended -> active transition.
+        if (current.endTime === undefined)
+            return current;
         current.endTime = undefined;
-        current.gitBranch = getGitBranch(current.projectPath);
+        current.gitBranch ?? (current.gitBranch = getGitBranch(current.projectPath));
         current.updatedAt = Date.now();
         current.updatedAtIso = new Date(current.updatedAt).toISOString();
+        writeSessionMetaUnlocked(current);
+        return current;
     });
-    return session ? projectSessionMetaWithThread(session) : null;
 }
 /** Keep the session metadata's additive Goal binding in sync with its sidecar. */
 function updateSessionGoalBinding(sessionId, goal) {
@@ -1139,30 +1220,7 @@ function loadSessionHarnessState(sessionId) {
     const session = loadSessionMeta(sessionId);
     if (!session)
         return null;
-    const sidecarPath = (0, config_dir_1.getProjectSessionHarnessPath)(session.projectPath, sessionId);
-    if ((0, fs_1.existsSync)(sidecarPath)) {
-        const sidecar = parseHarnessSidecarFile(sidecarPath);
-        if (sidecar?.state) {
-            return (0, harness_1.upgradeHarnessState)(sidecar.state, {
-                cwd: session.cwd ?? session.projectPath,
-                messages: readSessionMessages(sessionId),
-            });
-        }
-    }
-    if (session.harnessState) {
-        return (0, harness_1.upgradeHarnessState)(session.harnessState, {
-            cwd: session.cwd ?? session.projectPath,
-            messages: readSessionMessages(sessionId),
-        });
-    }
-    const messages = readSessionMessages(sessionId);
-    if (messages.length > 0) {
-        return (0, harness_1.upgradeHarnessState)(null, {
-            cwd: session.cwd ?? session.projectPath,
-            messages,
-        });
-    }
-    return null;
+    return restoreLegacyHarnessState(session, readSessionMessages(sessionId));
 }
 function updateSessionSkills(sessionId, skills) {
     if (skills.length === 0)
@@ -1486,17 +1544,7 @@ function loadSessionTranscriptMessages(sessionId) {
     if (rawSession) {
         const threadSummary = (0, thread_session_view_1.loadThreadSessionSummaryV1)(rawSession.projectPath, rawSession.id);
         if (threadSummary) {
-            return threadSummary.transcriptMessages.map(message => ({
-                role: message.role,
-                content: message.content,
-                timestamp: message.timestamp,
-                ...(message.modelVisibleContent
-                    ? { modelVisibleContent: message.modelVisibleContent }
-                    : {}),
-                ...(message.toolCallId ? { toolCallId: message.toolCallId } : {}),
-                ...(message.tool_calls ? { tool_calls: structuredClone(message.tool_calls) } : {}),
-                ...(message.appliedSkills ? { appliedSkills: [...message.appliedSkills] } : {}),
-            }));
+            return threadSummary.transcriptMessages.map(threadTranscriptMessageToSessionMessage);
         }
     }
     return (withLockedSession(sessionId, session => {
@@ -1510,6 +1558,17 @@ function loadSessionTranscriptMessages(sessionId) {
             : messages;
     }) ?? []);
 }
+function threadTranscriptMessageToSessionMessage(message) {
+    return {
+        role: message.role,
+        content: message.content,
+        timestamp: message.timestamp,
+        ...(message.modelVisibleContent ? { modelVisibleContent: message.modelVisibleContent } : {}),
+        ...(message.toolCallId ? { toolCallId: message.toolCallId } : {}),
+        ...(message.tool_calls ? { tool_calls: structuredClone(message.tool_calls) } : {}),
+        ...(message.appliedSkills ? { appliedSkills: [...message.appliedSkills] } : {}),
+    };
+}
 function hasPersistedCompactContext(messages) {
     return messages.some(message => message.content.includes('[Orion Code Context State v2]') ||
         message.content.includes('[Context Summary]') ||
@@ -1598,6 +1657,7 @@ function updateSessionSummary(sessionId, _messages) {
         session.filesModified = summary.filesModified;
         session.taskSummary = summary.taskSummary;
         session.messageCount = summary.messageCount;
+        session.historySizeBytes = computeSessionHistorySizeBytes(session);
         session.updatedAt = Date.now();
         session.updatedAtIso = new Date(session.updatedAt).toISOString();
         writeSessionMetaUnlocked(session);
@@ -1607,9 +1667,55 @@ function updateSessionSummary(sessionId, _messages) {
  * 获取项目最近的会话
  */
 function getLastSession(projectPath) {
-    const sessions = listProjectSessions(projectPath).filter(session => (session.messageCount ?? 0) > 0);
+    const sessions = filterSessionsWithRestorableHistory(listProjectSessions(projectPath));
     return sessions[0] ?? null;
 }
+/**
+ * Keep pre-read-model v2 Sessions discoverable without replaying their logs.
+ * An indexed Thread with no bound read model is "unknown", not "empty"; its
+ * metadata is repaired lazily when that target is actually opened.
+ */
+function filterSessionsWithRestorableHistory(sessions) {
+    const threadSessionsByProject = new Map();
+    const threadSessions = (projectPath) => {
+        const cached = threadSessionsByProject.get(projectPath);
+        if (cached)
+            return cached;
+        let entries = {};
+        try {
+            entries = (0, legacy_thread_materializer_1.loadThreadCutoverIndexV1)(projectPath).sessions;
+        }
+        catch (error) {
+            (0, debug_log_1.debugError)('session-storage.restorableThreadIndex', error, projectPath);
+        }
+        threadSessionsByProject.set(projectPath, entries);
+        return entries;
+    };
+    return sessions.filter(session => {
+        if ((session.messageCount ?? 0) > 0)
+            return true;
+        const entry = threadSessions(session.projectPath)[session.id];
+        if (!entry)
+            return false;
+        const readModel = session.threadReadModel;
+        if (!readModel || readModel.threadId !== entry.threadId)
+            return true;
+        try {
+            const stats = (0, fs_1.statSync)((0, path_1.join)((0, paths_1.getProjectThreadsV2Dir)(session.projectPath), `${readModel.threadId}.events.v1.jsonl`), { bigint: true });
+            const headStillCurrent = stats.size === BigInt(session.historySizeBytes ?? -1) &&
+                stats.dev.toString() === readModel.logDevice &&
+                stats.ino.toString() === readModel.logInode &&
+                stats.mtimeNs.toString() === readModel.logMtimeNs &&
+                stats.ctimeNs.toString() === readModel.logCtimeNs;
+            return !headStillCurrent;
+        }
+        catch {
+            // Missing or unreadable authoritative facts must remain discoverable so
+            // an explicit restore can surface the isolated corruption diagnostic.
+            return true;
+        }
+    });
+}
 // ============================================================================
 // 历史记录 (JSONL)
 // ============================================================================
@@ -1685,6 +1791,7 @@ function appendSessionMessage(sessionId, message) {
         session.updatedAt = Date.now();
         session.updatedAtIso = new Date(session.updatedAt).toISOString();
         session.messageCount = (session.messageCount ?? 0) + 1;
+        session.historySizeBytes = computeSessionHistorySizeBytes(session);
         writeSessionMetaUnlocked(session);
     });
 }
@@ -1701,13 +1808,13 @@ function appendSessionMessages(sessionId, messages) {
         (0, fs_1.appendFileSync)((0, config_dir_1.getProjectSessionMessagesPath)(session.projectPath, sessionId), lines, {
             mode: 0o600,
         });
-        for (const message of messages) {
-            (0, session_index_1.updateSessionIndex)(sessionId, session.projectPath, message);
+        (0, session_index_1.updateSessionIndexBatch)(sessionId, session.projectPath, messages);
+        for (const message of messages)
             mergeMessageSummary(session, message);
-        }
         session.updatedAt = Date.now();
         session.updatedAtIso = new Date(session.updatedAt).toISOString();
         session.messageCount = (session.messageCount ?? 0) + messages.length;
+        session.historySizeBytes = computeSessionHistorySizeBytes(session);
         writeSessionMetaUnlocked(session);
     });
 }
@@ -1737,10 +1844,9 @@ function overwriteSessionMessagesUnlocked(session, messages) {
         mode: 0o600,
     });
     (0, session_index_1.deleteSessionIndex)(session.id, session.projectPath);
-    for (const message of messages) {
-        (0, session_index_1.updateSessionIndex)(session.id, session.projectPath, message);
-    }
+    (0, session_index_1.updateSessionIndexBatch)(session.id, session.projectPath, messages);
     session.messageCount = messages.length;
+    session.historySizeBytes = computeSessionHistorySizeBytes(session);
     const summary = summarizeSessionMessages(messages);
     session.toolsUsed = summary.toolsUsed;
     session.filesModified = summary.filesModified;
@@ -1896,49 +2002,140 @@ function loadSessionHistory(sessionId) {
 }
 /** Load provider-safe history together with any explicit recovery provenance. */
 function loadSessionHistoryWithDiagnostics(sessionId) {
+    return loadSessionRestoreBundleInternal(sessionId, false).history;
+}
+/**
+ * Capture every projection needed by /resume from one stable storage view.
+ * A v2 target opens and verifies one ThreadEventStore; a legacy target reads
+ * messages and its compact checkpoint under one Session lock.
+ */
+function loadSessionRestoreBundle(sessionId) {
+    return loadSessionRestoreBundleInternal(sessionId, true);
+}
+function loadSessionRestoreBundleInternal(sessionId, includeRuntimeActivation) {
     const rawSession = loadRawSessionMeta(sessionId);
     if (rawSession) {
-        const threadView = (0, thread_session_view_1.loadThreadSessionViewV1)(rawSession.projectPath, rawSession.id);
+        const openedThread = includeRuntimeActivation
+            ? (0, thread_session_view_1.openThreadSessionViewV1)(rawSession.projectPath, rawSession.id)
+            : undefined;
+        const threadView = openedThread?.view ?? (0, thread_session_view_1.loadThreadSessionViewV1)(rawSession.projectPath, rawSession.id);
         if (threadView) {
+            const harnessState = restoreThreadHarnessState(rawSession, threadView);
+            try {
+                updateSessionThreadReadModel(sessionId, {
+                    threadId: threadView.threadId,
+                    cursor: threadView.cursor,
+                    projectionDigest: threadView.projectionDigest,
+                    cutoverGeneration: threadView.readModel.cutoverGeneration,
+                    lastRecordHash: threadView.readModel.lastRecordHash,
+                    logDevice: threadView.readModel.log.device,
+                    logInode: threadView.readModel.log.inode,
+                    logMtimeNs: threadView.readModel.log.mtimeNs,
+                    logCtimeNs: threadView.readModel.log.ctimeNs,
+                    messageCount: threadView.messageCount,
+                    historySizeBytes: threadView.historySizeBytes,
+                    updatedAt: threadView.updatedAt,
+                });
+            }
+            catch (error) {
+                (0, debug_log_1.debugError)('session-storage.repairThreadReadModel', error, sessionId);
+            }
             return {
-                messages: threadView.modelHistory.map(message => structuredClone(message)),
-                source: threadView.modelHistorySource,
-                diagnostics: threadView.diagnostics,
+                history: {
+                    messages: threadView.modelHistory.map(message => structuredClone(message)),
+                    source: threadView.modelHistorySource,
+                    diagnostics: threadView.diagnostics,
+                },
+                transcriptMessages: threadView.transcriptMessages.map(threadTranscriptMessageToSessionMessage),
+                sourceMessageCount: threadView.transcriptMessages.length,
+                checkpoint: null,
+                ...(harnessState ? { harnessState } : {}),
+                ...(openedThread ? { runtimeActivation: openedThread.runtimeActivation } : {}),
             };
         }
     }
-    const messages = withLockedSession(sessionId, session => {
+    return (withLockedSession(sessionId, session => {
         const messages = readSessionMessagesForSession(session);
+        const harnessState = restoreLegacyHarnessState(session, messages);
         const checkpoint = loadCompactCheckpointForSession(session, messages);
-        if (checkpoint) {
-            const restored = [
-                ...checkpoint.modelHistory.map(message => ({ ...message })),
-                ...messages.slice(checkpoint.sourceMessageCount).map(sessionMessageToModelMessage),
-            ];
-            if (checkpoint.version === 2) {
-                try {
-                    (0, tool_call_groups_1.assertToolCallGroups)(restored);
-                    return restored;
-                }
-                catch (error) {
-                    // Never mutate or synthesize data inside a validated V2
-                    // replacement. Fall back to the append-only transcript instead.
-                    (0, debug_log_1.debugError)('session-storage.restoreCompactCheckpoint.toolGroups', error, sessionId);
-                    return (0, tool_call_groups_1.sealToolCallGroups)(messages.map(sessionMessageToModelMessage));
-                }
-            }
-            return (0, tool_call_groups_1.sealToolCallGroups)(restored);
-        }
-        let modelVisibleMessages = messages;
-        if (typeof session.transcriptDisplayStartTime === 'number') {
-            const afterDisplayStart = messages.filter(message => (message.timestamp ?? 0) >= (session.transcriptDisplayStartTime ?? 0));
-            modelVisibleMessages = hasPersistedCompactContext(afterDisplayStart)
-                ? afterDisplayStart
+        const transcriptMessages = checkpoint
+            ? messages.slice(checkpoint.transcriptStartMessageIndex)
+            : typeof session.transcriptDisplayStartTime === 'number'
+                ? messages.filter(message => (message.timestamp ?? 0) >= (session.transcriptDisplayStartTime ?? 0))
                 : messages;
+        return {
+            history: {
+                messages: restoreLegacyModelHistory(sessionId, session, messages, checkpoint),
+                source: 'legacy',
+                diagnostics: [],
+            },
+            transcriptMessages,
+            sourceMessageCount: messages.length,
+            checkpoint,
+            ...(harnessState ? { harnessState } : {}),
+        };
+    }) ?? {
+        history: { messages: [], source: 'legacy', diagnostics: [] },
+        transcriptMessages: [],
+        sourceMessageCount: 0,
+        checkpoint: null,
+    });
+}
+function restoreThreadHarnessState(session, view) {
+    if (!view.latestTurnCommit) {
+        return restoreLegacyHarnessState(session, view.transcriptMessages.map(threadTranscriptMessageToSessionMessage));
+    }
+    const commit = (0, turn_commit_1.parseTurnCommitV1)(view.latestTurnCommit.receipt);
+    let state;
+    try {
+        state = JSON.parse(commit.taskContext);
+    }
+    catch {
+        throw new Error(`Session ${session.id} TurnCommit TaskContext is not valid JSON.`);
+    }
+    return (0, harness_1.upgradeHarnessState)(state, {
+        cwd: session.cwd ?? session.projectPath,
+        messages: view.modelHistory.map(message => structuredClone(message)),
+    });
+}
+function restoreLegacyHarnessState(session, messages) {
+    const sidecarPath = (0, config_dir_1.getProjectSessionHarnessPath)(session.projectPath, session.id);
+    const sidecar = (0, fs_1.existsSync)(sidecarPath) ? parseHarnessSidecarFile(sidecarPath) : null;
+    const state = sidecar?.state ?? session.harnessState ?? null;
+    if (!state && messages.length === 0)
+        return null;
+    return (0, harness_1.upgradeHarnessState)(state, {
+        cwd: session.cwd ?? session.projectPath,
+        messages: messages.map(message => structuredClone(message)),
+    });
+}
+function restoreLegacyModelHistory(sessionId, session, messages, checkpoint) {
+    if (checkpoint) {
+        const restored = [
+            ...checkpoint.modelHistory.map(message => ({ ...message })),
+            ...messages.slice(checkpoint.sourceMessageCount).map(sessionMessageToModelMessage),
+        ];
+        if (checkpoint.version === 2) {
+            try {
+                (0, tool_call_groups_1.assertToolCallGroups)(restored);
+                return restored;
+            }
+            catch (error) {
+                // Never mutate or synthesize data inside a validated V2 replacement.
+                (0, debug_log_1.debugError)('session-storage.restoreCompactCheckpoint.toolGroups', error, sessionId);
+                return (0, tool_call_groups_1.sealToolCallGroups)(messages.map(sessionMessageToModelMessage));
+            }
         }
-        return (0, tool_call_groups_1.sealToolCallGroups)(modelVisibleMessages.map(sessionMessageToModelMessage));
-    }) ?? [];
-    return { messages, source: 'legacy', diagnostics: [] };
+        return (0, tool_call_groups_1.sealToolCallGroups)(restored);
+    }
+    let modelVisibleMessages = messages;
+    if (typeof session.transcriptDisplayStartTime === 'number') {
+        const afterDisplayStart = messages.filter(message => (message.timestamp ?? 0) >= (session.transcriptDisplayStartTime ?? 0));
+        modelVisibleMessages = hasPersistedCompactContext(afterDisplayStart)
+            ? afterDisplayStart
+            : messages;
+    }
+    return (0, tool_call_groups_1.sealToolCallGroups)(modelVisibleMessages.map(sessionMessageToModelMessage));
 }
 function sessionMessageToModelMessage(message) {
     const result = {
@@ -1957,7 +2154,7 @@ function sessionMessageToModelMessage(message) {
  * 列出所有会话
  */
 function listSessions(limit) {
-    const sessions = sortSessionsNewestFirst(Object.values(loadOrRebuildSessionCatalog().sessions).map(projectSessionMetaWithThread));
+    const sessions = sortSessionsNewestFirst(Object.values(loadOrRebuildSessionCatalog().sessions));
     return limit ? sessions.slice(0, limit) : sessions;
 }
 /**
@@ -1965,9 +2162,7 @@ function listSessions(limit) {
  */
 function listProjectSessions(projectPath, limit) {
     const canonicalProjectPath = resolveProjectPath(projectPath);
-    const sessions = sortSessionsNewestFirst(Object.values(loadOrRebuildSessionCatalog().sessions)
-        .filter(session => session.projectPath === canonicalProjectPath)
-        .map(projectSessionMetaWithThread));
+    const sessions = sortSessionsNewestFirst(Object.values(loadOrRebuildSessionCatalog().sessions).filter(session => session.projectPath === canonicalProjectPath));
     return limit ? sessions.slice(0, limit) : sessions;
 }
 /**
@@ -1983,10 +2178,14 @@ function findSession(ref, projectPath, options = {}) {
  * conflict prompts.
  */
 function lookupSessionRef(ref, projectPath, options = {}) {
+    const candidates = options.allProjects || !projectPath ? listSessions() : listProjectSessions(projectPath);
+    return lookupSessionRefInSessions(ref, candidates);
+}
+/** Resolve a reference against an already-loaded picker snapshot. */
+function lookupSessionRefInSessions(ref, candidates) {
     const query = ref.trim();
     if (!query)
         return { status: 'not_found' };
-    const candidates = options.allProjects || !projectPath ? listSessions() : listProjectSessions(projectPath);
     const exactId = candidates.find(session => session.id === query);
     if (exactId)
         return { status: 'found', session: exactId };