@jingyi0605/codingns 0.3.0 → 0.3.6

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",
@@ -32,6 +34,7 @@ const MUTABLE_HISTORY_TAIL_REFRESH_INTERVAL_MS = 1_200;
 const WORKSPACE_DISCOVERY_BACKGROUND_MAX_AGE_MS = 15_000;
 const PROVIDER_CAPABILITY_CACHE_MAX_AGE_MS = 5_000;
 const WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE = 25;
+const SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS = 150;
 export class SessionHistoryService {
     db;
     workspaceRepository;
@@ -52,7 +55,7 @@ export class SessionHistoryService {
     openCodeModelOptionsService;
     providerCliCommandPaths;
     providerCliAvailability;
-    providerDiscoveryHelperClient = new ProviderDiscoveryHelperClient();
+    providerDiscoveryHelperClient = getSharedProviderDiscoveryHelperClient();
     providerSessionDiscoveryConfig;
     taskManager;
     workspaceDiscoveryStatuses = new Map();
@@ -148,8 +151,16 @@ 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)
+                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 +244,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
@@ -335,17 +349,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);
@@ -1090,41 +1104,54 @@ export class SessionHistoryService {
             providerSessionId: snapshot.providerSessionId,
             rawStoreRef: snapshot.rawStoreRef
         });
-        const currentBinding = this.sessionBindingRepository.findBySessionId(sessionId);
-        const timestamp = nowIso();
-        const duplicateBinding = this.findSameWorkspaceBindingDuplicate(sessionId, workspaceId, resolvedSnapshot);
-        this.db.transaction(() => {
-            if (duplicateBinding) {
-                // 运行时链路显式指定了当前 sessionId，就应该由当前会话接管同工作区里的重复底层会话。
-                // 否则后续事件重放或后台发现补录都会持续撞 UNIQUE(provider, provider_session_id)。
-                this.mergeSessionIntoTarget({
-                    workspaceId,
-                    targetSessionId: sessionId,
-                    sourceSessionId: duplicateBinding.sessionId,
-                    provider: resolvedSnapshot.provider,
-                    timestamp
-                });
+        // discovery 和 runtime 回填会并发命中这里；如果在事务外先看重复，再事务内写入，
+        // 中间就会留下一个竞态窗口，最后直接撞 UNIQUE(provider, provider_session_id)。
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            try {
+                this.db.transaction(() => {
+                    const currentBinding = this.sessionBindingRepository.findBySessionId(sessionId);
+                    const timestamp = nowIso();
+                    const duplicateBinding = this.findSameWorkspaceBindingDuplicate(sessionId, workspaceId, resolvedSnapshot);
+                    if (duplicateBinding) {
+                        // 运行时链路显式指定了当前 sessionId，就应该由当前会话接管同工作区里的重复底层会话。
+                        // 否则后续事件重放或后台发现补录都会持续撞 UNIQUE(provider, provider_session_id)。
+                        this.mergeSessionIntoTarget({
+                            workspaceId,
+                            targetSessionId: sessionId,
+                            sourceSessionId: duplicateBinding.sessionId,
+                            provider: resolvedSnapshot.provider,
+                            timestamp
+                        });
+                    }
+                    const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+                    this.sessionBindingRepository.upsert({
+                        sessionId,
+                        workspaceId,
+                        provider: resolvedSnapshot.provider,
+                        providerSessionId: resolvedSnapshot.providerSessionId,
+                        rawStoreRef: resolvedSnapshot.rawStoreRef,
+                        createdAt: pickEarlierIso(currentBinding?.createdAt ?? null, duplicateBinding?.createdAt ?? null)
+                            ?? timestamp,
+                        updatedAt: timestamp
+                    });
+                    if (currentIndex) {
+                        this.sessionIndexRepository.upsert({
+                            ...currentIndex,
+                            updatedAt: timestamp
+                        });
+                    }
+                })();
+                return;
             }
-            const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
-            this.sessionBindingRepository.upsert({
-                sessionId,
-                workspaceId,
-                provider: resolvedSnapshot.provider,
-                providerSessionId: resolvedSnapshot.providerSessionId,
-                rawStoreRef: resolvedSnapshot.rawStoreRef,
-                createdAt: pickEarlierIso(currentBinding?.createdAt ?? null, duplicateBinding?.createdAt ?? null)
-                    ?? timestamp,
-                updatedAt: timestamp
-            });
-            if (currentIndex) {
-                this.sessionIndexRepository.upsert({
-                    ...currentIndex,
-                    updatedAt: timestamp
-                });
+            catch (error) {
+                if (attempt === 0 && isSessionBindingProviderUniqueConflict(error)) {
+                    continue;
+                }
+                throw error;
             }
-        })();
+        }
     }
