@jingyi0605/codingns 0.3.5 → 0.4.0

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

@@ -14,13 +14,15 @@ import { SessionForkRepository } from "../../storage/repositories/session-fork-r
 import { enrichClaudeCapabilities } from "../provider/claude-model-options.js";
 import { CodexModelOptionsService, createFallbackCodexModelOptions, enrichCodexCapabilities } from "../provider/codex-model-options.js";
 import { OpenCodeModelOptionsService, createFallbackOpenCodeModelOptions, enrichOpenCodeCapabilities } from "../provider/opencode-model-options.js";
-import { ProviderDiscoveryHelperClient } from "../provider/provider-discovery-helper-client.js";
+import { getSharedProviderDiscoveryHelperClient } from "../provider/provider-discovery-helper-client.js";
+import { discoverWorkspaceSessionsInRuntime } from "../provider/provider-discovery-runtime.js";
 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";
 const RECONSTRUCTED_FORK_TARGET_PROVIDERS = new Set(["codex", "claude-code", "opencode"]);
 const FORK_RECONSTRUCTION_PAGE_SIZE = 200;
 const MAX_FORK_DEPTH = 4;
+const SYNTHETIC_CODEX_SESSION_CLEANUP_GRACE_MS = 120_000;
 const SESSION_START_DEFERRED_PROVIDERS = new Set([
     "codex",
     "claude-code",
@@ -30,8 +32,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;
@@ -52,14 +59,15 @@ export class SessionHistoryService {
     openCodeModelOptionsService;
     providerCliCommandPaths;
     providerCliAvailability;
-    providerDiscoveryHelperClient = new ProviderDiscoveryHelperClient();
+    providerDiscoveryHelperClient = getSharedProviderDiscoveryHelperClient();
     providerSessionDiscoveryConfig;
     taskManager;
     workspaceDiscoveryStatuses = new Map();
-    workspaceStateRefreshInflight = new Map();
+    workspaceStateRefreshStatuses = new Map();
     providerCapabilityCache = new Map();
     liveActivityObservationResolvers = 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;
@@ -148,8 +156,17 @@ export class SessionHistoryService {
         if (!this.taskManager.has(HOST_TASK_TYPES.workspaceDiscovery)) {
             this.taskManager.register({
                 taskType: HOST_TASK_TYPES.workspaceDiscovery,
+                executionLane: "host_background",
+                run: async ({ workspaceId, userId, refreshStateMode }, context) => this.runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode, context.signal)
+            });
+        }
+        if (!this.taskManager.has(HOST_TASK_TYPES.workspaceDiscoveryScan)) {
+            this.taskManager.register({
+                taskType: HOST_TASK_TYPES.workspaceDiscoveryScan,
                 executionLane: "helper_process",
-                run: async ({ workspaceId, userId, refreshStateMode }) => this.runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode)
+                concurrency: WORKSPACE_DISCOVERY_SCAN_CONCURRENCY,
+                helperProcessHandler: "session.workspace_discovery",
+                run: async ({ config, workspacePath, knownSessions }, context) => await discoverWorkspaceSessionsInRuntime(config, workspacePath, knownSessions, context.signal)
             });
         }
         if (!this.taskManager.has(HOST_TASK_TYPES.providerCapabilityRefresh)) {
@@ -233,7 +250,10 @@ export class SessionHistoryService {
     async readSessionHistory(sessionId, cursor, limit, direction = "forward", userId) {
         const startedAt = Date.now();
         const resolvedSessionId = this.resolveCanonicalSessionId(sessionId, userId);
-        const binding = this.getBindingOrThrow(resolvedSessionId);
+        let binding = this.getBindingOrThrow(resolvedSessionId);
+        if (userId) {
+            binding = await this.repairCodexDirtyBindingBeforeHistoryRead(resolvedSessionId, userId, binding);
+        }
         const current = this.sessionStatusSnapshotRepository.findBySessionId(resolvedSessionId);
         const safeLimit = clampLimit(limit);
         const knownTotalMessageCount = direction === "backward" && cursor === null
@@ -305,6 +325,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));
@@ -335,17 +361,17 @@ export class SessionHistoryService {
         await this.refreshSessionState(sessionId, userId);
         return this.enrichSessionItem(this.getSessionListItemOrThrow(sessionId, userId));
     }
-    async syncSessionTitle(sessionId) {
+    async syncSessionTitle(sessionId, signal) {
         const binding = this.getBindingOrThrow(sessionId);
-        await this.syncSessionTitleFromProvider(sessionId, binding);
+        await this.syncSessionTitleFromProvider(sessionId, binding, signal);
     }
-    async syncWorkspaceSessionTitles(workspaceId, userId, concurrency = 1) {
+    async syncWorkspaceSessionTitles(workspaceId, userId, concurrency = 1, signal) {
         const sessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
         await runWithConcurrency(sessions, concurrency, async (session) => {
-            await this.syncSessionTitle(session.sessionId).catch(() => {
+            await this.syncSessionTitle(session.sessionId, signal).catch(() => {
                 return;
             });
-        });
+        }, signal);
     }
     async listSessionChangedFiles(sessionId, userId) {
         this.getSession(sessionId, userId);
@@ -1137,7 +1163,7 @@ export class SessionHistoryService {
             }
         }
     }
-    async runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode = "inline") {
+    async runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode = "inline", signal) {
         const startedAt = Date.now();
         const debugStartedAtMs = terminalDebugNowMs();
         const workspace = this.getWorkspaceOrThrow(workspaceId);
@@ -1158,13 +1184,16 @@ export class SessionHistoryService {
             const discoverStartedAt = Date.now();
             const existingWorkspaceSessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
             const knownSessions = this.buildKnownSessionSummaries(existingWorkspaceSessions, workspace.path);
-            const discovery = await this.providerDiscoveryHelperClient
-                .discoverWorkspaceSessions({
-                config: this.providerSessionDiscoveryConfig,
-                workspacePath: workspace.path,
-                knownSessions
-            })
-                .catch((error) => {
+            const discoveryHandle = this.taskManager.enqueue(HOST_TASK_TYPES.workspaceDiscoveryScan, {
+                key: workspaceId,
+                source: "session_history.workspace_discovery.scan",
+                input: {
+                    config: this.providerSessionDiscoveryConfig,
+                    workspacePath: workspace.path,
+                    knownSessions
+                }
+            });
+            const discovery = await awaitTaskHandleWithSignal(discoveryHandle, signal).catch((error) => {
                 throw mapSessionProviderError(error);
             });
             const sessions = discovery.sessions;
@@ -1198,7 +1227,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,
@@ -1206,7 +1235,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;
@@ -1214,7 +1246,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,
@@ -1226,12 +1258,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,
@@ -1240,18 +1275,30 @@ 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
                     });
                 }
             });
             const persistPass1StartedAt = Date.now();
-            const persistPass1Stats = await runBatchedTransactions(sessions, WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, persistPass1Transaction);
+            const persistPass1Stats = await runBatchedTransactions(sessions, WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, persistPass1Transaction, {
+                scope: "workspace.discover_sessions.persist_pass1.batch",
+                thresholdMs: SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS,
+                detail: {
+                    workspaceId,
+                    workspacePath: workspace.path,
+                    phase: "pass1"
+                }
+            });
             persistPass1DurationMs = Date.now() - persistPass1StartedAt;
             persistPass1BatchCount = persistPass1Stats.batchCount;
             persistPass1MaxBatchMs = persistPass1Stats.maxBatchMs;
@@ -1268,7 +1315,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,
@@ -1290,15 +1337,26 @@ 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();
-            const persistPass2Stats = await runBatchedTransactions(persistedSessions, WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, persistPass2Transaction);
+            const persistPass2Stats = await runBatchedTransactions(persistedSessions, WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, persistPass2Transaction, {
+                scope: "workspace.discover_sessions.persist_pass2.batch",
+                thresholdMs: SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS,
+                detail: {
+                    workspaceId,
+                    workspacePath: workspace.path,
+                    phase: "pass2"
+                }
+            });
             persistPass2DurationMs = Date.now() - persistPass2StartedAt;
             persistPass2BatchCount = persistPass2Stats.batchCount;
             persistPass2MaxBatchMs = persistPass2Stats.maxBatchMs;
@@ -1354,7 +1412,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,
@@ -1509,13 +1582,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) {
@@ -1532,21 +1598,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
             };
         });
     }
