@jingyi0605/codingns 0.1.0

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

@@ -0,0 +1,1558 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { CapabilityService, ClaudeCodeAdapter, CodexAdapter, OpenCodeAdapter, ProviderRegistry, SessionSyncService } from "@codingns/session-sync-core";
+import { AppError } from "../../shared/errors/app-error.js";
+import { createId } from "../../shared/utils/id.js";
+import { logPerformance } from "../../shared/utils/perf-log.js";
+import { nowIso } from "../../shared/utils/time.js";
+import { inspectSessionActivity } from "./session-activity-inspector.js";
+import { mapSessionProviderError } from "./session-provider-error-mapper.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";
+export class SessionHistoryService {
+    db;
+    workspaceRepository;
+    sessionBindingRepository;
+    sessionChangedFileService;
+    sessionIndexRepository;
+    sessionMessageAttachmentService;
+    sessionStateRepository;
+    sessionStatusSnapshotRepository;
+    providerRegistry;
+    sessionSyncService;
+    capabilityService;
+    claudeCodeHomeDir;
+    codexModelOptionsService;
+    openCodeModelOptionsService;
+    workspaceDiscoveryStatuses = new Map();
+    workspaceDiscoveryInflight = new Map();
+    workspaceStateRefreshInflight = new Map();
+    workspaceSessionRelations = new Map();
+    constructor(db, workspaceRepository, sessionBindingRepository, sessionChangedFileService, sessionIndexRepository, sessionMessageAttachmentService, sessionStateRepository, sessionStatusSnapshotRepository, config) {
+        this.db = db;
+        this.workspaceRepository = workspaceRepository;
+        this.sessionBindingRepository = sessionBindingRepository;
+        this.sessionChangedFileService = sessionChangedFileService;
+        this.sessionIndexRepository = sessionIndexRepository;
+        this.sessionMessageAttachmentService = sessionMessageAttachmentService;
+        this.sessionStateRepository = sessionStateRepository;
+        this.sessionStatusSnapshotRepository = sessionStatusSnapshotRepository;
+        this.claudeCodeHomeDir = config.claudeCodeHomeDir;
+        this.providerRegistry = new ProviderRegistry([
+            new ClaudeCodeAdapter({ homeDir: config.claudeCodeHomeDir }),
+            new CodexAdapter({ homeDir: config.codexHomeDir }),
+            new OpenCodeAdapter({
+                baseUrl: config.opencodeBaseUrl,
+                baseUrlResolver: config.opencodeBaseUrlResolver?.resolve.bind(config.opencodeBaseUrlResolver),
+                dataDir: config.opencodeDataDir,
+                dbPath: config.opencodeDbPath
+            })
+        ]);
+        this.sessionSyncService = new SessionSyncService(this.providerRegistry);
+        this.capabilityService = new CapabilityService(this.providerRegistry);
+        this.codexModelOptionsService = new CodexModelOptionsService({
+            commandPath: config.codexCliPath
+        });
+        this.openCodeModelOptionsService = new OpenCodeModelOptionsService({
+            baseUrl: config.opencodeBaseUrl,
+            baseUrlResolver: config.opencodeBaseUrlResolver?.resolve.bind(config.opencodeBaseUrlResolver),
+            commandPath: config.opencodeCliPath
+        });
+    }
+    async discoverWorkspaceSessions(workspaceId, userId, options) {
+        const maxAgeMs = options?.maxAgeMs ?? 0;
+        const force = options?.force ?? false;
+        const discoveryStatus = this.workspaceDiscoveryStatuses.get(workspaceId);
+        const lastRefreshedAt = discoveryStatus?.refreshedAt ?? 0;
+        if (!force &&
+            discoveryStatus?.isComplete === true &&
+            maxAgeMs > 0 &&
+            Date.now() - lastRefreshedAt <= maxAgeMs) {
+            return this.listWorkspaceSessions(workspaceId, userId);
+        }
+        const inflight = this.workspaceDiscoveryInflight.get(workspaceId);
+        if (inflight) {
+            return inflight;
+        }
+        const task = this.runDiscoverWorkspaceSessions(workspaceId, userId, options?.refreshStateMode ?? "inline").finally(() => {
+            this.workspaceDiscoveryInflight.delete(workspaceId);
+        });
+        this.workspaceDiscoveryInflight.set(workspaceId, task);
+        return task;
+    }
+    needsWorkspaceDiscovery(workspaceId, maxAgeMs) {
+        if (maxAgeMs <= 0) {
+            return true;
+        }
+        const discoveryStatus = this.workspaceDiscoveryStatuses.get(workspaceId);
+        if (!discoveryStatus) {
+            return true;
+        }
+        if (!discoveryStatus.isComplete) {
+            return true;
+        }
+        return Date.now() - discoveryStatus.refreshedAt > maxAgeMs;
+    }
+    async readSessionHistory(sessionId, cursor, limit, direction = "forward", userId) {
+        const startedAt = Date.now();
+        const binding = this.getBindingOrThrow(sessionId);
+        const current = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        const safeLimit = clampLimit(limit);
+        const knownTotalMessageCount = direction === "backward" && cursor === null
+            ? this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.messageCount ?? null
+            : null;
+        let readDurationMs = 0;
+        let refreshStateDurationMs = 0;
+        this.upsertSnapshot(sessionId, {
+            syncStatus: "syncing",
+            syncCursor: current?.syncCursor ?? cursor,
+            lastSyncAt: current?.lastSyncAt ?? null,
+            lastErrorCode: null,
+            lastErrorDetail: null,
+            resumedAt: current?.resumedAt ?? null
+        });
+        try {
+            const readStartedAt = Date.now();
+            const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, cursor, safeLimit, direction, knownTotalMessageCount);
+            readDurationMs = Date.now() - readStartedAt;
+            this.upsertSnapshot(sessionId, {
+                syncStatus: "idle",
+                syncCursor: direction === "backward" && cursor !== null
+                    ? current?.syncCursor ?? page.cursor
+                    : page.cursor,
+                lastSyncAt: nowIso(),
+                lastErrorCode: null,
+                lastErrorDetail: null,
+                resumedAt: current?.resumedAt ?? null
+            });
+            logPerformance("session.read_history", Date.now() - startedAt, {
+                sessionId,
+                provider: binding.provider,
+                direction,
+                limit: safeLimit,
+                hasCursor: cursor !== null,
+                messageCount: page.messages.length,
+                total: page.total,
+                readMs: readDurationMs,
+                refreshStateMs: refreshStateDurationMs
+            }, {
+                thresholdMs: 300
+            });
+            return page;
+        }
+        catch (error) {
+            logPerformance("session.read_history.failed", Date.now() - startedAt, {
+                sessionId,
+                provider: binding.provider,
+                direction,
+                limit: safeLimit,
+                hasCursor: cursor !== null,
+                readMs: readDurationMs,
+                refreshStateMs: refreshStateDurationMs,
+                error: error instanceof Error ? error.message : "unknown"
+            }, {
+                thresholdMs: 0,
+                force: true
+            });
+            this.markSessionError(sessionId, "PROVIDER_READ_FAILED", error);
+            throw mapSessionProviderError(error);
+        }
+    }
+    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));
+        for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+            const knownTotalMessageCount = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.messageCount ?? null;
+            const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, null, 30, "backward", knownTotalMessageCount);
+            const matched = [...page.messages]
+                .reverse()
+                .find((message) => message.role === "user" &&
+                acceptedContents.has(message.content) &&
+                isMessageAtOrAfter(message.timestamp, minTimestamp));
+            if (matched) {
+                return matched;
+            }
+            if (attempt < maxAttempts - 1) {
+                await delay(100);
+            }
+        }
+        return null;
+    }
+    readSessionAttachment(sessionId, attachmentId) {
+        return this.sessionMessageAttachmentService.readAttachmentContent(sessionId, attachmentId);
+    }
+    getSession(sessionId, userId) {
+        return this.enrichSessionItem(this.getSessionListItemOrThrow(sessionId, userId));
+    }
+    async refreshRuntimeFallbackSession(sessionId, userId) {
+        await this.refreshSessionState(sessionId, userId);
+        return this.enrichSessionItem(this.getSessionListItemOrThrow(sessionId, userId));
+    }
+    async syncSessionTitle(sessionId) {
+        const binding = this.getBindingOrThrow(sessionId);
+        await this.syncSessionTitleFromProvider(sessionId, binding);
+    }
+    async syncWorkspaceSessionTitles(workspaceId, userId) {
+        const sessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
+        for (const session of sessions) {
+            await this.syncSessionTitle(session.sessionId).catch(() => {
+                return;
+            });
+        }
+    }
+    async listSessionChangedFiles(sessionId, userId) {
+        this.getSession(sessionId, userId);
+        await this.ensureSessionChangedFilesIndexed(sessionId);
+        return this.sessionChangedFileService.listBySessionId(sessionId);
+    }
+    listWorkspaceSessions(workspaceId, userId) {
+        return this.enrichSessionItems(workspaceId, this.sessionIndexRepository.listByWorkspace(workspaceId, userId));
+    }
+    getProviderCapabilitiesSnapshot(provider) {
+        try {
+            return this.capabilityService.getProviderCapabilities(provider);
+        }
+        catch (error) {
+            throw mapSessionProviderError(error);
+        }
+    }
+    async getProviderCapabilities(provider, workspaceId) {
+        try {
+            const workspacePath = workspaceId ? this.getWorkspaceOrThrow(workspaceId).path : null;
+            return await this.enrichProviderCapabilities(this.capabilityService.getProviderCapabilities(provider), workspacePath);
+        }
+        catch (error) {
+            throw mapSessionProviderError(error);
+        }
+    }
+    async getSessionCapabilities(sessionId) {
+        const binding = this.getBindingOrThrow(sessionId);
+        const workspace = this.getWorkspaceOrThrow(binding.workspaceId);
+        return this.capabilityService
+            .getSessionCapabilities(binding.provider, binding.providerSessionId)
+            .then((capabilities) => this.enrichProviderCapabilities(capabilities, workspace.path))
+            .catch((error) => {
+            throw mapSessionProviderError(error);
+        });
+    }
+    async enrichProviderCapabilities(capabilities, workspacePath) {
+        const claudeEnriched = enrichClaudeCapabilities(capabilities, {
+            claudeHomeDir: this.claudeCodeHomeDir,
+            workspacePath
+        });
+        const codexEnriched = await enrichCodexCapabilities(claudeEnriched, this.codexModelOptionsService);
+        return enrichOpenCodeCapabilities(codexEnriched, this.openCodeModelOptionsService, workspacePath);
+    }
+    async getSessionContextUsage(sessionId) {
+        const binding = this.getBindingOrThrow(sessionId);
+        try {
+            return await this.sessionSyncService.readContextUsage(binding.provider, binding.providerSessionId, binding.rawStoreRef);
+        }
+        catch (error) {
+            throw mapSessionProviderError(error);
+        }
+    }
+    async resumeSession(sessionId) {
+        const binding = this.getBindingOrThrow(sessionId);
+        try {
+            const result = await this.sessionSyncService.resumeSession(binding.provider, binding.providerSessionId, binding.rawStoreRef);
+            this.upsertSnapshot(sessionId, {
+                syncStatus: "idle",
+                syncCursor: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.syncCursor ?? null,
+                lastSyncAt: result.resumedAt,
+                lastErrorCode: null,
+                lastErrorDetail: null,
+                resumedAt: result.resumedAt
+            });
+            return {
+                sessionId,
+                provider: result.provider,
+                providerSessionId: result.providerSessionId,
+                resumedAt: result.resumedAt
+            };
+        }
+        catch (error) {
+            this.markSessionError(sessionId, "RESUME_FAILED", error);
+            throw mapSessionProviderError(error);
+        }
+    }
+    async startSession(input) {
+        const workspace = this.getWorkspaceOrThrow(input.workspaceId);
+        if (input.provider === "codex" || input.provider === "claude-code" || input.provider === "opencode") {
+            throw new AppError({
+                statusCode: 409,
+                errorCode: "SESSION_START_DEFERRED",
+                detail: "当前 provider 仅支持在首条消息发送时通过 start-live 创建原生会话",
+                field: "provider"
+            });
+        }
+        try {
+            const result = await this.sessionSyncService.startSession(input.provider, workspace.path, {
+                initialPrompt: input.initialPrompt
+            });
+            const sessionId = createId();
+            const timestamp = nowIso();
+            const persist = 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: result.session.parentProviderSessionId ?? null,
+                    isSubagent: result.session.isSubagent ?? false,
+                    subagentLabel: result.session.subagentLabel ?? null,
+                    title: result.session.title,
+                    messageCount: result.session.messageCount,
+                    isArchived: false,
+                    lastMessageAt: result.session.lastMessageAt,
+                    createdAt: timestamp,
+                    updatedAt: timestamp
+                });
+                this.sessionStatusSnapshotRepository.upsert({
+                    sessionId,
+                    syncStatus: "idle",
+                    syncCursor: result.initialCursor,
+                    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
+                });
+            });
+            persist();
+            return this.getSessionListItemOrThrow(sessionId, input.userId);
+        }
+        catch (error) {
+            throw mapSessionProviderError(error);
+        }
+    }
+    async sendMessage(sessionId, content, clientRequestId) {
+        const binding = this.getBindingOrThrow(sessionId);
+        const result = await this.sessionSyncService
+            .sendMessage(binding.provider, binding.providerSessionId, binding.rawStoreRef, content, clientRequestId)
+            .catch((error) => {
+            this.markSessionError(sessionId, "SEND_FAILED", error);
+            throw mapSessionProviderError(error);
+        });
+        const existing = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        this.sessionIndexRepository.upsert({
+            sessionId,
+            workspaceId: binding.workspaceId,
+            provider: binding.provider,
+            parentSessionId: existing?.parentSessionId ?? null,
+            isSubagent: existing?.isSubagent ?? false,
+            subagentLabel: existing?.subagentLabel ?? null,
+            title: existing?.title ?? result.message.content.slice(0, 48),
+            messageCount: (existing?.messageCount ?? 0) + 1,
+            isArchived: existing?.isArchived ?? false,
+            lastMessageAt: result.message.timestamp,
+            createdAt: existing?.createdAt ?? nowIso(),
+            updatedAt: result.message.timestamp
+        });
+        this.upsertSnapshot(sessionId, {
+            syncStatus: "idle",
+            syncCursor: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.syncCursor ?? null,
+            lastSyncAt: result.acceptedAt,
+            lastErrorCode: null,
+            lastErrorDetail: null,
+            resumedAt: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.resumedAt ?? null
+        });
+        return {
+            sessionId,
+            ...result
+        };
+    }
+    async subscribeSession(sessionId, cursor, limit, onEnvelope) {
+        const sentMessageIds = new Set();
+        const safeLimit = clampLimit(limit);
+        let currentCursor = cursor;
+        const current = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        let closed = false;
+        let polling = false;
+        this.upsertSnapshot(sessionId, {
+            syncStatus: "syncing",
+            syncCursor: current?.syncCursor ?? cursor,
+            lastSyncAt: current?.lastSyncAt ?? null,
+            lastErrorCode: null,
+            lastErrorDetail: null,
+            resumedAt: current?.resumedAt ?? null
+        });
+        try {
+            await this.pullSessionHistory(sessionId, currentCursor, safeLimit, sentMessageIds, onEnvelope, "session.backfill")
+                .then((nextCursor) => {
+                currentCursor = nextCursor;
+            });
+        }
+        catch (error) {
+            this.markSessionError(sessionId, "SUBSCRIBE_FAILED", error);
+            throw mapSessionProviderError(error);
+        }
+        const timer = setInterval(() => {
+            if (closed || polling) {
+                return;
+            }
+            polling = true;
+            void this.pullSessionHistory(sessionId, currentCursor, safeLimit, sentMessageIds, onEnvelope, "session.delta", () => closed)
+                .then((nextCursor) => {
+                currentCursor = nextCursor;
+            })
+                .catch((error) => {
+                this.markSessionError(sessionId, "SUBSCRIBE_FAILED", error);
+            })
+                .finally(() => {
+                polling = false;
+            });
+        }, 300);
+        return {
+            close() {
+                closed = true;
+                clearInterval(timer);
+            }
+        };
+    }
+    async readRecentHistoryEnvelope(sessionId, limit = 20) {
+        const binding = this.getBindingOrThrow(sessionId);
+        if (shouldSkipClaudePendingBinding(binding)) {
+            return null;
+        }
+        const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, null, clampLimit(limit), "backward", currentIndex?.messageCount ?? null);
+        if (!page.messages.some((message) => message.role !== "user")) {
+            return null;
+        }
+        await this.syncSessionTitleFromProvider(sessionId, binding);
+        this.upsertSnapshot(sessionId, {
+            syncStatus: "idle",
+            syncCursor: page.cursor,
+            lastSyncAt: nowIso(),
+            lastErrorCode: null,
+            lastErrorDetail: null,
+            resumedAt: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.resumedAt ?? null
+        });
+        return {
+            type: "session.delta",
+            sessionId,
+            cursor: page.cursor,
+            messages: page.messages
+        };
+    }
+    async markSessionSeen(sessionId, userId) {
+        const existing = this.sessionStateRepository.findBySessionAndUser(sessionId, userId) ??
+            (await this.refreshSessionState(sessionId, userId));
+        const seenAt = nowIso();
+        this.sessionStateRepository.upsert({
+            sessionId,
+            userId,
+            runningState: existing?.runningState ?? "idle",
+            activitySource: existing?.activitySource ?? "none",
+            favorite: existing?.favorite ?? false,
+            lastEventAt: existing?.lastEventAt ?? null,
+            completedAt: existing?.completedAt ?? null,
+            lastSeenAt: seenAt,
+            updatedAt: seenAt
+        });
+    }
+    async updateSessionFavoriteState(input) {
+        this.getBindingOrThrow(input.sessionId);
+        const existingItem = this.getSessionListItemOrThrow(input.sessionId, input.userId);
+        const currentState = this.sessionStateRepository.findBySessionAndUser(input.sessionId, input.userId) ??
+            (await this.refreshSessionState(input.sessionId, input.userId));
+        const timestamp = nowIso();
+        this.sessionStateRepository.upsert({
+            sessionId: input.sessionId,
+            userId: input.userId,
+            runningState: currentState?.runningState ?? "idle",
+            activitySource: currentState?.activitySource ?? "none",
+            favorite: input.isFavorite,
+            lastEventAt: currentState?.lastEventAt ?? existingItem.lastEventAt ?? null,
+            completedAt: currentState?.completedAt ?? existingItem.completedAt ?? null,
+            lastSeenAt: currentState?.lastSeenAt ?? existingItem.lastSeenAt ?? null,
+            updatedAt: timestamp
+        });
+        return this.enrichSessionItem({
+            ...this.getSessionListItemOrThrow(input.sessionId, input.userId),
+            isFavorite: input.isFavorite
+        });
+    }
+    async updateSessionArchiveState(input) {
+        const binding = this.getBindingOrThrow(input.sessionId);
+        const existing = this.getSessionListItemOrThrow(input.sessionId, input.userId);
+        const timestamp = nowIso();
+        let nextRawStoreRef = binding.rawStoreRef;
+        let nextArchivedState = input.isArchived;
+        if (binding.provider === "codex") {
+            const result = await this.sessionSyncService
+                .updateSessionArchiveState(binding.provider, binding.providerSessionId, binding.rawStoreRef, input.isArchived)
+                .catch((error) => {
+                throw mapSessionProviderError(error);
+            });
+            this.sessionBindingRepository.upsert({
+                ...binding,
+                rawStoreRef: result.rawStoreRef,
+                updatedAt: timestamp
+            });
+            nextRawStoreRef = result.rawStoreRef;
+            nextArchivedState = result.isArchived;
+        }
+        this.sessionIndexRepository.upsert({
+            sessionId: input.sessionId,
+            workspaceId: existing.workspaceId,
+            provider: existing.provider,
+            parentSessionId: existing.parentSessionId ?? null,
+            isSubagent: existing.isSubagent ?? false,
+            subagentLabel: existing.subagentLabel ?? null,
+            title: existing.title,
+            messageCount: existing.messageCount,
+            isArchived: nextArchivedState,
+            lastMessageAt: existing.lastMessageAt,
+            createdAt: existing.createdAt,
+            updatedAt: timestamp
+        });
+        return this.enrichSessionItem({
+            ...this.getSessionListItemOrThrow(input.sessionId, input.userId),
+            rawStoreRef: nextRawStoreRef,
+            isArchived: nextArchivedState
+        });
+    }
+    async renameSessionTitle(sessionId, userId, title) {
+        const binding = this.getBindingOrThrow(sessionId);
+        const existing = this.getSessionListItemOrThrow(sessionId, userId);
+        const nextTitle = title.trim();
+        const timestamp = nowIso();
+        try {
+            await this.sessionSyncService.renameSessionTitle(binding.provider, binding.providerSessionId, binding.rawStoreRef, nextTitle);
+        }
+        catch (error) {
+            throw mapSessionProviderError(error);
+        }
+        this.sessionIndexRepository.renameTitle(sessionId, nextTitle, timestamp);
+        return this.enrichSessionItem({
+            ...existing,
+            title: nextTitle,
+            updatedAt: timestamp
+        });
+    }
+    getBindingOrThrow(sessionId) {
+        const binding = this.sessionBindingRepository.findBySessionId(sessionId);
+        if (!binding) {
+            throw new AppError({
+                statusCode: 404,
+                errorCode: "SESSION_NOT_FOUND",
+                detail: "session 不存在"
+            });
+        }
+        return binding;
+    }
+    persistSessionBinding(sessionId, workspaceId, snapshot) {
+        if (!snapshot.providerSessionId || !snapshot.rawStoreRef) {
+            return;
+        }
+        const resolvedSnapshot = {
+            provider: snapshot.provider,
+            providerSessionId: snapshot.providerSessionId,
+            rawStoreRef: snapshot.rawStoreRef
+        };
+        const currentBinding = this.sessionBindingRepository.findBySessionId(sessionId);
+        const timestamp = nowIso();
+        const duplicateBinding = this.findPendingBindingDuplicate(sessionId, currentBinding, resolvedSnapshot);
+        this.db.transaction(() => {
+            if (duplicateBinding) {
+                // 新建运行时会话会先写入 pending 绑定，后台发现链路可能在真 ID 回填前先落一条重复记录。
+                // 这里保留当前 runtime session，把扫描出的重复会话并回当前会话，避免 provider_session_id 撞唯一键。
+                this.mergeSessionIntoTarget({
+                    workspaceId,
+                    targetSessionId: sessionId,
+                    sourceSessionId: duplicateBinding.sessionId,
+                    provider: resolvedSnapshot.provider,
+                    timestamp
+                });
+            }
+            const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+            this.sessionBindingRepository.upsert({
+                sessionId,
+                workspaceId,
+                provider: resolvedSnapshot.provider,
+                providerSessionId: resolvedSnapshot.providerSessionId,
+                rawStoreRef: resolvedSnapshot.rawStoreRef,
+                createdAt: pickEarlierIso(currentBinding?.createdAt ?? null, duplicateBinding?.createdAt ?? null)
+                    ?? timestamp,
+                updatedAt: timestamp
+            });
+            if (currentIndex) {
+                this.sessionIndexRepository.upsert({
+                    ...currentIndex,
+                    updatedAt: timestamp
+                });
+            }
+        })();
+    }
+    async runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode = "inline") {
+        const startedAt = Date.now();
+        const workspace = this.getWorkspaceOrThrow(workspaceId);
+        let discoverDurationMs = 0;
+        let persistDurationMs = 0;
+        const refreshStateCount = 10;
+        try {
+            const discoverStartedAt = Date.now();
+            const knownSessions = this.buildKnownSessionSummaries(this.sessionIndexRepository.listByWorkspace(workspaceId, userId), workspace.path);
+            const discovery = await this.sessionSyncService
+                .discoverWorkspaceSessions(workspace.path, {
+                knownSessions
+            })
+                .catch((error) => {
+                throw mapSessionProviderError(error);
+            });
+            const sessions = discovery.sessions;
+            discoverDurationMs = Date.now() - discoverStartedAt;
+            const timestamp = nowIso();
+            const discoveredSessionIds = new Map();
+            const persistedSessions = [];
+            const persist = this.db.transaction(() => {
+                for (const session of sessions) {
+                    const existing = this.sessionBindingRepository.findByProviderSession(session.provider, session.providerSessionId) ?? this.sessionBindingRepository.findByRawStoreRef(session.provider, session.rawStoreRef);
+                    const currentSnapshot = existing
+                        ? this.sessionStatusSnapshotRepository.findBySessionId(existing.sessionId)
+                        : null;
+                    const sessionId = existing?.sessionId ?? createId();
+                    const createdAt = existing?.createdAt ?? timestamp;
+                    const existingIndex = existing
+                        ? this.sessionIndexRepository.findIndexRecordBySessionId(existing.sessionId)
+                        : null;
+                    this.sessionBindingRepository.upsert({
+                        sessionId,
+                        workspaceId: workspace.id,
+                        provider: session.provider,
+                        providerSessionId: session.providerSessionId,
+                        rawStoreRef: session.rawStoreRef,
+                        createdAt,
+                        updatedAt: timestamp
+                    });
+                    this.sessionIndexRepository.upsert({
+                        sessionId,
+                        workspaceId: workspace.id,
+                        provider: session.provider,
+                        title: session.title,
+                        messageCount: session.messageCount,
+                        isArchived: resolveDiscoveredArchiveState(existingIndex?.isArchived ?? false, session.isArchived),
+                        lastMessageAt: session.lastMessageAt,
+                        createdAt,
+                        updatedAt: timestamp
+                    });
+                    this.sessionStatusSnapshotRepository.upsert({
+                        sessionId,
+                        syncStatus: currentSnapshot?.syncStatus ?? "idle",
+                        syncCursor: currentSnapshot?.syncCursor ?? null,
+                        lastSyncAt: currentSnapshot?.lastSyncAt ?? null,
+                        lastErrorCode: currentSnapshot?.lastErrorCode ?? null,
+                        lastErrorDetail: currentSnapshot?.lastErrorDetail ?? null,
+                        resumedAt: currentSnapshot?.resumedAt ?? null,
+                        updatedAt: timestamp
+                    });
+                    discoveredSessionIds.set(buildProviderSessionKey(session.provider, session.providerSessionId), sessionId);
+                    persistedSessions.push({
+                        session,
+                        sessionId,
+                        createdAt,
+                        existingIndex
+                    });
+                }
+                const relationMap = this.buildWorkspaceSessionRelationMap(sessions, discoveredSessionIds);
+                for (const persistedSession of persistedSessions) {
+                    const relation = relationMap.get(persistedSession.sessionId);
+                    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,
+                        messageCount: persistedSession.session.messageCount,
+                        isArchived: resolveDiscoveredArchiveState(persistedSession.existingIndex?.isArchived ?? false, persistedSession.session.isArchived),
+                        lastMessageAt: persistedSession.session.lastMessageAt,
+                        createdAt: persistedSession.createdAt,
+                        updatedAt: timestamp
+                    });
+                }
+            });
+            const persistStartedAt = Date.now();
+            persist();
+            persistDurationMs = Date.now() - persistStartedAt;
+            if (discovery.isComplete) {
+                this.cleanupStaleHiddenSessions(workspaceId, userId, sessions);
+            }
+            this.workspaceSessionRelations.set(workspaceId, this.buildWorkspaceSessionRelationMap(sessions, discoveredSessionIds));
+            const items = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
+            const recentItems = items.slice(0, refreshStateCount);
+            this.workspaceDiscoveryStatuses.set(workspaceId, {
+                refreshedAt: Date.now(),
+                isComplete: discovery.isComplete
+            });
+            if (refreshStateMode === "inline") {
+                await this.refreshRecentSessionStates(recentItems, userId);
+            }
+            else {
+                this.scheduleWorkspaceStateRefresh(workspaceId, userId, recentItems);
+            }
+            const nextItems = this.listWorkspaceSessions(workspaceId, userId);
+            logPerformance("workspace.discover_sessions", Date.now() - startedAt, {
+                workspaceId,
+                workspacePath: workspace.path,
+                knownSessions: knownSessions.length,
+                discoveredSessions: sessions.length,
+                returnedSessions: nextItems.length,
+                discoveryComplete: discovery.isComplete,
+                refreshedStates: Math.min(items.length, refreshStateCount),
+                discoverMs: discoverDurationMs,
+                persistMs: persistDurationMs,
+                refreshStateDeferred: refreshStateMode !== "inline"
+            }, {
+                thresholdMs: 500
+            });
+            return nextItems;
+        }
+        catch (error) {
+            logPerformance("workspace.discover_sessions.failed", Date.now() - startedAt, {
+                workspaceId,
+                workspacePath: workspace.path,
+                discoverMs: discoverDurationMs,
+                persistMs: persistDurationMs,
+                refreshStateDeferred: refreshStateMode !== "inline",
+                error: error instanceof Error ? error.message : "unknown"
+            }, {
+                thresholdMs: 0,
+                force: true
+            });
+            throw error;
+        }
+    }
+    async readPage(sessionId, provider, providerSessionId, rawStoreRef, cursor, limit, direction = "forward", knownTotalMessageCount = null) {
+        if (shouldShortCircuitMissingSyntheticCodexHistory(provider, rawStoreRef)) {
+            return {
+                messages: [],
+                cursor,
+                nextCursor: null,
+                total: 0
+            };
+        }
+        const historyTask = direction === "backward" && cursor === null && typeof knownTotalMessageCount === "number"
+            ? this.sessionSyncService.readRecentHistory(provider, providerSessionId, rawStoreRef, knownTotalMessageCount, limit)
+            : this.sessionSyncService.readHistory(provider, providerSessionId, rawStoreRef, cursor, limit, direction);
+        return historyTask
+            .then((page) => {
+            const messages = this.sessionMessageAttachmentService.enrichMessages(sessionId, page.messages);
+            this.persistSessionChangedFiles(sessionId, messages);
+            return {
+                ...page,
+                messages
+            };
+        })
+            .catch((error) => {
+            if (shouldTreatMissingSyntheticHistoryAsEmpty(provider, rawStoreRef, error)) {
+                return {
+                    messages: [],
+                    cursor,
+                    nextCursor: null,
+                    total: 0
+                };
+            }
+            throw mapSessionProviderError(error);
+        });
+    }
+    buildWorkspaceSessionRelationMap(sessions, discoveredSessionIds) {
+        const relationMap = new Map();
+        for (const session of sessions) {
+            const sessionId = discoveredSessionIds.get(buildProviderSessionKey(session.provider, session.providerSessionId));
+            if (!sessionId) {
+                continue;
+            }
+            const parentSessionId = session.parentProviderSessionId
+                ? discoveredSessionIds.get(buildProviderSessionKey(session.provider, session.parentProviderSessionId)) ??
+                    this.sessionBindingRepository.findByProviderSession(session.provider, session.parentProviderSessionId)?.sessionId ??
+                    null
+                : null;
+            relationMap.set(sessionId, {
+                parentSessionId,
+                isSubagent: Boolean(session.isSubagent || parentSessionId),
+                subagentLabel: session.subagentLabel?.trim() || null
+            });
+        }
+        return relationMap;
+    }
+    enrichSessionItems(workspaceId, items) {
+        const relationMap = this.workspaceSessionRelations.get(workspaceId);
+        if (!relationMap) {
+            return items.map((item) => this.enrichSessionItem(item));
+        }
+        return items.map((item) => {
+            const relation = relationMap.get(item.sessionId);
+            if (!relation) {
+                return this.enrichSessionItem(item);
+            }
+            return {
+                ...item,
+                parentSessionId: relation.parentSessionId,
+                isSubagent: relation.isSubagent,
+                subagentLabel: relation.subagentLabel
+            };
+        });
+    }
+    enrichSessionItem(item) {
+        const relation = this.workspaceSessionRelations.get(item.workspaceId)?.get(item.sessionId);
+        if (!relation) {
+            return {
+                ...item,
+                parentSessionId: item.parentSessionId ?? null,
+                isSubagent: item.isSubagent ?? false,
+                subagentLabel: item.subagentLabel ?? null
+            };
+        }
+        return {
+            ...item,
+            parentSessionId: relation.parentSessionId,
+            isSubagent: relation.isSubagent,
+            subagentLabel: relation.subagentLabel
+        };
+    }
+    async pullSessionHistory(sessionId, cursor, limit, sentMessageIds, 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);
+            const messages = page.messages.filter((message) => {
+                if (sentMessageIds.has(message.messageId)) {
+                    return false;
+                }
+                sentMessageIds.add(message.messageId);
+                return true;
+            });
+            if (messages.length > 0) {
+                await this.syncSessionTitleFromProvider(sessionId, binding);
+                this.upsertSnapshot(sessionId, {
+                    syncStatus: "idle",
+                    syncCursor: page.cursor,
+                    lastSyncAt: nowIso(),
+                    lastErrorCode: null,
+                    lastErrorDetail: null,
+                    resumedAt: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.resumedAt ?? null
+                });
+                await onEnvelope({
+                    type: envelopeType,
+                    sessionId,
+                    cursor: page.cursor,
+                    messages
+                });
+            }
+            currentCursor = page.cursor;
+            if (!page.nextCursor) {
+                return currentCursor;
+            }
+        }
+        return currentCursor;
+    }
+    async syncSessionTitleFromProvider(sessionId, binding) {
+        const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        if (!currentIndex) {
+            return;
+        }
+        if (shouldSkipClaudePendingBinding(binding)) {
+            return;
+        }
+        const nextTitle = (await this.sessionSyncService.readSessionTitle(binding.provider, binding.providerSessionId, binding.rawStoreRef)).trim();
+        if (nextTitle.length === 0 || nextTitle === currentIndex.title) {
+            return;
+        }
+        this.sessionIndexRepository.upsert({
+            ...currentIndex,
+            title: nextTitle,
+            updatedAt: nowIso()
+        });
+    }
+    async ensureSessionChangedFilesIndexed(sessionId) {
+        if (this.sessionChangedFileService.hasIndexedSession(sessionId)) {
+            return;
+        }
+        const binding = this.getBindingOrThrow(sessionId);
+        const seenCursors = new Set();
+        let cursor = null;
+        while (true) {
+            const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, cursor, 100, "forward");
+            if (!page.nextCursor || seenCursors.has(page.nextCursor)) {
+                this.sessionChangedFileService.markSessionIndexed(sessionId, nowIso());
+                return;
+            }
+            seenCursors.add(page.nextCursor);
+            cursor = page.nextCursor;
+        }
+    }
+    persistSessionChangedFiles(sessionId, messages) {
+        if (messages.length === 0) {
+            return;
+        }
+        const binding = this.sessionBindingRepository.findBySessionId(sessionId);
+        if (!binding) {
+            return;
+        }
+        const workspace = this.workspaceRepository.findById(binding.workspaceId);
+        if (!workspace) {
+            return;
+        }
+        this.sessionChangedFileService.recordMessages(sessionId, binding.workspaceId, workspace.path, messages);
+    }
+    getWorkspaceOrThrow(workspaceId) {
+        const workspace = this.workspaceRepository.findById(workspaceId);
+        if (!workspace) {
+            throw new AppError({
+                statusCode: 404,
+                errorCode: "WORKSPACE_NOT_FOUND",
+                detail: "工作区不存在"
+            });
+        }
+        return workspace;
+    }
+    getSessionListItemOrThrow(sessionId, userId) {
+        const item = this.sessionIndexRepository.findBySessionId(sessionId, userId);
+        if (!item) {
+            throw new AppError({
+                statusCode: 500,
+                errorCode: "SESSION_INDEX_MISSING",
+                detail: "session 索引缺失"
+            });
+        }
+        return item;
+    }
+    async refreshRecentSessionStates(sessions, userId) {
+        for (let index = 0; index < sessions.length; index += 1) {
+            if (index > 0) {
+                await delay(0);
+            }
+            await this.refreshSessionState(sessions[index].sessionId, userId);
+        }
+    }
+    scheduleWorkspaceStateRefresh(workspaceId, userId, sessions) {
+        if (sessions.length === 0) {
+            return;
+        }
+        const inflightKey = `${workspaceId}:${userId}`;
+        if (this.workspaceStateRefreshInflight.has(inflightKey)) {
+            return;
+        }
+        const startedAt = Date.now();
+        const task = delay(0)
+            .then(() => this.refreshRecentSessionStates(sessions, userId))
+            .then(() => {
+            logPerformance("workspace.refresh_recent_session_states", Date.now() - startedAt, {
+                workspaceId,
+                refreshedStates: sessions.length
+            }, {
+                thresholdMs: 300
+            });
+        })
+            .catch((error) => {
+            logPerformance("workspace.refresh_recent_session_states.failed", Date.now() - startedAt, {
+                workspaceId,
+                refreshedStates: sessions.length,
+                error: error instanceof Error ? error.message : "unknown"
+            }, {
+                thresholdMs: 0,
+                force: true
+            });
+        })
+            .finally(() => {
+            this.workspaceStateRefreshInflight.delete(inflightKey);
+        });
+        this.workspaceStateRefreshInflight.set(inflightKey, task);
+    }
+    cleanupStaleHiddenSessions(workspaceId, userId, sessions) {
+        const discoveredProviderSessionIds = new Set(sessions.map((session) => buildProviderSessionKey(session.provider, session.providerSessionId)));
+        const discoveredRawStoreRefs = new Set(sessions.map((session) => session.rawStoreRef));
+        const staleHiddenSessions = this.sessionIndexRepository
+            .listByWorkspace(workspaceId, userId)
+            .filter((session) => {
+            if (discoveredProviderSessionIds.has(buildProviderSessionKey(session.provider, session.providerSessionId))) {
+                return false;
+            }
+            if (discoveredRawStoreRefs.has(session.rawStoreRef)) {
+                return false;
+            }
+            return ((session.provider === "codex" &&
+                (isLegacyCodingNsRolloutSession(session.providerSessionId, session.rawStoreRef) ||
+                    shouldRemoveMissingSyntheticCodexSession(session.rawStoreRef))) ||
+                (session.provider === "claude-code" && shouldRemoveHiddenClaudeDebugSession(session)));
+        });
+        if (staleHiddenSessions.length === 0) {
+            return;
+        }
+        this.deleteSessionsByIds(staleHiddenSessions.map((session) => session.sessionId));
+    }
+    deleteSessionsByIds(sessionIds) {
+        const remove = this.db.transaction((ids) => {
+            for (const sessionId of ids) {
+                this.deleteSessionById(sessionId);
+            }
+        });
+        remove(sessionIds);
+    }
+    findPendingBindingDuplicate(sessionId, currentBinding, snapshot) {
+        if (!currentBinding || !isPendingBindingValue(currentBinding.providerSessionId)) {
+            return null;
+        }
+        if (isPendingBindingValue(snapshot.providerSessionId)) {
+            return null;
+        }
+        const existing = this.sessionBindingRepository.findByProviderSession(snapshot.provider, snapshot.providerSessionId) ?? this.sessionBindingRepository.findByRawStoreRef(snapshot.provider, snapshot.rawStoreRef);
+        if (!existing || existing.sessionId === sessionId) {
+            return null;
+        }
+        return existing;
+    }
+    mergeSessionIntoTarget(input) {
+        if (input.targetSessionId === input.sourceSessionId) {
+            return;
+        }
+        const targetBinding = this.sessionBindingRepository.findBySessionId(input.targetSessionId);
+        const sourceBinding = this.sessionBindingRepository.findBySessionId(input.sourceSessionId);
+        if (!targetBinding || !sourceBinding) {
+            return;
+        }
+        const targetIndex = this.sessionIndexRepository.findIndexRecordBySessionId(input.targetSessionId);
+        const sourceIndex = this.sessionIndexRepository.findIndexRecordBySessionId(input.sourceSessionId);
+        const targetSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(input.targetSessionId);
+        const sourceSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(input.sourceSessionId);
+        const targetStates = this.listSessionStatesBySessionId(input.targetSessionId);
+        const sourceStates = this.listSessionStatesBySessionId(input.sourceSessionId);
+        const targetStateByUserId = new Map(targetStates.map((state) => [state.userId, state]));
+        this.copyChangedFilesToTarget(input.targetSessionId, input.sourceSessionId);
+        this.copyChangedFileIndexStateToTarget(input.targetSessionId, input.sourceSessionId);
+        for (const sourceState of sourceStates) {
+            this.sessionStateRepository.upsert(mergeSessionStateRecord(targetStateByUserId.get(sourceState.userId) ?? null, {
+                ...sourceState,
+                sessionId: input.targetSessionId
+            }));
+        }
+        const mergedIndex = mergeSessionIndexRecord({
+            targetSessionId: input.targetSessionId,
+            workspaceId: input.workspaceId,
+            provider: input.provider,
+            target: targetIndex,
+            source: sourceIndex,
+            timestamp: input.timestamp
+        });
+        if (mergedIndex) {
+            this.sessionIndexRepository.upsert(mergedIndex);
+        }
+        const mergedSnapshot = mergeSessionStatusSnapshot({
+            targetSessionId: input.targetSessionId,
+            target: targetSnapshot,
+            source: sourceSnapshot,
+            timestamp: input.timestamp
+        });
+        if (mergedSnapshot) {
+            this.sessionStatusSnapshotRepository.upsert(mergedSnapshot);
+        }
+        this.db
+            .prepare(`UPDATE session_indices
+         SET parent_session_id = ?
+         WHERE parent_session_id = ?`)
+            .run(input.targetSessionId, input.sourceSessionId);
+        this.db
+            .prepare(`UPDATE session_message_attachments
+         SET session_id = ?
+         WHERE session_id = ?`)
+            .run(input.targetSessionId, input.sourceSessionId);
+        this.db
+            .prepare(`UPDATE session_file_context_bindings
+         SET session_id = ?
+         WHERE session_id = ?`)
+            .run(input.targetSessionId, input.sourceSessionId);
+        this.db
+            .prepare(`UPDATE session_send_queue
+         SET session_id = ?
+         WHERE session_id = ?`)
+            .run(input.targetSessionId, input.sourceSessionId);
+        this.db
+            .prepare("DELETE FROM session_changed_files WHERE session_id = ?")
+            .run(input.sourceSessionId);
+        this.db
+            .prepare("DELETE FROM session_changed_file_states WHERE session_id = ?")
+            .run(input.sourceSessionId);
+        this.db
+            .prepare("DELETE FROM session_states WHERE session_id = ?")
+            .run(input.sourceSessionId);
+        this.db
+            .prepare("DELETE FROM session_status_snapshots WHERE session_id = ?")
+            .run(input.sourceSessionId);
+        this.db
+            .prepare("DELETE FROM session_indices WHERE session_id = ?")
+            .run(input.sourceSessionId);
+        this.db
+            .prepare("DELETE FROM session_bindings WHERE session_id = ?")
+            .run(input.sourceSessionId);
+        this.rewriteWorkspaceSessionRelations(input.workspaceId, input.targetSessionId, input.sourceSessionId, targetIndex, sourceIndex);
+    }
+    listSessionStatesBySessionId(sessionId) {
+        return this.db
+            .prepare(`SELECT
+           session_id AS session_id,
+           user_id AS user_id,
+           running_state AS running_state,
+           activity_source AS activity_source,
+           favorite AS favorite,
+           last_event_at AS last_event_at,
+           completed_at AS completed_at,
+           last_seen_at AS last_seen_at,
+           updated_at AS updated_at
+         FROM session_states
+         WHERE session_id = ?`)
+            .all(sessionId)
+            .map((row) => mapSessionStateRecordRow(row));
+    }
+    copyChangedFilesToTarget(targetSessionId, sourceSessionId) {
+        this.db
+            .prepare(`INSERT INTO session_changed_files (
+           session_id,
+           workspace_id,
+           path,
+           first_detected_at,
+           last_detected_at,
+           last_tool_name
+         )
+         SELECT ?, workspace_id, path, first_detected_at, last_detected_at, last_tool_name
+         FROM session_changed_files
+         WHERE session_id = ?
+         ON CONFLICT(session_id, path) DO UPDATE SET
+           workspace_id = excluded.workspace_id,
+           first_detected_at = MIN(session_changed_files.first_detected_at, excluded.first_detected_at),
+           last_detected_at = MAX(session_changed_files.last_detected_at, excluded.last_detected_at),
+           last_tool_name = COALESCE(excluded.last_tool_name, session_changed_files.last_tool_name)`)
+            .run(targetSessionId, sourceSessionId);
+    }
+    copyChangedFileIndexStateToTarget(targetSessionId, sourceSessionId) {
+        this.db
+            .prepare(`INSERT INTO session_changed_file_states (
+           session_id,
+           indexed_at,
+           updated_at
+         )
+         SELECT ?, indexed_at, updated_at
+         FROM session_changed_file_states
+         WHERE session_id = ?
+         ON CONFLICT(session_id) DO UPDATE SET
+           indexed_at = MIN(session_changed_file_states.indexed_at, excluded.indexed_at),
+           updated_at = MAX(session_changed_file_states.updated_at, excluded.updated_at)`)
+            .run(targetSessionId, sourceSessionId);
+    }
+    rewriteWorkspaceSessionRelations(workspaceId, targetSessionId, sourceSessionId, targetIndex, sourceIndex) {
+        const relationMap = this.workspaceSessionRelations.get(workspaceId);
+        if (!relationMap) {
+            return;
+        }
+        const sourceRelation = relationMap.get(sourceSessionId);
+        const targetRelation = relationMap.get(targetSessionId);
+        const fallbackParentSessionId = targetIndex?.parentSessionId ?? sourceIndex?.parentSessionId ?? null;
+        relationMap.delete(sourceSessionId);
+        relationMap.set(targetSessionId, {
+            parentSessionId: targetRelation?.parentSessionId ?? sourceRelation?.parentSessionId ?? fallbackParentSessionId,
+            isSubagent: Boolean(targetRelation?.isSubagent
+                || sourceRelation?.isSubagent
+                || targetIndex?.isSubagent
+                || sourceIndex?.isSubagent
+                || fallbackParentSessionId),
+            subagentLabel: targetRelation?.subagentLabel
+                ?? sourceRelation?.subagentLabel
+                ?? targetIndex?.subagentLabel
+                ?? sourceIndex?.subagentLabel
+                ?? null
+        });
+        for (const relation of relationMap.values()) {
+            if (relation.parentSessionId === sourceSessionId) {
+                relation.parentSessionId = targetSessionId;
+            }
+        }
+    }
+    deleteSessionById(sessionId) {
+        this.sessionChangedFileService.deleteBySessionId(sessionId);
+        this.db
+            .prepare("DELETE FROM session_message_attachments WHERE session_id = ?")
+            .run(sessionId);
+        this.db
+            .prepare("DELETE FROM session_send_queue WHERE session_id = ?")
+            .run(sessionId);
+        this.db
+            .prepare("DELETE FROM session_file_context_bindings WHERE session_id = ?")
+            .run(sessionId);
+        this.db
+            .prepare("DELETE FROM session_states WHERE session_id = ?")
+            .run(sessionId);
+        this.db
+            .prepare("DELETE FROM session_status_snapshots WHERE session_id = ?")
+            .run(sessionId);
+        this.db
+            .prepare("DELETE FROM session_indices WHERE session_id = ?")
+            .run(sessionId);
+        this.db
+            .prepare("DELETE FROM session_bindings WHERE session_id = ?")
+            .run(sessionId);
+    }
+    buildKnownSessionSummaries(sessions, workspacePath) {
+        return sessions.map((session) => {
+            const stats = safeStat(session.rawStoreRef);
+            return {
+                provider: session.provider,
+                providerSessionId: session.providerSessionId,
+                title: session.title,
+                workspacePath,
+                rawStoreRef: session.rawStoreRef,
+                lastMessageAt: session.lastMessageAt,
+                messageCount: session.messageCount,
+                sourceMtimeMs: stats?.mtimeMs,
+                sourceSizeBytes: stats?.size
+            };
+        });
+    }
+    async refreshSessionState(sessionId, userId) {
+        const binding = this.getBindingOrThrow(sessionId);
+        const current = this.sessionStateRepository.findBySessionAndUser(sessionId, userId);
+        const inspection = inspectSessionActivity(binding.provider, binding.rawStoreRef);
+        const timestamp = nowIso();
+        if (shouldPreserveRuntimeTerminalState(current, inspection)) {
+            return current;
+        }
+        const nextRecord = {
+            sessionId,
+            userId,
+            runningState: inspection.runningState,
+            activitySource: inspection.lastEventAt || inspection.completedAtCandidate ? "inferred" : "none",
+            favorite: current?.favorite ?? false,
+            lastEventAt: inspection.lastEventAt,
+            completedAt: inspection.completedAtCandidate,
+            lastSeenAt: current?.lastSeenAt ?? null,
+            updatedAt: timestamp
+        };
+        this.sessionStateRepository.upsert(nextRecord);
+        const currentSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        this.sessionStatusSnapshotRepository.upsert({
+            sessionId,
+            syncStatus: inspection.runningState === "failed" ? "error" : currentSnapshot?.syncStatus ?? "idle",
+            syncCursor: currentSnapshot?.syncCursor ?? null,
+            lastSyncAt: inspection.lastEventAt ?? inspection.completedAtCandidate ?? currentSnapshot?.lastSyncAt ?? null,
+            lastErrorCode: inspection.runningState === "failed"
+                ? inspection.errorCode
+                : currentSnapshot?.lastErrorCode ?? null,
+            lastErrorDetail: inspection.runningState === "failed"
+                ? inspection.errorDetail
+                : currentSnapshot?.lastErrorDetail ?? null,
+            resumedAt: currentSnapshot?.resumedAt ?? null,
+            updatedAt: timestamp
+        });
+        return nextRecord;
+    }
+    upsertSnapshot(sessionId, input) {
+        this.sessionStatusSnapshotRepository.upsert({
+            sessionId,
+            ...input,
+            updatedAt: nowIso()
+        });
+    }
+    markSessionError(sessionId, errorCode, error) {
+        const current = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        this.sessionStatusSnapshotRepository.upsert({
+            sessionId,
+            syncStatus: "error",
+            syncCursor: current?.syncCursor ?? null,
+            lastSyncAt: current?.lastSyncAt ?? null,
+            lastErrorCode: errorCode,
+            lastErrorDetail: error instanceof Error ? error.message : "unknown",
+            resumedAt: current?.resumedAt ?? null,
+            updatedAt: nowIso()
+        });
+    }
+}
+function clampLimit(limit) {
+    if (!Number.isFinite(limit)) {
+        return 50;
+    }
+    return Math.max(1, Math.min(Math.trunc(limit), 100));
+}
+function mapSessionStateRecordRow(row) {
+    return {
+        sessionId: row.session_id,
+        userId: row.user_id,
+        runningState: row.running_state,
+        activitySource: row.activity_source,
+        favorite: row.favorite === 1,
+        lastEventAt: row.last_event_at,
+        completedAt: row.completed_at,
+        lastSeenAt: row.last_seen_at,
+        updatedAt: row.updated_at
+    };
+}
+function mergeSessionStateRecord(target, source) {
+    if (!target) {
+        return source;
+    }
+    const preferred = pickPreferredSessionState(target, source);
+    return {
+        sessionId: source.sessionId,
+        userId: source.userId,
+        runningState: preferred.runningState,
+        activitySource: preferred.activitySource,
+        favorite: target.favorite || source.favorite,
+        lastEventAt: pickLaterIso(target.lastEventAt, source.lastEventAt),
+        completedAt: pickLaterIso(target.completedAt, source.completedAt),
+        lastSeenAt: pickLaterIso(target.lastSeenAt, source.lastSeenAt),
+        updatedAt: pickLaterIso(target.updatedAt, source.updatedAt) ?? preferred.updatedAt
+    };
+}
+function pickPreferredSessionState(left, right) {
+    const leftPriority = scoreSessionState(left);
+    const rightPriority = scoreSessionState(right);
+    if (leftPriority !== rightPriority) {
+        return leftPriority > rightPriority ? left : right;
+    }
+    return (pickLaterIso(left.updatedAt, right.updatedAt) ?? left.updatedAt) === right.updatedAt
+        ? right
+        : left;
+}
+function scoreSessionState(record) {
+    if (record.activitySource === "runtime"
+        && (record.runningState === "starting" || record.runningState === "running")) {
+        return 6;
+    }
+    if (record.activitySource === "runtime") {
+        return 5;
+    }
+    if (record.activitySource === "inferred" && record.runningState === "running") {
+        return 4;
+    }
+    if (record.activitySource === "inferred") {
+        return 3;
+    }
+    return record.favorite ? 2 : 1;
+}
+function mergeSessionIndexRecord(input) {
+    if (!input.target && !input.source) {
+        return null;
+    }
+    return {
+        sessionId: input.targetSessionId,
+        workspaceId: input.workspaceId,
+        provider: (input.target?.provider ?? input.source?.provider ?? input.provider),
+        parentSessionId: input.target?.parentSessionId ?? input.source?.parentSessionId ?? 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),
+        messageCount: Math.max(input.target?.messageCount ?? 0, input.source?.messageCount ?? 0),
+        isArchived: Boolean(input.target?.isArchived || input.source?.isArchived),
+        lastMessageAt: pickLaterIso(input.target?.lastMessageAt ?? null, input.source?.lastMessageAt ?? null),
+        createdAt: pickEarlierIso(input.target?.createdAt ?? null, input.source?.createdAt ?? null) ?? input.timestamp,
+        updatedAt: input.timestamp
+    };
+}
+function mergeSessionStatusSnapshot(input) {
+    if (!input.target && !input.source) {
+        return null;
+    }
+    const preferred = pickPreferredSnapshot(input.target, input.source);
+    return {
+        sessionId: input.targetSessionId,
+        syncStatus: preferred?.syncStatus ?? "idle",
+        syncCursor: input.target?.syncCursor ?? input.source?.syncCursor ?? null,
+        lastSyncAt: pickLaterIso(input.target?.lastSyncAt ?? null, input.source?.lastSyncAt ?? null),
+        lastErrorCode: preferred?.lastErrorCode ?? null,
+        lastErrorDetail: preferred?.lastErrorDetail ?? null,
+        resumedAt: pickLaterIso(input.target?.resumedAt ?? null, input.source?.resumedAt ?? null),
+        updatedAt: input.timestamp
+    };
+}
+function pickPreferredSnapshot(left, right) {
+    if (!left) {
+        return right;
+    }
+    if (!right) {
+        return left;
+    }
+    if (left.syncStatus === "error" && right.syncStatus !== "error") {
+        return left;
+    }
+    if (right.syncStatus === "error" && left.syncStatus !== "error") {
+        return right;
+    }
+    return (pickLaterIso(left.updatedAt, right.updatedAt) ?? left.updatedAt) === right.updatedAt
+        ? right
+        : left;
+}
+function pickPreferredSessionTitle(target, source) {
+    const normalizedTarget = target?.trim() ?? "";
+    const normalizedSource = source?.trim() ?? "";
+    if (!normalizedTarget) {
+        return normalizedSource;
+    }
+    if (!normalizedSource) {
+        return normalizedTarget;
+    }
+    if (looksLikeGeneratedSessionTitle(normalizedTarget) && !looksLikeGeneratedSessionTitle(normalizedSource)) {
+        return normalizedSource;
+    }
+    return normalizedTarget;
+}
+function looksLikeGeneratedSessionTitle(title) {
+    return /^(Claude|Codex|OpenCode)\s+会话\b/i.test(title);
+}
+function pickEarlierIso(left, right) {
+    if (!left) {
+        return right;
+    }
+    if (!right) {
+        return left;
+    }
+    return left.localeCompare(right) <= 0 ? left : right;
+}
+function pickLaterIso(left, right) {
+    if (!left) {
+        return right;
+    }
+    if (!right) {
+        return left;
+    }
+    return left.localeCompare(right) >= 0 ? left : right;
+}
+function buildProviderSessionKey(provider, providerSessionId) {
+    return `${provider}::${providerSessionId}`;
+}
+function shouldSkipClaudePendingBinding(binding) {
+    if (binding.provider !== "claude-code") {
+        return false;
+    }
+    if (isPendingBindingValue(binding.providerSessionId)) {
+        return true;
+    }
+    const normalizedRawStoreRef = binding.rawStoreRef.replaceAll("\\", "/").toLowerCase();
+    return normalizedRawStoreRef.includes("/.pending-");
+}
+function isPendingBindingValue(value) {
+    return value.trim().toLowerCase().startsWith("pending://");
+}
+function resolveDiscoveredArchiveState(existingArchived, discoveredArchived) {
+    if (existingArchived) {
+        return true;
+    }
+    return discoveredArchived === true;
+}
+function isMessageAtOrAfter(timestamp, minTimestamp) {
+    if (!minTimestamp) {
+        return true;
+    }
+    const messageAt = Date.parse(timestamp);
+    const minAt = Date.parse(minTimestamp);
+    if (!Number.isFinite(messageAt) || !Number.isFinite(minAt)) {
+        return true;
+    }
+    return messageAt >= minAt;
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function safeStat(filePath) {
+    try {
+        const stats = statSync(filePath);
+        return {
+            mtimeMs: stats.mtimeMs,
+            size: stats.size
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function shouldTreatMissingSyntheticHistoryAsEmpty(provider, rawStoreRef, error) {
+    if (provider !== "codex") {
+        return false;
+    }
+    if (!isSyntheticCodexRawStoreRef(rawStoreRef)) {
+        return false;
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    return detail.includes("ENOENT");
+}
+function shouldShortCircuitMissingSyntheticCodexHistory(provider, rawStoreRef) {
+    return provider === "codex" && isSyntheticCodexRawStoreRef(rawStoreRef) && !existsSync(rawStoreRef);
+}
+function isSyntheticCodexRawStoreRef(rawStoreRef) {
+    const normalizedRawStoreRef = rawStoreRef.replaceAll("\\", "/").toLowerCase();
+    return (normalizedRawStoreRef.includes("/runtime/codex/") ||
+        normalizedRawStoreRef.startsWith("runtime/codex/"));
+}
+function isLegacyCodingNsRolloutSession(providerSessionId, rawStoreRef) {
+    if (!providerSessionId.startsWith("rollout-")) {
+        return false;
+    }
+    if (!existsSync(rawStoreRef)) {
+        return false;
+    }
+    try {
+        const firstLine = readFileSync(rawStoreRef, "utf8")
+            .split(/\r?\n/, 1)
+            .at(0)
+            ?.trim();
+        if (!firstLine) {
+            return false;
+        }
+        const record = JSON.parse(firstLine);
+        return record.type === "session_meta" && record.payload?.source === "codingns";
+    }
+    catch {
+        return false;
+    }
+}
+function shouldRemoveMissingSyntheticCodexSession(rawStoreRef) {
+    return isSyntheticCodexRawStoreRef(rawStoreRef) && !existsSync(rawStoreRef);
+}
+function shouldRemoveHiddenClaudeDebugSession(session) {
+    const normalizedRawStoreRef = session.rawStoreRef.replaceAll("\\", "/");
+    if (normalizedRawStoreRef.includes("/subagents/")) {
+        return false;
+    }
+    return (/^agent-[^/]+$/i.test(session.providerSessionId) &&
+        /\/agent-[^/]+\.jsonl$/i.test(normalizedRawStoreRef));
+}
+function shouldPreserveRuntimeTerminalState(current, inspection) {
+    if (!current || current.activitySource !== "runtime") {
+        return false;
+    }
+    if (!inspection.lastEventAt || !current.lastEventAt) {
+        return true;
+    }
+    if (isTerminalRunningState(current.runningState)) {
+        return inspection.lastEventAt.localeCompare(current.lastEventAt) <= 0;
+    }
+    if (current.runningState === "starting" || current.runningState === "running") {
+        return inspection.lastEventAt.localeCompare(current.lastEventAt) < 0;
+    }
+    return false;
+}
+function isTerminalRunningState(state) {
+    return state === "completed" || state === "interrupted" || state === "failed";
+}
+//# sourceMappingURL=session-history-service.js.map