@jingyi0605/codingns 0.5.5 → 0.6.1

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";
@@ -11,6 +11,7 @@ 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 { buildParallelGroupColorToken, resolveParallelDisplayParentSessionId } from "../parallel-sessions/parallel-session-group-service.js";
 import { enrichClaudeCapabilities } from "../provider/claude-model-options.js";
 import { CodexModelOptionsService, createFallbackCodexModelOptions, enrichCodexCapabilities } from "../provider/codex-model-options.js";
 import { OpenCodeModelOptionsService, createFallbackOpenCodeModelOptions, enrichOpenCodeCapabilities } from "../provider/opencode-model-options.js";
@@ -24,13 +25,23 @@ 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",
+    "opencode"
+]);
 const MUTABLE_HISTORY_TAIL_REFRESH_INTERVAL_MS = 1_200;
 const WORKSPACE_DISCOVERY_BACKGROUND_MAX_AGE_MS = 15_000;
 const WORKSPACE_DISCOVERY_SCAN_CONCURRENCY = 2;
@@ -62,8 +73,12 @@ export class SessionHistoryService {
     openCodeModelOptionsService;
     providerCliCommandPaths;
     providerCliAvailability;
+    parallelSessionGroupRepository;
+    parallelSessionMemberRepository;
+    sessionIsolatedWorkspaceRepository;
     providerDiscoveryHelperClient = getSharedProviderDiscoveryHelperClient();
     providerSessionDiscoveryConfig;
+    sessionProviderConfigService;
     taskManager;
     workspaceDiscoveryStatuses = new Map();
     workspaceStateRefreshStatuses = new Map();
@@ -73,7 +88,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()) {
+    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) {
         this.db = db;
         this.workspaceRepository = workspaceRepository;
         this.sessionBindingRepository = sessionBindingRepository;
@@ -88,9 +103,14 @@ export class SessionHistoryService {
         this.providerSessionDeleteCli =
             adapterOverrides.providerSessionDeleteCli ?? new CodingnsProviderSessionDeleteCli(config);
         this.taskManager = taskManager;
+        this.parallelSessionGroupRepository = parallelSessionGroupRepository;
+        this.parallelSessionMemberRepository = parallelSessionMemberRepository;
+        this.sessionIsolatedWorkspaceRepository = sessionIsolatedWorkspaceRepository;
+        this.sessionProviderConfigService = sessionProviderConfigService;
         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
@@ -99,8 +119,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,
@@ -111,6 +133,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
@@ -309,8 +335,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;
@@ -423,9 +449,11 @@ export class SessionHistoryService {
         return this.sessionChangedFileService.listBySessionId(sessionId);
     }
     listWorkspaceSessions(workspaceId, userId) {
-        return this.enrichSessionItems(workspaceId, this.sessionIndexRepository
+        const directItems = this.sessionIndexRepository
             .listByWorkspace(workspaceId, userId)
-            .filter((item) => !this.isPendingSessionAlias(item)));
+            .filter((item) => !this.isPendingSessionAlias(item));
+        const projectedItems = this.listProjectedIsolatedWorkspaceSessions(workspaceId, userId);
+        return this.enrichSessionItems(workspaceId, sortSessionListItemsByRecentActivity(mergeSessionListItemsBySessionId([...directItems, ...projectedItems])));
     }
     getProviderCapabilitiesSnapshot(provider) {
         try {
@@ -439,6 +467,15 @@ 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 refreshed;
+            }
             this.scheduleProviderCapabilityRefresh(baseCapabilities, workspacePath);
             return this.resolveProviderCapabilitiesImmediate(baseCapabilities, workspacePath);
         }
@@ -454,6 +491,17 @@ 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 refreshed;
+                });
+            }
             this.scheduleProviderCapabilityRefresh(normalizedCapabilities, workspacePath);
             return this.resolveProviderCapabilitiesImmediate(normalizedCapabilities, workspacePath);
         })
@@ -594,11 +642,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({
@@ -607,6 +661,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
                 });
