@jingyi0605/codingns 0.2.5 → 0.3.5

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

@@ -58,6 +58,7 @@ export class SessionHistoryService {
     workspaceDiscoveryStatuses = new Map();
     workspaceStateRefreshInflight = new Map();
     providerCapabilityCache = new Map();
+    liveActivityObservationResolvers = new Set();
     workspaceSessionRelations = new Map();
     constructor(db, workspaceRepository, sessionBindingRepository, sessionChangedFileService, sessionIndexRepository, sessionMessageAttachmentService, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService(), sessionMessageOriginRepository = null, sessionForkRepository = null, adapterOverrides = {}, taskManager = createTaskManager()) {
         this.db = db;
@@ -130,6 +131,19 @@ export class SessionHistoryService {
     observeBackgroundTaskMetrics() {
         return this.taskManager.observe();
     }
+    registerLiveActivityObservationResolver(resolver) {
+        this.liveActivityObservationResolvers.add(resolver);
+        let closed = false;
+        return {
+            close: () => {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                this.liveActivityObservationResolvers.delete(resolver);
+            }
+        };
+    }
     registerBackgroundTasks() {
         if (!this.taskManager.has(HOST_TASK_TYPES.workspaceDiscovery)) {
             this.taskManager.register({
@@ -1076,39 +1090,52 @@ export class SessionHistoryService {
             providerSessionId: snapshot.providerSessionId,
             rawStoreRef: snapshot.rawStoreRef
         });
-        const currentBinding = this.sessionBindingRepository.findBySessionId(sessionId);
-        const timestamp = nowIso();
-        const duplicateBinding = this.findPendingBindingDuplicate(sessionId, workspaceId, 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
-                });
+        // discovery 和 runtime 回填会并发命中这里；如果在事务外先看重复，再事务内写入，
+        // 中间就会留下一个竞态窗口，最后直接撞 UNIQUE(provider, provider_session_id)。
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            try {
+                this.db.transaction(() => {
+                    const currentBinding = this.sessionBindingRepository.findBySessionId(sessionId);
+                    const timestamp = nowIso();
+                    const duplicateBinding = this.findSameWorkspaceBindingDuplicate(sessionId, workspaceId, resolvedSnapshot);
+                    if (duplicateBinding) {
+                        // 运行时链路显式指定了当前 sessionId，就应该由当前会话接管同工作区里的重复底层会话。
+                        // 否则后续事件重放或后台发现补录都会持续撞 UNIQUE(provider, 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
+                        });
+                    }
+                })();
+                return;
             }
-            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
-                });
+            catch (error) {
+                if (attempt === 0 && isSessionBindingProviderUniqueConflict(error)) {
+                    continue;
+                }
+                throw error;
             }
-        })();
+        }
     }
     async runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode = "inline") {
         const startedAt = Date.now();
@@ -1148,7 +1175,9 @@ export class SessionHistoryService {
             const claimedPendingSessionIds = new Set();
             const persistPass1Transaction = this.db.transaction((batch) => {
                 for (const session of batch) {
-                    const exactExisting = this.sessionBindingRepository.findByProviderSession(session.provider, session.providerSessionId) ?? this.sessionBindingRepository.findByRawStoreRef(session.provider, session.rawStoreRef);
+                    const exactExisting = this.sessionBindingRepository.findByProviderSession(session.provider, session.providerSessionId) ?? (shouldMatchSessionBindingByRawStoreRef(session.provider)
+                        ? this.sessionBindingRepository.findByRawStoreRef(session.provider, session.rawStoreRef)
+                        : null);
                     if (exactExisting && exactExisting.workspaceId !== workspaceId) {
                         continue;
                     }
@@ -1391,12 +1420,13 @@ export class SessionHistoryService {
             ? this.sessionSyncService.readRecentHistory(provider, providerSessionId, rawStoreRef, knownTotalMessageCount, limit)
             : this.sessionSyncService.readHistory(provider, providerSessionId, rawStoreRef, cursor, limit, direction);
         return historyTask
-            .then((page) => {
-            const messagesWithAttachments = this.sessionMessageAttachmentService.enrichMessages(sessionId, page.messages);
+            .then(async (page) => {
+            const sanitizedPage = await this.sanitizeForkHistoryPage(sessionId, page, cursor, direction);
+            const messagesWithAttachments = this.sessionMessageAttachmentService.enrichMessages(sessionId, sanitizedPage.messages);
             const messages = this.enrichMessagesWithOrigin(sessionId, messagesWithAttachments);
             this.persistSessionChangedFiles(sessionId, messages);
             return {
-                ...page,
+                ...sanitizedPage,
                 messages
             };
         })
@@ -1415,6 +1445,56 @@ export class SessionHistoryService {
     enrichMessagesWithOrigin(sessionId, messages) {
         return this.resolveMessageOrigins(sessionId, messages);
     }
+    async sanitizeForkHistoryPage(sessionId, page, cursor, direction) {
+        if (direction !== "forward" || cursor !== null || page.messages.length === 0) {
+            return page;
+        }
+        const forkRecord = this.sessionForkRepository.findBySessionId(sessionId);
+        if (!forkRecord
+            || forkRecord.forkSourceType !== "message"
+            || !forkRecord.forkSourceMessageId) {
+            return page;
+        }
+        const childSession = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        const childCreatedAt = childSession?.createdAt?.trim() || null;
+        if (!childCreatedAt) {
+            return page;
+        }
+        const parentBinding = this.getBindingOrThrow(forkRecord.forkSourceSessionId);
+        const inheritedMessages = await this.readForkSourceMessages(forkRecord.forkSourceSessionId, parentBinding, "message", forkRecord.forkSourceMessageId, null);
+        const expectedInheritedCount = inheritedMessages.length;
+        if (expectedInheritedCount <= 0) {
+            return page;
+        }
+        const parentMessages = await this.readForkSourceMessages(forkRecord.forkSourceSessionId, parentBinding, "session", null, null);
+        let leakedInheritedCount = countCommonHistoryPrefixLength(page.messages.slice(expectedInheritedCount), parentMessages.slice(expectedInheritedCount));
+        if (leakedInheritedCount <= 0) {
+            for (let index = expectedInheritedCount; index < page.messages.length; index += 1) {
+                const message = page.messages[index];
+                if (!message || message.timestamp > childCreatedAt) {
+                    break;
+                }
+                leakedInheritedCount += 1;
+            }
+        }
+        if (forkRecord.inheritedPrefixMessageCount !== expectedInheritedCount) {
+            this.sessionForkRepository.upsert({
+                ...forkRecord,
+                inheritedPrefixMessageCount: expectedInheritedCount
+            });
+        }
+        if (leakedInheritedCount <= 0) {
+            return page;
+        }
+        return {
+            ...page,
+            messages: [
+                ...page.messages.slice(0, expectedInheritedCount),
+                ...page.messages.slice(expectedInheritedCount + leakedInheritedCount)
+            ],
+            total: Math.max(0, page.total - leakedInheritedCount)
+        };
+    }
     resolveMessageOrigins(sessionId, messages) {
         const originRepository = this.sessionMessageOriginRepository;
         if (!originRepository || messages.length === 0) {
@@ -1669,7 +1749,13 @@ export class SessionHistoryService {
         return workspace;
     }
     getSessionListItemOrThrow(sessionId, userId) {
-        const item = this.sessionIndexRepository.findBySessionId(sessionId, userId);
+        const canonicalSessionId = this.resolveCanonicalSessionId(sessionId, userId);
+        const item = this.findSessionListItem(canonicalSessionId, sessionId, userId)
+            ?? this.repairMissingSessionListItem(canonicalSessionId, userId)
+            ?? (canonicalSessionId === sessionId
+                ? null
+                : this.repairMissingSessionListItem(sessionId, userId))
+            ?? this.findSessionListItem(canonicalSessionId, sessionId, userId);
         if (!item) {
             throw new AppError({
                 statusCode: 500,
@@ -1683,6 +1769,75 @@ export class SessionHistoryService {
         }
         return this.sessionIndexRepository.findBySessionId(aliasTargetSessionId, userId) ?? item;
     }
+    findSessionListItem(canonicalSessionId, sessionId, userId) {
+        return (this.sessionIndexRepository.findBySessionId(canonicalSessionId, userId)
+            ?? (canonicalSessionId === sessionId
+                ? null
+                : this.sessionIndexRepository.findBySessionId(sessionId, userId)));
+    }
+    repairMissingSessionListItem(sessionId, userId) {
+        const binding = this.sessionBindingRepository.findBySessionId(sessionId);
+        if (!binding) {
+            return null;
+        }
+        const existingIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        const existingSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        const existingState = this.sessionStateRepository.findBySessionAndUser(sessionId, userId);
+        const timestamp = nowIso();
+        const fallbackLastMessageAt = existingIndex?.lastMessageAt
+            ?? existingState?.lastEventAt
+            ?? existingSnapshot?.lastSyncAt
+            ?? null;
+        const fallbackCreatedAt = pickEarlierIso(binding.createdAt, existingIndex?.createdAt ?? null)
+            ?? timestamp;
+        this.db.transaction(() => {
+            this.sessionIndexRepository.upsert({
+                sessionId,
+                workspaceId: binding.workspaceId,
+                provider: binding.provider,
+                parentSessionId: existingIndex?.parentSessionId ?? this.sessionForkRepository.findBySessionId(sessionId)?.parentSessionId ?? null,
+                sessionKind: existingIndex?.sessionKind ?? "default",
+                annotationSourceMessageId: existingIndex?.annotationSourceMessageId ?? null,
+                annotationSourceText: existingIndex?.annotationSourceText ?? null,
+                isSubagent: existingIndex?.isSubagent ?? false,
+                subagentLabel: existingIndex?.subagentLabel ?? null,
+                title: existingIndex?.title?.trim()
+                    || buildRecoveredSessionTitle(binding.provider, binding.providerSessionId),
+                messageCount: existingIndex?.messageCount ?? 0,
+                isArchived: existingIndex?.isArchived ?? false,
+                lastMessageAt: fallbackLastMessageAt,
+                createdAt: fallbackCreatedAt,
+                updatedAt: timestamp
+            });
+            if (!existingSnapshot) {
+                this.sessionStatusSnapshotRepository.upsert({
+                    sessionId,
+                    syncStatus: "idle",
+                    syncCursor: null,
+                    lastSyncAt: fallbackLastMessageAt,
+                    lastErrorCode: null,
+                    lastErrorDetail: null,
+                    resumedAt: null,
+                    updatedAt: timestamp
+                });
+            }
+            if (!existingState) {
+                this.sessionStateRepository.upsert({
+                    sessionId,
+                    userId,
+                    runningState: inferRecoveredSessionRunningState(binding),
+                    activitySource: inferRecoveredSessionActivitySource(binding),
+                    favorite: false,
+                    lastEventAt: shouldRecoverSessionAsActive(binding) ? (binding.updatedAt || timestamp) : fallbackLastMessageAt,
+                    completedAt: null,
+                    lastSeenAt: null,
+                    updatedAt: timestamp
+                });
+            }
+        })();
+        console.warn(`[session-history] repaired missing session index for ${sessionId} (${binding.provider})`);
+        return this.sessionIndexRepository.findBySessionId(sessionId, userId);
+    }
     resolveCanonicalSessionId(sessionId, userId) {
         if (userId) {
             const item = this.sessionIndexRepository.findBySessionId(sessionId, userId);
@@ -1705,11 +1860,11 @@ export class SessionHistoryService {
         return this.sessionBindingRepository.findBySessionId(aliasTargetSessionId);
     }
     findPendingSessionAliasTargetSessionId(descriptor) {
-        if (!descriptor || descriptor.provider !== "gemini") {
+        if (!descriptor) {
             return null;
         }
-        const aliasTargetSessionId = extractPendingBindingTargetSessionId(descriptor.providerSessionId)
-            ?? extractPendingBindingTargetSessionId(descriptor.rawStoreRef);
+        const aliasTargetSessionId = extractSessionAliasTargetSessionId(descriptor.providerSessionId)
+            ?? extractSessionAliasTargetSessionId(descriptor.rawStoreRef);
         if (!aliasTargetSessionId || aliasTargetSessionId === descriptor.sessionId) {
             return null;
         }
@@ -1794,14 +1949,13 @@ export class SessionHistoryService {
         });
         await runBatchedTransactions(staleHiddenSessions.map((session) => session.sessionId), WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, deleteTransaction);
     }
-    findPendingBindingDuplicate(sessionId, workspaceId, currentBinding, snapshot) {
-        if (!currentBinding || !isPendingBindingValue(currentBinding.providerSessionId)) {
-            return null;
-        }
+    findSameWorkspaceBindingDuplicate(sessionId, workspaceId, snapshot) {
         if (isPendingBindingValue(snapshot.providerSessionId)) {
             return null;
         }
-        const existing = this.sessionBindingRepository.findByProviderSession(snapshot.provider, snapshot.providerSessionId) ?? this.sessionBindingRepository.findByRawStoreRef(snapshot.provider, snapshot.rawStoreRef);
+        const existing = this.sessionBindingRepository.findByProviderSession(snapshot.provider, snapshot.providerSessionId) ?? (shouldMatchSessionBindingByRawStoreRef(snapshot.provider)
+            ? this.sessionBindingRepository.findByRawStoreRef(snapshot.provider, snapshot.rawStoreRef)
+            : null);
         if (!existing || existing.sessionId === sessionId) {
             return null;
         }
@@ -1814,11 +1968,22 @@ export class SessionHistoryService {
         if (input.targetSessionId === input.sourceSessionId) {
             return;
         }
-        const targetBinding = this.sessionBindingRepository.findBySessionId(input.targetSessionId);
         const sourceBinding = this.sessionBindingRepository.findBySessionId(input.sourceSessionId);
-        if (!targetBinding || !sourceBinding) {
+        if (!sourceBinding) {
             return;
         }
+        const targetBinding = this.sessionBindingRepository.findBySessionId(input.targetSessionId);
+        if (!targetBinding) {
+            this.sessionBindingRepository.upsert({
+                sessionId: input.targetSessionId,
+                workspaceId: input.workspaceId,
+                provider: input.provider,
+                providerSessionId: buildPendingBindingValue(input.provider, input.targetSessionId),
+                rawStoreRef: buildPendingBindingValue(input.provider, input.targetSessionId),
+                createdAt: sourceBinding.createdAt,
+                updatedAt: input.timestamp
+            });
+        }
         const targetIndex = this.sessionIndexRepository.findIndexRecordBySessionId(input.targetSessionId);
         const sourceIndex = this.sessionIndexRepository.findIndexRecordBySessionId(input.sourceSessionId);
         const targetSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(input.targetSessionId);
@@ -1889,12 +2054,22 @@ export class SessionHistoryService {
         this.db
             .prepare("DELETE FROM session_forks WHERE session_id = ?")
             .run(input.sourceSessionId);
-        this.db
-            .prepare("DELETE FROM session_indices WHERE session_id = ?")
-            .run(input.sourceSessionId);
-        this.db
-            .prepare("DELETE FROM session_bindings WHERE session_id = ?")
-            .run(input.sourceSessionId);
+        // 保留旧 session_id 作为 alias，避免前端或 Butler 还拿着旧 id 时直接炸成 SESSION_NOT_FOUND。
+        this.sessionBindingRepository.upsert({
+            sessionId: input.sourceSessionId,
+            workspaceId: sourceBinding.workspaceId,
+            provider: sourceBinding.provider,
+            providerSessionId: buildAliasBindingValue(input.provider, input.targetSessionId, input.sourceSessionId),
+            rawStoreRef: buildAliasBindingValue(input.provider, input.targetSessionId, input.sourceSessionId),
+            createdAt: sourceBinding.createdAt,
+            updatedAt: input.timestamp
+        });
+        if (sourceIndex) {
+            this.sessionIndexRepository.upsert({
+                ...sourceIndex,
+                updatedAt: input.timestamp
+            });
+        }
         this.rewriteWorkspaceSessionRelations(input.workspaceId, input.targetSessionId, input.sourceSessionId, targetIndex, sourceIndex);
     }
     listSessionStatesBySessionId(sessionId) {
@@ -2020,6 +2195,7 @@ export class SessionHistoryService {
     }
     buildKnownSessionSummaries(sessions, workspacePath) {
         return sessions
+            .filter((session) => !this.isPendingSessionAlias(session))
             .filter((session) => !shouldSkipClaudePendingBinding(session))
             .map((session) => {
             const stats = safeStat(session.rawStoreRef);
@@ -2039,19 +2215,28 @@ export class SessionHistoryService {
     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();
-        const nowMs = Date.parse(timestamp);
-        if (shouldClearStaleRuntimeWithoutInspection(current, inspection, nowMs)) {
-            this.sessionActivityAuthorityService.clearSession(sessionId);
-        }
-        if (shouldPreserveRuntimeTerminalState(current, inspection)) {
-            return current;
+        const liveObservation = this.resolveLiveActivityObservation(sessionId);
+        const inspection = liveObservation
+            ? null
+            : inspectSessionActivity(binding.provider, binding.rawStoreRef);
+        if (inspection) {
+            const nowMs = Date.parse(timestamp);
+            if (shouldClearStaleRuntimeWithoutInspection(current, inspection, nowMs)) {
+                this.sessionActivityAuthorityService.clearSession(sessionId);
+            }
+            if (shouldPreserveRuntimeTerminalState(current, inspection)) {
+                return current;
+            }
         }
-        const resolution = this.sessionActivityAuthorityService.observe(buildInspectionActivityObservation(sessionId, inspection, timestamp));
-        const resolvedLastEventAt = hasInspectionEvidence(inspection)
-            ? resolution.lastObservedAt ?? inspection.lastEventAt ?? current?.lastEventAt ?? null
-            : current?.lastEventAt ?? null;
+        const resolution = liveObservation
+            ? this.sessionActivityAuthorityService.observe(liveObservation)
+            : this.sessionActivityAuthorityService.observe(buildInspectionActivityObservation(sessionId, inspection, timestamp));
+        const resolvedLastEventAt = liveObservation
+            ? resolution.lastObservedAt ?? current?.lastEventAt ?? null
+            : inspection && hasInspectionEvidence(inspection)
+                ? resolution.lastObservedAt ?? inspection.lastEventAt ?? current?.lastEventAt ?? null
+                : current?.lastEventAt ?? null;
         const nextRecord = {
             sessionId,
             userId,
@@ -2060,7 +2245,7 @@ export class SessionHistoryService {
             favorite: current?.favorite ?? false,
             lastEventAt: resolvedLastEventAt,
             completedAt: isTerminalResolvedRunningState(resolution.runningState)
-                ? resolution.terminalAt ?? inspection.completedAtCandidate ?? current?.completedAt ?? null
+                ? resolution.terminalAt ?? inspection?.completedAtCandidate ?? current?.completedAt ?? null
                 : null,
             lastSeenAt: current?.lastSeenAt ?? null,
             updatedAt: timestamp
@@ -2078,8 +2263,8 @@ export class SessionHistoryService {
             syncCursor: currentSnapshot?.syncCursor ?? null,
             lastSyncAt: resolution.lastObservedAt
                 ?? resolution.terminalAt
-                ?? inspection.lastEventAt
-                ?? inspection.completedAtCandidate
+                ?? inspection?.lastEventAt
+                ?? inspection?.completedAtCandidate
                 ?? currentSnapshot?.lastSyncAt
                 ?? null,
             lastErrorCode: resolution.runningState === "failed"
@@ -2097,17 +2282,34 @@ export class SessionHistoryService {
         });
         return nextRecord;
     }
+    resolveLiveActivityObservation(sessionId) {
+        for (const resolver of this.liveActivityObservationResolvers) {
+            const observation = resolver(sessionId);
+            if (observation) {
+                return observation;
+            }
+        }
+        return null;
+    }
     upsertSnapshot(sessionId, input) {
+        const resolvedSessionId = this.resolveCanonicalSessionId(sessionId);
+        if (!this.sessionBindingRepository.findBySessionId(resolvedSessionId)) {
+            return;
+        }
         this.sessionStatusSnapshotRepository.upsert({
-            sessionId,
+            sessionId: resolvedSessionId,
             ...input,
             updatedAt: nowIso()
         });
     }
     markSessionError(sessionId, errorCode, error) {
-        const current = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        const resolvedSessionId = this.resolveCanonicalSessionId(sessionId);
+        if (!this.sessionBindingRepository.findBySessionId(resolvedSessionId)) {
+            return;
+        }
+        const current = this.sessionStatusSnapshotRepository.findBySessionId(resolvedSessionId);
         this.sessionStatusSnapshotRepository.upsert({
-            sessionId,
+            sessionId: resolvedSessionId,
             syncStatus: "error",
             syncCursor: current?.syncCursor ?? null,
             lastSyncAt: current?.lastSyncAt ?? null,
@@ -2167,6 +2369,7 @@ function buildInspectionActivityObservation(sessionId, inspection, observedAt) {
         source: hasInspectionEvidence(inspection) ? "inferred_log" : "unknown",
         confidence: "weak",
         detail: inspection.errorDetail,
+        interruptSource: null,
         errorCode: inspection.errorCode,
         observedAt: inspection.completedAtCandidate ?? inspection.lastEventAt ?? observedAt
     };
@@ -2177,23 +2380,28 @@ function hasInspectionEvidence(inspection) {
         || !!inspection.completedAtCandidate;
 }
 function applySessionActivityResolution(item, resolution) {
-    const runningState = resolution.runningState;
-    const shouldClearResolvedFailure = runningState !== "failed" && item.runningState === "failed";
+    const rawResolvedRunningState = resolution.runningState === "unknown" && item.runningState === null
+        ? null
+        : resolution.runningState;
+    const resolvedRunningState = resolution.activityResolutionSource === "inferred_log" && rawResolvedRunningState === "completed"
+        ? "idle"
+        : rawResolvedRunningState;
+    const shouldClearResolvedFailure = resolvedRunningState !== "failed" && item.runningState === "failed";
     const lastEventAt = resolution.lastObservedAt ?? item.lastEventAt;
-    const completedAt = isTerminalResolvedRunningState(runningState)
+    const completedAt = rawResolvedRunningState && isTerminalResolvedRunningState(rawResolvedRunningState)
         ? resolution.terminalAt ?? item.completedAt
         : null;
-    const lastErrorCode = runningState === "failed"
+    const lastErrorCode = resolvedRunningState === "failed"
         ? resolution.errorCode ?? item.lastErrorCode
         : shouldClearResolvedFailure
             ? null
             : item.lastErrorCode;
-    const lastErrorDetail = runningState === "failed"
+    const lastErrorDetail = resolvedRunningState === "failed"
         ? resolution.detail ?? item.lastErrorDetail
         : shouldClearResolvedFailure
             ? null
             : item.lastErrorDetail;
-    const syncStatus = runningState === "failed"
+    const syncStatus = resolvedRunningState === "failed"
         ? "error"
         : shouldClearResolvedFailure && item.syncStatus === "error"
             ? "idle"
@@ -2201,7 +2409,7 @@ function applySessionActivityResolution(item, resolution) {
     return {
         ...item,
         syncStatus,
-        runningState,
+        runningState: resolvedRunningState,
         activitySource: mapResolutionSourceToCompatibilitySource(resolution.activityResolutionSource),
         activityResolutionSource: resolution.activityResolutionSource,
         activityConfidence: resolution.activityConfidence,
@@ -2211,7 +2419,7 @@ function applySessionActivityResolution(item, resolution) {
         lastErrorCode,
         lastErrorDetail,
         watchdogTriggeredAt: resolution.watchdogTriggeredAt,
-        activityState: resolveActivityState(runningState, completedAt, item.lastSeenAt)
+        activityState: resolveActivityState(resolvedRunningState, completedAt, item.lastSeenAt)
     };
 }
 function clampLimit(limit) {
@@ -2395,6 +2603,35 @@ function normalizeSessionBindingSnapshot(sessionId, snapshot) {
         rawStoreRef: buildPendingBindingValue("claude-code", sessionId)
     };
 }
+function countCommonHistoryPrefixLength(left, right) {
+    const maxLength = Math.min(left.length, right.length);
+    let count = 0;
+    for (; count < maxLength; count += 1) {
+        if (!areHistoryMessagesEquivalent(left[count], right[count])) {
+            break;
+        }
+    }
+    return count;
+}
+function areHistoryMessagesEquivalent(left, right) {
+    if (!left || !right) {
+        return false;
+    }
+    if (left.messageId && right.messageId) {
+        if (left.messageId === right.messageId) {
+            return true;
+        }
+    }
+    if (left.rawRef && right.rawRef) {
+        if (left.rawRef === right.rawRef) {
+            return true;
+        }
+    }
+    return left.role === right.role
+        && left.kind === right.kind
+        && left.content === right.content
+        && left.timestamp === right.timestamp;
+}
 function shouldSkipClaudePendingBinding(binding) {
     if (binding.provider !== "claude-code") {
         return false;
@@ -2407,9 +2644,27 @@ function shouldSkipClaudePendingBinding(binding) {
 function isPendingBindingValue(value) {
     return value.trim().toLowerCase().startsWith("pending://");
 }
+function isSessionBindingProviderUniqueConflict(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.message.includes("UNIQUE constraint failed: session_bindings.provider, session_bindings.provider_session_id");
+}
 function buildPendingBindingValue(provider, sessionId) {
     return `pending://${provider}/${sessionId}`;
 }
+function shouldRecoverSessionAsActive(binding) {
+    return isPendingBindingValue(binding.providerSessionId) || isPendingBindingValue(binding.rawStoreRef);
+}
+function inferRecoveredSessionRunningState(binding) {
+    return shouldRecoverSessionAsActive(binding) ? "starting" : "idle";
+}
+function inferRecoveredSessionActivitySource(binding) {
+    return shouldRecoverSessionAsActive(binding) ? "runtime" : "none";
+}
+function buildAliasBindingValue(provider, targetSessionId, sourceSessionId) {
+    return `alias://${provider}/${targetSessionId}/${sourceSessionId}`;
+}
 function extractPendingBindingTargetSessionId(value) {
     if (!isPendingBindingValue(value)) {
         return null;
@@ -2418,6 +2673,25 @@ function extractPendingBindingTargetSessionId(value) {
     const targetSessionId = normalizedValue.slice(normalizedValue.indexOf("/", "pending://".length) + 1).trim();
     return targetSessionId || null;
 }
+function extractAliasBindingTargetSessionId(value) {
+    const normalizedValue = value.trim();
+    if (!normalizedValue.toLowerCase().startsWith("alias://")) {
+        return null;
+    }
+    const pathStart = normalizedValue.indexOf("/", "alias://".length);
+    if (pathStart < 0) {
+        return null;
+    }
+    const targetAndSource = normalizedValue.slice(pathStart + 1).trim();
+    if (targetAndSource.length === 0) {
+        return null;
+    }
+    const [targetSessionId] = targetAndSource.split("/", 1);
+    return targetSessionId?.trim() || null;
+}
+function extractSessionAliasTargetSessionId(value) {
+    return extractAliasBindingTargetSessionId(value) ?? extractPendingBindingTargetSessionId(value);
+}
 function isClaudePendingRuntimeRawStoreRef(rawStoreRef) {
     const normalizedRawStoreRef = rawStoreRef.replaceAll("\\", "/").toLowerCase();
     return normalizedRawStoreRef.includes("/.pending-");
@@ -2671,6 +2945,9 @@ function isLegacyCodingNsRolloutSession(providerSessionId, rawStoreRef) {
 function shouldRemoveMissingSyntheticCodexSession(rawStoreRef) {
     return isSyntheticCodexRawStoreRef(rawStoreRef) && !existsSync(rawStoreRef);
 }
+function shouldMatchSessionBindingByRawStoreRef(provider) {
+    return provider !== "codex";
+}
 function resolveSessionListTitle(provider, existingTitle, fallbackContent, parentTitle = null) {
     const normalizedExistingTitle = existingTitle?.trim() ?? "";
     const normalizedParentTitle = parentTitle?.trim() ?? "";
@@ -2693,6 +2970,24 @@ function buildUserMessageTitle(content, fallbackTitle) {
     const title = content.trim().replace(/\s+/g, " ");
     return title.slice(0, 48) || fallbackTitle;
 }
+function buildRecoveredSessionTitle(provider, providerSessionId) {
+    if (isPendingBindingValue(providerSessionId)) {
+        return "新会话";
+    }
+    const normalizedProvider = provider.trim().toLowerCase();
+    const providerLabel = normalizedProvider === "claude-code"
+        ? "Claude"
+        : normalizedProvider === "codex"
+            ? "Codex"
+            : normalizedProvider === "gemini"
+                ? "Gemini"
+                : normalizedProvider === "kimi"
+                    ? "Kimi"
+                    : normalizedProvider === "opencode"
+                        ? "OpenCode"
+                        : provider;
+    return `${providerLabel} 会话 ${providerSessionId.slice(0, 8)}`;
+}
 function resolvePersistedSessionTitle(provider, discoveredTitle, existingTitle, parentTitle = null) {
     const nextTitle = discoveredTitle.trim();
     const currentTitle = existingTitle?.trim() ?? "";
@@ -2786,7 +3081,7 @@ function mapResolutionSourceToLegacyActivitySource(source, inspection) {
     if (source === "authoritative_runtime" || source === "authoritative_provider_event") {
         return "runtime";
     }
-    if (inspection.lastEventAt || inspection.completedAtCandidate) {
+    if (inspection && (inspection.lastEventAt || inspection.completedAtCandidate)) {
         return "inferred";
     }
     return "none";