@jingyi0605/codingns 0.2.0 → 0.3.0

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

@@ -4,6 +4,7 @@ import { AppError } from "../../shared/errors/app-error.js";
 import { hashContent } from "../../shared/utils/hash.js";
 import { createId } from "../../shared/utils/id.js";
 import { logPerformance } from "../../shared/utils/perf-log.js";
+import { isTerminalDebugEnabled, logTerminalDebug, terminalDebugNowMs } from "../../shared/utils/terminal-debug-log.js";
 import { nowIso } from "../../shared/utils/time.js";
 import { isCommandAvailable } from "../../shared/utils/command-availability.js";
 import { inspectSessionActivity } from "./session-activity-inspector.js";
@@ -11,8 +12,11 @@ import { SessionActivityAuthorityService } from "./session-activity-authority-se
 import { mapSessionProviderError } from "./session-provider-error-mapper.js";
 import { SessionForkRepository } from "../../storage/repositories/session-fork-repository.js";
 import { enrichClaudeCapabilities } from "../provider/claude-model-options.js";
-import { CodexModelOptionsService, enrichCodexCapabilities } from "../provider/codex-model-options.js";
-import { OpenCodeModelOptionsService, enrichOpenCodeCapabilities } from "../provider/opencode-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 { 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;
@@ -25,6 +29,9 @@ const SESSION_START_DEFERRED_PROVIDERS = new Set([
     "kimi"
 ]);
 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;
 export class SessionHistoryService {
     db;
     workspaceRepository;
@@ -45,11 +52,15 @@ export class SessionHistoryService {
     openCodeModelOptionsService;
     providerCliCommandPaths;
     providerCliAvailability;
+    providerDiscoveryHelperClient = new ProviderDiscoveryHelperClient();
+    providerSessionDiscoveryConfig;
+    taskManager;
     workspaceDiscoveryStatuses = new Map();
-    workspaceDiscoveryInflight = new Map();
     workspaceStateRefreshInflight = new Map();
+    providerCapabilityCache = new Map();
+    liveActivityObservationResolvers = new Set();
     workspaceSessionRelations = new Map();
-    constructor(db, workspaceRepository, sessionBindingRepository, sessionChangedFileService, sessionIndexRepository, sessionMessageAttachmentService, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService(), sessionMessageOriginRepository = null, sessionForkRepository = null, adapterOverrides = {}) {
+    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;
         this.sessionBindingRepository = sessionBindingRepository;
@@ -61,6 +72,7 @@ export class SessionHistoryService {
         this.sessionMessageOriginRepository = sessionMessageOriginRepository;
         this.sessionActivityAuthorityService = sessionActivityAuthorityService;
         this.sessionForkRepository = sessionForkRepository ?? new SessionForkRepository(db);
+        this.taskManager = taskManager;
         this.claudeCodeHomeDir = config.claudeCodeHomeDir;
         this.providerCliCommandPaths = {
             "claude-code": process.platform === "win32" ? "claude.cmd" : "claude",
@@ -70,6 +82,18 @@ export class SessionHistoryService {
         };
         // CLI 是否可用只在 Host 启动时探测一次；后续统一读缓存，更新 CLI 后重启 Host 生效。
         this.providerCliAvailability = buildProviderCliAvailabilitySnapshot(this.providerCliCommandPaths);
+        this.providerSessionDiscoveryConfig = {
+            claudeCodeHomeDir: config.claudeCodeHomeDir,
+            codexCliPath: config.codexCliPath,
+            codexHomeDir: config.codexHomeDir,
+            geminiCliPath: config.geminiCliPath,
+            geminiHomeDir: config.geminiHomeDir,
+            kimiDefaultModel: config.kimiDefaultModel,
+            kimiHomeDir: config.kimiHomeDir,
+            opencodeBaseUrl: config.opencodeBaseUrl,
+            opencodeDataDir: config.opencodeDataDir,
+            opencodeDbPath: config.opencodeDbPath
+        };
         this.providerRegistry = new ProviderRegistry([
             new ClaudeCodeAdapter({ homeDir: config.claudeCodeHomeDir }),
             new CodexAdapter({
@@ -102,6 +126,45 @@ export class SessionHistoryService {
             baseUrlResolver: config.opencodeBaseUrlResolver?.resolve.bind(config.opencodeBaseUrlResolver),
             commandPath: config.opencodeCliPath
         });
+        this.registerBackgroundTasks();
+    }
+    observeBackgroundTaskMetrics() {
+        return this.taskManager.observe();
+    }
+    registerLiveActivityObservationResolver(resolver) {
+        this.liveActivityObservationResolvers.add(resolver);
+        let closed = false;
+        return {
+            close: () => {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                this.liveActivityObservationResolvers.delete(resolver);
+            }
+        };
+    }
+    registerBackgroundTasks() {
+        if (!this.taskManager.has(HOST_TASK_TYPES.workspaceDiscovery)) {
+            this.taskManager.register({
+                taskType: HOST_TASK_TYPES.workspaceDiscovery,
+                executionLane: "helper_process",
+                run: async ({ workspaceId, userId, refreshStateMode }) => this.runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode)
+            });
+        }
+        if (!this.taskManager.has(HOST_TASK_TYPES.providerCapabilityRefresh)) {
+            this.taskManager.register({
+                taskType: HOST_TASK_TYPES.providerCapabilityRefresh,
+                executionLane: "external_process",
+                run: async ({ capabilities, workspacePath }) => {
+                    const value = await this.enrichProviderCapabilities(capabilities, workspacePath);
+                    this.providerCapabilityCache.set(buildProviderCapabilityCacheKey(capabilities.provider, workspacePath), {
+                        refreshedAt: Date.now(),
+                        value
+                    });
+                }
+            });
+        }
     }
     async discoverWorkspaceSessions(workspaceId, userId, options) {
         const maxAgeMs = options?.maxAgeMs ?? 0;
@@ -112,17 +175,47 @@ export class SessionHistoryService {
             discoveryStatus?.isComplete === true &&
             maxAgeMs > 0 &&
             Date.now() - lastRefreshedAt <= maxAgeMs) {
+            this.taskManager.recordCacheHit(HOST_TASK_TYPES.workspaceDiscovery, workspaceId);
             return this.listWorkspaceSessions(workspaceId, userId);
         }
-        const inflight = this.workspaceDiscoveryInflight.get(workspaceId);
-        if (inflight) {
-            return inflight;
+        return this.taskManager.enqueue(HOST_TASK_TYPES.workspaceDiscovery, {
+            key: workspaceId,
+            source: "session_history.discover_workspace_sessions",
+            input: {
+                workspaceId,
+                userId,
+                refreshStateMode: options?.refreshStateMode ?? "inline"
+            }
+        }).promise;
+    }
+    requestWorkspaceDiscovery(workspaceId, userId, options) {
+        const maxAgeMs = options?.maxAgeMs ?? WORKSPACE_DISCOVERY_BACKGROUND_MAX_AGE_MS;
+        const force = options?.force ?? false;
+        if (!force && !this.needsWorkspaceDiscovery(workspaceId, maxAgeMs)) {
+            return;
+        }
+        const task = this.taskManager.enqueue(HOST_TASK_TYPES.workspaceDiscovery, {
+            key: workspaceId,
+            source: "session_history.request_workspace_discovery",
+            input: {
+                workspaceId,
+                userId,
+                refreshStateMode: options?.refreshStateMode ?? "deferred"
+            }
+        });
+        if (task.deduped) {
+            return;
         }
-        const task = this.runDiscoverWorkspaceSessions(workspaceId, userId, options?.refreshStateMode ?? "inline").finally(() => {
-            this.workspaceDiscoveryInflight.delete(workspaceId);
+        void task.promise.catch((error) => {
+            logPerformance("workspace.discover_sessions.background_failed", 0, {
+                workspaceId,
+                error: error instanceof Error ? error.message : "unknown"
+            }, {
+                thresholdMs: 0,
+                force: true
+            });
+            return this.listWorkspaceSessions(workspaceId, userId);
         });
-        this.workspaceDiscoveryInflight.set(workspaceId, task);
-        return task;
     }
     needsWorkspaceDiscovery(workspaceId, maxAgeMs) {
         if (maxAgeMs <= 0) {
@@ -246,13 +339,13 @@ export class SessionHistoryService {
         const binding = this.getBindingOrThrow(sessionId);
         await this.syncSessionTitleFromProvider(sessionId, binding);
     }
-    async syncWorkspaceSessionTitles(workspaceId, userId) {
+    async syncWorkspaceSessionTitles(workspaceId, userId, concurrency = 1) {
         const sessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
-        for (const session of sessions) {
+        await runWithConcurrency(sessions, concurrency, async (session) => {
             await this.syncSessionTitle(session.sessionId).catch(() => {
                 return;
             });
-        }
+        });
     }
     async listSessionChangedFiles(sessionId, userId) {
         this.getSession(sessionId, userId);
@@ -266,7 +359,7 @@ export class SessionHistoryService {
     }
     getProviderCapabilitiesSnapshot(provider) {
         try {
-            return this.applyProviderCliAvailability(this.capabilityService.getProviderCapabilities(provider));
+            return this.resolveProviderCapabilitiesImmediate(this.applyProviderCliAvailability(this.capabilityService.getProviderCapabilities(provider)), null);
         }
         catch (error) {
             throw mapSessionProviderError(error);
@@ -275,7 +368,9 @@ export class SessionHistoryService {
     async getProviderCapabilities(provider, workspaceId) {
         try {
             const workspacePath = workspaceId ? this.getWorkspaceOrThrow(workspaceId).path : null;
-            return await this.enrichProviderCapabilities(this.applyProviderCliAvailability(this.capabilityService.getProviderCapabilities(provider)), workspacePath);
+            const baseCapabilities = this.applyProviderCliAvailability(this.capabilityService.getProviderCapabilities(provider));
+            this.scheduleProviderCapabilityRefresh(baseCapabilities, workspacePath);
+            return this.resolveProviderCapabilitiesImmediate(baseCapabilities, workspacePath);
         }
         catch (error) {
             throw mapSessionProviderError(error);
@@ -284,9 +379,14 @@ export class SessionHistoryService {
     async getSessionCapabilities(sessionId) {
         const binding = this.getBindingOrThrow(sessionId);
         const workspace = this.getWorkspaceOrThrow(binding.workspaceId);
+        const workspacePath = workspace.path;
         return this.capabilityService
             .getSessionCapabilities(binding.provider, binding.providerSessionId)
-            .then((capabilities) => this.enrichProviderCapabilities(this.applyProviderCliAvailability(capabilities), workspace.path))
+            .then((capabilities) => {
+            const normalizedCapabilities = this.applyProviderCliAvailability(capabilities);
+            this.scheduleProviderCapabilityRefresh(normalizedCapabilities, workspacePath);
+            return this.resolveProviderCapabilitiesImmediate(normalizedCapabilities, workspacePath);
+        })
             .catch((error) => {
             throw mapSessionProviderError(error);
         });
@@ -299,6 +399,48 @@ export class SessionHistoryService {
         const codexEnriched = await enrichCodexCapabilities(claudeEnriched, this.codexModelOptionsService);
         return enrichOpenCodeCapabilities(codexEnriched, this.openCodeModelOptionsService, workspacePath);
     }
+    resolveProviderCapabilitiesImmediate(capabilities, workspacePath) {
+        const cacheKey = buildProviderCapabilityCacheKey(capabilities.provider, workspacePath);
+        const cached = this.providerCapabilityCache.get(cacheKey);
+        if (cached) {
+            this.taskManager.recordCacheHit(HOST_TASK_TYPES.providerCapabilityRefresh, cacheKey);
+            return cached.value;
+        }
+        const claudeEnriched = enrichClaudeCapabilities(capabilities, {
+            claudeHomeDir: this.claudeCodeHomeDir,
+            workspacePath
+        });
+        return applyImmediateModelOptionFallbacks(claudeEnriched, this.codexModelOptionsService.peekSnapshot(), this.openCodeModelOptionsService.peekSnapshot(workspacePath));
+    }
+    scheduleProviderCapabilityRefresh(capabilities, workspacePath) {
+        const cacheKey = buildProviderCapabilityCacheKey(capabilities.provider, workspacePath);
+        const cached = this.providerCapabilityCache.get(cacheKey);
+        if (cached &&
+            Date.now() - cached.refreshedAt <= PROVIDER_CAPABILITY_CACHE_MAX_AGE_MS) {
+            return;
+        }
+        const task = this.taskManager.enqueue(HOST_TASK_TYPES.providerCapabilityRefresh, {
+            key: cacheKey,
+            source: "session_history.provider_capability_refresh",
+            input: {
+                capabilities,
+                workspacePath
+            }
+        });
+        if (task.deduped) {
+            return;
+        }
+        void task.promise.catch((error) => {
+            logPerformance("provider.capabilities.background_failed", 0, {
+                provider: capabilities.provider,
+                workspacePath,
+                error: error instanceof Error ? error.message : "unknown"
+            }, {
+                thresholdMs: 0,
+                force: true
+            });
+        });
+    }
     applyProviderCliAvailability(capabilities) {
         if (!isProviderCliBacked(capabilities.provider)) {
             return capabilities;
@@ -472,6 +614,7 @@ export class SessionHistoryService {
                 rawStoreRef: binding.rawStoreRef,
                 sourceType: input.sourceType,
                 sourceMessageId,
+                sourceMessageSnapshot: input.sourceMessageSnapshot ?? null,
                 strategy: input.strategy ?? "auto"
             });
             const sessionId = createId();
@@ -561,7 +704,7 @@ export class SessionHistoryService {
             throw mapSessionProviderError(new Error("FORK_TARGET_PROVIDER_NOT_SUPPORTED"));
         }
         const sourceIndex = this.sessionIndexRepository.findIndexRecordBySessionId(input.sessionId);
-        const inheritedMessages = await this.readForkSourceMessages(input.sessionId, sourceBinding, input.sourceType, sourceMessageId);
+        const inheritedMessages = await this.readForkSourceMessages(input.sessionId, sourceBinding, input.sourceType, sourceMessageId, input.sourceMessageSnapshot ?? null);
         const reconstructedMessages = inheritedMessages.filter((message) => (message.role === "user" || message.role === "assistant")
             && message.kind === "text"
             && message.content.trim().length > 0);
@@ -624,7 +767,7 @@ export class SessionHistoryService {
         this.workspaceSessionRelations.set(sourceBinding.workspaceId, relationMap);
         return this.getSessionListItemOrThrow(startedSession.sessionId, input.userId);
     }
-    async readForkSourceMessages(sessionId, binding, sourceType, sourceMessageId) {
+    async readForkSourceMessages(sessionId, binding, sourceType, sourceMessageId, sourceMessageSnapshot = null) {
         const messages = [];
         let cursor = null;
         while (true) {
@@ -642,7 +785,21 @@ export class SessionHistoryService {
         if (targetIndex < 0) {
             throw mapSessionProviderError(new Error("FORK_SOURCE_MESSAGE_NOT_FOUND"));
         }
-        return messages.slice(0, targetIndex + 1);
+        const inheritedMessages = messages.slice(0, targetIndex + 1);
+        if (!sourceMessageSnapshot) {
+            return inheritedMessages;
+        }
+        const targetMessage = inheritedMessages[targetIndex];
+        if (!targetMessage) {
+            return inheritedMessages;
+        }
+        inheritedMessages[targetIndex] = {
+            ...targetMessage,
+            role: sourceMessageSnapshot.role,
+            kind: sourceMessageSnapshot.kind,
+            content: sourceMessageSnapshot.content
+        };
+        return inheritedMessages;
     }
     assertForkDepthWithinLimit(parentSessionId) {
         const nextDepth = this.getSessionForkDepth(parentSessionId) + 1;
@@ -935,11 +1092,11 @@ export class SessionHistoryService {
         });
         const currentBinding = this.sessionBindingRepository.findBySessionId(sessionId);
         const timestamp = nowIso();
-        const duplicateBinding = this.findPendingBindingDuplicate(sessionId, workspaceId, currentBinding, resolvedSnapshot);
+        const duplicateBinding = this.findSameWorkspaceBindingDuplicate(sessionId, workspaceId, resolvedSnapshot);
         this.db.transaction(() => {
             if (duplicateBinding) {
-                // 新建运行时会话会先写入 pending 绑定，后台发现链路可能在真 ID 回填前先落一条重复记录。
-                // 这里保留当前 runtime session，把扫描出的重复会话并回当前会话，避免 provider_session_id 撞唯一键。
+                // 运行时链路显式指定了当前 sessionId，就应该由当前会话接管同工作区里的重复底层会话。
+                // 否则后续事件重放或后台发现补录都会持续撞 UNIQUE(provider, provider_session_id)。
                 this.mergeSessionIntoTarget({
                     workspaceId,
                     targetSessionId: sessionId,
@@ -969,16 +1126,29 @@ export class SessionHistoryService {
     }
     async runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode = "inline") {
         const startedAt = Date.now();
+        const debugStartedAtMs = terminalDebugNowMs();
         const workspace = this.getWorkspaceOrThrow(workspaceId);
         let discoverDurationMs = 0;
         let persistDurationMs = 0;
+        let persistPass1DurationMs = 0;
+        let persistPass1BatchCount = 0;
+        let persistPass1MaxBatchMs = 0;
+        let relationMapDurationMs = 0;
+        let persistPass2DurationMs = 0;
+        let persistPass2BatchCount = 0;
+        let persistPass2MaxBatchMs = 0;
+        let cleanupDurationMs = 0;
+        let listItemsDurationMs = 0;
+        let refreshStateDurationMs = 0;
         const refreshStateCount = 10;
         try {
             const discoverStartedAt = Date.now();
             const existingWorkspaceSessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
             const knownSessions = this.buildKnownSessionSummaries(existingWorkspaceSessions, workspace.path);
-            const discovery = await this.sessionSyncService
-                .discoverWorkspaceSessions(workspace.path, {
+            const discovery = await this.providerDiscoveryHelperClient
+                .discoverWorkspaceSessions({
+                config: this.providerSessionDiscoveryConfig,
+                workspacePath: workspace.path,
                 knownSessions
             })
                 .catch((error) => {
@@ -990,10 +1160,9 @@ export class SessionHistoryService {
             const discoveredSessionIds = new Map();
             const persistedSessions = [];
             const claimedPendingSessionIds = new Set();
-            const persist = this.db.transaction(() => {
-                for (const session of sessions) {
+            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);
-                    // discover 只能补全当前工作区，不能把别的工作区已有会话偷过来重绑。
                     if (exactExisting && exactExisting.workspaceId !== workspaceId) {
                         continue;
                     }
@@ -1065,8 +1234,17 @@ export class SessionHistoryService {
                         existingIndex
                     });
                 }
-                const relationMap = this.buildWorkspaceSessionRelationMap(sessions, discoveredSessionIds);
-                for (const persistedSession of persistedSessions) {
+            });
+            const persistPass1StartedAt = Date.now();
+            const persistPass1Stats = await runBatchedTransactions(sessions, WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, persistPass1Transaction);
+            persistPass1DurationMs = Date.now() - persistPass1StartedAt;
+            persistPass1BatchCount = persistPass1Stats.batchCount;
+            persistPass1MaxBatchMs = persistPass1Stats.maxBatchMs;
+            const relationMapStartedAt = Date.now();
+            const relationMap = this.buildWorkspaceSessionRelationMap(sessions, discoveredSessionIds);
+            relationMapDurationMs = Date.now() - relationMapStartedAt;
+            const persistPass2Transaction = this.db.transaction((batch) => {
+                for (const persistedSession of batch) {
                     const relation = relationMap.get(persistedSession.sessionId);
                     const resolvedParentSessionId = relation?.parentSessionId
                         ?? persistedSession.existingIndex?.parentSessionId
@@ -1104,26 +1282,56 @@ export class SessionHistoryService {
                     });
                 }
             });
-            const persistStartedAt = Date.now();
-            persist();
-            persistDurationMs = Date.now() - persistStartedAt;
+            const persistPass2StartedAt = Date.now();
+            const persistPass2Stats = await runBatchedTransactions(persistedSessions, WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, persistPass2Transaction);
+            persistPass2DurationMs = Date.now() - persistPass2StartedAt;
+            persistPass2BatchCount = persistPass2Stats.batchCount;
+            persistPass2MaxBatchMs = persistPass2Stats.maxBatchMs;
+            persistDurationMs = persistPass1DurationMs + relationMapDurationMs + persistPass2DurationMs;
             if (discovery.isComplete) {
-                this.cleanupStaleHiddenSessions(workspaceId, userId, sessions);
+                const cleanupStartedAt = Date.now();
+                await this.cleanupStaleHiddenSessions(workspaceId, userId, sessions);
+                cleanupDurationMs = Date.now() - cleanupStartedAt;
             }
-            this.workspaceSessionRelations.set(workspaceId, this.buildWorkspaceSessionRelationMap(sessions, discoveredSessionIds));
+            this.workspaceSessionRelations.set(workspaceId, relationMap);
+            const listItemsStartedAt = Date.now();
             const items = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
+            listItemsDurationMs = Date.now() - listItemsStartedAt;
             const refreshCandidates = buildSessionStateRefreshCandidates(items, refreshStateCount);
             this.workspaceDiscoveryStatuses.set(workspaceId, {
                 refreshedAt: Date.now(),
                 isComplete: discovery.isComplete
             });
+            const refreshStateStartedAt = Date.now();
             if (refreshStateMode === "inline") {
                 await this.refreshRecentSessionStates(refreshCandidates, userId);
             }
             else {
                 this.scheduleWorkspaceStateRefresh(workspaceId, userId, refreshCandidates);
             }
+            refreshStateDurationMs = Date.now() - refreshStateStartedAt;
             const nextItems = this.listWorkspaceSessions(workspaceId, userId);
+            if (isTerminalDebugEnabled()) {
+                logTerminalDebug("workspace.discovery.completed", {
+                    workspaceId,
+                    sessionCount: sessions.length,
+                    returnedSessionCount: nextItems.length,
+                    discoverMs: discoverDurationMs,
+                    persistMs: persistDurationMs,
+                    persistPass1Ms: persistPass1DurationMs,
+                    persistPass1BatchCount,
+                    persistPass1MaxBatchMs,
+                    relationMapMs: relationMapDurationMs,
+                    persistPass2Ms: persistPass2DurationMs,
+                    persistPass2BatchCount,
+                    persistPass2MaxBatchMs,
+                    cleanupMs: cleanupDurationMs,
+                    listItemsMs: listItemsDurationMs,
+                    refreshStateMs: refreshStateDurationMs,
+                    refreshStateDeferred: refreshStateMode !== "inline",
+                    durationMs: terminalDebugNowMs() - debugStartedAtMs
+                });
+            }
             logPerformance("workspace.discover_sessions", Date.now() - startedAt, {
                 workspaceId,
                 workspacePath: workspace.path,
@@ -1135,6 +1343,16 @@ export class SessionHistoryService {
                 refreshedStates: refreshCandidates.length,
                 discoverMs: discoverDurationMs,
                 persistMs: persistDurationMs,
+                persistPass1Ms: persistPass1DurationMs,
+                persistPass1BatchCount,
+                persistPass1MaxBatchMs,
+                relationMapMs: relationMapDurationMs,
+                persistPass2Ms: persistPass2DurationMs,
+                persistPass2BatchCount,
+                persistPass2MaxBatchMs,
+                cleanupMs: cleanupDurationMs,
+                listItemsMs: listItemsDurationMs,
+                refreshStateMs: refreshStateDurationMs,
                 refreshStateDeferred: refreshStateMode !== "inline"
             }, {
                 thresholdMs: 500
@@ -1147,6 +1365,16 @@ export class SessionHistoryService {
                 workspacePath: workspace.path,
                 discoverMs: discoverDurationMs,
                 persistMs: persistDurationMs,
+                persistPass1Ms: persistPass1DurationMs,
+                persistPass1BatchCount,
+                persistPass1MaxBatchMs,
+                relationMapMs: relationMapDurationMs,
+                persistPass2Ms: persistPass2DurationMs,
+                persistPass2BatchCount,
+                persistPass2MaxBatchMs,
+                cleanupMs: cleanupDurationMs,
+                listItemsMs: listItemsDurationMs,
+                refreshStateMs: refreshStateDurationMs,
                 refreshStateDeferred: refreshStateMode !== "inline",
                 error: error instanceof Error ? error.message : "unknown"
             }, {
@@ -1391,7 +1619,12 @@ export class SessionHistoryService {
         if (shouldSkipClaudePendingBinding(binding)) {
             return;
         }
-        const nextTitle = (await this.sessionSyncService.readSessionTitle(binding.provider, binding.providerSessionId, binding.rawStoreRef)).trim();
+        const nextTitle = (await this.providerDiscoveryHelperClient.readSessionTitle({
+            config: this.providerSessionDiscoveryConfig,
+            provider: binding.provider,
+            providerSessionId: binding.providerSessionId,
+            rawStoreRef: binding.rawStoreRef
+        })).trim();
         const resolvedTitle = resolvePersistedSessionTitle(binding.provider, nextTitle, currentIndex.title);
         if (resolvedTitle.length === 0 || resolvedTitle === currentIndex.title) {
             return;
@@ -1486,11 +1719,11 @@ export class SessionHistoryService {
         return this.sessionBindingRepository.findBySessionId(aliasTargetSessionId);
     }
     findPendingSessionAliasTargetSessionId(descriptor) {
-        if (!descriptor || descriptor.provider !== "gemini") {
+        if (!descriptor) {
             return null;
         }
-        const aliasTargetSessionId = extractPendingBindingTargetSessionId(descriptor.providerSessionId)
-            ?? extractPendingBindingTargetSessionId(descriptor.rawStoreRef);
+        const aliasTargetSessionId = extractSessionAliasTargetSessionId(descriptor.providerSessionId)
+            ?? extractSessionAliasTargetSessionId(descriptor.rawStoreRef);
         if (!aliasTargetSessionId || aliasTargetSessionId === descriptor.sessionId) {
             return null;
         }
@@ -1548,7 +1781,7 @@ export class SessionHistoryService {
         });
         this.workspaceStateRefreshInflight.set(inflightKey, task);
     }
-    cleanupStaleHiddenSessions(workspaceId, userId, sessions) {
+    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 staleHiddenSessions = this.sessionIndexRepository
@@ -1568,20 +1801,14 @@ export class SessionHistoryService {
         if (staleHiddenSessions.length === 0) {
             return;
         }
-        this.deleteSessionsByIds(staleHiddenSessions.map((session) => session.sessionId));
-    }
-    deleteSessionsByIds(sessionIds) {
-        const remove = this.db.transaction((ids) => {
+        const deleteTransaction = this.db.transaction((ids) => {
             for (const sessionId of ids) {
                 this.deleteSessionById(sessionId);
             }
         });
-        remove(sessionIds);
+        await runBatchedTransactions(staleHiddenSessions.map((session) => session.sessionId), WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, deleteTransaction);
     }
-    findPendingBindingDuplicate(sessionId, workspaceId, currentBinding, snapshot) {
-        if (!currentBinding || !isPendingBindingValue(currentBinding.providerSessionId)) {
-            return null;
-        }
+    findSameWorkspaceBindingDuplicate(sessionId, workspaceId, snapshot) {
         if (isPendingBindingValue(snapshot.providerSessionId)) {
             return null;
         }
@@ -1673,12 +1900,22 @@ export class SessionHistoryService {
         this.db
             .prepare("DELETE FROM session_forks WHERE session_id = ?")
             .run(input.sourceSessionId);
-        this.db
-            .prepare("DELETE FROM session_indices WHERE session_id = ?")
-            .run(input.sourceSessionId);
-        this.db
-            .prepare("DELETE FROM session_bindings WHERE session_id = ?")
-            .run(input.sourceSessionId);
+        // 保留旧 session_id 作为 alias，避免前端或 Butler 还拿着旧 id 时直接炸成 SESSION_NOT_FOUND。
+        this.sessionBindingRepository.upsert({
+            sessionId: input.sourceSessionId,
+            workspaceId: sourceBinding.workspaceId,
+            provider: sourceBinding.provider,
+            providerSessionId: buildAliasBindingValue(input.provider, input.targetSessionId, input.sourceSessionId),
+            rawStoreRef: buildAliasBindingValue(input.provider, input.targetSessionId, input.sourceSessionId),
+            createdAt: sourceBinding.createdAt,
+            updatedAt: input.timestamp
+        });
+        if (sourceIndex) {
+            this.sessionIndexRepository.upsert({
+                ...sourceIndex,
+                updatedAt: input.timestamp
+            });
+        }
         this.rewriteWorkspaceSessionRelations(input.workspaceId, input.targetSessionId, input.sourceSessionId, targetIndex, sourceIndex);
     }
     listSessionStatesBySessionId(sessionId) {
@@ -1804,6 +2041,7 @@ export class SessionHistoryService {
     }
     buildKnownSessionSummaries(sessions, workspacePath) {
         return sessions
+            .filter((session) => !this.isPendingSessionAlias(session))
             .filter((session) => !shouldSkipClaudePendingBinding(session))
             .map((session) => {
             const stats = safeStat(session.rawStoreRef);
@@ -1823,19 +2061,28 @@ export class SessionHistoryService {
     async refreshSessionState(sessionId, userId) {
         const binding = this.getBindingOrThrow(sessionId);
         const current = this.sessionStateRepository.findBySessionAndUser(sessionId, userId);
-        const inspection = inspectSessionActivity(binding.provider, binding.rawStoreRef);
         const timestamp = nowIso();
-        const nowMs = Date.parse(timestamp);
-        if (shouldClearStaleRuntimeWithoutInspection(current, inspection, nowMs)) {
-            this.sessionActivityAuthorityService.clearSession(sessionId);
-        }
-        if (shouldPreserveRuntimeTerminalState(current, inspection)) {
-            return current;
+        const liveObservation = this.resolveLiveActivityObservation(sessionId);
+        const inspection = liveObservation
+            ? null
+            : inspectSessionActivity(binding.provider, binding.rawStoreRef);
+        if (inspection) {
+            const nowMs = Date.parse(timestamp);
+            if (shouldClearStaleRuntimeWithoutInspection(current, inspection, nowMs)) {
+                this.sessionActivityAuthorityService.clearSession(sessionId);
+            }
+            if (shouldPreserveRuntimeTerminalState(current, inspection)) {
+                return current;
+            }
         }
-        const resolution = this.sessionActivityAuthorityService.observe(buildInspectionActivityObservation(sessionId, inspection, timestamp));
-        const resolvedLastEventAt = hasInspectionEvidence(inspection)
-            ? resolution.lastObservedAt ?? inspection.lastEventAt ?? current?.lastEventAt ?? null
-            : current?.lastEventAt ?? null;
+        const resolution = liveObservation
+            ? this.sessionActivityAuthorityService.observe(liveObservation)
+            : this.sessionActivityAuthorityService.observe(buildInspectionActivityObservation(sessionId, inspection, timestamp));
+        const resolvedLastEventAt = liveObservation
+            ? resolution.lastObservedAt ?? current?.lastEventAt ?? null
+            : inspection && hasInspectionEvidence(inspection)
+                ? resolution.lastObservedAt ?? inspection.lastEventAt ?? current?.lastEventAt ?? null
+                : current?.lastEventAt ?? null;
         const nextRecord = {
             sessionId,
             userId,
@@ -1844,7 +2091,7 @@ export class SessionHistoryService {
             favorite: current?.favorite ?? false,
             lastEventAt: resolvedLastEventAt,
             completedAt: isTerminalResolvedRunningState(resolution.runningState)
-                ? resolution.terminalAt ?? inspection.completedAtCandidate ?? current?.completedAt ?? null
+                ? resolution.terminalAt ?? inspection?.completedAtCandidate ?? current?.completedAt ?? null
                 : null,
             lastSeenAt: current?.lastSeenAt ?? null,
             updatedAt: timestamp
@@ -1862,8 +2109,8 @@ export class SessionHistoryService {
             syncCursor: currentSnapshot?.syncCursor ?? null,
             lastSyncAt: resolution.lastObservedAt
                 ?? resolution.terminalAt
-                ?? inspection.lastEventAt
-                ?? inspection.completedAtCandidate
+                ?? inspection?.lastEventAt
+                ?? inspection?.completedAtCandidate
                 ?? currentSnapshot?.lastSyncAt
                 ?? null,
             lastErrorCode: resolution.runningState === "failed"
@@ -1881,17 +2128,34 @@ export class SessionHistoryService {
         });
         return nextRecord;
     }
+    resolveLiveActivityObservation(sessionId) {
+        for (const resolver of this.liveActivityObservationResolvers) {
+            const observation = resolver(sessionId);
+            if (observation) {
+                return observation;
+            }
+        }
+        return null;
+    }
     upsertSnapshot(sessionId, input) {
+        const resolvedSessionId = this.resolveCanonicalSessionId(sessionId);
+        if (!this.sessionBindingRepository.findBySessionId(resolvedSessionId)) {
+            return;
+        }
         this.sessionStatusSnapshotRepository.upsert({
-            sessionId,
+            sessionId: resolvedSessionId,
             ...input,
             updatedAt: nowIso()
         });
     }
     markSessionError(sessionId, errorCode, error) {
-        const current = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        const resolvedSessionId = this.resolveCanonicalSessionId(sessionId);
+        if (!this.sessionBindingRepository.findBySessionId(resolvedSessionId)) {
+            return;
+        }
+        const current = this.sessionStatusSnapshotRepository.findBySessionId(resolvedSessionId);
         this.sessionStatusSnapshotRepository.upsert({
-            sessionId,
+            sessionId: resolvedSessionId,
             syncStatus: "error",
             syncCursor: current?.syncCursor ?? null,
             lastSyncAt: current?.lastSyncAt ?? null,
@@ -1961,23 +2225,28 @@ function hasInspectionEvidence(inspection) {
         || !!inspection.completedAtCandidate;
 }
 function applySessionActivityResolution(item, resolution) {
-    const runningState = resolution.runningState;
-    const shouldClearResolvedFailure = runningState !== "failed" && item.runningState === "failed";
+    const rawResolvedRunningState = resolution.runningState === "unknown" && item.runningState === null
+        ? null
+        : resolution.runningState;
+    const resolvedRunningState = resolution.activityResolutionSource === "inferred_log" && rawResolvedRunningState === "completed"
+        ? "idle"
+        : rawResolvedRunningState;
+    const shouldClearResolvedFailure = resolvedRunningState !== "failed" && item.runningState === "failed";
     const lastEventAt = resolution.lastObservedAt ?? item.lastEventAt;
-    const completedAt = isTerminalResolvedRunningState(runningState)
+    const completedAt = rawResolvedRunningState && isTerminalResolvedRunningState(rawResolvedRunningState)
         ? resolution.terminalAt ?? item.completedAt
         : null;
-    const lastErrorCode = runningState === "failed"
+    const lastErrorCode = resolvedRunningState === "failed"
         ? resolution.errorCode ?? item.lastErrorCode
         : shouldClearResolvedFailure
             ? null
             : item.lastErrorCode;
-    const lastErrorDetail = runningState === "failed"
+    const lastErrorDetail = resolvedRunningState === "failed"
         ? resolution.detail ?? item.lastErrorDetail
         : shouldClearResolvedFailure
             ? null
             : item.lastErrorDetail;
-    const syncStatus = runningState === "failed"
+    const syncStatus = resolvedRunningState === "failed"
         ? "error"
         : shouldClearResolvedFailure && item.syncStatus === "error"
             ? "idle"
@@ -1985,7 +2254,7 @@ function applySessionActivityResolution(item, resolution) {
     return {
         ...item,
         syncStatus,
-        runningState,
+        runningState: resolvedRunningState,
         activitySource: mapResolutionSourceToCompatibilitySource(resolution.activityResolutionSource),
         activityResolutionSource: resolution.activityResolutionSource,
         activityConfidence: resolution.activityConfidence,
@@ -1995,7 +2264,7 @@ function applySessionActivityResolution(item, resolution) {
         lastErrorCode,
         lastErrorDetail,
         watchdogTriggeredAt: resolution.watchdogTriggeredAt,
-        activityState: resolveActivityState(runningState, completedAt, item.lastSeenAt)
+        activityState: resolveActivityState(resolvedRunningState, completedAt, item.lastSeenAt)
     };
 }
 function clampLimit(limit) {
@@ -2194,6 +2463,9 @@ function isPendingBindingValue(value) {
 function buildPendingBindingValue(provider, sessionId) {
     return `pending://${provider}/${sessionId}`;
 }
+function buildAliasBindingValue(provider, targetSessionId, sourceSessionId) {
+    return `alias://${provider}/${targetSessionId}/${sourceSessionId}`;
+}
 function extractPendingBindingTargetSessionId(value) {
     if (!isPendingBindingValue(value)) {
         return null;
@@ -2202,6 +2474,25 @@ function extractPendingBindingTargetSessionId(value) {
     const targetSessionId = normalizedValue.slice(normalizedValue.indexOf("/", "pending://".length) + 1).trim();
     return targetSessionId || null;
 }
+function extractAliasBindingTargetSessionId(value) {
+    const normalizedValue = value.trim();
+    if (!normalizedValue.toLowerCase().startsWith("alias://")) {
+        return null;
+    }
+    const pathStart = normalizedValue.indexOf("/", "alias://".length);
+    if (pathStart < 0) {
+        return null;
+    }
+    const targetAndSource = normalizedValue.slice(pathStart + 1).trim();
+    if (targetAndSource.length === 0) {
+        return null;
+    }
+    const [targetSessionId] = targetAndSource.split("/", 1);
+    return targetSessionId?.trim() || null;
+}
+function extractSessionAliasTargetSessionId(value) {
+    return extractAliasBindingTargetSessionId(value) ?? extractPendingBindingTargetSessionId(value);
+}
 function isClaudePendingRuntimeRawStoreRef(rawStoreRef) {
     const normalizedRawStoreRef = rawStoreRef.replaceAll("\\", "/").toLowerCase();
     return normalizedRawStoreRef.includes("/.pending-");
@@ -2570,7 +2861,7 @@ function mapResolutionSourceToLegacyActivitySource(source, inspection) {
     if (source === "authoritative_runtime" || source === "authoritative_provider_event") {
         return "runtime";
     }
-    if (inspection.lastEventAt || inspection.completedAtCandidate) {
+    if (inspection && (inspection.lastEventAt || inspection.completedAtCandidate)) {
         return "inferred";
     }
     return "none";
@@ -2620,4 +2911,71 @@ function buildReconstructedForkPrompt(input) {
     }
     return lines.join("\n").trim();
 }
+function buildProviderCapabilityCacheKey(provider, workspacePath) {
+    return `${provider}::${workspacePath ?? ""}`;
+}
+async function runWithConcurrency(items, concurrency, worker) {
+    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) {
+            const current = queue.shift();
+            if (current === undefined) {
+                return;
+            }
+            await worker(current);
+        }
+    });
+    await Promise.all(runners);
+}
+async function runBatchedTransactions(items, batchSize, transaction) {
+    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);
+        const batchDurationMs = Date.now() - batchStartedAt;
+        batchCount += 1;
+        maxBatchMs = Math.max(maxBatchMs, batchDurationMs);
+        if (index + normalizedBatchSize < items.length) {
+            await delay(0);
+        }
+    }
+    return {
+        batchCount,
+        maxBatchMs
+    };
+}
+function applyImmediateModelOptionFallbacks(capabilities, codexSnapshot, openCodeSnapshot) {
+    if (capabilities.provider === "codex") {
+        return {
+            ...capabilities,
+            modelOptions: codexSnapshot?.modelOptions ?? createFallbackCodexModelOptions(null),
+            defaultReasoningLevel: codexSnapshot?.defaultReasoningLevel ?? null,
+            limitations: codexSnapshot
+                ? capabilities.limitations
+                : Array.from(new Set([
+                    ...capabilities.limitations,
+                    "当前暂时使用缓存或兜底模型列表，后台会继续刷新 Codex 能力。"
+                ]))
+        };
+    }
+    if (capabilities.provider === "opencode") {
+        return {
+            ...capabilities,
+            modelOptions: openCodeSnapshot?.modelOptions ?? createFallbackOpenCodeModelOptions(null),
+            limitations: openCodeSnapshot
+                ? capabilities.limitations
+                : Array.from(new Set([
+                    ...capabilities.limitations,
+                    "当前暂时使用缓存或兜底模型列表，后台会继续刷新 OpenCode 能力。"
+                ]))
+        };
+    }
+    return capabilities;
+}
 //# sourceMappingURL=session-history-service.js.map