@@ -1677,7 +1732,7 @@ export class SessionHistoryService {
             messages
         });
     }
-    async syncSessionTitleFromProvider(sessionId, binding) {
+    async syncSessionTitleFromProvider(sessionId, binding, signal) {
         const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
         if (!currentIndex) {
             return;
@@ -1685,12 +1740,15 @@ 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,
             providerSessionId: binding.providerSessionId,
             rawStoreRef: binding.rawStoreRef
-        })).trim();
+        }, signal)).trim();
         const resolvedTitle = resolvePersistedSessionTitle(binding.provider, nextTitle, currentIndex.title);
         if (resolvedTitle.length === 0 || resolvedTitle === currentIndex.title) {
             return;
@@ -1893,13 +1951,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
@@ -1908,6 +2024,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,
@@ -1918,13 +2037,47 @@ 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)));
         const discoveredRawStoreRefs = new Set(sessions.map((session) => session.rawStoreRef));
+        const nowMs = Date.now();
         const staleHiddenSessions = this.sessionIndexRepository
             .listByWorkspace(workspaceId, userId)
             .filter((session) => {
@@ -1936,10 +2089,13 @@ export class SessionHistoryService {
             }
             return ((session.provider === "codex" &&
                 (isLegacyCodingNsRolloutSession(session.providerSessionId, session.rawStoreRef) ||
-                    shouldRemoveMissingSyntheticCodexSession(session.rawStoreRef))) ||
+                    (shouldRemoveMissingSyntheticCodexSession(session.rawStoreRef) &&
+                        !this.shouldPreserveSyntheticCodexSession(session, nowMs)))) ||
                 (session.provider === "claude-code" && shouldRemoveHiddenClaudeDebugSession(session)));
         });
