@jingyi0605/codingns 0.6.0 → 0.6.5

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

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { CapabilityService, ClaudeCodeAdapter, CodexAdapter, GeminiAdapter, KimiAdapter, OpenCodeAdapter, ProviderRegistry, SessionSyncService } from "@codingns/session-sync-core";
+import { CapabilityService, ClaudeCodeAdapter, CodexAdapter, GeminiAdapter, KimiAdapter, LegnaCodeAdapter, 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";
@@ -17,6 +17,7 @@ import { CodexModelOptionsService, createFallbackCodexModelOptions, enrichCodexC
 import { OpenCodeModelOptionsService, createFallbackOpenCodeModelOptions, enrichOpenCodeCapabilities } from "../provider/opencode-model-options.js";
 import { getSharedProviderDiscoveryHelperClient } from "../provider/provider-discovery-helper-client.js";
 import { discoverWorkspaceSessionsInRuntime } from "../provider/provider-discovery-runtime.js";
+import { applyProviderDisabledState, createProviderCapabilityBlockedError } from "../provider/provider-disabled.js";
 import { createTaskManager } from "../tasks/task-manager.js";
 import { HOST_TASK_TYPES } from "../tasks/task-types.js";
 import { CodexAppServerHelperClient } from "./codex-app-server-helper-client.js";
@@ -25,15 +26,18 @@ const RECONSTRUCTED_FORK_TARGET_PROVIDERS = new Set(["codex", "claude-code", "op
 const FORK_RECONSTRUCTION_PAGE_SIZE = 200;
 const MAX_FORK_DEPTH = 4;
 const SYNTHETIC_CODEX_SESSION_CLEANUP_GRACE_MS = 120_000;
+const GEMINI_RUNTIME_CHAT_DISCOVERY_GRACE_MS = 30_000;
 const SESSION_START_DEFERRED_PROVIDERS = new Set([
     "codex",
     "claude-code",
+    "legna-code",
     "opencode",
     "gemini",
     "kimi"
 ]);
 const MUTABLE_HISTORY_TAIL_PROVIDERS = new Set([
     "claude-code",
+    "legna-code",
     "codex",
     "gemini",
     "kimi",
@@ -75,6 +79,8 @@ export class SessionHistoryService {
     sessionIsolatedWorkspaceRepository;
     providerDiscoveryHelperClient = getSharedProviderDiscoveryHelperClient();
     providerSessionDiscoveryConfig;
+    sessionProviderConfigService;
+    providerControlRepository;
     taskManager;
     workspaceDiscoveryStatuses = new Map();
     workspaceStateRefreshStatuses = new Map();
@@ -84,7 +90,7 @@ export class SessionHistoryService {
     sessionDeletedObservers = new Set();
     workspaceSessionRelations = new Map();
     workspaceStateRefreshTaskSequence = 0;
-    constructor(db, workspaceRepository, sessionBindingRepository, sessionChangedFileService, sessionIndexRepository, sessionMessageAttachmentService, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService(), sessionMessageOriginRepository = null, sessionForkRepository = null, adapterOverrides = {}, taskManager = createTaskManager(), parallelSessionGroupRepository = null, parallelSessionMemberRepository = null, sessionIsolatedWorkspaceRepository = null) {
+    constructor(db, workspaceRepository, sessionBindingRepository, sessionChangedFileService, sessionIndexRepository, sessionMessageAttachmentService, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService(), sessionMessageOriginRepository = null, sessionForkRepository = null, adapterOverrides = {}, taskManager = createTaskManager(), parallelSessionGroupRepository = null, parallelSessionMemberRepository = null, sessionIsolatedWorkspaceRepository = null, sessionProviderConfigService = null, providerControlRepository = null) {
         this.db = db;
         this.workspaceRepository = workspaceRepository;
         this.sessionBindingRepository = sessionBindingRepository;
@@ -102,9 +108,18 @@ export class SessionHistoryService {
         this.parallelSessionGroupRepository = parallelSessionGroupRepository;
         this.parallelSessionMemberRepository = parallelSessionMemberRepository;
         this.sessionIsolatedWorkspaceRepository = sessionIsolatedWorkspaceRepository;
+        this.sessionProviderConfigService = sessionProviderConfigService;
+        this.providerControlRepository = providerControlRepository ?? {
+            get: (providerId) => ({
+                providerId: providerId.trim(),
+                enabled: true,
+                updatedAt: ""
+            })
+        };
         this.claudeCodeHomeDir = config.claudeCodeHomeDir;
         this.providerCliCommandPaths = {
             "claude-code": process.platform === "win32" ? "claude.cmd" : "claude",
+            "legna-code": config.legnaCodeCliPath,
             codex: config.codexCliPath,
             gemini: config.geminiCliPath,
             kimi: config.kimiCliPath
@@ -113,8 +128,10 @@ export class SessionHistoryService {
         this.providerCliAvailability = buildProviderCliAvailabilitySnapshot(this.providerCliCommandPaths);
         this.providerSessionDiscoveryConfig = {
             claudeCodeHomeDir: config.claudeCodeHomeDir,
+            legnaCodeHomeDir: config.legnaCodeHomeDir,
             codexCliPath: config.codexCliPath,
             codexHomeDir: config.codexHomeDir,
+            legnaCodeCliPath: config.legnaCodeCliPath,
             geminiCliPath: config.geminiCliPath,
             geminiHomeDir: config.geminiHomeDir,
             kimiDefaultModel: config.kimiDefaultModel,
@@ -125,6 +142,10 @@ export class SessionHistoryService {
         };
         this.providerRegistry = new ProviderRegistry([
             new ClaudeCodeAdapter({ homeDir: config.claudeCodeHomeDir }),
+            new LegnaCodeAdapter({
+                homeDir: config.legnaCodeHomeDir,
+                legacyClaudeHomeDir: config.claudeCodeHomeDir
+            }),
             new CodexAdapter({
                 homeDir: config.codexHomeDir,
                 forkTransportFactory: adapterOverrides.codexForkTransportFactory
@@ -196,7 +217,7 @@ export class SessionHistoryService {
                 executionLane: "helper_process",
                 concurrency: WORKSPACE_DISCOVERY_SCAN_CONCURRENCY,
                 helperProcessHandler: "session.workspace_discovery",
-                run: async ({ config, workspacePath, knownSessions }, context) => await discoverWorkspaceSessionsInRuntime(config, workspacePath, knownSessions, context.signal)
+                run: async ({ config, workspacePath, knownSessions, enabledProviders }, context) => await discoverWorkspaceSessionsInRuntime(config, workspacePath, knownSessions, enabledProviders, context.signal)
             });
         }
         if (!this.taskManager.has(HOST_TASK_TYPES.providerCapabilityRefresh)) {
@@ -323,8 +344,8 @@ export class SessionHistoryService {
                     ? current?.syncCursor ?? page.cursor
                     : page.cursor,
                 lastSyncAt: nowIso(),
-                lastErrorCode: current?.lastErrorCode ?? null,
-                lastErrorDetail: current?.lastErrorDetail ?? null,
+                lastErrorCode: clearSuccessfulProviderReadErrorCode(current?.lastErrorCode ?? null),
+                lastErrorDetail: clearSuccessfulProviderReadErrorDetail(current?.lastErrorCode ?? null, current?.lastErrorDetail ?? null),
                 resumedAt: current?.resumedAt ?? null
             });
             snapshotIdleMs = Date.now() - snapshotIdleStartedAt;
@@ -441,11 +462,11 @@ export class SessionHistoryService {
             .listByWorkspace(workspaceId, userId)
             .filter((item) => !this.isPendingSessionAlias(item));
         const projectedItems = this.listProjectedIsolatedWorkspaceSessions(workspaceId, userId);
-        return this.enrichSessionItems(workspaceId, sortSessionListItemsByRecentActivity(mergeSessionListItemsBySessionId([...directItems, ...projectedItems])));
+        return this.filterDisabledProviderSessions(this.enrichSessionItems(workspaceId, sortSessionListItemsByRecentActivity(mergeSessionListItemsBySessionId([...directItems, ...projectedItems]))));
     }
     getProviderCapabilitiesSnapshot(provider) {
         try {
-            return this.resolveProviderCapabilitiesImmediate(this.applyProviderCliAvailability(this.capabilityService.getProviderCapabilities(provider)), null);
+            return this.applyProviderEnabledState(this.resolveProviderCapabilitiesImmediate(this.applyProviderCliAvailability(this.capabilityService.getProviderCapabilities(provider)), null));
         }
         catch (error) {
             throw mapSessionProviderError(error);
@@ -455,8 +476,17 @@ export class SessionHistoryService {
         try {
             const workspacePath = workspaceId ? this.getWorkspaceOrThrow(workspaceId).path : null;
             const baseCapabilities = this.applyProviderCliAvailability(this.capabilityService.getProviderCapabilities(provider));
+            if (baseCapabilities.provider === "opencode" && workspacePath) {
+                const refreshed = await this.enrichProviderCapabilities(baseCapabilities, workspacePath);
+                const cacheKey = buildProviderCapabilityCacheKey(baseCapabilities.provider, workspacePath);
+                this.providerCapabilityCache.set(cacheKey, {
+                    refreshedAt: Date.now(),
+                    value: refreshed
+                });
+                return this.applyProviderEnabledState(refreshed);
+            }
             this.scheduleProviderCapabilityRefresh(baseCapabilities, workspacePath);
-            return this.resolveProviderCapabilitiesImmediate(baseCapabilities, workspacePath);
+            return this.applyProviderEnabledState(this.resolveProviderCapabilitiesImmediate(baseCapabilities, workspacePath));
         }
         catch (error) {
             throw mapSessionProviderError(error);
@@ -470,8 +500,19 @@ export class SessionHistoryService {
             .getSessionCapabilities(binding.provider, binding.providerSessionId)
             .then((capabilities) => {
             const normalizedCapabilities = this.applyProviderCliAvailability(capabilities);
+            if (normalizedCapabilities.provider === "opencode") {
+                return this.enrichProviderCapabilities(normalizedCapabilities, workspacePath)
+                    .then((refreshed) => {
+                    const cacheKey = buildProviderCapabilityCacheKey(normalizedCapabilities.provider, workspacePath);
+                    this.providerCapabilityCache.set(cacheKey, {
+                        refreshedAt: Date.now(),
+                        value: refreshed
+                    });
+                    return this.applyProviderEnabledState(refreshed);
+                });
+            }
             this.scheduleProviderCapabilityRefresh(normalizedCapabilities, workspacePath);
-            return this.resolveProviderCapabilitiesImmediate(normalizedCapabilities, workspacePath);
+            return this.applyProviderEnabledState(this.resolveProviderCapabilitiesImmediate(normalizedCapabilities, workspacePath));
         })
             .catch((error) => {
             throw mapSessionProviderError(error);
@@ -499,6 +540,9 @@ export class SessionHistoryService {
         return applyImmediateModelOptionFallbacks(claudeEnriched, this.codexModelOptionsService.peekSnapshot(), this.openCodeModelOptionsService.peekSnapshot(workspacePath));
     }
     scheduleProviderCapabilityRefresh(capabilities, workspacePath) {
+        if (!this.isProviderEnabled(capabilities.provider)) {
+            return;
+        }
         const cacheKey = buildProviderCapabilityCacheKey(capabilities.provider, workspacePath);
         const cached = this.providerCapabilityCache.get(cacheKey);
         if (cached &&
@@ -550,17 +594,31 @@ export class SessionHistoryService {
             limitations
         };
     }
+    applyProviderEnabledState(capabilities) {
+        if (this.isProviderEnabled(capabilities.provider)) {
+            return capabilities;
+        }
+        return applyProviderDisabledState(capabilities);
+    }
+    isProviderEnabled(provider) {
+        return this.providerControlRepository.get(provider.trim()).enabled;
+    }
+    filterDisabledProviderSessions(items) {
+        return items.filter((item) => this.isProviderEnabled(item.provider));
+    }
     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"
-        });
+        throw createProviderCapabilityBlockedError(capabilities, "provider", fallbackDetail);
+    }
+    assertProviderSendEnabled(provider, field, fallbackDetail) {
+        const capabilities = this.getProviderCapabilitiesSnapshot(provider);
+        if (capabilities.canSendMessage) {
+            return;
+        }
+        throw createProviderCapabilityBlockedError(capabilities, field, fallbackDetail);
     }
     async getSessionContextUsage(sessionId) {
         const binding = this.getBindingOrThrow(sessionId);
@@ -597,6 +655,7 @@ export class SessionHistoryService {
         }
     }
     async startSession(input) {
+        this.assertProviderCapabilityEnabled(input.provider, "canStartSession", "当前 provider 不支持创建会话");
         if (SESSION_START_DEFERRED_PROVIDERS.has(input.provider)) {
             throw new AppError({
                 statusCode: 409,
@@ -610,11 +669,17 @@ export class SessionHistoryService {
     async startSessionDirect(input) {
         const workspace = this.getWorkspaceOrThrow(input.workspaceId);
         this.assertProviderCapabilityEnabled(input.provider, "canStartSession", "当前 provider 不支持创建会话");
+        const sessionId = createId();
+        const providerBinding = this.prepareDirectSessionBinding({
+            sessionId,
+            provider: input.provider,
+            providerConfigMode: input.providerConfigMode ?? null,
+            providerPresetId: input.providerPresetId ?? null
+        });
         try {
-            const result = await this.sessionSyncService.startSession(input.provider, workspace.path, {
+            const result = await this.startProviderSessionWithBinding(input.provider, workspace.path, providerBinding.runtimeHomeDir, {
                 initialPrompt: input.initialPrompt
             });
-            const sessionId = createId();
             const timestamp = nowIso();
             const persist = this.db.transaction(() => {
                 this.sessionBindingRepository.upsert({
@@ -623,6 +688,9 @@ export class SessionHistoryService {
                     provider: result.session.provider,
                     providerSessionId: result.session.providerSessionId,
                     rawStoreRef: result.session.rawStoreRef,
+                    providerConfigMode: providerBinding.providerConfigMode,
+                    providerPresetId: providerBinding.providerPresetId,
+                    runtimeHomeDir: providerBinding.runtimeHomeDir,
                     createdAt: timestamp,
                     updatedAt: timestamp
                 });
@@ -690,10 +758,18 @@ export class SessionHistoryService {
             });
         }
         this.assertForkDepthWithinLimit(input.sessionId);
-        if (targetProvider !== binding.provider) {
+        const requestedTargetSelection = resolveRequestedProviderSelection({
+            existingBinding: targetProvider === binding.provider ? binding : null,
+            providerConfigMode: input.providerConfigMode ?? undefined,
+            providerPresetId: input.providerPresetId ?? undefined
+        });
+        if (targetProvider !== binding.provider
+            || !areEquivalentProviderBindingSelection(binding, requestedTargetSelection)) {
             return this.forkSessionAcrossProviders({
                 ...input,
-                targetProvider
+                targetProvider,
+                providerConfigMode: requestedTargetSelection.providerConfigMode,
+                providerPresetId: requestedTargetSelection.providerPresetId
             }, binding, sourceMessageId);
         }
         try {
@@ -713,6 +789,9 @@ export class SessionHistoryService {
                     provider: result.session.provider,
                     providerSessionId: result.session.providerSessionId,
                     rawStoreRef: result.session.rawStoreRef,
+                    providerConfigMode: binding.providerConfigMode,
+                    providerPresetId: binding.providerPresetId,
+                    runtimeHomeDir: binding.runtimeHomeDir,
                     createdAt: timestamp,
                     updatedAt: timestamp
                 });
@@ -807,6 +886,8 @@ export class SessionHistoryService {
             userId: input.userId,
             provider: input.targetProvider,
             initialPrompt: inheritedPrompt,
+            providerConfigMode: input.providerConfigMode ?? null,
+            providerPresetId: input.providerPresetId ?? null,
             parentSessionId: input.sessionId,
             sessionKind: input.sessionKind ?? "default",
             annotationSourceMessageId: input.annotationSourceMessageId ?? null,
@@ -854,6 +935,40 @@ export class SessionHistoryService {
         this.workspaceSessionRelations.set(input.targetWorkspaceId?.trim() || sourceBinding.workspaceId, relationMap);
         return this.getSessionListItemOrThrow(startedSession.sessionId, input.userId);
     }
+    prepareDirectSessionBinding(input) {
+        if (!this.sessionProviderConfigService) {
+            return {
+                providerConfigMode: "global-default",
+                providerPresetId: null,
+                runtimeHomeDir: null
+            };
+        }
+        return this.sessionProviderConfigService.prepareSessionBinding({
+            sessionId: input.sessionId,
+            provider: input.provider,
+            providerConfigMode: input.providerConfigMode ?? undefined,
+            providerPresetId: input.providerPresetId ?? null
+        });
+    }
+    startProviderSessionWithBinding(provider, workspacePath, runtimeHomeDir, options) {
+        const scopedRuntimeHomeDir = runtimeHomeDir?.trim() || null;
+        if (!scopedRuntimeHomeDir) {
+            return this.sessionSyncService.startSession(provider, workspacePath, options);
+        }
+        switch (provider) {
+            case "claude-code":
+                return new ClaudeCodeAdapter({ homeDir: scopedRuntimeHomeDir }).startSession(workspacePath, options);
+            case "codex":
+                return new CodexAdapter({ homeDir: scopedRuntimeHomeDir }).startSession(workspacePath, options);
+            case "gemini":
+                return new GeminiAdapter({
+                    homeDir: scopedRuntimeHomeDir,
+                    commandPath: this.providerSessionDiscoveryConfig.geminiCliPath
+                }).startSession(workspacePath, options);
+            default:
+                return this.sessionSyncService.startSession(provider, workspacePath, options);
+        }
+    }
     async readForkSourceMessages(sessionId, binding, sourceType, sourceMessageId, sourceMessageSnapshot = null) {
         const messages = [];
         let cursor = null;
@@ -920,6 +1035,7 @@ export class SessionHistoryService {
     }
     async sendMessage(sessionId, content, clientRequestId, permissionMode = null) {
         const binding = this.getBindingOrThrow(sessionId);
+        this.assertProviderSendEnabled(binding.provider, "sessionId", "当前 provider 不支持继续发送消息");
         const result = await this.sessionSyncService
             .sendMessage(binding.provider, binding.providerSessionId, binding.rawStoreRef, content, clientRequestId, permissionMode)
             .catch((error) => {
@@ -1024,13 +1140,14 @@ export class SessionHistoryService {
             return null;
         }
         await this.syncSessionTitleFromProvider(sessionId, binding);
+        const snapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
         this.upsertSnapshot(sessionId, {
             syncStatus: "idle",
             syncCursor: page.cursor,
             lastSyncAt: nowIso(),
-            lastErrorCode: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.lastErrorCode ?? null,
-            lastErrorDetail: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.lastErrorDetail ?? null,
-            resumedAt: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.resumedAt ?? null
+            lastErrorCode: clearSuccessfulProviderReadErrorCode(snapshot?.lastErrorCode ?? null),
+            lastErrorDetail: clearSuccessfulProviderReadErrorDetail(snapshot?.lastErrorCode ?? null, snapshot?.lastErrorDetail ?? null),
+            resumedAt: snapshot?.resumedAt ?? null
         });
         return {
             type: "session.delta",
@@ -1244,6 +1361,15 @@ export class SessionHistoryService {
                         provider: resolvedSnapshot.provider,
                         providerSessionId: resolvedSnapshot.providerSessionId,
                         rawStoreRef: resolvedSnapshot.rawStoreRef,
+                        providerConfigMode: currentBinding?.providerConfigMode
+                            ?? duplicateBinding?.providerConfigMode
+                            ?? "global-default",
+                        providerPresetId: currentBinding?.providerPresetId
+                            ?? duplicateBinding?.providerPresetId
+                            ?? null,
+                        runtimeHomeDir: currentBinding?.runtimeHomeDir
+                            ?? duplicateBinding?.runtimeHomeDir
+                            ?? null,
                         createdAt: pickEarlierIso(currentBinding?.createdAt ?? null, duplicateBinding?.createdAt ?? null)
                             ?? timestamp,
                         updatedAt: timestamp
@@ -1285,14 +1411,19 @@ export class SessionHistoryService {
         try {
             const discoverStartedAt = Date.now();
             const existingWorkspaceSessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
-            const knownSessions = this.buildKnownSessionSummaries(existingWorkspaceSessions, workspace.path);
+            const enabledProviders = this.providerRegistry
+                .list()
+                .map((adapter) => adapter.providerId)
+                .filter((providerId) => this.isProviderEnabled(providerId));
+            const knownSessions = this.buildKnownSessionSummaries(existingWorkspaceSessions.filter((session) => enabledProviders.includes(session.provider)), workspace.path);
             const discoveryHandle = this.taskManager.enqueue(HOST_TASK_TYPES.workspaceDiscoveryScan, {
                 key: workspaceId,
                 source: "session_history.workspace_discovery.scan",
                 input: {
                     config: this.providerSessionDiscoveryConfig,
                     workspacePath: workspace.path,
-                    knownSessions
+                    knownSessions,
+                    enabledProviders
                 }
             });
             const discovery = await awaitTaskHandleWithSignal(discoveryHandle, signal).catch((error) => {
@@ -1335,6 +1466,9 @@ export class SessionHistoryService {
                         provider: session.provider,
                         providerSessionId: session.providerSessionId,
                         rawStoreRef: session.rawStoreRef,
+                        providerConfigMode: existing?.providerConfigMode ?? "global-default",
+                        providerPresetId: existing?.providerPresetId ?? null,
+                        runtimeHomeDir: existing?.runtimeHomeDir ?? null,
                         createdAt,
                         updatedAt: timestamp
                     };
@@ -1614,9 +1748,24 @@ export class SessionHistoryService {
                     total: 0
                 };
             }
+            if (this.shouldTreatMissingGeminiRuntimeHistoryAsEmpty(sessionId, provider, error)) {
+                return {
+                    messages: [],
+                    cursor,
+                    nextCursor: null,
+                    total: 0
+                };
+            }
             throw mapSessionProviderError(error);
         });
     }
+    shouldTreatMissingGeminiRuntimeHistoryAsEmpty(sessionId, provider, error) {
+        if (provider !== "gemini" || !isGeminiChatNotFoundError(error)) {
+            return false;
+        }
+        const sessionIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        return this.listSessionStatesBySessionId(sessionId).some((state) => shouldTreatMissingGeminiRuntimeHistoryStateAsTransient(state, sessionIndex));
+    }
     enrichMessagesWithOrigin(sessionId, messages) {
         return this.resolveMessageOrigins(sessionId, messages);
     }
@@ -1909,8 +2058,8 @@ export class SessionHistoryService {
             syncStatus: "idle",
             syncCursor: page.cursor,
             lastSyncAt: nowIso(),
-            lastErrorCode: snapshot?.lastErrorCode ?? null,
-            lastErrorDetail: snapshot?.lastErrorDetail ?? null,
+            lastErrorCode: clearSuccessfulProviderReadErrorCode(snapshot?.lastErrorCode ?? null),
+            lastErrorDetail: clearSuccessfulProviderReadErrorDetail(snapshot?.lastErrorCode ?? null, snapshot?.lastErrorDetail ?? null),
             resumedAt: snapshot?.resumedAt ?? null
         });
         await onEnvelope({
@@ -1936,7 +2085,12 @@ export class SessionHistoryService {
             provider: binding.provider,
             providerSessionId: binding.providerSessionId,
             rawStoreRef: binding.rawStoreRef
-        }, signal)).trim();
+        }, signal).catch((error) => {
+            if (this.shouldTreatMissingGeminiRuntimeHistoryAsEmpty(sessionId, binding.provider, error)) {
+                return "";
+            }
+            throw error;
+        })).trim();
         const resolvedTitle = resolvePersistedSessionTitle(binding.provider, nextTitle, currentIndex.title);
         if (resolvedTitle.length === 0 || resolvedTitle === currentIndex.title) {
             return;
@@ -2371,6 +2525,9 @@ export class SessionHistoryService {
                 provider: input.provider,
                 providerSessionId: buildPendingBindingValue(input.provider, input.targetSessionId),
                 rawStoreRef: buildPendingBindingValue(input.provider, input.targetSessionId),
+                providerConfigMode: sourceBinding.providerConfigMode,
+                providerPresetId: sourceBinding.providerPresetId,
+                runtimeHomeDir: sourceBinding.runtimeHomeDir,
                 createdAt: sourceBinding.createdAt,
                 updatedAt: input.timestamp
             });
@@ -2452,6 +2609,9 @@ export class SessionHistoryService {
             provider: sourceBinding.provider,
             providerSessionId: buildAliasBindingValue(input.provider, input.targetSessionId, input.sourceSessionId),
             rawStoreRef: buildAliasBindingValue(input.provider, input.targetSessionId, input.sourceSessionId),
+            providerConfigMode: sourceBinding.providerConfigMode,
+            providerPresetId: sourceBinding.providerPresetId,
+            runtimeHomeDir: sourceBinding.runtimeHomeDir,
             createdAt: sourceBinding.createdAt,
             updatedAt: input.timestamp
         });
@@ -2690,7 +2850,9 @@ export class SessionHistoryService {
         const liveObservation = this.resolveLiveActivityObservation(sessionId);
         const inspection = liveObservation
             ? null
-            : inspectSessionActivity(binding.provider, binding.rawStoreRef);
+            : binding.provider === "gemini"
+                ? await this.inspectGeminiHistoryActivity(sessionId, binding)
+                : inspectSessionActivity(binding.provider, binding.rawStoreRef);
         if (inspection) {
             const nowMs = Date.parse(timestamp);
             if (shouldClearStaleRuntimeWithoutInspection(current, inspection, nowMs)) {
@@ -2753,6 +2915,15 @@ export class SessionHistoryService {
         });
         return nextRecord;
     }
+    async inspectGeminiHistoryActivity(sessionId, binding) {
+        try {
+            const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, null, GEMINI_ACTIVITY_INFERENCE_HISTORY_LIMIT, "backward", this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.messageCount ?? null);
+            return inferGeminiInspectionFromHistory(page.messages);
+        }
+        catch {
+            return inspectSessionActivity(binding.provider, binding.rawStoreRef);
+        }
+    }
     async repairCodexDirtyBindingBeforeHistoryRead(sessionId, userId, binding) {
         if (!shouldRepairCodexDirtyBinding(binding)) {
             this.codexDirtyBindingRepairStates.delete(sessionId);
@@ -2829,7 +3000,11 @@ export class SessionHistoryService {
     }
 }
 function isProviderCliBacked(provider) {
-    return provider === "claude-code" || provider === "codex" || provider === "gemini" || provider === "kimi";
+    return provider === "claude-code"
+        || provider === "legna-code"
+        || provider === "codex"
+        || provider === "gemini"
+        || provider === "kimi";
 }
 function buildProviderCliAvailabilitySnapshot(commandPaths) {
     return Object.freeze(Object.fromEntries(Object.entries(commandPaths).map(([provider, commandPath]) => [
@@ -2841,6 +3016,8 @@ function buildProviderCliUnavailableMessage(provider) {
     switch (provider) {
         case "claude-code":
             return "未检测到 Claude CLI";
+        case "legna-code":
+            return "未检测到 Legna CLI";
         case "codex":
             return "未检测到 Codex CLI";
         case "gemini":
@@ -2900,6 +3077,46 @@ function hasInspectionEvidence(inspection) {
         || !!inspection.lastEventAt
         || !!inspection.completedAtCandidate;
 }
+function inferGeminiInspectionFromHistory(messages) {
+    let lastEventAt = null;
+    let lastUserAt = null;
+    let latestNonUserMessage = null;
+    const pendingToolCallIds = new Set();
+    for (const message of messages) {
+        lastEventAt = pickLaterIso(lastEventAt, message.timestamp);
+        if (message.role === "user") {
+            lastUserAt = pickLaterIso(lastUserAt, message.timestamp);
+            continue;
+        }
+        latestNonUserMessage = message;
+        if (message.kind === "tool_call" && message.toolCall?.callId) {
+            pendingToolCallIds.add(message.toolCall.callId);
+            continue;
+        }
+        if (message.kind === "tool_result" && message.toolCall?.callId) {
+            pendingToolCallIds.delete(message.toolCall.callId);
+        }
+    }
+    const latestNonUserAt = latestNonUserMessage?.timestamp ?? null;
+    const hasReplyAfterLatestUser = !!latestNonUserAt && (!lastUserAt || latestNonUserAt.localeCompare(lastUserAt) >= 0);
+    const isTerminalReplyKind = latestNonUserMessage?.kind === "text" || latestNonUserMessage?.kind === "tool_result";
+    const completedAtCandidate = hasReplyAfterLatestUser && isTerminalReplyKind && pendingToolCallIds.size === 0
+        ? latestNonUserAt
+        : null;
+    const hasOpenTurn = !completedAtCandidate
+        && hasReplyAfterLatestUser
+        && (pendingToolCallIds.size > 0
+            || latestNonUserMessage?.kind === "thinking"
+            || latestNonUserMessage?.kind === "tool_call");
+    return {
+        runningState: hasOpenTurn ? "running" : "idle",
+        hasPendingTools: pendingToolCallIds.size > 0,
+        lastEventAt,
+        completedAtCandidate,
+        errorCode: null,
+        errorDetail: null
+    };
+}
 function applySessionActivityResolution(item, resolution) {
     const rawResolvedRunningState = resolution.runningState === "unknown" && item.runningState === null
         ? null
@@ -3453,6 +3670,40 @@ function shouldTreatMissingSyntheticHistoryAsEmpty(provider, rawStoreRef, error)
     const detail = error instanceof Error ? error.message : String(error);
     return detail.includes("ENOENT");
 }
+function shouldTreatMissingGeminiRuntimeHistoryStateAsTransient(state, sessionIndex) {
+    if (state.activitySource !== "runtime") {
+        return false;
+    }
+    if (state.runningState === "starting" || state.runningState === "running") {
+        return true;
+    }
+    if ((sessionIndex?.messageCount ?? 0) !== 0) {
+        return false;
+    }
+    return isWithinGeminiRuntimeChatDiscoveryGraceWindow(state.lastEventAt ?? state.updatedAt ?? sessionIndex?.updatedAt ?? sessionIndex?.createdAt ?? null);
+}
+function isWithinGeminiRuntimeChatDiscoveryGraceWindow(timestamp) {
+    if (!timestamp) {
+        return false;
+    }
+    const timestampMs = Date.parse(timestamp);
+    if (!Number.isFinite(timestampMs)) {
+        return false;
+    }
+    return Date.now() - timestampMs <= GEMINI_RUNTIME_CHAT_DISCOVERY_GRACE_MS;
+}
+function isGeminiChatNotFoundError(error) {
+    if (error instanceof AppError) {
+        return error.errorCode === "GEMINI_CHAT_NOT_FOUND";
+    }
+    return error instanceof Error && error.message === "GEMINI_CHAT_NOT_FOUND";
+}
+function clearSuccessfulProviderReadErrorCode(errorCode) {
+    return errorCode === "PROVIDER_READ_FAILED" ? null : errorCode;
+}
+function clearSuccessfulProviderReadErrorDetail(errorCode, errorDetail) {
+    return errorCode === "PROVIDER_READ_FAILED" ? null : errorDetail;
+}
 function shouldShortCircuitMissingSyntheticCodexHistory(provider, rawStoreRef) {
     return provider === "codex" && isSyntheticCodexRawStoreRef(rawStoreRef) && !existsSync(rawStoreRef);
 }
@@ -3599,6 +3850,9 @@ 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 isSyntheticGeminiSessionTitle(title) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(title);
+}
 function shouldSyncSessionTitleFromProvider(provider, currentTitle) {
     const normalizedTitle = currentTitle?.trim() ?? "";
     if (normalizedTitle.length === 0) {
@@ -3607,6 +3861,9 @@ function shouldSyncSessionTitleFromProvider(provider, currentTitle) {
     if (provider === "codex" && isSyntheticCodexSessionTitle(normalizedTitle)) {
         return true;
     }
+    if (provider === "gemini" && isSyntheticGeminiSessionTitle(normalizedTitle)) {
+        return true;
+    }
     return false;
 }
 function shouldRemoveHiddenClaudeDebugSession(session) {
@@ -3618,6 +3875,7 @@ function shouldRemoveHiddenClaudeDebugSession(session) {
         /\/agent-[^/]+\.jsonl$/i.test(normalizedRawStoreRef));
 }
 const STALE_RUNTIME_WITHOUT_INSPECTION_GRACE_MS = 120_000;
+const GEMINI_ACTIVITY_INFERENCE_HISTORY_LIMIT = 80;
 function shouldClearStaleRuntimeWithoutInspection(current, inspection, nowMs) {
     if (!current || current.activitySource !== "runtime") {
         return false;
@@ -3795,8 +4053,51 @@ function areEquivalentSessionBindings(current, next) {
         current.provider === next.provider &&
         current.providerSessionId === next.providerSessionId &&
         current.rawStoreRef === next.rawStoreRef &&
+        current.providerConfigMode === next.providerConfigMode &&
+        current.providerPresetId === next.providerPresetId &&
+        current.runtimeHomeDir === next.runtimeHomeDir &&
         current.createdAt === next.createdAt);
 }
+function resolveRequestedProviderSelection(input) {
+    const existingSelection = input.existingBinding
+        ? {
+            providerConfigMode: input.existingBinding.providerConfigMode,
+            providerPresetId: input.existingBinding.providerPresetId
+        }
+        : null;
+    const normalizedPresetId = input.providerPresetId?.trim() || null;
+    if (input.providerConfigMode === undefined && input.providerPresetId === undefined) {
+        return existingSelection ?? {
+            providerConfigMode: "global-default",
+            providerPresetId: null
+        };
+    }
+    const providerConfigMode = input.providerConfigMode
+        ?? (normalizedPresetId ? "cc-switch-preset" : "global-default");
+    if (providerConfigMode === "global-default") {
+        return {
+            providerConfigMode,
+            providerPresetId: null
+        };
+    }
+    const providerPresetId = normalizedPresetId ?? existingSelection?.providerPresetId ?? null;
+    if (!providerPresetId) {
+        throw new AppError({
+            statusCode: 400,
+            errorCode: "INVALID_INPUT",
+            detail: "使用 cc-switch preset 时必须提供 providerPresetId",
+            field: "providerPresetId"
+        });
+    }
+    return {
+        providerConfigMode,
+        providerPresetId
+    };
+}
+function areEquivalentProviderBindingSelection(binding, selection) {
+    return (binding.providerConfigMode === selection.providerConfigMode
+        && binding.providerPresetId === selection.providerPresetId);
+}
 function areEquivalentSessionIndexRecords(current, next) {
     if (!current) {
         return false;