@jingyi0605/codingns 0.3.6 → 0.5.0

package/dist/server/modules/sessions/session-history-service.js

@@ -19,6 +19,7 @@ import { discoverWorkspaceSessionsInRuntime } from "../provider/provider-discove
 import { createTaskManager } from "../tasks/task-manager.js";
 import { HOST_TASK_TYPES } from "../tasks/task-types.js";
 import { CodexAppServerHelperClient } from "./codex-app-server-helper-client.js";
+import { CodingnsProviderSessionDeleteCli } from "./provider-session-delete-cli.js";
 const RECONSTRUCTED_FORK_TARGET_PROVIDERS = new Set(["codex", "claude-code", "opencode"]);
 const FORK_RECONSTRUCTION_PAGE_SIZE = 200;
 const MAX_FORK_DEPTH = 4;
@@ -32,9 +33,13 @@ const SESSION_START_DEFERRED_PROVIDERS = new Set([
 ]);
 const MUTABLE_HISTORY_TAIL_REFRESH_INTERVAL_MS = 1_200;
 const WORKSPACE_DISCOVERY_BACKGROUND_MAX_AGE_MS = 15_000;
+const WORKSPACE_DISCOVERY_SCAN_CONCURRENCY = 2;
 const PROVIDER_CAPABILITY_CACHE_MAX_AGE_MS = 5_000;
 const WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE = 25;
 const SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS = 150;