-        if (staleHiddenSessions.length === 0) {
+        const managedButlerSessionIds = this.listManagedButlerSessionIds(staleHiddenSessions.map((session) => session.sessionId));
+        const deletableSessions = staleHiddenSessions.filter((session) => !managedButlerSessionIds.has(session.sessionId));
+        if (deletableSessions.length === 0) {
             return;
         }
         const deleteTransaction = this.db.transaction((ids) => {
@@ -1947,7 +2103,53 @@ export class SessionHistoryService {
                 this.deleteSessionById(sessionId);
             }
         });
-        await runBatchedTransactions(staleHiddenSessions.map((session) => session.sessionId), WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, deleteTransaction);
+        await runBatchedTransactions(deletableSessions.map((session) => session.sessionId), WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, deleteTransaction, {
+            scope: "workspace.discover_sessions.cleanup_hidden.batch",
+            thresholdMs: SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS,
+            detail: {
+                workspaceId,
+                userId,
+                phase: "cleanup_hidden"
+            }
+        });
+    }
+    listManagedButlerSessionIds(sessionIds) {
+        if (sessionIds.length === 0) {
+            return new Set();
+        }
+        const managedSessionIds = new Set();
+        for (let index = 0; index < sessionIds.length; index += WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE) {
+            const batch = sessionIds.slice(index, index + WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE);
+            const placeholders = batch.map(() => "?").join(", ");
+            const rows = this.db
+                .prepare(`SELECT session_id
+           FROM butler_sessions
+           WHERE session_id IN (${placeholders})`)
+                .all(...batch);
+            for (const row of rows) {
+                managedSessionIds.add(row.session_id);
+            }
+        }
+        return managedSessionIds;
+    }
+    shouldPreserveSyntheticCodexSession(session, nowMs) {
+        if (session.activitySource === "runtime"
+            || session.runningState === "starting"
+            || session.runningState === "running") {
+            return true;
+        }
+        const hasActiveRuntimeState = this.listSessionStatesBySessionId(session.sessionId).some((state) => state.activitySource === "runtime"
+            || state.runningState === "starting"
+            || state.runningState === "running");
+        if (hasActiveRuntimeState) {
+            return true;
+        }
+        const latestTouchedAt = pickLaterIso(session.updatedAt, session.createdAt) ?? session.updatedAt;
+        const latestTouchedAtMs = Date.parse(latestTouchedAt);
+        if (!Number.isFinite(latestTouchedAtMs)) {
+            return false;
+        }
+        return nowMs - latestTouchedAtMs <= SYNTHETIC_CODEX_SESSION_CLEANUP_GRACE_MS;
     }
     findSameWorkspaceBindingDuplicate(sessionId, workspaceId, snapshot) {
         if (isPendingBindingValue(snapshot.providerSessionId)) {
@@ -2282,6 +2484,18 @@ export class SessionHistoryService {
         });
         return nextRecord;
     }