@@ -658,7 +715,8 @@ export class SessionHistoryService {
     }
     async forkSession(input) {
         const binding = this.getBindingOrThrow(input.sessionId);
-        const workspace = this.getWorkspaceOrThrow(binding.workspaceId);
+        const targetWorkspaceId = input.targetWorkspaceId?.trim() || binding.workspaceId;
+        const workspace = this.getWorkspaceOrThrow(targetWorkspaceId);
         const targetProvider = input.targetProvider?.trim() || binding.provider;
         this.assertProviderCapabilityEnabled(targetProvider, "canStartSession", "当前 provider 不支持 fork 创建会话");
         const sourceMessageId = input.sourceType === "message"
@@ -673,10 +731,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 {
@@ -696,6 +762,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
                 });
@@ -786,10 +855,12 @@ export class SessionHistoryService {
             messages: reconstructedMessages
         });
         const startedSession = await this.startSessionDirect({
-            workspaceId: sourceBinding.workspaceId,
+            workspaceId: input.targetWorkspaceId?.trim() || sourceBinding.workspaceId,
             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,
@@ -824,7 +895,7 @@ export class SessionHistoryService {
                 createdAt: timestamp
             });
         })();
-        const relationMap = this.workspaceSessionRelations.get(sourceBinding.workspaceId)
+        const relationMap = this.workspaceSessionRelations.get(input.targetWorkspaceId?.trim() || sourceBinding.workspaceId)
             ?? new Map();
         relationMap.set(startedSession.sessionId, {
             parentSessionId: input.sessionId,
@@ -834,9 +905,43 @@ export class SessionHistoryService {
             isSubagent: startedSession.isSubagent ?? false,
             subagentLabel: startedSession.subagentLabel ?? null
         });
-        this.workspaceSessionRelations.set(sourceBinding.workspaceId, relationMap);
+        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;
@@ -1007,13 +1112,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",
@@ -1125,7 +1231,10 @@ export class SessionHistoryService {
     async deleteSession(sessionId, userId) {
         const binding = this.getBindingOrThrow(sessionId);
         const existing = this.getSessionListItemOrThrow(sessionId, userId);
-        if (existing.runningState === "starting" || existing.runningState === "running") {
+        const resolvedExisting = existing.runningState === "starting" || existing.runningState === "running"
+            ? await this.refreshRuntimeFallbackSession(sessionId, userId).catch(() => existing)
+            : existing;
+        if (resolvedExisting.runningState === "starting" || resolvedExisting.runningState === "running") {
             throw new AppError({
                 statusCode: 409,
                 errorCode: "SESSION_DELETE_RUNNING",
@@ -1224,6 +1333,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
@@ -1315,6 +1433,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
                     };
@@ -1594,9 +1715,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);
     }
@@ -1715,13 +1851,14 @@ export class SessionHistoryService {
     }
     enrichSessionItems(workspaceId, items) {
         const relationMap = this.workspaceSessionRelations.get(workspaceId);
+        const projectionBySessionId = this.buildParallelProjectionBySessionId(items);
         if (!relationMap) {
-            return items.map((item) => this.enrichSessionItem(item));
+            return items.map((item) => this.enrichSessionItem(item, projectionBySessionId.get(item.sessionId)));
         }
         return items.map((item) => {
             const relation = relationMap.get(item.sessionId);
             if (!relation) {
-                return this.enrichSessionItem(item);
+                return this.enrichSessionItem(item, projectionBySessionId.get(item.sessionId));
             }
             return this.enrichSessionItem({
                 ...item,
@@ -1731,10 +1868,12 @@ export class SessionHistoryService {
                 annotationSourceText: relation.annotationSourceText,
                 isSubagent: relation.isSubagent,
                 subagentLabel: relation.subagentLabel
-            });
+            }, projectionBySessionId.get(item.sessionId));
         });
     }
-    enrichSessionItem(item) {
+    enrichSessionItem(item, projection) {
+        const resolvedProjection = projection
+            ?? this.buildParallelProjectionBySessionId([item]).get(item.sessionId);
         const relation = this.workspaceSessionRelations.get(item.workspaceId)?.get(item.sessionId);
         const nextItem = relation
             ? {
@@ -1756,7 +1895,90 @@ export class SessionHistoryService {
                 subagentLabel: item.subagentLabel ?? null
             };
         const resolution = this.sessionActivityAuthorityService.resolvePersistedSession(nextItem);
-        return applySessionActivityResolution(nextItem, resolution);
+        return applySessionActivityResolution({
+            ...nextItem,
+            parallelGroup: resolvedProjection?.parallelGroup ?? null,
+            displayParentSessionId: resolvedProjection?.displayParentSessionId ?? null,
+            sessionIsolatedWorkspace: resolvedProjection?.sessionIsolatedWorkspace ?? null
+        }, resolution);
+    }
+    buildParallelProjectionBySessionId(items) {
+        const projectionBySessionId = new Map();
+        if (!this.parallelSessionGroupRepository
+            || !this.parallelSessionMemberRepository
+            || !this.sessionIsolatedWorkspaceRepository
+            || items.length === 0) {
+            return projectionBySessionId;
+        }
+        const sessionIds = items.map((item) => item.sessionId);
+        const members = this.parallelSessionMemberRepository
+            .listBySessionIds(sessionIds)
+            .filter((member) => member.deletedAt === null);
+        if (members.length === 0) {
+            return projectionBySessionId;
+        }
+        const groupIds = [...new Set(members.map((member) => member.groupId))];
+        const groups = this.parallelSessionGroupRepository
+            .listByIds(groupIds)
+            .filter((group) => group.status !== "deleted");
+        const groupById = new Map(groups.map((group) => [group.id, group]));
+        const activeMembersByGroupId = new Map();
+        for (const member of this.parallelSessionMemberRepository.listByGroupIds(groupIds)) {
+            if (member.deletedAt !== null) {
+                continue;
+            }
+            const groupMembers = activeMembersByGroupId.get(member.groupId) ?? [];
+            groupMembers.push(member);
+            activeMembersByGroupId.set(member.groupId, groupMembers);
+        }
+        const isolatedWorkspaceBySessionId = new Map(this.sessionIsolatedWorkspaceRepository
+            .listByOwnerSessionIds(sessionIds)
+            .map((record) => [record.ownerSessionId, record]));
+        for (const member of members) {
+            const group = groupById.get(member.groupId);
+            if (!group) {
+                continue;
+            }
+            const activeMembers = activeMembersByGroupId.get(member.groupId) ?? [member];
+            const isolatedWorkspace = isolatedWorkspaceBySessionId.get(member.sessionId) ?? null;
+            projectionBySessionId.set(member.sessionId, {
+                parallelGroup: {
+                    groupId: group.id,
+                    role: member.sessionId === group.anchorSessionId ? "anchor" : "member",
+                    memberCount: activeMembers.length,
+                    sourceType: group.sourceType,
+                    sourceSessionId: group.sourceSessionId,
+                    anchorSessionId: group.anchorSessionId,
+                    colorToken: buildParallelGroupColorToken(group.id)
+                },
+                displayParentSessionId: resolveParallelDisplayParentSessionId(group, member),
+                sessionIsolatedWorkspace: isolatedWorkspace
+                    ? {
+                        id: isolatedWorkspace.id,
+                        workspaceId: isolatedWorkspace.workspaceId,
+                        sourceWorkspaceId: isolatedWorkspace.sourceWorkspaceId,
+                        branchName: isolatedWorkspace.branchName,
+                        lifecycleStatus: isolatedWorkspace.lifecycleStatus,
+                        promotedAt: isolatedWorkspace.promotedAt,
+                        createdAt: isolatedWorkspace.createdAt,
+                        updatedAt: isolatedWorkspace.updatedAt
+                    }
+                    : null
+            });
+        }
+        return projectionBySessionId;
+    }
+    listProjectedIsolatedWorkspaceSessions(workspaceId, userId) {
+        if (!this.sessionIsolatedWorkspaceRepository) {
+            return [];
+        }
+        return this.sessionIsolatedWorkspaceRepository
+            .listBySourceWorkspaceId(workspaceId)
+            .filter((record) => record.lifecycleStatus === "active"
+            || record.lifecycleStatus === "removing")
+            .map((record) => this.sessionIndexRepository.findBySessionId(record.ownerSessionId, userId))
+            .filter((item) => Boolean(item))
+            .filter((item) => !this.isPendingSessionAlias(item));
     }
     async pullSessionHistory(sessionId, cursor, limit, deliveredMessages, onEnvelope, envelopeType, isClosed = () => false) {
         let currentCursor = cursor;
@@ -1803,8 +2025,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({
@@ -1830,7 +2052,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;
@@ -2265,6 +2492,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
             });
@@ -2346,6 +2576,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
         });
@@ -2584,7 +2817,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)) {
@@ -2647,6 +2882,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);
@@ -2723,7 +2967,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]) => [
@@ -2735,6 +2983,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":
@@ -2794,6 +3044,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
@@ -3289,7 +3579,7 @@ function createDeliveredHistoryMessageState() {
     };
 }
 function shouldRefreshMutableHistoryTail(provider, page, cursor, deliveredMessages) {
-    if (provider !== "kimi" || cursor === null || page.messages.length > 0) {
+    if (!MUTABLE_HISTORY_TAIL_PROVIDERS.has(provider) || cursor === null || page.messages.length > 0) {
         return false;
     }
     return Date.now() - deliveredMessages.lastMutableTailRefreshAtMs >= MUTABLE_HISTORY_TAIL_REFRESH_INTERVAL_MS;
@@ -3347,6 +3637,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);
 }