+const WORKSPACE_STATE_REFRESH_COOLDOWN_MS = 1_500;
+const SQLITE_BUSY_RETRY_LIMIT = 3;
+const SQLITE_BUSY_RETRY_DELAY_MS = 100;
 export class SessionHistoryService {
     db;
     workspaceRepository;
@@ -50,6 +55,7 @@ export class SessionHistoryService {
     capabilityService;
     sessionActivityAuthorityService;
     sessionForkRepository;
+    providerSessionDeleteCli;
     claudeCodeHomeDir;
     codexModelOptionsService;
     openCodeModelOptionsService;
@@ -59,10 +65,12 @@ export class SessionHistoryService {
     providerSessionDiscoveryConfig;
     taskManager;
     workspaceDiscoveryStatuses = new Map();
-    workspaceStateRefreshInflight = new Map();
+    workspaceStateRefreshStatuses = new Map();
     providerCapabilityCache = new Map();
     liveActivityObservationResolvers = new Set();
+    sessionDeletedObservers = new Set();
     workspaceSessionRelations = new Map();
+    workspaceStateRefreshTaskSequence = 0;
     constructor(db, workspaceRepository, sessionBindingRepository, sessionChangedFileService, sessionIndexRepository, sessionMessageAttachmentService, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService(), sessionMessageOriginRepository = null, sessionForkRepository = null, adapterOverrides = {}, taskManager = createTaskManager()) {
         this.db = db;
         this.workspaceRepository = workspaceRepository;
@@ -75,6 +83,8 @@ export class SessionHistoryService {
         this.sessionMessageOriginRepository = sessionMessageOriginRepository;
         this.sessionActivityAuthorityService = sessionActivityAuthorityService;
         this.sessionForkRepository = sessionForkRepository ?? new SessionForkRepository(db);
+        this.providerSessionDeleteCli =
+            adapterOverrides.providerSessionDeleteCli ?? new CodingnsProviderSessionDeleteCli(config);
         this.taskManager = taskManager;
         this.claudeCodeHomeDir = config.claudeCodeHomeDir;
         this.providerCliCommandPaths = {
@@ -102,7 +112,8 @@ export class SessionHistoryService {
             new CodexAdapter({
                 homeDir: config.codexHomeDir,
                 forkTransportFactory: adapterOverrides.codexForkTransportFactory
-                    ?? createCodexForkTransportFactory(config.codexCliPath, config.codexHomeDir)
+                    ?? createCodexForkTransportFactory(config.codexCliPath, config.codexHomeDir),
+                threadControlTransportFactory: createCodexThreadControlTransportFactory(config.codexCliPath, config.codexHomeDir)
             }),
             new GeminiAdapter({
                 homeDir: config.geminiHomeDir,
@@ -147,6 +158,14 @@ export class SessionHistoryService {
             }
         };
     }
+    registerSessionDeletedObserver(observer) {
+        this.sessionDeletedObservers.add(observer);
+        return {
+            close: () => {
+                this.sessionDeletedObservers.delete(observer);
+            }
+        };
+    }
     registerBackgroundTasks() {
         if (!this.taskManager.has(HOST_TASK_TYPES.workspaceDiscovery)) {
             this.taskManager.register({
@@ -159,6 +178,7 @@ export class SessionHistoryService {
             this.taskManager.register({
                 taskType: HOST_TASK_TYPES.workspaceDiscoveryScan,
                 executionLane: "helper_process",
+                concurrency: WORKSPACE_DISCOVERY_SCAN_CONCURRENCY,
                 helperProcessHandler: "session.workspace_discovery",
                 run: async ({ config, workspacePath, knownSessions }, context) => await discoverWorkspaceSessionsInRuntime(config, workspacePath, knownSessions, context.signal)
             });
@@ -319,6 +339,12 @@ export class SessionHistoryService {
             originRef: null
         };
     }
+    resolveMessageOriginByClientRequestId(sessionId, clientRequestId, messageId, updatedAt) {
+        if (!this.sessionMessageOriginRepository || !clientRequestId || !messageId) {
+            return;
+        }
+        this.sessionMessageOriginRepository.resolveMessageId(sessionId, clientRequestId, messageId, updatedAt);
+    }
     async findLatestUserMessage(sessionId, content, maxAttempts = 12, minTimestamp = null) {
         const binding = this.getBindingOrThrow(sessionId);
         const acceptedContents = new Set((Array.isArray(content) ? content : [content]).filter((value) => value.trim().length > 0));
@@ -1066,6 +1092,44 @@ export class SessionHistoryService {
             isArchived: nextArchivedState
         });
     }
+    async deleteSession(sessionId, userId) {
+        const binding = this.getBindingOrThrow(sessionId);
+        const existing = this.getSessionListItemOrThrow(sessionId, userId);
+        if (existing.runningState === "starting" || existing.runningState === "running") {
+            throw new AppError({
+                statusCode: 409,
+                errorCode: "SESSION_DELETE_RUNNING",
+                detail: "运行中的会话不能直接删除，请先等当前执行结束",
+                field: "sessionId"
+            });
+        }
+        try {
+            await this.providerSessionDeleteCli.deleteSession({
+                provider: binding.provider,
+                providerSessionId: binding.providerSessionId,
+                rawStoreRef: binding.rawStoreRef
+            });
+        }
+        catch (error) {
+            if (!isProviderSessionMissing(error)) {
+                throw mapSessionProviderError(error);
+            }
+        }
+        for (const observer of this.sessionDeletedObservers) {
+            await observer({
+                sessionId,
+                userId,
+                workspaceId: binding.workspaceId,
+                remainingWorkspaceSessionCount: this.countOtherWorkspaceSessions(binding.workspaceId, sessionId)
+            });
+        }
+        const deleteTransaction = this.db.transaction((targetSessionId) => {
+            this.detachSessionRelationsBeforeDelete(targetSessionId);
+            this.deleteSessionById(targetSessionId);
+        });
+        deleteTransaction(sessionId);
+        this.removeWorkspaceSessionRelation(sessionId);
+    }
     async renameSessionTitle(sessionId, userId, title) {
         const binding = this.getBindingOrThrow(sessionId);
         const existing = this.getSessionListItemOrThrow(sessionId, userId);
@@ -1215,7 +1279,7 @@ export class SessionHistoryService {
                     const existingIndex = existing
                         ? this.sessionIndexRepository.findIndexRecordBySessionId(existing.sessionId)
                         : null;
-                    this.sessionBindingRepository.upsert({
+                    const nextBinding = {
                         sessionId,
                         workspaceId: workspace.id,
                         provider: session.provider,
@@ -1223,7 +1287,10 @@ export class SessionHistoryService {
                         rawStoreRef: session.rawStoreRef,
                         createdAt,
                         updatedAt: timestamp
-                    });
+                    };
+                    if (!areEquivalentSessionBindings(existing, nextBinding)) {
+                        this.sessionBindingRepository.upsert(nextBinding);
+                    }
                     const preservedParentSessionId = existingIndex?.parentSessionId
                         ?? this.sessionForkRepository.findBySessionId(sessionId)?.parentSessionId
                         ?? null;
@@ -1231,7 +1298,7 @@ export class SessionHistoryService {
                         ? this.sessionIndexRepository.findIndexRecordBySessionId(preservedParentSessionId)?.title ?? null
                         : null;
                     const preservedTitle = resolvePersistedSessionTitle(session.provider, session.title, existingIndex?.title ?? null, preservedParentTitle);
-                    this.sessionIndexRepository.upsert({
+                    const nextIndex = {
                         sessionId,
                         workspaceId: workspace.id,
                         provider: session.provider,
@@ -1243,12 +1310,15 @@ export class SessionHistoryService {
                         subagentLabel: existingIndex?.subagentLabel ?? null,
                         title: preservedTitle,
                         messageCount: session.messageCount,
-                        isArchived: resolveDiscoveredArchiveState(existingIndex?.isArchived ?? false, session.isArchived),
+                        isArchived: resolveDiscoveredArchiveState(session.provider, existingIndex?.isArchived ?? false, session.isArchived),
                         lastMessageAt: session.lastMessageAt,
                         createdAt,
                         updatedAt: timestamp
-                    });
-                    this.sessionStatusSnapshotRepository.upsert({
+                    };
+                    if (!areEquivalentSessionIndexRecords(existingIndex, nextIndex)) {
+                        this.sessionIndexRepository.upsert(nextIndex);
+                    }
+                    const nextSnapshot = {
                         sessionId,
                         syncStatus: currentSnapshot?.syncStatus ?? "idle",
                         syncCursor: currentSnapshot?.syncCursor ?? null,
@@ -1257,13 +1327,17 @@ export class SessionHistoryService {
                         lastErrorDetail: currentSnapshot?.lastErrorDetail ?? null,
                         resumedAt: currentSnapshot?.resumedAt ?? null,
                         updatedAt: timestamp
-                    });
+                    };
+                    if (!areEquivalentSessionStatusSnapshots(currentSnapshot, nextSnapshot)) {
+                        this.sessionStatusSnapshotRepository.upsert(nextSnapshot);
+                    }
                     discoveredSessionIds.set(buildProviderSessionKey(session.provider, session.providerSessionId), sessionId);
                     persistedSessions.push({
                         session,
                         sessionId,
                         createdAt,
-                        existingIndex
+                        existingIndex,
+                        pass1Index: nextIndex
                     });
                 }
             });
@@ -1293,7 +1367,7 @@ export class SessionHistoryService {
                     const resolvedParentTitle = resolvedParentSessionId
                         ? this.sessionIndexRepository.findIndexRecordBySessionId(resolvedParentSessionId)?.title ?? null
                         : null;
-                    this.sessionIndexRepository.upsert({
+                    const nextIndex = {
                         sessionId: persistedSession.sessionId,
                         workspaceId: workspace.id,
                         provider: persistedSession.session.provider,
@@ -1315,11 +1389,14 @@ export class SessionHistoryService {
                             ?? null,
                         title: resolvePersistedSessionTitle(persistedSession.session.provider, persistedSession.session.title, persistedSession.existingIndex?.title ?? null, resolvedParentTitle),
                         messageCount: persistedSession.session.messageCount,
-                        isArchived: resolveDiscoveredArchiveState(persistedSession.existingIndex?.isArchived ?? false, persistedSession.session.isArchived),
+                        isArchived: resolveDiscoveredArchiveState(persistedSession.session.provider, persistedSession.existingIndex?.isArchived ?? false, persistedSession.session.isArchived),
                         lastMessageAt: persistedSession.session.lastMessageAt,
                         createdAt: persistedSession.createdAt,
                         updatedAt: timestamp
-                    });
+                    };
+                    if (!areEquivalentSessionIndexRecords(persistedSession.pass1Index, nextIndex)) {
+                        this.sessionIndexRepository.upsert(nextIndex);
+                    }
                 }
             });
             const persistPass2StartedAt = Date.now();
@@ -1387,7 +1464,22 @@ export class SessionHistoryService {
                 discoveredSessions: sessions.length,
                 returnedSessions: nextItems.length,
                 discoveryComplete: discovery.isComplete,
-                providerDiagnostics: (discovery.providerDiagnostics ?? []).map((entry) => `${entry.provider}:${entry.status}:${Math.round(entry.durationMs)}ms`),
+                providerDiagnostics: (discovery.providerDiagnostics ?? []).map((entry) => {
+                    const scannedFiles = entry.scannedFiles ?? 0;
+                    const skippedByMtimeSize = entry.skippedByMtimeSize ?? 0;
+                    const parsedFiles = entry.parsedFiles ?? 0;
+                    const bytesRead = entry.bytesRead ?? 0;
+                    return [
+                        entry.provider,
+                        entry.status,
+                        `${Math.round(entry.durationMs)}ms`,
+                        `sessions=${entry.sessionCount}`,
+                        `scanned=${scannedFiles}`,
+                        `skipped=${skippedByMtimeSize}`,
+                        `parsed=${parsedFiles}`,
+                        `bytes=${bytesRead}`
+                    ].join(":");
+                }),
                 refreshedStates: refreshCandidates.length,
                 discoverMs: discoverDurationMs,
                 persistMs: persistDurationMs,
@@ -1542,13 +1634,6 @@ export class SessionHistoryService {
         const originByMessageId = new Map(originRows
             .filter((row) => row.messageId)
             .map((row) => [row.messageId, row]));
-        const unresolvedRows = originRepository.listUnresolvedBySessionAndContents(sessionId, [...new Set(messages.map((message) => message.content).filter((content) => content.trim().length > 0))]);
-        const unresolvedByContent = new Map();
-        for (const row of unresolvedRows) {
-            const current = unresolvedByContent.get(row.content) ?? [];
-            current.push(row);
-            unresolvedByContent.set(row.content, current);
-        }
         return messages.map((message) => {
             const resolved = originByMessageId.get(message.messageId) ?? null;
             if (resolved) {
@@ -1565,21 +1650,10 @@ export class SessionHistoryService {
                     originRef: null
                 };
             }
-            const candidates = unresolvedByContent.get(message.content) ?? [];
-            const matched = candidates.find((row) => isMessageAtOrAfter(message.timestamp, row.createdAt)) ?? null;
-            if (!matched) {
-                return {
-                    ...message,
-                    origin: null,
-                    originRef: null
-                };
-            }
-            originRepository.resolveMessageId(sessionId, matched.clientRequestId, message.messageId, message.timestamp);
-            unresolvedByContent.set(message.content, candidates.filter((candidate) => candidate.clientRequestId !== matched.clientRequestId));
             return {
                 ...message,
-                origin: matched.origin,
-                originRef: matched.originRef
+                origin: null,
+                originRef: null
             };
         });
     }
@@ -1718,6 +1792,9 @@ export class SessionHistoryService {
         if (shouldSkipClaudePendingBinding(binding)) {
             return;
         }
+        if (!shouldSyncSessionTitleFromProvider(binding.provider, currentIndex.title)) {
+            return;
+        }
         const nextTitle = (await this.providerDiscoveryHelperClient.readSessionTitle({
             config: this.providerSessionDiscoveryConfig,
             provider: binding.provider,
@@ -1926,13 +2003,71 @@ export class SessionHistoryService {
             return;
         }
         const inflightKey = `${workspaceId}:${userId}`;
-        if (this.workspaceStateRefreshInflight.has(inflightKey)) {
+        const refreshState = this.getOrCreateWorkspaceStateRefreshStatus(inflightKey);
+        const now = Date.now();
+        refreshState.lastRequestedAt = now;
+        refreshState.phase = refreshState.phase === "fresh" ? "stale" : refreshState.phase;
+        refreshState.dirtyReasons.add("workspace.discovery.deferred_state_refresh");
+        mergeWorkspaceStateRefreshSessions(refreshState.pendingSessions, sessions);
+        if (refreshState.phase === "running" && refreshState.runningPromise) {
             return;
         }
+        if (this.isWorkspaceStateRefreshCoolingDown(refreshState, now)) {
+            refreshState.phase = "stale";
+            this.ensureWorkspaceStateRefreshCooldownTimer(inflightKey, workspaceId, userId, refreshState);
+            return;
+        }
+        this.startWorkspaceStateRefreshTask(inflightKey, workspaceId, userId, refreshState);
+    }
+    getOrCreateWorkspaceStateRefreshStatus(key) {
+        const existing = this.workspaceStateRefreshStatuses.get(key);
+        if (existing) {
+            return existing;
+        }
+        const created = {
+            phase: "fresh",
+            dirtyReasons: new Set(),
+            pendingSessions: new Map(),
+            runningPromise: null,
+            cooldownTimer: null,
+            lastRequestedAt: null,
+            lastStartedAt: null,
+            lastCompletedAt: null,
+            lastFailedAt: null,
+            nextAllowedAt: null,
+            runningTaskId: null
+        };
+        this.workspaceStateRefreshStatuses.set(key, created);
+        return created;
+    }
+    isWorkspaceStateRefreshCoolingDown(state, now) {
+        if (state.nextAllowedAt === null || now >= state.nextAllowedAt) {
+            return false;
+        }
+        return state.phase === "cooldown" || state.phase === "failed";
+    }
+    startWorkspaceStateRefreshTask(key, workspaceId, userId, state) {
+        if (state.runningPromise) {
+            return;
+        }
+        const sessions = [...state.pendingSessions.values()];
+        if (sessions.length === 0) {
+            state.phase = "fresh";
+            state.dirtyReasons.clear();
+            return;
+        }
+        state.pendingSessions.clear();
+        state.phase = "running";
+        state.lastStartedAt = Date.now();
+        state.runningTaskId = `${key}:${++this.workspaceStateRefreshTaskSequence}`;
         const startedAt = Date.now();
         const task = delay(0)
             .then(() => this.refreshRecentSessionStates(sessions, userId))
             .then(() => {
+            state.lastCompletedAt = Date.now();
+            state.phase = "cooldown";
+            state.nextAllowedAt = state.lastCompletedAt + WORKSPACE_STATE_REFRESH_COOLDOWN_MS;
+            state.dirtyReasons.clear();
             logPerformance("workspace.refresh_recent_session_states", Date.now() - startedAt, {
                 workspaceId,
                 refreshedStates: sessions.length
@@ -1941,6 +2076,9 @@ export class SessionHistoryService {
             });
         })
             .catch((error) => {
+            state.lastFailedAt = Date.now();
+            state.phase = "failed";
+            state.nextAllowedAt = state.lastFailedAt + WORKSPACE_STATE_REFRESH_COOLDOWN_MS;
             logPerformance("workspace.refresh_recent_session_states.failed", Date.now() - startedAt, {
                 workspaceId,
                 refreshedStates: sessions.length,
@@ -1951,9 +2089,42 @@ export class SessionHistoryService {
             });
         })
             .finally(() => {
-            this.workspaceStateRefreshInflight.delete(inflightKey);
+            state.runningPromise = null;
+            state.runningTaskId = null;
+            if (state.pendingSessions.size === 0) {
+                if (state.phase === "cooldown") {
+                    this.ensureWorkspaceStateRefreshCooldownTimer(key, workspaceId, userId, state);
+                    return;
+                }
+                if (state.phase === "failed") {
+                    this.ensureWorkspaceStateRefreshCooldownTimer(key, workspaceId, userId, state);
+                    return;
+                }
+                state.phase = "fresh";
+                return;
+            }
+            state.phase = "stale";
+            this.ensureWorkspaceStateRefreshCooldownTimer(key, workspaceId, userId, state);
         });
-        this.workspaceStateRefreshInflight.set(inflightKey, task);
+        state.runningPromise = task;
+    }
+    ensureWorkspaceStateRefreshCooldownTimer(key, workspaceId, userId, state) {
+        if (state.cooldownTimer) {
+            return;
+        }
+        const now = Date.now();
+        const delayMs = Math.max(0, (state.nextAllowedAt ?? now) - now);
+        state.cooldownTimer = setTimeout(() => {
+            state.cooldownTimer = null;
+            if (state.pendingSessions.size === 0) {
+                state.phase = "fresh";
+                state.dirtyReasons.clear();
+                state.nextAllowedAt = null;
+                return;
+            }
+            state.phase = "stale";
+            this.startWorkspaceStateRefreshTask(key, workspaceId, userId, state);
+        }, delayMs);
     }
     async cleanupStaleHiddenSessions(workspaceId, userId, sessions) {
         const discoveredProviderSessionIds = new Set(sessions.map((session) => buildProviderSessionKey(session.provider, session.providerSessionId)));
@@ -1981,6 +2152,7 @@ export class SessionHistoryService {
         }
         const deleteTransaction = this.db.transaction((ids) => {
             for (const sessionId of ids) {
+                this.detachSessionRelationsBeforeDelete(sessionId);
                 this.deleteSessionById(sessionId);
             }
         });
@@ -2250,10 +2422,14 @@ export class SessionHistoryService {
         }
     }
     deleteSessionById(sessionId) {
+        this.sessionMessageAttachmentService.deleteSessionAttachments(sessionId);
         this.sessionChangedFileService.deleteBySessionId(sessionId);
         this.db
             .prepare("DELETE FROM session_message_attachments WHERE session_id = ?")
             .run(sessionId);
+        this.db
+            .prepare("DELETE FROM session_message_origins WHERE session_id = ?")
+            .run(sessionId);
         this.db
             .prepare("DELETE FROM session_send_queue WHERE session_id = ?")
             .run(sessionId);
@@ -2276,6 +2452,82 @@ export class SessionHistoryService {
             .prepare("DELETE FROM session_bindings WHERE session_id = ?")
             .run(sessionId);
     }
+    countOtherWorkspaceSessions(workspaceId, sessionId) {
+        const row = this.db
+            .prepare(`SELECT COUNT(*) AS count
+         FROM session_bindings
+         WHERE workspace_id = ?
+           AND session_id != ?`)
+            .get(workspaceId, sessionId);
+        return Number(row?.count ?? 0);
+    }
+    detachSessionRelationsBeforeDelete(sessionId) {
+        this.db
+            .prepare(`UPDATE session_indices
+         SET parent_session_id = NULL
+         WHERE parent_session_id = ?`)
+            .run(sessionId);
+        this.db
+            .prepare(`DELETE FROM session_forks
+         WHERE parent_session_id = ?
+            OR fork_source_session_id = ?`)
+            .run(sessionId, sessionId);
+        this.db
+            .prepare("DELETE FROM butler_control_sessions WHERE session_id = ?")
+            .run(sessionId);
+        const butlerSessionIds = this.db
+            .prepare(`SELECT id
+         FROM butler_sessions
+         WHERE session_id = ?`)
+            .all(sessionId)
+            .map((row) => String(row.id));
+        if (butlerSessionIds.length === 0) {
+            return;
+        }
+        const butlerPlaceholders = butlerSessionIds.map(() => "?").join(", ");
+        const checkpointIds = this.db
+            .prepare(`SELECT id
+         FROM session_checkpoints
+         WHERE butler_session_id IN (${butlerPlaceholders})`)
+            .all(...butlerSessionIds)
+            .map((row) => String(row.id));
+        if (checkpointIds.length > 0) {
+            const checkpointPlaceholders = checkpointIds.map(() => "?").join(", ");
+            this.db
+                .prepare(`UPDATE project_memories
+           SET source_checkpoint_id = NULL
+           WHERE source_checkpoint_id IN (${checkpointPlaceholders})`)
+                .run(...checkpointIds);
+        }
+        this.db
+            .prepare(`UPDATE project_memories
+         SET source_butler_session_id = NULL
+         WHERE source_butler_session_id IN (${butlerPlaceholders})`)
+            .run(...butlerSessionIds);
+        this.db
+            .prepare(`UPDATE patrol_runs
+         SET butler_session_id = NULL
+         WHERE butler_session_id IN (${butlerPlaceholders})`)
+            .run(...butlerSessionIds);
+        this.db
+            .prepare(`UPDATE verification_runs
+         SET butler_session_id = NULL
+         WHERE butler_session_id IN (${butlerPlaceholders})`)
+            .run(...butlerSessionIds);
+        this.db
+            .prepare("DELETE FROM butler_sessions WHERE session_id = ?")
+            .run(sessionId);
+    }
+    removeWorkspaceSessionRelation(sessionId) {
+        for (const relationMap of this.workspaceSessionRelations.values()) {
+            relationMap.delete(sessionId);
+            for (const relation of relationMap.values()) {
+                if (relation.parentSessionId === sessionId) {
+                    relation.parentSessionId = null;
+                }
+            }
+        }
+    }
     buildKnownSessionSummaries(sessions, workspacePath) {
         return sessions
             .filter((session) => !this.isPendingSessionAlias(session))
@@ -2451,6 +2703,19 @@ function createCodexForkTransportFactory(commandPath, homeDir) {
         };
     };
 }
+function createCodexThreadControlTransportFactory(commandPath, homeDir) {
+    return () => {
+        const client = new CodexAppServerHelperClient(commandPath, { homeDir });
+        const transport = client.createThreadControlTransport();
+        return {
+            ...transport,
+            close() {
+                transport.close();
+                client.dispose();
+            }
+        };
+    };
+}
 function buildInspectionActivityObservation(sessionId, inspection, observedAt) {
     const resolvedRunningState = inspection.runningState === "failed"
         ? "failed"
@@ -2532,6 +2797,11 @@ function buildSessionStateRefreshCandidates(items, recentCount) {
     }
     return Array.from(deduped.values());
 }
+function mergeWorkspaceStateRefreshSessions(target, sessions) {
+    for (const session of sessions) {
+        target.set(session.sessionId, session);
+    }
+}
 function isSessionStateRefreshCandidate(item) {
     return item.activityState === "running"
         || item.runningState === "starting"
@@ -2609,12 +2879,20 @@ function mergeSessionIndexRecord(input) {
         subagentLabel: input.target?.subagentLabel ?? input.source?.subagentLabel ?? null,
         title: pickPreferredSessionTitle(input.target?.title ?? null, input.source?.title ?? null),
         messageCount: Math.max(input.target?.messageCount ?? 0, input.source?.messageCount ?? 0),
-        isArchived: Boolean(input.target?.isArchived || input.source?.isArchived),
+        isArchived: mergePersistedArchiveState(input.provider, input.target?.isArchived, input.source?.isArchived),
         lastMessageAt: pickLaterIso(input.target?.lastMessageAt ?? null, input.source?.lastMessageAt ?? null),
         createdAt: pickEarlierIso(input.target?.createdAt ?? null, input.source?.createdAt ?? null) ?? input.timestamp,
         updatedAt: input.timestamp
     };
 }
+function mergePersistedArchiveState(provider, targetArchived, sourceArchived) {
+    // 只有 Codex 这类真实支持归档的 provider 才认底层归档真相；
+    // 其他 provider 的归档完全由 Host 本地索引维护，不能让旧副本把恢复状态再刷回去。
+    if (shouldUseProviderDiscoveredArchiveState(provider)) {
+        return Boolean(targetArchived || sourceArchived);
+    }
+    return targetArchived ?? sourceArchived ?? false;
+}
 function mergeSessionStatusSnapshot(input) {
     if (!input.target && !input.source) {
         return null;
@@ -2915,12 +3193,16 @@ function isCloseClaudeSessionTimestamp(left, right, maxGapMs = 2 * 60 * 1000) {
     }
     return Math.abs(leftAt - rightAt) <= maxGapMs;
 }
-function resolveDiscoveredArchiveState(existingArchived, discoveredArchived) {
-    if (existingArchived) {
-        return true;
+function resolveDiscoveredArchiveState(provider, existingArchived, discoveredArchived) {
+    if (!shouldUseProviderDiscoveredArchiveState(provider)) {
+        return existingArchived;
     }
     return discoveredArchived === true;
 }
+function shouldUseProviderDiscoveredArchiveState(provider) {
+    // 当前只有 Codex 的归档能稳定映射到底层文件位置；其余 provider 一律信本地 session_indices。
+    return provider === "codex";
+}
 function isMessageAtOrAfter(timestamp, minTimestamp) {
     if (!minTimestamp) {
         return true;
@@ -2942,6 +3224,9 @@ function isAcceptedUserMessageTimestamp(provider, timestamp, minTimestamp) {
 function isSyntheticKimiHistoryTimestamp(timestamp) {
     return timestamp.startsWith("2020-01-01T00:");
 }
+function isProviderSessionMissing(error) {
+    return error instanceof Error && error.message === "PROVIDER_SESSION_NOT_FOUND";
+}
 function createDeliveredHistoryMessageState() {
     return {
         signaturesByMessageId: new Map(),
@@ -3153,6 +3438,16 @@ function isSyntheticCodexSessionTitle(title) {
     return (/^rollout-\d{4}-\d{2}-\d{2}t/i.test(title) ||
         /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(title));
 }
+function shouldSyncSessionTitleFromProvider(provider, currentTitle) {
+    const normalizedTitle = currentTitle?.trim() ?? "";
+    if (normalizedTitle.length === 0) {
+        return true;
+    }
+    if (provider === "codex" && isSyntheticCodexSessionTitle(normalizedTitle)) {
+        return true;
+    }
+    return false;
+}
 function shouldRemoveHiddenClaudeDebugSession(session) {
     const normalizedRawStoreRef = session.rawStoreRef.replaceAll("\\", "/");
     if (normalizedRawStoreRef.includes("/subagents/")) {
@@ -3325,6 +3620,56 @@ function getAbortMessage(reason) {
     }
     return "任务已取消";
 }
+function areEquivalentSessionBindings(current, next) {
+    if (!current) {
+        return false;
+    }
+    return (current.sessionId === next.sessionId &&
+        current.workspaceId === next.workspaceId &&
+        current.provider === next.provider &&
+        current.providerSessionId === next.providerSessionId &&
+        current.rawStoreRef === next.rawStoreRef &&
+        current.createdAt === next.createdAt);
+}
+function areEquivalentSessionIndexRecords(current, next) {
+    if (!current) {
+        return false;
+    }
+    return (current.sessionId === next.sessionId &&
+        current.workspaceId === next.workspaceId &&
+        current.provider === next.provider &&
+        (current.parentSessionId ?? null) === (next.parentSessionId ?? null) &&
+        (current.sessionKind ?? "default") === (next.sessionKind ?? "default") &&
+        (current.annotationSourceMessageId ?? null) === (next.annotationSourceMessageId ?? null) &&
+        (current.annotationSourceText ?? null) === (next.annotationSourceText ?? null) &&
+        (current.isSubagent ?? false) === (next.isSubagent ?? false) &&
+        (current.subagentLabel ?? null) === (next.subagentLabel ?? null) &&
+        current.title === next.title &&
+        current.messageCount === next.messageCount &&
+        current.isArchived === next.isArchived &&
+        (current.lastMessageAt ?? null) === (next.lastMessageAt ?? null) &&
+        current.createdAt === next.createdAt);
+}
+function areEquivalentSessionStatusSnapshots(current, next) {
+    if (!current) {
+        return false;
+    }
+    return (current.sessionId === next.sessionId &&
+        current.syncStatus === next.syncStatus &&
+        (current.syncCursor ?? null) === (next.syncCursor ?? null) &&
+        (current.lastSyncAt ?? null) === (next.lastSyncAt ?? null) &&
+        (current.lastErrorCode ?? null) === (next.lastErrorCode ?? null) &&
+        (current.lastErrorDetail ?? null) === (next.lastErrorDetail ?? null) &&
+        (current.resumedAt ?? null) === (next.resumedAt ?? null));
+}
+function isSqliteBusyError(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const sqliteCode = "code" in error ? error.code : null;
+    const message = error instanceof Error ? error.message : String(error);
+    return sqliteCode === "SQLITE_BUSY" || message.includes("database is locked");
+}
 async function runBatchedTransactions(items, batchSize, transaction, logOptions) {
     const normalizedBatchSize = Math.max(1, Math.floor(batchSize) || 1);
     let batchCount = 0;
@@ -3332,7 +3677,20 @@ async function runBatchedTransactions(items, batchSize, transaction, logOptions)
     for (let index = 0; index < items.length; index += normalizedBatchSize) {
         const batch = items.slice(index, index + normalizedBatchSize);
         const batchStartedAt = Date.now();
-        transaction(batch);
+        let retryCount = 0;
+        while (true) {
+            try {
+                transaction(batch);
+                break;
+            }
+            catch (error) {
+                if (!isSqliteBusyError(error) || retryCount >= SQLITE_BUSY_RETRY_LIMIT) {
+                    throw error;
+                }
+                retryCount += 1;
+                await delay(SQLITE_BUSY_RETRY_DELAY_MS * retryCount);
+            }
+        }
         const batchDurationMs = Date.now() - batchStartedAt;
         const nextBatchIndex = batchCount + 1;
         if (logOptions) {
@@ -3341,6 +3699,7 @@ async function runBatchedTransactions(items, batchSize, transaction, logOptions)
                 batchIndex: nextBatchIndex,
                 batchSize: batch.length,
                 batchStartIndex: index,
+                retryCount,
                 totalItems: items.length,
                 configuredBatchSize: normalizedBatchSize
             }, {