@jingyi0605/codingns 0.1.5 → 0.2.0

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

@@ -5,12 +5,18 @@ import { hashContent } from "../../shared/utils/hash.js";
 import { createId } from "../../shared/utils/id.js";
 import { logPerformance } from "../../shared/utils/perf-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 { 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",
@@ -33,14 +39,17 @@ export class SessionHistoryService {
     sessionSyncService;
     capabilityService;
     sessionActivityAuthorityService;
+    sessionForkRepository;
     claudeCodeHomeDir;
     codexModelOptionsService;
     openCodeModelOptionsService;
+    providerCliCommandPaths;
+    providerCliAvailability;
     workspaceDiscoveryStatuses = new Map();
     workspaceDiscoveryInflight = new Map();
     workspaceStateRefreshInflight = 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 = {}) {
         this.db = db;
         this.workspaceRepository = workspaceRepository;
         this.sessionBindingRepository = sessionBindingRepository;
@@ -51,10 +60,23 @@ export class SessionHistoryService {
         this.sessionStatusSnapshotRepository = sessionStatusSnapshotRepository;
         this.sessionMessageOriginRepository = sessionMessageOriginRepository;
         this.sessionActivityAuthorityService = sessionActivityAuthorityService;
+        this.sessionForkRepository = sessionForkRepository ?? new SessionForkRepository(db);
         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.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
@@ -244,7 +266,7 @@ export class SessionHistoryService {
     }
     getProviderCapabilitiesSnapshot(provider) {
         try {
-            return this.capabilityService.getProviderCapabilities(provider);
+            return this.applyProviderCliAvailability(this.capabilityService.getProviderCapabilities(provider));
         }
         catch (error) {
             throw mapSessionProviderError(error);
@@ -253,7 +275,7 @@ 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);
+            return await this.enrichProviderCapabilities(this.applyProviderCliAvailability(this.capabilityService.getProviderCapabilities(provider)), workspacePath);
         }
         catch (error) {
             throw mapSessionProviderError(error);
@@ -264,7 +286,7 @@ export class SessionHistoryService {
         const workspace = this.getWorkspaceOrThrow(binding.workspaceId);
         return this.capabilityService
             .getSessionCapabilities(binding.provider, binding.providerSessionId)
-            .then((capabilities) => this.enrichProviderCapabilities(capabilities, workspace.path))
+            .then((capabilities) => this.enrichProviderCapabilities(this.applyProviderCliAvailability(capabilities), workspace.path))
             .catch((error) => {
             throw mapSessionProviderError(error);
         });
@@ -277,6 +299,41 @@ export class SessionHistoryService {
         const codexEnriched = await enrichCodexCapabilities(claudeEnriched, this.codexModelOptionsService);
         return enrichOpenCodeCapabilities(codexEnriched, this.openCodeModelOptionsService, workspacePath);
     }
+    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 +345,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 +369,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 +377,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 +402,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 +444,236 @@ 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,
+                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);
+        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) {
+        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"));
+        }
+        return messages.slice(0, targetIndex + 1);
+    }
+    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 +683,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 +795,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 +877,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,
@@ -699,11 +1023,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,
@@ -731,14 +1068,34 @@ export class SessionHistoryService {
                 const relationMap = this.buildWorkspaceSessionRelationMap(sessions, discoveredSessionIds);
                 for (const persistedSession of persistedSessions) {
                     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,
@@ -755,16 +1112,16 @@ export class SessionHistoryService {
             }
             this.workspaceSessionRelations.set(workspaceId, this.buildWorkspaceSessionRelationMap(sessions, discoveredSessionIds));
             const items = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
-            const recentItems = items.slice(0, refreshStateCount);
+            const refreshCandidates = buildSessionStateRefreshCandidates(items, refreshStateCount);
             this.workspaceDiscoveryStatuses.set(workspaceId, {
                 refreshedAt: Date.now(),
                 isComplete: discovery.isComplete
             });
             if (refreshStateMode === "inline") {
-                await this.refreshRecentSessionStates(recentItems, userId);
+                await this.refreshRecentSessionStates(refreshCandidates, userId);
             }
             else {
-                this.scheduleWorkspaceStateRefresh(workspaceId, userId, recentItems);
+                this.scheduleWorkspaceStateRefresh(workspaceId, userId, refreshCandidates);
             }
             const nextItems = this.listWorkspaceSessions(workspaceId, userId);
             logPerformance("workspace.discover_sessions", Date.now() - startedAt, {
@@ -774,7 +1131,8 @@ 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,
                 refreshStateDeferred: refreshStateMode !== "inline"
@@ -909,11 +1267,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 +1295,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 +1309,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
             };
@@ -1019,15 +1392,21 @@ export class SessionHistoryService {
             return;
         }
         const nextTitle = (await this.sessionSyncService.readSessionTitle(binding.provider, binding.providerSessionId, binding.rawStoreRef)).trim();
-        if (nextTitle.length === 0 || nextTitle === currentIndex.title) {
+        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;
@@ -1291,6 +1670,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 +1744,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 +1792,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 +1825,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 +1902,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 +2004,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 +2083,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 +2455,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 +2513,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 +2593,31 @@ 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();
+}
 //# sourceMappingURL=session-history-service.js.map