@jingyi0605/codingns 0.1.4 → 0.2.0

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

@@ -1,15 +1,30 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { CapabilityService, ClaudeCodeAdapter, CodexAdapter, OpenCodeAdapter, ProviderRegistry, SessionSyncService } from "@codingns/session-sync-core";
+import { CapabilityService, ClaudeCodeAdapter, CodexAdapter, GeminiAdapter, KimiAdapter, OpenCodeAdapter, ProviderRegistry, SessionSyncService } from "@codingns/session-sync-core";
 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 { 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",
+    "opencode",
+    "gemini",
+    "kimi"
+]);
+const MUTABLE_HISTORY_TAIL_REFRESH_INTERVAL_MS = 1_200;
 export class SessionHistoryService {
     db;
     workspaceRepository;
@@ -19,18 +34,22 @@ export class SessionHistoryService {
     sessionMessageAttachmentService;
     sessionStateRepository;
     sessionStatusSnapshotRepository;
+    sessionMessageOriginRepository;
     providerRegistry;
     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()) {
+    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;
@@ -39,11 +58,33 @@ export class SessionHistoryService {
         this.sessionMessageAttachmentService = sessionMessageAttachmentService;
         this.sessionStateRepository = sessionStateRepository;
         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
+            }),
+            new KimiAdapter({
+                homeDir: config.kimiHomeDir,
+                defaultModel: config.kimiDefaultModel
+            }),
             new OpenCodeAdapter({
                 baseUrl: config.opencodeBaseUrl,
                 baseUrlResolver: config.opencodeBaseUrlResolver?.resolve.bind(config.opencodeBaseUrlResolver),
@@ -98,15 +139,16 @@ export class SessionHistoryService {
     }
     async readSessionHistory(sessionId, cursor, limit, direction = "forward", userId) {
         const startedAt = Date.now();
-        const binding = this.getBindingOrThrow(sessionId);
-        const current = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        const resolvedSessionId = this.resolveCanonicalSessionId(sessionId, userId);
+        const binding = this.getBindingOrThrow(resolvedSessionId);
+        const current = this.sessionStatusSnapshotRepository.findBySessionId(resolvedSessionId);
         const safeLimit = clampLimit(limit);
         const knownTotalMessageCount = direction === "backward" && cursor === null
-            ? this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.messageCount ?? null
+            ? this.sessionIndexRepository.findIndexRecordBySessionId(resolvedSessionId)?.messageCount ?? null
             : null;
         let readDurationMs = 0;
         let refreshStateDurationMs = 0;
-        this.upsertSnapshot(sessionId, {
+        this.upsertSnapshot(resolvedSessionId, {
             syncStatus: "syncing",
             syncCursor: current?.syncCursor ?? cursor,
             lastSyncAt: current?.lastSyncAt ?? null,
@@ -116,9 +158,9 @@ export class SessionHistoryService {
         });
         try {
             const readStartedAt = Date.now();
-            const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, cursor, safeLimit, direction, knownTotalMessageCount);
+            const page = await this.readPage(resolvedSessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, cursor, safeLimit, direction, knownTotalMessageCount);
             readDurationMs = Date.now() - readStartedAt;
-            this.upsertSnapshot(sessionId, {
+            this.upsertSnapshot(resolvedSessionId, {
                 syncStatus: "idle",
                 syncCursor: direction === "backward" && cursor !== null
                     ? current?.syncCursor ?? page.cursor
@@ -129,7 +171,8 @@ export class SessionHistoryService {
                 resumedAt: current?.resumedAt ?? null
             });
             logPerformance("session.read_history", Date.now() - startedAt, {
-                sessionId,
+                sessionId: resolvedSessionId,
+                requestedSessionId: sessionId,
                 provider: binding.provider,
                 direction,
                 limit: safeLimit,
@@ -145,7 +188,8 @@ export class SessionHistoryService {
         }
         catch (error) {
             logPerformance("session.read_history.failed", Date.now() - startedAt, {
-                sessionId,
+                sessionId: resolvedSessionId,
+                requestedSessionId: sessionId,
                 provider: binding.provider,
                 direction,
                 limit: safeLimit,
@@ -157,10 +201,17 @@ export class SessionHistoryService {
                 thresholdMs: 0,
                 force: true
             });
-            this.markSessionError(sessionId, "PROVIDER_READ_FAILED", error);
+            this.markSessionError(resolvedSessionId, "PROVIDER_READ_FAILED", error);
             throw mapSessionProviderError(error);
         }
     }
+    resolveMessageOrigin(sessionId, message) {
+        return this.resolveMessageOrigins(sessionId, [message])[0] ?? {
+            ...message,
+            origin: null,
+            originRef: null
+        };
+    }
     async findLatestUserMessage(sessionId, content, maxAttempts = 12, minTimestamp = null) {
         const binding = this.getBindingOrThrow(sessionId);
         const acceptedContents = new Set((Array.isArray(content) ? content : [content]).filter((value) => value.trim().length > 0));
@@ -171,7 +222,7 @@ export class SessionHistoryService {
                 .reverse()
                 .find((message) => message.role === "user" &&
                 acceptedContents.has(message.content) &&
-                isMessageAtOrAfter(message.timestamp, minTimestamp));
+                isAcceptedUserMessageTimestamp(binding.provider, message.timestamp, minTimestamp));
             if (matched) {
                 return matched;
             }
@@ -209,11 +260,13 @@ export class SessionHistoryService {
         return this.sessionChangedFileService.listBySessionId(sessionId);
     }
     listWorkspaceSessions(workspaceId, userId) {
-        return this.enrichSessionItems(workspaceId, this.sessionIndexRepository.listByWorkspace(workspaceId, userId));
+        return this.enrichSessionItems(workspaceId, this.sessionIndexRepository
+            .listByWorkspace(workspaceId, userId)
+            .filter((item) => !this.isPendingSessionAlias(item)));
     }
     getProviderCapabilitiesSnapshot(provider) {
         try {
-            return this.capabilityService.getProviderCapabilities(provider);
+            return this.applyProviderCliAvailability(this.capabilityService.getProviderCapabilities(provider));
         }
         catch (error) {
             throw mapSessionProviderError(error);
@@ -222,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);
@@ -233,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);
         });
@@ -246,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 {
@@ -257,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, {
@@ -280,8 +369,7 @@ export class SessionHistoryService {
         }
     }
     async startSession(input) {
-        const workspace = this.getWorkspaceOrThrow(input.workspaceId);
-        if (input.provider === "codex" || input.provider === "claude-code" || input.provider === "opencode") {
+        if (SESSION_START_DEFERRED_PROVIDERS.has(input.provider)) {
             throw new AppError({
                 statusCode: 409,
                 errorCode: "SESSION_START_DEFERRED",
@@ -289,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
@@ -309,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,
@@ -348,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
@@ -357,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,
@@ -385,7 +718,7 @@ export class SessionHistoryService {
         };
     }
     async subscribeSession(sessionId, cursor, limit, onEnvelope) {
-        const sentMessageIds = new Set();
+        const deliveredMessages = createDeliveredHistoryMessageState();
         const safeLimit = clampLimit(limit);
         let currentCursor = cursor;
         const current = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
@@ -401,10 +734,10 @@ export class SessionHistoryService {
         });
         try {
             if (currentCursor === null) {
-                currentCursor = await this.pullRecentSessionHistory(sessionId, safeLimit, sentMessageIds, onEnvelope, "session.backfill");
+                currentCursor = await this.pullRecentSessionHistory(sessionId, safeLimit, deliveredMessages, onEnvelope, "session.backfill");
             }
             else {
-                await this.pullSessionHistory(sessionId, currentCursor, safeLimit, sentMessageIds, onEnvelope, "session.backfill").then((nextCursor) => {
+                await this.pullSessionHistory(sessionId, currentCursor, safeLimit, deliveredMessages, onEnvelope, "session.backfill").then((nextCursor) => {
                     currentCursor = nextCursor;
                 });
             }
@@ -418,7 +751,7 @@ export class SessionHistoryService {
                 return;
             }
             polling = true;
-            void this.pullSessionHistory(sessionId, currentCursor, safeLimit, sentMessageIds, onEnvelope, "session.delta", () => closed)
+            void this.pullSessionHistory(sessionId, currentCursor, safeLimit, deliveredMessages, onEnvelope, "session.delta", () => closed)
                 .then((nextCursor) => {
                 currentCursor = nextCursor;
             })
@@ -462,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));
@@ -525,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,
@@ -567,7 +922,7 @@ export class SessionHistoryService {
                 detail: "session 不存在"
             });
         }
-        return binding;
+        return this.resolvePendingSessionAliasBinding(binding) ?? binding;
     }
     persistSessionBinding(sessionId, workspaceId, snapshot) {
         if (!snapshot.providerSessionId || !snapshot.rawStoreRef) {
@@ -643,7 +998,8 @@ export class SessionHistoryService {
                         continue;
                     }
                     const pendingDuplicate = exactExisting
-                        ?? findClaudePendingDiscoveryDuplicate(session, existingWorkspaceSessions, claimedPendingSessionIds);
+                        ?? findClaudePendingDiscoveryDuplicate(session, existingWorkspaceSessions, claimedPendingSessionIds)
+                        ?? findKimiRuntimeDiscoveryDuplicate(session, existingWorkspaceSessions, claimedPendingSessionIds);
                     const existing = exactExisting ?? (pendingDuplicate
                         ? this.sessionBindingRepository.findBySessionId(pendingDuplicate.sessionId)
                         : null);
@@ -667,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,
@@ -699,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,
@@ -723,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, {
@@ -742,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"
@@ -788,7 +1178,8 @@ export class SessionHistoryService {
             : this.sessionSyncService.readHistory(provider, providerSessionId, rawStoreRef, cursor, limit, direction);
         return historyTask
             .then((page) => {
-            const messages = this.sessionMessageAttachmentService.enrichMessages(sessionId, page.messages);
+            const messagesWithAttachments = this.sessionMessageAttachmentService.enrichMessages(sessionId, page.messages);
+            const messages = this.enrichMessagesWithOrigin(sessionId, messagesWithAttachments);
             this.persistSessionChangedFiles(sessionId, messages);
             return {
                 ...page,
@@ -807,6 +1198,64 @@ export class SessionHistoryService {
             throw mapSessionProviderError(error);
         });
     }
+    enrichMessagesWithOrigin(sessionId, messages) {
+        return this.resolveMessageOrigins(sessionId, messages);
+    }
+    resolveMessageOrigins(sessionId, messages) {
+        const originRepository = this.sessionMessageOriginRepository;
+        if (!originRepository || messages.length === 0) {
+            return messages.map((message) => ({
+                ...message,
+                origin: null,
+                originRef: null
+            }));
+        }
+        const messageIds = [...new Set(messages.map((message) => message.messageId).filter(Boolean))];
+        const originRows = originRepository.listBySessionAndMessageIds(sessionId, messageIds);
+        const originByMessageId = new Map(originRows
+            .filter((row) => row.messageId)
+            .map((row) => [row.messageId, row]));
+        const unresolvedRows = originRepository.listUnresolvedBySessionAndContents(sessionId, [...new Set(messages.map((message) => message.content).filter((content) => content.trim().length > 0))]);
+        const unresolvedByContent = new Map();
+        for (const row of unresolvedRows) {
+            const current = unresolvedByContent.get(row.content) ?? [];
+            current.push(row);
+            unresolvedByContent.set(row.content, current);
+        }
+        return messages.map((message) => {
+            const resolved = originByMessageId.get(message.messageId) ?? null;
+            if (resolved) {
+                return {
+                    ...message,
+                    origin: resolved.origin,
+                    originRef: resolved.originRef
+                };
+            }
+            if (message.role !== "user") {
+                return {
+                    ...message,
+                    origin: null,
+                    originRef: null
+                };
+            }
+            const candidates = unresolvedByContent.get(message.content) ?? [];
+            const matched = candidates.find((row) => isMessageAtOrAfter(message.timestamp, row.createdAt)) ?? null;
+            if (!matched) {
+                return {
+                    ...message,
+                    origin: null,
+                    originRef: null
+                };
+            }
+            originRepository.resolveMessageId(sessionId, matched.clientRequestId, message.messageId, message.timestamp);
+            unresolvedByContent.set(message.content, candidates.filter((candidate) => candidate.clientRequestId !== matched.clientRequestId));
+            return {
+                ...message,
+                origin: matched.origin,
+                originRef: matched.originRef
+            };
+        });
+    }
     buildWorkspaceSessionRelationMap(sessions, discoveredSessionIds) {
         const relationMap = new Map();
         for (const session of sessions) {
@@ -818,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;
@@ -840,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
             });
@@ -851,24 +1309,36 @@ 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
             };
         const resolution = this.sessionActivityAuthorityService.resolvePersistedSession(nextItem);
         return applySessionActivityResolution(nextItem, resolution);
     }
-    async pullSessionHistory(sessionId, cursor, limit, sentMessageIds, onEnvelope, envelopeType, isClosed = () => false) {
+    async pullSessionHistory(sessionId, cursor, limit, deliveredMessages, onEnvelope, envelopeType, isClosed = () => false) {
         let currentCursor = cursor;
         while (!isClosed()) {
             const binding = this.getBindingOrThrow(sessionId);
             const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, currentCursor, limit);
-            await this.publishHistoryEnvelope(sessionId, binding, page, sentMessageIds, onEnvelope, envelopeType);
+            await this.publishHistoryEnvelope(sessionId, binding, page, deliveredMessages, onEnvelope, envelopeType);
+            if (envelopeType === "session.delta" &&
+                shouldRefreshMutableHistoryTail(binding.provider, page, currentCursor, deliveredMessages)) {
+                const tailPage = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, null, Math.max(limit, 20), "backward");
+                deliveredMessages.lastMutableTailRefreshAtMs = Date.now();
+                await this.publishHistoryEnvelope(sessionId, binding, tailPage, deliveredMessages, onEnvelope, envelopeType);
+            }
             currentCursor = page.cursor;
             if (!page.nextCursor) {
                 return currentCursor;
@@ -876,19 +1346,21 @@ export class SessionHistoryService {
         }
         return currentCursor;
     }
-    async pullRecentSessionHistory(sessionId, limit, sentMessageIds, onEnvelope, envelopeType) {
+    async pullRecentSessionHistory(sessionId, limit, deliveredMessages, onEnvelope, envelopeType) {
         const binding = this.getBindingOrThrow(sessionId);
         const knownTotalMessageCount = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.messageCount ?? null;
         const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, null, limit, "backward", knownTotalMessageCount);
-        await this.publishHistoryEnvelope(sessionId, binding, page, sentMessageIds, onEnvelope, envelopeType);
+        await this.publishHistoryEnvelope(sessionId, binding, page, deliveredMessages, onEnvelope, envelopeType);
         return page.cursor;
     }
-    async publishHistoryEnvelope(sessionId, binding, page, sentMessageIds, onEnvelope, envelopeType) {
+    async publishHistoryEnvelope(sessionId, binding, page, deliveredMessages, onEnvelope, envelopeType) {
         const messages = page.messages.filter((message) => {
-            if (sentMessageIds.has(message.messageId)) {
+            const nextSignature = buildDeliveredHistoryMessageSignature(message);
+            const previousSignature = deliveredMessages.signaturesByMessageId.get(message.messageId);
+            if (previousSignature === nextSignature) {
                 return false;
             }
-            sentMessageIds.add(message.messageId);
+            rememberDeliveredHistoryMessage(deliveredMessages, message.messageId, nextSignature);
             return true;
         });
         if (messages.length === 0) {
@@ -920,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;
@@ -980,7 +1458,53 @@ export class SessionHistoryService {
                 detail: "session 索引缺失"
             });
         }
-        return item;
+        const aliasTargetSessionId = this.findPendingSessionAliasTargetSessionId(item);
+        if (!aliasTargetSessionId) {
+            return item;
+        }
+        return this.sessionIndexRepository.findBySessionId(aliasTargetSessionId, userId) ?? item;
+    }
+    resolveCanonicalSessionId(sessionId, userId) {
+        if (userId) {
+            const item = this.sessionIndexRepository.findBySessionId(sessionId, userId);
+            const aliasTargetSessionId = this.findPendingSessionAliasTargetSessionId(item);
+            if (aliasTargetSessionId) {
+                return aliasTargetSessionId;
+            }
+        }
+        const binding = this.sessionBindingRepository.findBySessionId(sessionId);
+        return this.findPendingSessionAliasTargetSessionId(binding) ?? sessionId;
+    }
+    isPendingSessionAlias(item) {
+        return Boolean(this.findPendingSessionAliasTargetSessionId(item));
+    }
+    resolvePendingSessionAliasBinding(binding) {
+        const aliasTargetSessionId = this.findPendingSessionAliasTargetSessionId(binding);
+        if (!aliasTargetSessionId) {
+            return null;
+        }
+        return this.sessionBindingRepository.findBySessionId(aliasTargetSessionId);
+    }
+    findPendingSessionAliasTargetSessionId(descriptor) {
+        if (!descriptor || descriptor.provider !== "gemini") {
+            return null;
+        }
+        const aliasTargetSessionId = extractPendingBindingTargetSessionId(descriptor.providerSessionId)
+            ?? extractPendingBindingTargetSessionId(descriptor.rawStoreRef);
+        if (!aliasTargetSessionId || aliasTargetSessionId === descriptor.sessionId) {
+            return null;
+        }
+        const targetBinding = this.sessionBindingRepository.findBySessionId(aliasTargetSessionId);
+        if (!targetBinding) {
+            return null;
+        }
+        if (targetBinding.workspaceId !== descriptor.workspaceId
+            || targetBinding.provider !== descriptor.provider
+            || isPendingBindingValue(targetBinding.providerSessionId)
+            || isPendingBindingValue(targetBinding.rawStoreRef)) {
+            return null;
+        }
+        return aliasTargetSessionId;
     }
     async refreshRecentSessionStates(sessions, userId) {
         for (let index = 0; index < sessions.length; index += 1) {
@@ -1146,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);
@@ -1217,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
@@ -1251,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);
@@ -1281,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,
@@ -1351,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,
@@ -1412,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,
@@ -1477,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),
@@ -1585,12 +2194,20 @@ function isPendingBindingValue(value) {
 function buildPendingBindingValue(provider, sessionId) {
     return `pending://${provider}/${sessionId}`;
 }
+function extractPendingBindingTargetSessionId(value) {
+    if (!isPendingBindingValue(value)) {
+        return null;
+    }
+    const normalizedValue = value.trim();
+    const targetSessionId = normalizedValue.slice(normalizedValue.indexOf("/", "pending://".length) + 1).trim();
+    return targetSessionId || null;
+}
 function isClaudePendingRuntimeRawStoreRef(rawStoreRef) {
     const normalizedRawStoreRef = rawStoreRef.replaceAll("\\", "/").toLowerCase();
     return normalizedRawStoreRef.includes("/.pending-");
 }
 function shouldShortCircuitClaudePendingHistory(provider, providerSessionId, rawStoreRef) {
-    if (provider !== "claude-code") {
+    if (provider !== "claude-code" && provider !== "gemini") {
         return false;
     }
     return isPendingBindingValue(providerSessionId) || isPendingBindingValue(rawStoreRef);
@@ -1639,6 +2256,66 @@ function findClaudePendingDiscoveryDuplicate(session, existingSessions, claimedS
     });
     return activePendingCandidates.length === 1 ? activePendingCandidates[0] : null;
 }
+function findKimiRuntimeDiscoveryDuplicate(session, existingSessions, claimedSessionIds) {
+    if (session.provider !== "kimi" || isPendingBindingValue(session.providerSessionId)) {
+        return null;
+    }
+    const candidates = existingSessions.filter((item) => {
+        if (claimedSessionIds.has(item.sessionId)) {
+            return false;
+        }
+        if (item.provider !== "kimi" || !shouldRecoverKimiRuntimeBinding(item)) {
+            return false;
+        }
+        return isCloseKimiSessionTimestamp(item.lastMessageAt ?? item.createdAt, session.lastMessageAt);
+    });
+    if (candidates.length === 1) {
+        return candidates[0];
+    }
+    const comparableTitle = normalizeKimiComparableTitle(session.title);
+    if (!comparableTitle) {
+        return null;
+    }
+    const titleMatchedCandidates = candidates.filter((item) => normalizeKimiComparableTitle(item.title) === comparableTitle);
+    return titleMatchedCandidates.length === 1
+        ? titleMatchedCandidates[0]
+        : null;
+}
+function shouldRecoverKimiRuntimeBinding(item) {
+    if (isPendingBindingValue(item.providerSessionId)) {
+        return true;
+    }
+    if (item.messageCount !== 0 || item.activitySource !== "runtime") {
+        return false;
+    }
+    if (item.runningState === "starting") {
+        return true;
+    }
+    if (item.lastErrorCode === "PROVIDER_READ_FAILED") {
+        return true;
+    }
+    return (item.lastErrorDetail ?? "").includes("provider 会话不存在");
+}
+function normalizeKimiComparableTitle(title) {
+    const normalized = title.trim().replace(/\s+/g, " ");
+    if (!normalized) {
+        return null;
+    }
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(normalized)
+        ? null
+        : normalized;
+}
+function isCloseKimiSessionTimestamp(left, right) {
+    if (!left || !right) {
+        return false;
+    }
+    const leftAt = Date.parse(left);
+    const rightAt = Date.parse(right);
+    if (!Number.isFinite(leftAt) || !Number.isFinite(rightAt)) {
+        return false;
+    }
+    return Math.abs(leftAt - rightAt) <= 2 * 60 * 1_000;
+}
 function normalizeClaudeComparableTitle(title) {
     return title?.trim().replace(/\s+/g, " ").toLowerCase() ?? "";
 }
@@ -1670,6 +2347,54 @@ function isMessageAtOrAfter(timestamp, minTimestamp) {
     }
     return messageAt >= minAt;
 }
+function isAcceptedUserMessageTimestamp(provider, timestamp, minTimestamp) {
+    if (provider === "kimi"
+        && isSyntheticKimiHistoryTimestamp(timestamp)) {
+        return true;
+    }
+    return isMessageAtOrAfter(timestamp, minTimestamp);
+}
+function isSyntheticKimiHistoryTimestamp(timestamp) {
+    return timestamp.startsWith("2020-01-01T00:");
+}
+function createDeliveredHistoryMessageState() {
+    return {
+        signaturesByMessageId: new Map(),
+        lastMutableTailRefreshAtMs: 0
+    };
+}
+function shouldRefreshMutableHistoryTail(provider, page, cursor, deliveredMessages) {
+    if (provider !== "kimi" || cursor === null || page.messages.length > 0) {
+        return false;
+    }
+    return Date.now() - deliveredMessages.lastMutableTailRefreshAtMs >= MUTABLE_HISTORY_TAIL_REFRESH_INTERVAL_MS;
+}
+function buildDeliveredHistoryMessageSignature(message) {
+    return hashContent(JSON.stringify({
+        provider: message.provider,
+        providerSessionId: message.providerSessionId,
+        role: message.role,
+        kind: message.kind,
+        content: message.content,
+        toolCall: message.toolCall,
+        attachments: message.attachments ?? [],
+        timestamp: message.timestamp,
+        rawRef: message.rawRef
+    }));
+}
+function rememberDeliveredHistoryMessage(state, messageId, signature) {
+    if (state.signaturesByMessageId.has(messageId)) {
+        state.signaturesByMessageId.delete(messageId);
+    }
+    state.signaturesByMessageId.set(messageId, signature);
+    while (state.signaturesByMessageId.size > 2_048) {
+        const oldestMessageId = state.signaturesByMessageId.keys().next().value;
+        if (typeof oldestMessageId !== "string") {
+            break;
+        }
+        state.signaturesByMessageId.delete(oldestMessageId);
+    }
+}
 function delay(ms) {
     return new Promise((resolve) => {
         setTimeout(resolve, ms);
@@ -1730,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/")) {
@@ -1738,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)) {
@@ -1795,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