@jingyi0605/codingns 0.1.5 → 0.2.5

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

@@ -4,13 +4,23 @@ 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";
 import { SessionActivityAuthorityService } from "./session-activity-authority-service.js";
 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;
+const MAX_FORK_DEPTH = 4;
 const SESSION_START_DEFERRED_PROVIDERS = new Set([
     "codex",
     "claude-code",
@@ -19,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;
@@ -33,14 +46,20 @@ export class SessionHistoryService {
     sessionSyncService;
     capabilityService;
     sessionActivityAuthorityService;
+    sessionForkRepository;
     claudeCodeHomeDir;
     codexModelOptionsService;
     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) {
+    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;
@@ -51,10 +70,36 @@ export class SessionHistoryService {
         this.sessionStatusSnapshotRepository = sessionStatusSnapshotRepository;
         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",
+            codex: config.codexCliPath,
+            gemini: config.geminiCliPath,
+            kimi: config.kimiCliPath
+        };
+        // 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({ homeDir: config.codexHomeDir }),
+            new CodexAdapter({
+                homeDir: config.codexHomeDir,
+                forkTransportFactory: adapterOverrides.codexForkTransportFactory
+                    ?? createCodexForkTransportFactory(config.codexCliPath, config.codexHomeDir)
+            }),
             new GeminiAdapter({
                 homeDir: config.geminiHomeDir,
                 commandPath: config.geminiCliPath
@@ -80,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;
@@ -90,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.runDiscoverWorkspaceSessions(workspaceId, userId, options?.refreshStateMode ?? "inline").finally(() => {
-            this.workspaceDiscoveryInflight.delete(workspaceId);
+        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;
+        }
+        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) {
@@ -224,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);
@@ -244,7 +345,7 @@ export class SessionHistoryService {
     }
     getProviderCapabilitiesSnapshot(provider) {
         try {
-            return this.capabilityService.getProviderCapabilities(provider);
+            return this.resolveProviderCapabilitiesImmediate(this.applyProviderCliAvailability(this.capabilityService.getProviderCapabilities(provider)), null);
         }
         catch (error) {
             throw mapSessionProviderError(error);
@@ -253,7 +354,9 @@ export class SessionHistoryService {
     async getProviderCapabilities(provider, workspaceId) {
         try {
             const workspacePath = workspaceId ? this.getWorkspaceOrThrow(workspaceId).path : null;
-            return await this.enrichProviderCapabilities(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);
@@ -262,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(capabilities, workspace.path))
+            .then((capabilities) => {
+            const normalizedCapabilities = this.applyProviderCliAvailability(capabilities);
+            this.scheduleProviderCapabilityRefresh(normalizedCapabilities, workspacePath);
+            return this.resolveProviderCapabilitiesImmediate(normalizedCapabilities, workspacePath);
+        })
             .catch((error) => {
             throw mapSessionProviderError(error);
         });
@@ -277,6 +385,83 @@ 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;
+        }
+        if (this.providerCliAvailability[capabilities.provider]) {
+            return capabilities;
+        }
+        const limitation = buildProviderCliUnavailableMessage(capabilities.provider);
+        const limitations = capabilities.limitations.includes(limitation)
+            ? capabilities.limitations
+            : [limitation, ...capabilities.limitations];
+        return {
+            ...capabilities,
+            canStartSession: false,
+            canResumeSession: false,
+            canSendMessage: false,
+            supportsSubagents: false,
+            supportsInterrupt: false,
+            supportsSessionFork: false,
+            supportsNativeAgents: false,
+            limitations
+        };
+    }
+    assertProviderCapabilityEnabled(provider, capability, fallbackDetail) {
+        const capabilities = this.getProviderCapabilitiesSnapshot(provider);
+        if (capabilities[capability]) {
+            return;
+        }
+        throw new AppError({
+            statusCode: 409,
+            errorCode: "PROVIDER_UNAVAILABLE",
+            detail: capabilities.limitations[0] ?? fallbackDetail,
+            field: "provider"
+        });
+    }
     async getSessionContextUsage(sessionId) {
         const binding = this.getBindingOrThrow(sessionId);
         try {
@@ -288,6 +473,7 @@ export class SessionHistoryService {
     }
     async resumeSession(sessionId) {
         const binding = this.getBindingOrThrow(sessionId);
+        this.assertProviderCapabilityEnabled(binding.provider, "canResumeSession", "当前 provider 不支持继续会话");
         try {
             const result = await this.sessionSyncService.resumeSession(binding.provider, binding.providerSessionId, binding.rawStoreRef);
             this.upsertSnapshot(sessionId, {
@@ -311,7 +497,6 @@ export class SessionHistoryService {
         }
     }
     async startSession(input) {
-        const workspace = this.getWorkspaceOrThrow(input.workspaceId);
         if (SESSION_START_DEFERRED_PROVIDERS.has(input.provider)) {
             throw new AppError({
                 statusCode: 409,
@@ -320,6 +505,11 @@ export class SessionHistoryService {
                 field: "provider"
             });
         }
+        return this.startSessionDirect(input);
+    }
+    async startSessionDirect(input) {
+        const workspace = this.getWorkspaceOrThrow(input.workspaceId);
+        this.assertProviderCapabilityEnabled(input.provider, "canStartSession", "当前 provider 不支持创建会话");
         try {
             const result = await this.sessionSyncService.startSession(input.provider, workspace.path, {
                 initialPrompt: input.initialPrompt
@@ -340,7 +530,10 @@ export class SessionHistoryService {
                     sessionId,
                     workspaceId: workspace.id,
                     provider: result.session.provider,
-                    parentSessionId: result.session.parentProviderSessionId ?? null,
+                    parentSessionId: input.parentSessionId ?? result.session.parentProviderSessionId ?? null,
+                    sessionKind: input.sessionKind ?? "default",
+                    annotationSourceMessageId: input.annotationSourceMessageId ?? null,
+                    annotationSourceText: input.annotationSourceText ?? null,
                     isSubagent: result.session.isSubagent ?? false,
                     subagentLabel: result.session.subagentLabel ?? null,
                     title: result.session.title,
@@ -379,6 +572,251 @@ export class SessionHistoryService {
             throw mapSessionProviderError(error);
         }
     }
+    async forkSession(input) {
+        const binding = this.getBindingOrThrow(input.sessionId);
+        const workspace = this.getWorkspaceOrThrow(binding.workspaceId);
+        const targetProvider = input.targetProvider?.trim() || binding.provider;
+        this.assertProviderCapabilityEnabled(targetProvider, "canStartSession", "当前 provider 不支持 fork 创建会话");
+        const sourceMessageId = input.sourceType === "message"
+            ? input.sourceMessageId?.trim() || null
+            : null;
+        if (input.sourceType === "message" && !sourceMessageId) {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "INVALID_INPUT",
+                detail: "按消息派生会话时必须提供 sourceMessageId",
+                field: "sourceMessageId"
+            });
+        }
+        this.assertForkDepthWithinLimit(input.sessionId);
+        if (targetProvider !== binding.provider) {
+            return this.forkSessionAcrossProviders({
+                ...input,
+                targetProvider
+            }, binding, sourceMessageId);
+        }
+        try {
+            const result = await this.sessionSyncService.forkSession(binding.provider, binding.providerSessionId, workspace.path, {
+                rawStoreRef: binding.rawStoreRef,
+                sourceType: input.sourceType,
+                sourceMessageId,
+                sourceMessageSnapshot: input.sourceMessageSnapshot ?? null,
+                strategy: input.strategy ?? "auto"
+            });
+            const sessionId = createId();
+            const timestamp = nowIso();
+            this.db.transaction(() => {
+                this.sessionBindingRepository.upsert({
+                    sessionId,
+                    workspaceId: workspace.id,
+                    provider: result.session.provider,
+                    providerSessionId: result.session.providerSessionId,
+                    rawStoreRef: result.session.rawStoreRef,
+                    createdAt: timestamp,
+                    updatedAt: timestamp
+                });
+                this.sessionIndexRepository.upsert({
+                    sessionId,
+                    workspaceId: workspace.id,
+                    provider: result.session.provider,
+                    parentSessionId: input.sessionId,
+                    sessionKind: input.sessionKind ?? "default",
+                    annotationSourceMessageId: input.annotationSourceMessageId ?? null,
+                    annotationSourceText: input.annotationSourceText ?? null,
+                    isSubagent: result.session.isSubagent ?? false,
+                    subagentLabel: result.session.subagentLabel ?? null,
+                    title: result.session.title,
+                    messageCount: result.session.messageCount,
+                    isArchived: result.session.isArchived ?? false,
+                    lastMessageAt: result.session.lastMessageAt,
+                    createdAt: timestamp,
+                    updatedAt: timestamp
+                });
+                this.sessionForkRepository.upsert({
+                    sessionId,
+                    parentSessionId: input.sessionId,
+                    provider: result.session.provider,
+                    forkSourceType: result.forkSourceType,
+                    forkSourceSessionId: input.sessionId,
+                    forkSourceMessageId: sourceMessageId,
+                    inheritedPrefixMessageCount: result.inheritedPrefixMessageCount,
+                    providerParentSessionId: binding.providerSessionId,
+                    providerSourceMessageId: result.providerSourceMessageId ?? null,
+                    forkMethod: result.forkMethod,
+                    createdAt: timestamp
+                });
+                this.sessionStatusSnapshotRepository.upsert({
+                    sessionId,
+                    syncStatus: "idle",
+                    syncCursor: null,
+                    lastSyncAt: timestamp,
+                    lastErrorCode: null,
+                    lastErrorDetail: null,
+                    resumedAt: null,
+                    updatedAt: timestamp
+                });
+                this.sessionStateRepository.upsert({
+                    sessionId,
+                    userId: input.userId,
+                    runningState: "idle",
+                    activitySource: "none",
+                    favorite: false,
+                    lastEventAt: result.session.lastMessageAt,
+                    completedAt: null,
+                    lastSeenAt: null,
+                    updatedAt: timestamp
+                });
+            })();
+            const forkedSession = this.getSessionListItemOrThrow(sessionId, input.userId);
+            const relationMap = this.workspaceSessionRelations.get(workspace.id)
+                ?? new Map();
+            relationMap.set(sessionId, {
+                parentSessionId: input.sessionId,
+                sessionKind: forkedSession.sessionKind ?? input.sessionKind ?? "default",
+                annotationSourceMessageId: forkedSession.annotationSourceMessageId ?? input.annotationSourceMessageId ?? null,
+                annotationSourceText: forkedSession.annotationSourceText ?? input.annotationSourceText ?? null,
+                isSubagent: forkedSession.isSubagent ?? false,
+                subagentLabel: forkedSession.subagentLabel ?? null
+            });
+            this.workspaceSessionRelations.set(workspace.id, relationMap);
+            return this.getSessionListItemOrThrow(sessionId, input.userId);
+        }
+        catch (error) {
+            throw mapSessionProviderError(error);
+        }
+    }
+    async forkSessionAcrossProviders(input, sourceBinding, sourceMessageId) {
+        if (!RECONSTRUCTED_FORK_TARGET_PROVIDERS.has(input.targetProvider)) {
+            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, input.sourceMessageSnapshot ?? null);
+        const reconstructedMessages = inheritedMessages.filter((message) => (message.role === "user" || message.role === "assistant")
+            && message.kind === "text"
+            && message.content.trim().length > 0);
+        const inheritedPrompt = buildReconstructedForkPrompt({
+            sourceProvider: sourceBinding.provider,
+            targetProvider: input.targetProvider,
+            sourceType: input.sourceType,
+            sourceTitle: sourceIndex?.title?.trim() || null,
+            messages: reconstructedMessages
+        });
+        const startedSession = await this.startSessionDirect({
+            workspaceId: sourceBinding.workspaceId,
+            userId: input.userId,
+            provider: input.targetProvider,
+            initialPrompt: inheritedPrompt,
+            parentSessionId: input.sessionId,
+            sessionKind: input.sessionKind ?? "default",
+            annotationSourceMessageId: input.annotationSourceMessageId ?? null,
+            annotationSourceText: input.annotationSourceText ?? null
+        });
+        const timestamp = nowIso();
+        const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(startedSession.sessionId);
+        this.db.transaction(() => {
+            if (currentIndex) {
+                this.sessionIndexRepository.upsert({
+                    ...currentIndex,
+                    parentSessionId: input.sessionId,
+                    sessionKind: input.sessionKind ?? currentIndex.sessionKind ?? "default",
+                    annotationSourceMessageId: input.annotationSourceMessageId ?? currentIndex.annotationSourceMessageId ?? null,
+                    annotationSourceText: input.annotationSourceText ?? currentIndex.annotationSourceText ?? null,
+                    updatedAt: timestamp
+                });
+            }
+            this.sessionForkRepository.upsert({
+                sessionId: startedSession.sessionId,
+                parentSessionId: input.sessionId,
+                provider: input.targetProvider,
+                forkSourceType: input.sourceType,
+                forkSourceSessionId: input.sessionId,
+                forkSourceMessageId: sourceMessageId,
+                inheritedPrefixMessageCount: reconstructedMessages.length,
+                providerParentSessionId: sourceBinding.providerSessionId,
+                providerSourceMessageId: null,
+                forkMethod: input.sourceType === "session"
+                    ? "reconstructed_session_fork"
+                    : "reconstructed_message_fork",
+                createdAt: timestamp
+            });
+        })();
+        const relationMap = this.workspaceSessionRelations.get(sourceBinding.workspaceId)
+            ?? new Map();
+        relationMap.set(startedSession.sessionId, {
+            parentSessionId: input.sessionId,
+            sessionKind: startedSession.sessionKind ?? input.sessionKind ?? "default",
+            annotationSourceMessageId: startedSession.annotationSourceMessageId ?? input.annotationSourceMessageId ?? null,
+            annotationSourceText: startedSession.annotationSourceText ?? input.annotationSourceText ?? null,
+            isSubagent: startedSession.isSubagent ?? false,
+            subagentLabel: startedSession.subagentLabel ?? null
+        });
+        this.workspaceSessionRelations.set(sourceBinding.workspaceId, relationMap);
+        return this.getSessionListItemOrThrow(startedSession.sessionId, input.userId);
+    }
+    async readForkSourceMessages(sessionId, binding, sourceType, sourceMessageId, sourceMessageSnapshot = null) {
+        const messages = [];
+        let cursor = null;
+        while (true) {
+            const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, cursor, FORK_RECONSTRUCTION_PAGE_SIZE, "forward");
+            messages.push(...page.messages);
+            if (!page.nextCursor) {
+                break;
+            }
+            cursor = page.nextCursor;
+        }
+        if (sourceType === "session") {
+            return messages;
+        }
+        const targetIndex = messages.findIndex((message) => message.messageId === sourceMessageId);
+        if (targetIndex < 0) {
+            throw mapSessionProviderError(new Error("FORK_SOURCE_MESSAGE_NOT_FOUND"));
+        }
+        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;
+        if (nextDepth > MAX_FORK_DEPTH) {
+            throw new AppError({
+                statusCode: 409,
+                errorCode: "FORK_DEPTH_LIMIT_EXCEEDED",
+                detail: `fork 会话层级最多支持 ${MAX_FORK_DEPTH} 级`
+            });
+        }
+    }
+    getSessionForkDepth(sessionId) {
+        let depth = 1;
+        let currentSessionId = sessionId;
+        const visitedSessionIds = new Set();
+        while (currentSessionId) {
+            if (visitedSessionIds.has(currentSessionId)) {
+                return depth;
+            }
+            visitedSessionIds.add(currentSessionId);
+            const parentSessionId = this.sessionForkRepository.findBySessionId(currentSessionId)?.parentSessionId
+                ?? this.sessionIndexRepository.findIndexRecordBySessionId(currentSessionId)?.parentSessionId
+                ?? null;
+            if (!parentSessionId) {
+                return depth;
+            }
+            depth += 1;
+            currentSessionId = parentSessionId;
+        }
+        return depth;
+    }
     async sendMessage(sessionId, content, clientRequestId, permissionMode = null) {
         const binding = this.getBindingOrThrow(sessionId);
         const result = await this.sessionSyncService
@@ -388,14 +826,21 @@ export class SessionHistoryService {
             throw mapSessionProviderError(error);
         });
         const existing = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        const sessionFork = this.sessionForkRepository.findBySessionId(sessionId);
+        const parentTitle = sessionFork?.parentSessionId
+            ? this.sessionIndexRepository.findIndexRecordBySessionId(sessionFork.parentSessionId)?.title ?? null
+            : null;
         this.sessionIndexRepository.upsert({
             sessionId,
             workspaceId: binding.workspaceId,
             provider: binding.provider,
             parentSessionId: existing?.parentSessionId ?? null,
+            sessionKind: existing?.sessionKind ?? "default",
+            annotationSourceMessageId: existing?.annotationSourceMessageId ?? null,
+            annotationSourceText: existing?.annotationSourceText ?? null,
             isSubagent: existing?.isSubagent ?? false,
             subagentLabel: existing?.subagentLabel ?? null,
-            title: existing?.title ?? result.message.content.slice(0, 48),
+            title: resolveSessionListTitle(binding.provider, existing?.title ?? null, result.message.content, parentTitle),
             messageCount: (existing?.messageCount ?? 0) + 1,
             isArchived: existing?.isArchived ?? false,
             lastMessageAt: result.message.timestamp,
@@ -493,6 +938,25 @@ export class SessionHistoryService {
             messages: page.messages
         };
     }
+    async readAllTextHistoryMessages(sessionId, limit = FORK_RECONSTRUCTION_PAGE_SIZE) {
+        const binding = this.getBindingOrThrow(sessionId);
+        const messages = [];
+        let cursor = null;
+        let remaining = Math.max(limit, 0);
+        while (remaining > 0) {
+            const pageSize = Math.min(remaining, FORK_RECONSTRUCTION_PAGE_SIZE);
+            const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, cursor, pageSize, "forward");
+            messages.push(...page.messages.filter((message) => (message.role === "user" || message.role === "assistant")
+                && message.kind === "text"
+                && message.content.trim().length > 0));
+            if (!page.nextCursor || page.messages.length === 0) {
+                break;
+            }
+            cursor = page.nextCursor;
+            remaining -= page.messages.length;
+        }
+        return messages;
+    }
     async markSessionSeen(sessionId, userId) {
         const existing = this.sessionStateRepository.findBySessionAndUser(sessionId, userId) ??
             (await this.refreshSessionState(sessionId, userId));
@@ -556,6 +1020,9 @@ export class SessionHistoryService {
             workspaceId: existing.workspaceId,
             provider: existing.provider,
             parentSessionId: existing.parentSessionId ?? null,
+            sessionKind: existing.sessionKind ?? "default",
+            annotationSourceMessageId: existing.annotationSourceMessageId ?? null,
+            annotationSourceText: existing.annotationSourceText ?? null,
             isSubagent: existing.isSubagent ?? false,
             subagentLabel: existing.subagentLabel ?? null,
             title: existing.title,
@@ -645,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) => {
@@ -666,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;
                     }
@@ -699,11 +1178,24 @@ export class SessionHistoryService {
                         createdAt,
                         updatedAt: timestamp
                     });
+                    const preservedParentSessionId = existingIndex?.parentSessionId
+                        ?? this.sessionForkRepository.findBySessionId(sessionId)?.parentSessionId
+                        ?? null;
+                    const preservedParentTitle = preservedParentSessionId
+                        ? this.sessionIndexRepository.findIndexRecordBySessionId(preservedParentSessionId)?.title ?? null
+                        : null;
+                    const preservedTitle = resolvePersistedSessionTitle(session.provider, session.title, existingIndex?.title ?? null, preservedParentTitle);
                     this.sessionIndexRepository.upsert({
                         sessionId,
                         workspaceId: workspace.id,
                         provider: session.provider,
-                        title: session.title,
+                        parentSessionId: preservedParentSessionId,
+                        sessionKind: existingIndex?.sessionKind ?? "default",
+                        annotationSourceMessageId: existingIndex?.annotationSourceMessageId ?? null,
+                        annotationSourceText: existingIndex?.annotationSourceText ?? null,
+                        isSubagent: existingIndex?.isSubagent ?? false,
+                        subagentLabel: existingIndex?.subagentLabel ?? null,
+                        title: preservedTitle,
                         messageCount: session.messageCount,
                         isArchived: resolveDiscoveredArchiveState(existingIndex?.isArchived ?? false, session.isArchived),
                         lastMessageAt: session.lastMessageAt,
@@ -728,17 +1220,46 @@ 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
+                        ?? this.sessionForkRepository.findBySessionId(persistedSession.sessionId)?.parentSessionId
+                        ?? null;
+                    const resolvedParentTitle = resolvedParentSessionId
+                        ? this.sessionIndexRepository.findIndexRecordBySessionId(resolvedParentSessionId)?.title ?? null
+                        : null;
                     this.sessionIndexRepository.upsert({
                         sessionId: persistedSession.sessionId,
                         workspaceId: workspace.id,
                         provider: persistedSession.session.provider,
-                        parentSessionId: relation?.parentSessionId ?? null,
-                        isSubagent: relation?.isSubagent ?? false,
-                        subagentLabel: relation?.subagentLabel ?? null,
-                        title: persistedSession.session.title,
+                        parentSessionId: resolvedParentSessionId,
+                        sessionKind: relation?.sessionKind
+                            ?? persistedSession.existingIndex?.sessionKind
+                            ?? "default",
+                        annotationSourceMessageId: relation?.annotationSourceMessageId
+                            ?? persistedSession.existingIndex?.annotationSourceMessageId
+                            ?? null,
+                        annotationSourceText: relation?.annotationSourceText
+                            ?? persistedSession.existingIndex?.annotationSourceText
+                            ?? null,
+                        isSubagent: relation?.isSubagent
+                            ?? persistedSession.existingIndex?.isSubagent
+                            ?? false,
+                        subagentLabel: relation?.subagentLabel
+                            ?? persistedSession.existingIndex?.subagentLabel
+                            ?? null,
+                        title: resolvePersistedSessionTitle(persistedSession.session.provider, persistedSession.session.title, persistedSession.existingIndex?.title ?? null, resolvedParentTitle),
                         messageCount: persistedSession.session.messageCount,
                         isArchived: resolveDiscoveredArchiveState(persistedSession.existingIndex?.isArchived ?? false, persistedSession.session.isArchived),
                         lastMessageAt: persistedSession.session.lastMessageAt,
@@ -747,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);
-            const recentItems = items.slice(0, refreshStateCount);
+            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(recentItems, userId);
+                await this.refreshRecentSessionStates(refreshCandidates, userId);
             }
             else {
-                this.scheduleWorkspaceStateRefresh(workspaceId, userId, recentItems);
+                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,
@@ -774,9 +1325,20 @@ export class SessionHistoryService {
                 discoveredSessions: sessions.length,
                 returnedSessions: nextItems.length,
                 discoveryComplete: discovery.isComplete,
-                refreshedStates: Math.min(items.length, refreshStateCount),
+                providerDiagnostics: (discovery.providerDiagnostics ?? []).map((entry) => `${entry.provider}:${entry.status}:${Math.round(entry.durationMs)}ms`),
+                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
@@ -789,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"
             }, {
@@ -909,11 +1481,17 @@ export class SessionHistoryService {
                 ? discoveredSessionIds.get(buildProviderSessionKey(session.provider, session.parentProviderSessionId)) ??
                     this.sessionBindingRepository.findByProviderSession(session.provider, session.parentProviderSessionId)?.sessionId ??
                     null
-                : null;
+                : this.resolvePersistedParentSessionId(sessionId);
             relationMap.set(sessionId, {
                 parentSessionId,
-                isSubagent: Boolean(session.isSubagent || parentSessionId),
-                subagentLabel: session.subagentLabel?.trim() || null
+                sessionKind: this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.sessionKind ?? "default",
+                annotationSourceMessageId: this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.annotationSourceMessageId ?? null,
+                annotationSourceText: this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.annotationSourceText ?? null,
+                isSubagent: session.isSubagent === true
+                    || this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.isSubagent === true,
+                subagentLabel: session.subagentLabel?.trim()
+                    || this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.subagentLabel
+                    || null
             });
         }
         return relationMap;
@@ -931,6 +1509,9 @@ export class SessionHistoryService {
             return this.enrichSessionItem({
                 ...item,
                 parentSessionId: relation.parentSessionId,
+                sessionKind: relation.sessionKind,
+                annotationSourceMessageId: relation.annotationSourceMessageId,
+                annotationSourceText: relation.annotationSourceText,
                 isSubagent: relation.isSubagent,
                 subagentLabel: relation.subagentLabel
             });
@@ -942,12 +1523,18 @@ export class SessionHistoryService {
             ? {
                 ...item,
                 parentSessionId: relation.parentSessionId,
+                sessionKind: relation.sessionKind,
+                annotationSourceMessageId: relation.annotationSourceMessageId,
+                annotationSourceText: relation.annotationSourceText,
                 isSubagent: relation.isSubagent,
                 subagentLabel: relation.subagentLabel
             }
             : {
                 ...item,
                 parentSessionId: item.parentSessionId ?? null,
+                sessionKind: item.sessionKind ?? "default",
+                annotationSourceMessageId: item.annotationSourceMessageId ?? null,
+                annotationSourceText: item.annotationSourceText ?? null,
                 isSubagent: item.isSubagent ?? false,
                 subagentLabel: item.subagentLabel ?? null
             };
@@ -1018,16 +1605,27 @@ export class SessionHistoryService {
         if (shouldSkipClaudePendingBinding(binding)) {
             return;
         }
-        const nextTitle = (await this.sessionSyncService.readSessionTitle(binding.provider, binding.providerSessionId, binding.rawStoreRef)).trim();
-        if (nextTitle.length === 0 || nextTitle === currentIndex.title) {
+        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;
         }
         this.sessionIndexRepository.upsert({
             ...currentIndex,
-            title: nextTitle,
+            title: resolvedTitle,
             updatedAt: nowIso()
         });
     }
+    resolvePersistedParentSessionId(sessionId) {
+        return (this.sessionForkRepository.findBySessionId(sessionId)?.parentSessionId
+            ?? this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.parentSessionId
+            ?? null);
+    }
     async ensureSessionChangedFilesIndexed(sessionId) {
         if (this.sessionChangedFileService.hasIndexedSession(sessionId)) {
             return;
@@ -1169,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
@@ -1189,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)) {
@@ -1291,6 +1886,9 @@ export class SessionHistoryService {
         this.db
             .prepare("DELETE FROM session_status_snapshots WHERE session_id = ?")
             .run(input.sourceSessionId);
+        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);
@@ -1362,11 +1960,25 @@ export class SessionHistoryService {
         relationMap.delete(sourceSessionId);
         relationMap.set(targetSessionId, {
             parentSessionId: targetRelation?.parentSessionId ?? sourceRelation?.parentSessionId ?? fallbackParentSessionId,
+            sessionKind: targetRelation?.sessionKind
+                ?? sourceRelation?.sessionKind
+                ?? targetIndex?.sessionKind
+                ?? sourceIndex?.sessionKind
+                ?? "default",
+            annotationSourceMessageId: targetRelation?.annotationSourceMessageId
+                ?? sourceRelation?.annotationSourceMessageId
+                ?? targetIndex?.annotationSourceMessageId
+                ?? sourceIndex?.annotationSourceMessageId
+                ?? null,
+            annotationSourceText: targetRelation?.annotationSourceText
+                ?? sourceRelation?.annotationSourceText
+                ?? targetIndex?.annotationSourceText
+                ?? sourceIndex?.annotationSourceText
+                ?? null,
             isSubagent: Boolean(targetRelation?.isSubagent
                 || sourceRelation?.isSubagent
                 || targetIndex?.isSubagent
-                || sourceIndex?.isSubagent
-                || fallbackParentSessionId),
+                || sourceIndex?.isSubagent),
             subagentLabel: targetRelation?.subagentLabel
                 ?? sourceRelation?.subagentLabel
                 ?? targetIndex?.subagentLabel
@@ -1396,6 +2008,9 @@ export class SessionHistoryService {
         this.db
             .prepare("DELETE FROM session_status_snapshots WHERE session_id = ?")
             .run(sessionId);
+        this.db
+            .prepare("DELETE FROM session_forks WHERE session_id = ?")
+            .run(sessionId);
         this.db
             .prepare("DELETE FROM session_indices WHERE session_id = ?")
             .run(sessionId);
@@ -1426,17 +2041,24 @@ export class SessionHistoryService {
         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 resolution = this.sessionActivityAuthorityService.observe(buildInspectionActivityObservation(sessionId, inspection, timestamp));
+        const resolvedLastEventAt = hasInspectionEvidence(inspection)
+            ? resolution.lastObservedAt ?? inspection.lastEventAt ?? current?.lastEventAt ?? null
+            : current?.lastEventAt ?? null;
         const nextRecord = {
             sessionId,
             userId,
             runningState: mapResolvedRunningStateToStored(resolution.runningState, current),
             activitySource: mapResolutionSourceToLegacyActivitySource(resolution.activityResolutionSource, inspection),
             favorite: current?.favorite ?? false,
-            lastEventAt: resolution.lastObservedAt ?? inspection.lastEventAt ?? current?.lastEventAt ?? null,
+            lastEventAt: resolvedLastEventAt,
             completedAt: isTerminalResolvedRunningState(resolution.runningState)
                 ? resolution.terminalAt ?? inspection.completedAtCandidate ?? current?.completedAt ?? null
                 : null,
@@ -1496,11 +2118,52 @@ export class SessionHistoryService {
         });
     }
 }
+function isProviderCliBacked(provider) {
+    return provider === "claude-code" || provider === "codex" || provider === "gemini" || provider === "kimi";
+}
+function buildProviderCliAvailabilitySnapshot(commandPaths) {
+    return Object.freeze(Object.fromEntries(Object.entries(commandPaths).map(([provider, commandPath]) => [
+        provider,
+        isCommandAvailable(commandPath)
+    ])));
+}
+function buildProviderCliUnavailableMessage(provider) {
+    switch (provider) {
+        case "claude-code":
+            return "未检测到 Claude CLI";
+        case "codex":
+            return "未检测到 Codex CLI";
+        case "gemini":
+            return "未检测到 Gemini CLI";
+        case "kimi":
+            return "未检测到 Kimi CLI";
+        default:
+            return "未检测到对应 CLI";
+    }
+}
+function createCodexForkTransportFactory(commandPath, homeDir) {
+    return () => {
+        const client = new CodexAppServerHelperClient(commandPath, { homeDir });
+        const transport = client.createForkTransport();
+        return {
+            ...transport,
+            close() {
+                transport.close();
+                client.dispose();
+            }
+        };
+    };
+}
 function buildInspectionActivityObservation(sessionId, inspection, observedAt) {
+    const resolvedRunningState = inspection.runningState === "failed"
+        ? "failed"
+        : inspection.completedAtCandidate
+            ? "completed"
+            : inspection.runningState;
     return {
         sessionId,
         runId: null,
-        runningState: inspection.runningState,
+        runningState: resolvedRunningState,
         source: hasInspectionEvidence(inspection) ? "inferred_log" : "unknown",
         confidence: "weak",
         detail: inspection.errorDetail,
@@ -1557,6 +2220,20 @@ function clampLimit(limit) {
     }
     return Math.max(1, Math.min(Math.trunc(limit), 100));
 }
+function buildSessionStateRefreshCandidates(items, recentCount) {
+    const recentItems = items.slice(0, recentCount);
+    const activeResidues = items.filter((item) => isSessionStateRefreshCandidate(item));
+    const deduped = new Map();
+    for (const item of [...recentItems, ...activeResidues]) {
+        deduped.set(item.sessionId, item);
+    }
+    return Array.from(deduped.values());
+}
+function isSessionStateRefreshCandidate(item) {
+    return item.activityState === "running"
+        || item.runningState === "starting"
+        || item.runningState === "running";
+}
 function mapSessionStateRecordRow(row) {
     return {
         sessionId: row.session_id,
@@ -1622,6 +2299,9 @@ function mergeSessionIndexRecord(input) {
         workspaceId: input.workspaceId,
         provider: (input.target?.provider ?? input.source?.provider ?? input.provider),
         parentSessionId: input.target?.parentSessionId ?? input.source?.parentSessionId ?? null,
+        sessionKind: input.target?.sessionKind ?? input.source?.sessionKind ?? "default",
+        annotationSourceMessageId: input.target?.annotationSourceMessageId ?? input.source?.annotationSourceMessageId ?? null,
+        annotationSourceText: input.target?.annotationSourceText ?? input.source?.annotationSourceText ?? null,
         isSubagent: Boolean(input.target?.isSubagent || input.source?.isSubagent),
         subagentLabel: input.target?.subagentLabel ?? input.source?.subagentLabel ?? null,
         title: pickPreferredSessionTitle(input.target?.title ?? null, input.source?.title ?? null),
@@ -1991,6 +2671,56 @@ function isLegacyCodingNsRolloutSession(providerSessionId, rawStoreRef) {
 function shouldRemoveMissingSyntheticCodexSession(rawStoreRef) {
     return isSyntheticCodexRawStoreRef(rawStoreRef) && !existsSync(rawStoreRef);
 }
+function resolveSessionListTitle(provider, existingTitle, fallbackContent, parentTitle = null) {
+    const normalizedExistingTitle = existingTitle?.trim() ?? "";
+    const normalizedParentTitle = parentTitle?.trim() ?? "";
+    const fallbackTitle = buildUserMessageTitle(fallbackContent, normalizedExistingTitle || "继续对话");
+    if (normalizedExistingTitle.length > 0 &&
+        !isSyntheticCodexSessionTitle(normalizedExistingTitle) &&
+        (normalizedParentTitle.length === 0 ||
+            normalizedExistingTitle !== normalizedParentTitle)) {
+        return normalizedExistingTitle;
+    }
+    if (normalizedParentTitle.length > 0 && normalizedExistingTitle === normalizedParentTitle) {
+        return fallbackTitle;
+    }
+    if (provider === "codex") {
+        return fallbackTitle;
+    }
+    return normalizedExistingTitle || fallbackTitle;
+}
+function buildUserMessageTitle(content, fallbackTitle) {
+    const title = content.trim().replace(/\s+/g, " ");
+    return title.slice(0, 48) || fallbackTitle;
+}
+function resolvePersistedSessionTitle(provider, discoveredTitle, existingTitle, parentTitle = null) {
+    const nextTitle = discoveredTitle.trim();
+    const currentTitle = existingTitle?.trim() ?? "";
+    const normalizedParentTitle = parentTitle?.trim() ?? "";
+    if (!currentTitle) {
+        if (provider === "codex" && isSyntheticCodexSessionTitle(nextTitle)) {
+            return currentTitle;
+        }
+        if (normalizedParentTitle.length > 0 && nextTitle === normalizedParentTitle) {
+            return currentTitle;
+        }
+        return nextTitle;
+    }
+    if (nextTitle.length === 0) {
+        return currentTitle;
+    }
+    if (provider === "codex" && isSyntheticCodexSessionTitle(nextTitle)) {
+        return currentTitle;
+    }
+    if (normalizedParentTitle.length > 0 && nextTitle === normalizedParentTitle && currentTitle !== normalizedParentTitle) {
+        return currentTitle;
+    }
+    return nextTitle;
+}
+function isSyntheticCodexSessionTitle(title) {
+    return (/^rollout-\d{4}-\d{2}-\d{2}t/i.test(title) ||
+        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(title));
+}
 function shouldRemoveHiddenClaudeDebugSession(session) {
     const normalizedRawStoreRef = session.rawStoreRef.replaceAll("\\", "/");
     if (normalizedRawStoreRef.includes("/subagents/")) {
@@ -1999,11 +2729,34 @@ function shouldRemoveHiddenClaudeDebugSession(session) {
     return (/^agent-[^/]+$/i.test(session.providerSessionId) &&
         /\/agent-[^/]+\.jsonl$/i.test(normalizedRawStoreRef));
 }
+const STALE_RUNTIME_WITHOUT_INSPECTION_GRACE_MS = 120_000;
+function shouldClearStaleRuntimeWithoutInspection(current, inspection, nowMs) {
+    if (!current || current.activitySource !== "runtime") {
+        return false;
+    }
+    if (current.runningState !== "starting" && current.runningState !== "running") {
+        return false;
+    }
+    if (inspection.lastEventAt || inspection.completedAtCandidate || inspection.errorCode) {
+        return false;
+    }
+    if (!current.lastEventAt) {
+        return true;
+    }
+    const lastEventAtMs = Date.parse(current.lastEventAt);
+    if (!Number.isFinite(lastEventAtMs)) {
+        return true;
+    }
+    return nowMs - lastEventAtMs > STALE_RUNTIME_WITHOUT_INSPECTION_GRACE_MS;
+}
 function shouldPreserveRuntimeTerminalState(current, inspection) {
     if (!current || current.activitySource !== "runtime") {
         return false;
     }
-    if (!inspection.lastEventAt || !current.lastEventAt) {
+    if (!inspection.lastEventAt) {
+        return !shouldClearStaleRuntimeWithoutInspection(current, inspection, Date.now());
+    }
+    if (!current.lastEventAt) {
         return true;
     }
     if (isTerminalRunningState(current.runningState)) {
@@ -2056,4 +2809,98 @@ function resolveActivityState(runningState, completedAt, lastSeenAt) {
     }
     return "idle";
 }
+function buildReconstructedForkPrompt(input) {
+    const lines = [
+        input.sourceTitle
+            ? `源会话：${input.sourceTitle}`
+            : "源会话：未命名会话",
+        `源 provider：${input.sourceProvider}`,
+        `目标 provider：${input.targetProvider}`,
+        input.sourceType === "message"
+            ? "分叉方式：从指定消息点重建后续上下文"
+            : "分叉方式：从整条会话重建上下文",
+        "",
+        "下面是需要继承到新会话里的历史文本。",
+        "请把这些内容当作已经发生过的上下文事实，不要逐条复述，也不要把它们当成新的用户问题重新回答。",
+        "后续我会在这条新分支里继续追加新的指令。",
+        ""
+    ];
+    if (input.messages.length === 0) {
+        lines.push("当前没有可继承的历史文本。");
+        return lines.join("\n");
+    }
+    for (const message of input.messages) {
+        lines.push(message.role === "user" ? "[用户]" : "[助手]");
+        lines.push(message.content.trim());
+        lines.push("");
+    }
+    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