+    async repairCodexDirtyBindingBeforeHistoryRead(sessionId, userId, binding) {
+        if (!shouldRepairCodexDirtyBinding(binding)) {
+            return binding;
+        }
+        await this.discoverWorkspaceSessions(binding.workspaceId, userId, {
+            force: true,
+            refreshStateMode: "deferred"
+        }).catch(() => {
+            return [];
+        });
+        return this.getBindingOrThrow(sessionId);
+    }
     resolveLiveActivityObservation(sessionId) {
         for (const resolver of this.liveActivityObservationResolvers) {
             const observation = resolver(sessionId);
@@ -2437,6 +2651,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"
@@ -2514,12 +2733,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;
@@ -2820,12 +3047,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;
@@ -2945,6 +3176,48 @@ function isLegacyCodingNsRolloutSession(providerSessionId, rawStoreRef) {
 function shouldRemoveMissingSyntheticCodexSession(rawStoreRef) {
     return isSyntheticCodexRawStoreRef(rawStoreRef) && !existsSync(rawStoreRef);
 }
+function shouldRepairCodexDirtyBinding(binding) {
+    if (binding.provider !== "codex") {
+        return false;
+    }
+    if (isSyntheticCodexRawStoreRef(binding.rawStoreRef)) {
+        return false;
+    }
+    const expectedThreadId = binding.providerSessionId.trim();
+    if (!expectedThreadId) {
+        return false;
+    }
+    const boundThreadId = readCodexThreadIdFromRawStore(binding.rawStoreRef);
+    if (boundThreadId) {
+        return boundThreadId !== expectedThreadId;
+    }
+    return !existsSync(binding.rawStoreRef);
+}
+function readCodexThreadIdFromRawStore(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const firstLine = readFileSync(filePath, "utf8")
+            .split(/\r?\n/, 1)
+            .at(0)
+            ?.trim();
+        if (!firstLine) {
+            return null;
+        }
+        const record = JSON.parse(firstLine);
+        if (record.type !== "session_meta") {
+            return null;
+        }
+        const threadId = typeof record.payload?.id === "string"
+            ? record.payload.id.trim()
+            : "";
+        return threadId.length > 0 ? threadId : null;
+    }
+    catch {
+        return null;
+    }
+}
 function shouldMatchSessionBindingByRawStoreRef(provider) {
     return provider !== "codex";
 }
@@ -3016,6 +3289,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/")) {
@@ -3134,13 +3417,14 @@ function buildReconstructedForkPrompt(input) {
 function buildProviderCapabilityCacheKey(provider, workspacePath) {
     return `${provider}::${workspacePath ?? ""}`;
 }
-async function runWithConcurrency(items, concurrency, worker) {
+async function runWithConcurrency(items, concurrency, worker, signal) {
     const normalizedConcurrency = Math.max(1, Math.floor(concurrency) || 1);
     const queue = [...items];
     const runners = Array.from({
         length: Math.min(normalizedConcurrency, queue.length || 1)
     }, async () => {
         while (queue.length > 0) {
+            throwIfAborted(signal);
             const current = queue.shift();
             if (current === undefined) {
                 return;
@@ -3150,15 +3434,129 @@ async function runWithConcurrency(items, concurrency, worker) {
     });
     await Promise.all(runners);
 }
-async function runBatchedTransactions(items, batchSize, transaction) {
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw signal.reason ?? new Error("任务已取消");
+    }
+}
+async function awaitTaskHandleWithSignal(handle, signal) {
+    if (!signal) {
+        return await handle.promise;
+    }
+    if (signal.aborted) {
+        handle.cancel(getAbortMessage(signal.reason));
+        throw signal.reason ?? new Error("任务已取消");
+    }
+    return await new Promise((resolve, reject) => {
+        const onAbort = () => {
+            handle.cancel(getAbortMessage(signal.reason));
+            reject(signal.reason ?? new Error("任务已取消"));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        handle.promise.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}
+function getAbortMessage(reason) {
+    if (reason instanceof Error && reason.message.trim().length > 0) {
+        return reason.message;
+    }
+    if (typeof reason === "string" && reason.trim().length > 0) {
+        return 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;
     let maxBatchMs = 0;
     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) {
+            logPerformance(logOptions.scope, batchDurationMs, {
+                ...logOptions.detail,
+                batchIndex: nextBatchIndex,
+                batchSize: batch.length,
+                batchStartIndex: index,
+                retryCount,
+                totalItems: items.length,
+                configuredBatchSize: normalizedBatchSize
+            }, {
+                thresholdMs: logOptions.thresholdMs ?? SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS
+            });
+        }
         batchCount += 1;
         maxBatchMs = Math.max(maxBatchMs, batchDurationMs);
         if (index + normalizedBatchSize < items.length) {