@@ -3493,6 +3817,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) {
@@ -3501,6 +3828,9 @@ function shouldSyncSessionTitleFromProvider(provider, currentTitle) {
     if (provider === "codex" && isSyntheticCodexSessionTitle(normalizedTitle)) {
         return true;
     }
+    if (provider === "gemini" && isSyntheticGeminiSessionTitle(normalizedTitle)) {
+        return true;
+    }
     return false;
 }
 function shouldRemoveHiddenClaudeDebugSession(session) {
@@ -3512,6 +3842,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;
@@ -3545,6 +3876,11 @@ function shouldPreserveRuntimeTerminalState(current, inspection) {
         return inspection.lastEventAt.localeCompare(current.lastEventAt) <= 0;
     }
     if (current.runningState === "starting" || current.runningState === "running") {
+        if (inspection.completedAtCandidate
+            || inspection.errorCode
+            || inspection.runningState === "interrupted") {
+            return false;
+        }
         return inspection.lastEventAt.localeCompare(current.lastEventAt) <= 0;
     }
     return false;
@@ -3684,8 +4020,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;
@@ -3772,6 +4151,23 @@ async function runBatchedTransactions(items, batchSize, transaction, logOptions)
         maxBatchMs
     };
 }
+function mergeSessionListItemsBySessionId(items) {
+    const itemBySessionId = new Map();
+    for (const item of items) {
+        itemBySessionId.set(item.sessionId, item);
+    }
+    return [...itemBySessionId.values()];
+}
+function sortSessionListItemsByRecentActivity(items) {
+    return [...items].sort((left, right) => {
+        const leftPrimary = left.lastMessageAt ?? left.updatedAt;
+        const rightPrimary = right.lastMessageAt ?? right.updatedAt;
+        if (leftPrimary !== rightPrimary) {
+            return rightPrimary.localeCompare(leftPrimary);
+        }
+        return right.updatedAt.localeCompare(left.updatedAt);
+    });
+}
 function applyImmediateModelOptionFallbacks(capabilities, codexSnapshot, openCodeSnapshot) {
     if (capabilities.provider === "codex") {
         return {