-    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);
@@ -1145,13 +1172,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;
@@ -1162,7 +1192,9 @@ export class SessionHistoryService {
             const claimedPendingSessionIds = new Set();
             const persistPass1Transaction = this.db.transaction((batch) => {
                 for (const session of batch) {
-                    const exactExisting = this.sessionBindingRepository.findByProviderSession(session.provider, session.providerSessionId) ?? this.sessionBindingRepository.findByRawStoreRef(session.provider, session.rawStoreRef);
+                    const exactExisting = this.sessionBindingRepository.findByProviderSession(session.provider, session.providerSessionId) ?? (shouldMatchSessionBindingByRawStoreRef(session.provider)
+                        ? this.sessionBindingRepository.findByRawStoreRef(session.provider, session.rawStoreRef)
+                        : null);
                     if (exactExisting && exactExisting.workspaceId !== workspaceId) {
                         continue;
                     }
@@ -1236,7 +1268,15 @@ export class SessionHistoryService {
                 }
             });
             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;
@@ -1283,7 +1323,15 @@ export class SessionHistoryService {
                 }
             });
             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;
@@ -1405,12 +1453,13 @@ export class SessionHistoryService {
             ? this.sessionSyncService.readRecentHistory(provider, providerSessionId, rawStoreRef, knownTotalMessageCount, limit)
             : this.sessionSyncService.readHistory(provider, providerSessionId, rawStoreRef, cursor, limit, direction);
         return historyTask
-            .then((page) => {
-            const messagesWithAttachments = this.sessionMessageAttachmentService.enrichMessages(sessionId, page.messages);
+            .then(async (page) => {
+            const sanitizedPage = await this.sanitizeForkHistoryPage(sessionId, page, cursor, direction);
+            const messagesWithAttachments = this.sessionMessageAttachmentService.enrichMessages(sessionId, sanitizedPage.messages);
             const messages = this.enrichMessagesWithOrigin(sessionId, messagesWithAttachments);
             this.persistSessionChangedFiles(sessionId, messages);
             return {
-                ...page,
+                ...sanitizedPage,
                 messages
             };
         })
@@ -1429,6 +1478,56 @@ export class SessionHistoryService {
     enrichMessagesWithOrigin(sessionId, messages) {
         return this.resolveMessageOrigins(sessionId, messages);
     }
+    async sanitizeForkHistoryPage(sessionId, page, cursor, direction) {
+        if (direction !== "forward" || cursor !== null || page.messages.length === 0) {
+            return page;
+        }
+        const forkRecord = this.sessionForkRepository.findBySessionId(sessionId);
+        if (!forkRecord
+            || forkRecord.forkSourceType !== "message"
+            || !forkRecord.forkSourceMessageId) {
+            return page;
+        }
+        const childSession = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        const childCreatedAt = childSession?.createdAt?.trim() || null;
+        if (!childCreatedAt) {
+            return page;
+        }
+        const parentBinding = this.getBindingOrThrow(forkRecord.forkSourceSessionId);
+        const inheritedMessages = await this.readForkSourceMessages(forkRecord.forkSourceSessionId, parentBinding, "message", forkRecord.forkSourceMessageId, null);
+        const expectedInheritedCount = inheritedMessages.length;
+        if (expectedInheritedCount <= 0) {
+            return page;
+        }
+        const parentMessages = await this.readForkSourceMessages(forkRecord.forkSourceSessionId, parentBinding, "session", null, null);
+        let leakedInheritedCount = countCommonHistoryPrefixLength(page.messages.slice(expectedInheritedCount), parentMessages.slice(expectedInheritedCount));
+        if (leakedInheritedCount <= 0) {
+            for (let index = expectedInheritedCount; index < page.messages.length; index += 1) {
+                const message = page.messages[index];
+                if (!message || message.timestamp > childCreatedAt) {
+                    break;
+                }
+                leakedInheritedCount += 1;
+            }
+        }
+        if (forkRecord.inheritedPrefixMessageCount !== expectedInheritedCount) {
+            this.sessionForkRepository.upsert({
+                ...forkRecord,
+                inheritedPrefixMessageCount: expectedInheritedCount
+            });
+        }
+        if (leakedInheritedCount <= 0) {
+            return page;
+        }
+        return {
+            ...page,
+            messages: [
+                ...page.messages.slice(0, expectedInheritedCount),
+                ...page.messages.slice(expectedInheritedCount + leakedInheritedCount)
+            ],
+            total: Math.max(0, page.total - leakedInheritedCount)
+        };
+    }
     resolveMessageOrigins(sessionId, messages) {
         const originRepository = this.sessionMessageOriginRepository;
         if (!originRepository || messages.length === 0) {
@@ -1611,7 +1710,7 @@ export class SessionHistoryService {
             messages
         });
     }
-    async syncSessionTitleFromProvider(sessionId, binding) {
+    async syncSessionTitleFromProvider(sessionId, binding, signal) {
         const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
         if (!currentIndex) {
             return;
@@ -1624,7 +1723,7 @@ export class SessionHistoryService {
             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;
@@ -1683,7 +1782,13 @@ export class SessionHistoryService {
         return workspace;
     }
     getSessionListItemOrThrow(sessionId, userId) {
-        const item = this.sessionIndexRepository.findBySessionId(sessionId, userId);
+        const canonicalSessionId = this.resolveCanonicalSessionId(sessionId, userId);
+        const item = this.findSessionListItem(canonicalSessionId, sessionId, userId)
+            ?? this.repairMissingSessionListItem(canonicalSessionId, userId)
+            ?? (canonicalSessionId === sessionId
+                ? null
+                : this.repairMissingSessionListItem(sessionId, userId))
+            ?? this.findSessionListItem(canonicalSessionId, sessionId, userId);
         if (!item) {
             throw new AppError({
                 statusCode: 500,
@@ -1697,6 +1802,75 @@ export class SessionHistoryService {
         }
         return this.sessionIndexRepository.findBySessionId(aliasTargetSessionId, userId) ?? item;
     }
+    findSessionListItem(canonicalSessionId, sessionId, userId) {
+        return (this.sessionIndexRepository.findBySessionId(canonicalSessionId, userId)
+            ?? (canonicalSessionId === sessionId
+                ? null
+                : this.sessionIndexRepository.findBySessionId(sessionId, userId)));
+    }
+    repairMissingSessionListItem(sessionId, userId) {
+        const binding = this.sessionBindingRepository.findBySessionId(sessionId);
+        if (!binding) {
+            return null;
+        }
+        const existingIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        const existingSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        const existingState = this.sessionStateRepository.findBySessionAndUser(sessionId, userId);
+        const timestamp = nowIso();
+        const fallbackLastMessageAt = existingIndex?.lastMessageAt
+            ?? existingState?.lastEventAt
+            ?? existingSnapshot?.lastSyncAt
+            ?? null;
+        const fallbackCreatedAt = pickEarlierIso(binding.createdAt, existingIndex?.createdAt ?? null)
+            ?? timestamp;
+        this.db.transaction(() => {
+            this.sessionIndexRepository.upsert({
+                sessionId,
+                workspaceId: binding.workspaceId,
+                provider: binding.provider,
+                parentSessionId: existingIndex?.parentSessionId ?? this.sessionForkRepository.findBySessionId(sessionId)?.parentSessionId ?? null,
+                sessionKind: existingIndex?.sessionKind ?? "default",
+                annotationSourceMessageId: existingIndex?.annotationSourceMessageId ?? null,
+                annotationSourceText: existingIndex?.annotationSourceText ?? null,
+                isSubagent: existingIndex?.isSubagent ?? false,
+                subagentLabel: existingIndex?.subagentLabel ?? null,
+                title: existingIndex?.title?.trim()
+                    || buildRecoveredSessionTitle(binding.provider, binding.providerSessionId),
+                messageCount: existingIndex?.messageCount ?? 0,
+                isArchived: existingIndex?.isArchived ?? false,
+                lastMessageAt: fallbackLastMessageAt,
+                createdAt: fallbackCreatedAt,
+                updatedAt: timestamp
+            });
+            if (!existingSnapshot) {
+                this.sessionStatusSnapshotRepository.upsert({
+                    sessionId,
+                    syncStatus: "idle",
+                    syncCursor: null,
+                    lastSyncAt: fallbackLastMessageAt,
+                    lastErrorCode: null,
+                    lastErrorDetail: null,
+                    resumedAt: null,
+                    updatedAt: timestamp
+                });
+            }
+            if (!existingState) {
+                this.sessionStateRepository.upsert({
+                    sessionId,
+                    userId,
+                    runningState: inferRecoveredSessionRunningState(binding),
+                    activitySource: inferRecoveredSessionActivitySource(binding),
+                    favorite: false,
+                    lastEventAt: shouldRecoverSessionAsActive(binding) ? (binding.updatedAt || timestamp) : fallbackLastMessageAt,
+                    completedAt: null,
+                    lastSeenAt: null,
+                    updatedAt: timestamp
+                });
+            }
+        })();
+        console.warn(`[session-history] repaired missing session index for ${sessionId} (${binding.provider})`);
+        return this.sessionIndexRepository.findBySessionId(sessionId, userId);
+    }
     resolveCanonicalSessionId(sessionId, userId) {
         if (userId) {
             const item = this.sessionIndexRepository.findBySessionId(sessionId, userId);
@@ -1784,6 +1958,7 @@ export class SessionHistoryService {
     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) => {
@@ -1795,10 +1970,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) => {
@@ -1806,13 +1984,61 @@ 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)) {
             return null;
         }
-        const existing = this.sessionBindingRepository.findByProviderSession(snapshot.provider, snapshot.providerSessionId) ?? this.sessionBindingRepository.findByRawStoreRef(snapshot.provider, snapshot.rawStoreRef);
+        const existing = this.sessionBindingRepository.findByProviderSession(snapshot.provider, snapshot.providerSessionId) ?? (shouldMatchSessionBindingByRawStoreRef(snapshot.provider)
+            ? this.sessionBindingRepository.findByRawStoreRef(snapshot.provider, snapshot.rawStoreRef)
+            : null);
         if (!existing || existing.sessionId === sessionId) {
             return null;
         }
@@ -1825,11 +2051,22 @@ export class SessionHistoryService {
         if (input.targetSessionId === input.sourceSessionId) {
             return;
         }
-        const targetBinding = this.sessionBindingRepository.findBySessionId(input.targetSessionId);
         const sourceBinding = this.sessionBindingRepository.findBySessionId(input.sourceSessionId);
-        if (!targetBinding || !sourceBinding) {
+        if (!sourceBinding) {
             return;
         }
+        const targetBinding = this.sessionBindingRepository.findBySessionId(input.targetSessionId);
+        if (!targetBinding) {
+            this.sessionBindingRepository.upsert({
+                sessionId: input.targetSessionId,
+                workspaceId: input.workspaceId,
+                provider: input.provider,
+                providerSessionId: buildPendingBindingValue(input.provider, input.targetSessionId),
+                rawStoreRef: buildPendingBindingValue(input.provider, input.targetSessionId),
+                createdAt: sourceBinding.createdAt,
+                updatedAt: input.timestamp
+            });
+        }
         const targetIndex = this.sessionIndexRepository.findIndexRecordBySessionId(input.targetSessionId);
         const sourceIndex = this.sessionIndexRepository.findIndexRecordBySessionId(input.sourceSessionId);
         const targetSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(input.targetSessionId);
@@ -2128,6 +2365,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);
@@ -2215,6 +2464,7 @@ function buildInspectionActivityObservation(sessionId, inspection, observedAt) {
         source: hasInspectionEvidence(inspection) ? "inferred_log" : "unknown",
         confidence: "weak",
         detail: inspection.errorDetail,
+        interruptSource: null,
         errorCode: inspection.errorCode,
         observedAt: inspection.completedAtCandidate ?? inspection.lastEventAt ?? observedAt
     };
@@ -2448,6 +2698,35 @@ function normalizeSessionBindingSnapshot(sessionId, snapshot) {
         rawStoreRef: buildPendingBindingValue("claude-code", sessionId)
     };
 }
+function countCommonHistoryPrefixLength(left, right) {
+    const maxLength = Math.min(left.length, right.length);
+    let count = 0;
+    for (; count < maxLength; count += 1) {
+        if (!areHistoryMessagesEquivalent(left[count], right[count])) {
+            break;
+        }
+    }
+    return count;
+}
+function areHistoryMessagesEquivalent(left, right) {
+    if (!left || !right) {
+        return false;
+    }
+    if (left.messageId && right.messageId) {
+        if (left.messageId === right.messageId) {
+            return true;
+        }
+    }
+    if (left.rawRef && right.rawRef) {
+        if (left.rawRef === right.rawRef) {
+            return true;
+        }
+    }
+    return left.role === right.role
+        && left.kind === right.kind
+        && left.content === right.content
+        && left.timestamp === right.timestamp;
+}
 function shouldSkipClaudePendingBinding(binding) {
     if (binding.provider !== "claude-code") {
         return false;
@@ -2460,9 +2739,24 @@ function shouldSkipClaudePendingBinding(binding) {
 function isPendingBindingValue(value) {
     return value.trim().toLowerCase().startsWith("pending://");
 }
+function isSessionBindingProviderUniqueConflict(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.message.includes("UNIQUE constraint failed: session_bindings.provider, session_bindings.provider_session_id");
+}
 function buildPendingBindingValue(provider, sessionId) {
     return `pending://${provider}/${sessionId}`;
 }
+function shouldRecoverSessionAsActive(binding) {
+    return isPendingBindingValue(binding.providerSessionId) || isPendingBindingValue(binding.rawStoreRef);
+}
+function inferRecoveredSessionRunningState(binding) {
+    return shouldRecoverSessionAsActive(binding) ? "starting" : "idle";
+}
+function inferRecoveredSessionActivitySource(binding) {
+    return shouldRecoverSessionAsActive(binding) ? "runtime" : "none";
+}
 function buildAliasBindingValue(provider, targetSessionId, sourceSessionId) {
     return `alias://${provider}/${targetSessionId}/${sourceSessionId}`;
 }
@@ -2746,6 +3040,51 @@ 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";
+}
 function resolveSessionListTitle(provider, existingTitle, fallbackContent, parentTitle = null) {
     const normalizedExistingTitle = existingTitle?.trim() ?? "";
     const normalizedParentTitle = parentTitle?.trim() ?? "";
@@ -2768,6 +3107,24 @@ function buildUserMessageTitle(content, fallbackTitle) {
     const title = content.trim().replace(/\s+/g, " ");
     return title.slice(0, 48) || fallbackTitle;
 }
+function buildRecoveredSessionTitle(provider, providerSessionId) {
+    if (isPendingBindingValue(providerSessionId)) {
+        return "新会话";
+    }
+    const normalizedProvider = provider.trim().toLowerCase();
+    const providerLabel = normalizedProvider === "claude-code"
+        ? "Claude"
+        : normalizedProvider === "codex"
+            ? "Codex"
+            : normalizedProvider === "gemini"
+                ? "Gemini"
+                : normalizedProvider === "kimi"
+                    ? "Kimi"
+                    : normalizedProvider === "opencode"
+                        ? "OpenCode"
+                        : provider;
+    return `${providerLabel} 会话 ${providerSessionId.slice(0, 8)}`;
+}
 function resolvePersistedSessionTitle(provider, discoveredTitle, existingTitle, parentTitle = null) {
     const nextTitle = discoveredTitle.trim();
     const currentTitle = existingTitle?.trim() ?? "";
@@ -2914,13 +3271,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;
@@ -2930,7 +3288,44 @@ 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 "任务已取消";
+}
+async function runBatchedTransactions(items, batchSize, transaction, logOptions) {
     const normalizedBatchSize = Math.max(1, Math.floor(batchSize) || 1);
     let batchCount = 0;
     let maxBatchMs = 0;
@@ -2939,6 +3334,19 @@ async function runBatchedTransactions(items, batchSize, transaction) {
         const batchStartedAt = Date.now();
         transaction(batch);
         const batchDurationMs = Date.now() - batchStartedAt;
+        const nextBatchIndex = batchCount + 1;
+        if (logOptions) {
+            logPerformance(logOptions.scope, batchDurationMs, {
+                ...logOptions.detail,
+                batchIndex: nextBatchIndex,
+                batchSize: batch.length,
+                batchStartIndex: index,
+                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) {