@jingyi0605/codingns 0.2.0 → 0.2.5

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,14 @@ export class SessionHistoryService {
     openCodeModelOptionsService;
     providerCliCommandPaths;
     providerCliAvailability;
+    providerDiscoveryHelperClient = new ProviderDiscoveryHelperClient();
+    providerSessionDiscoveryConfig;
+    taskManager;
     workspaceDiscoveryStatuses = new Map();
-    workspaceDiscoveryInflight = new Map();
     workspaceStateRefreshInflight = new Map();
+    providerCapabilityCache = new Map();
     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 +71,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 +81,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 +125,32 @@ export class SessionHistoryService {
             baseUrlResolver: config.opencodeBaseUrlResolver?.resolve.bind(config.opencodeBaseUrlResolver),
             commandPath: config.opencodeCliPath
         });
+        this.registerBackgroundTasks();
+    }
+    observeBackgroundTaskMetrics() {
+        return this.taskManager.observe();
+    }
+    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 +161,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 +325,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 +345,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 +354,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 +365,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 +385,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 +600,7 @@ export class SessionHistoryService {
                 rawStoreRef: binding.rawStoreRef,
                 sourceType: input.sourceType,
                 sourceMessageId,
+                sourceMessageSnapshot: input.sourceMessageSnapshot ?? null,
                 strategy: input.strategy ?? "auto"
             });
             const sessionId = createId();
@@ -561,7 +690,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 +753,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 +771,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;
@@ -969,16 +1112,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 +1146,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 +1220,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 +1268,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 +1329,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 +1351,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 +1605,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;
@@ -1548,7 +1767,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,15 +1787,12 @@ 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)) {
@@ -2620,4 +2836,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