@jingyi0605/codingns 0.3.6 → 0.4.0

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

@@ -32,9 +32,13 @@ const SESSION_START_DEFERRED_PROVIDERS = new Set([
 ]);
 const MUTABLE_HISTORY_TAIL_REFRESH_INTERVAL_MS = 1_200;
 const WORKSPACE_DISCOVERY_BACKGROUND_MAX_AGE_MS = 15_000;
+const WORKSPACE_DISCOVERY_SCAN_CONCURRENCY = 2;
 const PROVIDER_CAPABILITY_CACHE_MAX_AGE_MS = 5_000;
 const WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE = 25;
 const SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS = 150;
+const WORKSPACE_STATE_REFRESH_COOLDOWN_MS = 1_500;
+const SQLITE_BUSY_RETRY_LIMIT = 3;
+const SQLITE_BUSY_RETRY_DELAY_MS = 100;
 export class SessionHistoryService {
     db;
     workspaceRepository;
@@ -59,10 +63,11 @@ export class SessionHistoryService {
     providerSessionDiscoveryConfig;
     taskManager;
     workspaceDiscoveryStatuses = new Map();
-    workspaceStateRefreshInflight = new Map();
+    workspaceStateRefreshStatuses = new Map();
     providerCapabilityCache = new Map();
     liveActivityObservationResolvers = new Set();
     workspaceSessionRelations = new Map();
+    workspaceStateRefreshTaskSequence = 0;
     constructor(db, workspaceRepository, sessionBindingRepository, sessionChangedFileService, sessionIndexRepository, sessionMessageAttachmentService, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService(), sessionMessageOriginRepository = null, sessionForkRepository = null, adapterOverrides = {}, taskManager = createTaskManager()) {
         this.db = db;
         this.workspaceRepository = workspaceRepository;
@@ -159,6 +164,7 @@ export class SessionHistoryService {
             this.taskManager.register({
                 taskType: HOST_TASK_TYPES.workspaceDiscoveryScan,
                 executionLane: "helper_process",
+                concurrency: WORKSPACE_DISCOVERY_SCAN_CONCURRENCY,
                 helperProcessHandler: "session.workspace_discovery",
                 run: async ({ config, workspacePath, knownSessions }, context) => await discoverWorkspaceSessionsInRuntime(config, workspacePath, knownSessions, context.signal)
             });
@@ -319,6 +325,12 @@ export class SessionHistoryService {
             originRef: null
         };
     }
+    resolveMessageOriginByClientRequestId(sessionId, clientRequestId, messageId, updatedAt) {
+        if (!this.sessionMessageOriginRepository || !clientRequestId || !messageId) {
+            return;
+        }
+        this.sessionMessageOriginRepository.resolveMessageId(sessionId, clientRequestId, messageId, updatedAt);
+    }
     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));
@@ -1215,7 +1227,7 @@ export class SessionHistoryService {
                     const existingIndex = existing
                         ? this.sessionIndexRepository.findIndexRecordBySessionId(existing.sessionId)
                         : null;
-                    this.sessionBindingRepository.upsert({
+                    const nextBinding = {
                         sessionId,
                         workspaceId: workspace.id,
                         provider: session.provider,
@@ -1223,7 +1235,10 @@ export class SessionHistoryService {
                         rawStoreRef: session.rawStoreRef,
                         createdAt,
                         updatedAt: timestamp
-                    });
+                    };
+                    if (!areEquivalentSessionBindings(existing, nextBinding)) {
+                        this.sessionBindingRepository.upsert(nextBinding);
+                    }
                     const preservedParentSessionId = existingIndex?.parentSessionId
                         ?? this.sessionForkRepository.findBySessionId(sessionId)?.parentSessionId
                         ?? null;
@@ -1231,7 +1246,7 @@ export class SessionHistoryService {
                         ? this.sessionIndexRepository.findIndexRecordBySessionId(preservedParentSessionId)?.title ?? null
                         : null;
                     const preservedTitle = resolvePersistedSessionTitle(session.provider, session.title, existingIndex?.title ?? null, preservedParentTitle);
-                    this.sessionIndexRepository.upsert({
+                    const nextIndex = {
                         sessionId,
                         workspaceId: workspace.id,
                         provider: session.provider,
@@ -1243,12 +1258,15 @@ export class SessionHistoryService {
                         subagentLabel: existingIndex?.subagentLabel ?? null,
                         title: preservedTitle,
                         messageCount: session.messageCount,
-                        isArchived: resolveDiscoveredArchiveState(existingIndex?.isArchived ?? false, session.isArchived),
+                        isArchived: resolveDiscoveredArchiveState(session.provider, existingIndex?.isArchived ?? false, session.isArchived),
                         lastMessageAt: session.lastMessageAt,
                         createdAt,
                         updatedAt: timestamp
-                    });
-                    this.sessionStatusSnapshotRepository.upsert({
+                    };
+                    if (!areEquivalentSessionIndexRecords(existingIndex, nextIndex)) {
+                        this.sessionIndexRepository.upsert(nextIndex);
+                    }
+                    const nextSnapshot = {
                         sessionId,
                         syncStatus: currentSnapshot?.syncStatus ?? "idle",
                         syncCursor: currentSnapshot?.syncCursor ?? null,
@@ -1257,13 +1275,17 @@ export class SessionHistoryService {
                         lastErrorDetail: currentSnapshot?.lastErrorDetail ?? null,
                         resumedAt: currentSnapshot?.resumedAt ?? null,
                         updatedAt: timestamp
-                    });
+                    };
+                    if (!areEquivalentSessionStatusSnapshots(currentSnapshot, nextSnapshot)) {
+                        this.sessionStatusSnapshotRepository.upsert(nextSnapshot);
+                    }
                     discoveredSessionIds.set(buildProviderSessionKey(session.provider, session.providerSessionId), sessionId);
                     persistedSessions.push({
                         session,
                         sessionId,
                         createdAt,
-                        existingIndex
+                        existingIndex,
+                        pass1Index: nextIndex
                     });
                 }
             });
@@ -1293,7 +1315,7 @@ export class SessionHistoryService {
                     const resolvedParentTitle = resolvedParentSessionId
                         ? this.sessionIndexRepository.findIndexRecordBySessionId(resolvedParentSessionId)?.title ?? null
                         : null;
-                    this.sessionIndexRepository.upsert({
+                    const nextIndex = {
                         sessionId: persistedSession.sessionId,
                         workspaceId: workspace.id,
                         provider: persistedSession.session.provider,
@@ -1315,11 +1337,14 @@ export class SessionHistoryService {
                             ?? null,
                         title: resolvePersistedSessionTitle(persistedSession.session.provider, persistedSession.session.title, persistedSession.existingIndex?.title ?? null, resolvedParentTitle),
                         messageCount: persistedSession.session.messageCount,
-                        isArchived: resolveDiscoveredArchiveState(persistedSession.existingIndex?.isArchived ?? false, persistedSession.session.isArchived),
+                        isArchived: resolveDiscoveredArchiveState(persistedSession.session.provider, persistedSession.existingIndex?.isArchived ?? false, persistedSession.session.isArchived),
                         lastMessageAt: persistedSession.session.lastMessageAt,
                         createdAt: persistedSession.createdAt,
                         updatedAt: timestamp
-                    });
+                    };
+                    if (!areEquivalentSessionIndexRecords(persistedSession.pass1Index, nextIndex)) {
+                        this.sessionIndexRepository.upsert(nextIndex);
+                    }
                 }
             });
             const persistPass2StartedAt = Date.now();
@@ -1387,7 +1412,22 @@ export class SessionHistoryService {
                 discoveredSessions: sessions.length,
                 returnedSessions: nextItems.length,
                 discoveryComplete: discovery.isComplete,
-                providerDiagnostics: (discovery.providerDiagnostics ?? []).map((entry) => `${entry.provider}:${entry.status}:${Math.round(entry.durationMs)}ms`),
+                providerDiagnostics: (discovery.providerDiagnostics ?? []).map((entry) => {
+                    const scannedFiles = entry.scannedFiles ?? 0;
+                    const skippedByMtimeSize = entry.skippedByMtimeSize ?? 0;
+                    const parsedFiles = entry.parsedFiles ?? 0;
+                    const bytesRead = entry.bytesRead ?? 0;
+                    return [
+                        entry.provider,
+                        entry.status,
+                        `${Math.round(entry.durationMs)}ms`,
+                        `sessions=${entry.sessionCount}`,
+                        `scanned=${scannedFiles}`,
+                        `skipped=${skippedByMtimeSize}`,
+                        `parsed=${parsedFiles}`,
+                        `bytes=${bytesRead}`
+                    ].join(":");
+                }),
                 refreshedStates: refreshCandidates.length,
                 discoverMs: discoverDurationMs,
                 persistMs: persistDurationMs,
@@ -1542,13 +1582,6 @@ export class SessionHistoryService {
         const originByMessageId = new Map(originRows
             .filter((row) => row.messageId)
             .map((row) => [row.messageId, row]));
-        const unresolvedRows = originRepository.listUnresolvedBySessionAndContents(sessionId, [...new Set(messages.map((message) => message.content).filter((content) => content.trim().length > 0))]);
-        const unresolvedByContent = new Map();
-        for (const row of unresolvedRows) {
-            const current = unresolvedByContent.get(row.content) ?? [];
-            current.push(row);
-            unresolvedByContent.set(row.content, current);
-        }
         return messages.map((message) => {
             const resolved = originByMessageId.get(message.messageId) ?? null;
             if (resolved) {
@@ -1565,21 +1598,10 @@ export class SessionHistoryService {
                     originRef: null
                 };
             }
-            const candidates = unresolvedByContent.get(message.content) ?? [];
-            const matched = candidates.find((row) => isMessageAtOrAfter(message.timestamp, row.createdAt)) ?? null;
-            if (!matched) {
-                return {
-                    ...message,
-                    origin: null,
-                    originRef: null
-                };
-            }
-            originRepository.resolveMessageId(sessionId, matched.clientRequestId, message.messageId, message.timestamp);
-            unresolvedByContent.set(message.content, candidates.filter((candidate) => candidate.clientRequestId !== matched.clientRequestId));
             return {
                 ...message,
-                origin: matched.origin,
-                originRef: matched.originRef
+                origin: null,
+                originRef: null
             };
         });
     }
@@ -1718,6 +1740,9 @@ export class SessionHistoryService {
         if (shouldSkipClaudePendingBinding(binding)) {
             return;
         }
+        if (!shouldSyncSessionTitleFromProvider(binding.provider, currentIndex.title)) {
+            return;
+        }
         const nextTitle = (await this.providerDiscoveryHelperClient.readSessionTitle({
             config: this.providerSessionDiscoveryConfig,
             provider: binding.provider,
@@ -1926,13 +1951,71 @@ export class SessionHistoryService {
             return;
         }
         const inflightKey = `${workspaceId}:${userId}`;
-        if (this.workspaceStateRefreshInflight.has(inflightKey)) {
+        const refreshState = this.getOrCreateWorkspaceStateRefreshStatus(inflightKey);
+        const now = Date.now();
+        refreshState.lastRequestedAt = now;
+        refreshState.phase = refreshState.phase === "fresh" ? "stale" : refreshState.phase;
+        refreshState.dirtyReasons.add("workspace.discovery.deferred_state_refresh");
+        mergeWorkspaceStateRefreshSessions(refreshState.pendingSessions, sessions);
+        if (refreshState.phase === "running" && refreshState.runningPromise) {
+            return;
+        }
+        if (this.isWorkspaceStateRefreshCoolingDown(refreshState, now)) {
+            refreshState.phase = "stale";
+            this.ensureWorkspaceStateRefreshCooldownTimer(inflightKey, workspaceId, userId, refreshState);
             return;
         }
+        this.startWorkspaceStateRefreshTask(inflightKey, workspaceId, userId, refreshState);
+    }
+    getOrCreateWorkspaceStateRefreshStatus(key) {
+        const existing = this.workspaceStateRefreshStatuses.get(key);
+        if (existing) {
+            return existing;
+        }
+        const created = {
+            phase: "fresh",
+            dirtyReasons: new Set(),
+            pendingSessions: new Map(),
+            runningPromise: null,
+            cooldownTimer: null,
+            lastRequestedAt: null,
+            lastStartedAt: null,
+            lastCompletedAt: null,
+            lastFailedAt: null,
+            nextAllowedAt: null,
+            runningTaskId: null
+        };
+        this.workspaceStateRefreshStatuses.set(key, created);
+        return created;
+    }
+    isWorkspaceStateRefreshCoolingDown(state, now) {
+        if (state.nextAllowedAt === null || now >= state.nextAllowedAt) {
+            return false;
+        }
+        return state.phase === "cooldown" || state.phase === "failed";
+    }
+    startWorkspaceStateRefreshTask(key, workspaceId, userId, state) {
+        if (state.runningPromise) {
+            return;
+        }
+        const sessions = [...state.pendingSessions.values()];
+        if (sessions.length === 0) {
+            state.phase = "fresh";
+            state.dirtyReasons.clear();
+            return;
+        }
+        state.pendingSessions.clear();
+        state.phase = "running";
+        state.lastStartedAt = Date.now();
+        state.runningTaskId = `${key}:${++this.workspaceStateRefreshTaskSequence}`;
         const startedAt = Date.now();
         const task = delay(0)
             .then(() => this.refreshRecentSessionStates(sessions, userId))
             .then(() => {
+            state.lastCompletedAt = Date.now();
+            state.phase = "cooldown";
+            state.nextAllowedAt = state.lastCompletedAt + WORKSPACE_STATE_REFRESH_COOLDOWN_MS;
+            state.dirtyReasons.clear();
             logPerformance("workspace.refresh_recent_session_states", Date.now() - startedAt, {
                 workspaceId,
                 refreshedStates: sessions.length
@@ -1941,6 +2024,9 @@ export class SessionHistoryService {
             });
         })
             .catch((error) => {
+            state.lastFailedAt = Date.now();
+            state.phase = "failed";
+            state.nextAllowedAt = state.lastFailedAt + WORKSPACE_STATE_REFRESH_COOLDOWN_MS;
             logPerformance("workspace.refresh_recent_session_states.failed", Date.now() - startedAt, {
                 workspaceId,
                 refreshedStates: sessions.length,
@@ -1951,9 +2037,42 @@ export class SessionHistoryService {
             });
         })
             .finally(() => {
-            this.workspaceStateRefreshInflight.delete(inflightKey);
+            state.runningPromise = null;
+            state.runningTaskId = null;
+            if (state.pendingSessions.size === 0) {
+                if (state.phase === "cooldown") {
+                    this.ensureWorkspaceStateRefreshCooldownTimer(key, workspaceId, userId, state);
+                    return;
+                }
+                if (state.phase === "failed") {
+                    this.ensureWorkspaceStateRefreshCooldownTimer(key, workspaceId, userId, state);
+                    return;
+                }
+                state.phase = "fresh";
+                return;
+            }
+            state.phase = "stale";
+            this.ensureWorkspaceStateRefreshCooldownTimer(key, workspaceId, userId, state);
         });
-        this.workspaceStateRefreshInflight.set(inflightKey, task);
+        state.runningPromise = task;
+    }
+    ensureWorkspaceStateRefreshCooldownTimer(key, workspaceId, userId, state) {
+        if (state.cooldownTimer) {
+            return;
+        }
+        const now = Date.now();
+        const delayMs = Math.max(0, (state.nextAllowedAt ?? now) - now);
+        state.cooldownTimer = setTimeout(() => {
+            state.cooldownTimer = null;
+            if (state.pendingSessions.size === 0) {
+                state.phase = "fresh";
+                state.dirtyReasons.clear();
+                state.nextAllowedAt = null;
+                return;
+            }
+            state.phase = "stale";
+            this.startWorkspaceStateRefreshTask(key, workspaceId, userId, state);
+        }, delayMs);
     }
     async cleanupStaleHiddenSessions(workspaceId, userId, sessions) {
         const discoveredProviderSessionIds = new Set(sessions.map((session) => buildProviderSessionKey(session.provider, session.providerSessionId)));
@@ -2532,6 +2651,11 @@ function buildSessionStateRefreshCandidates(items, recentCount) {
     }
     return Array.from(deduped.values());
 }
+function mergeWorkspaceStateRefreshSessions(target, sessions) {
+    for (const session of sessions) {
+        target.set(session.sessionId, session);
+    }
+}
 function isSessionStateRefreshCandidate(item) {
     return item.activityState === "running"
         || item.runningState === "starting"
@@ -2609,12 +2733,20 @@ function mergeSessionIndexRecord(input) {
         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),
+        isArchived: mergePersistedArchiveState(input.provider, 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 mergePersistedArchiveState(provider, targetArchived, sourceArchived) {
+    // 只有 Codex 这类真实支持归档的 provider 才认底层归档真相；
+    // 其他 provider 的归档完全由 Host 本地索引维护，不能让旧副本把恢复状态再刷回去。
+    if (shouldUseProviderDiscoveredArchiveState(provider)) {
+        return Boolean(targetArchived || sourceArchived);
+    }
+    return targetArchived ?? sourceArchived ?? false;
+}
 function mergeSessionStatusSnapshot(input) {
     if (!input.target && !input.source) {
         return null;
@@ -2915,12 +3047,16 @@ function isCloseClaudeSessionTimestamp(left, right, maxGapMs = 2 * 60 * 1000) {
     }
     return Math.abs(leftAt - rightAt) <= maxGapMs;
 }
-function resolveDiscoveredArchiveState(existingArchived, discoveredArchived) {
-    if (existingArchived) {
-        return true;
+function resolveDiscoveredArchiveState(provider, existingArchived, discoveredArchived) {
+    if (!shouldUseProviderDiscoveredArchiveState(provider)) {
+        return existingArchived;
     }
     return discoveredArchived === true;
 }
+function shouldUseProviderDiscoveredArchiveState(provider) {
+    // 当前只有 Codex 的归档能稳定映射到底层文件位置；其余 provider 一律信本地 session_indices。
+    return provider === "codex";
+}
 function isMessageAtOrAfter(timestamp, minTimestamp) {
     if (!minTimestamp) {
         return true;
@@ -3153,6 +3289,16 @@ function isSyntheticCodexSessionTitle(title) {
     return (/^rollout-\d{4}-\d{2}-\d{2}t/i.test(title) ||
         /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(title));
 }
+function shouldSyncSessionTitleFromProvider(provider, currentTitle) {
+    const normalizedTitle = currentTitle?.trim() ?? "";
+    if (normalizedTitle.length === 0) {
+        return true;
+    }
+    if (provider === "codex" && isSyntheticCodexSessionTitle(normalizedTitle)) {
+        return true;
+    }
+    return false;
+}
 function shouldRemoveHiddenClaudeDebugSession(session) {
     const normalizedRawStoreRef = session.rawStoreRef.replaceAll("\\", "/");
     if (normalizedRawStoreRef.includes("/subagents/")) {
@@ -3325,6 +3471,56 @@ function getAbortMessage(reason) {
     }
     return "任务已取消";
 }
+function areEquivalentSessionBindings(current, next) {
+    if (!current) {
+        return false;
+    }
+    return (current.sessionId === next.sessionId &&
+        current.workspaceId === next.workspaceId &&
+        current.provider === next.provider &&
+        current.providerSessionId === next.providerSessionId &&
+        current.rawStoreRef === next.rawStoreRef &&
+        current.createdAt === next.createdAt);
+}
+function areEquivalentSessionIndexRecords(current, next) {
+    if (!current) {
+        return false;
+    }
+    return (current.sessionId === next.sessionId &&
+        current.workspaceId === next.workspaceId &&
+        current.provider === next.provider &&
+        (current.parentSessionId ?? null) === (next.parentSessionId ?? null) &&
+        (current.sessionKind ?? "default") === (next.sessionKind ?? "default") &&
+        (current.annotationSourceMessageId ?? null) === (next.annotationSourceMessageId ?? null) &&
+        (current.annotationSourceText ?? null) === (next.annotationSourceText ?? null) &&
+        (current.isSubagent ?? false) === (next.isSubagent ?? false) &&
+        (current.subagentLabel ?? null) === (next.subagentLabel ?? null) &&
+        current.title === next.title &&
+        current.messageCount === next.messageCount &&
+        current.isArchived === next.isArchived &&
+        (current.lastMessageAt ?? null) === (next.lastMessageAt ?? null) &&
+        current.createdAt === next.createdAt);
+}
+function areEquivalentSessionStatusSnapshots(current, next) {
+    if (!current) {
+        return false;
+    }
+    return (current.sessionId === next.sessionId &&
+        current.syncStatus === next.syncStatus &&
+        (current.syncCursor ?? null) === (next.syncCursor ?? null) &&
+        (current.lastSyncAt ?? null) === (next.lastSyncAt ?? null) &&
+        (current.lastErrorCode ?? null) === (next.lastErrorCode ?? null) &&
+        (current.lastErrorDetail ?? null) === (next.lastErrorDetail ?? null) &&
+        (current.resumedAt ?? null) === (next.resumedAt ?? null));
+}
+function isSqliteBusyError(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const sqliteCode = "code" in error ? error.code : null;
+    const message = error instanceof Error ? error.message : String(error);
+    return sqliteCode === "SQLITE_BUSY" || message.includes("database is locked");
+}
 async function runBatchedTransactions(items, batchSize, transaction, logOptions) {
     const normalizedBatchSize = Math.max(1, Math.floor(batchSize) || 1);
     let batchCount = 0;
@@ -3332,7 +3528,20 @@ async function runBatchedTransactions(items, batchSize, transaction, logOptions)
     for (let index = 0; index < items.length; index += normalizedBatchSize) {
         const batch = items.slice(index, index + normalizedBatchSize);
         const batchStartedAt = Date.now();
-        transaction(batch);
+        let retryCount = 0;
+        while (true) {
+            try {
+                transaction(batch);
+                break;
+            }
+            catch (error) {
+                if (!isSqliteBusyError(error) || retryCount >= SQLITE_BUSY_RETRY_LIMIT) {
+                    throw error;
+                }
+                retryCount += 1;
+                await delay(SQLITE_BUSY_RETRY_DELAY_MS * retryCount);
+            }
+        }
         const batchDurationMs = Date.now() - batchStartedAt;
         const nextBatchIndex = batchCount + 1;
         if (logOptions) {
@@ -3341,6 +3550,7 @@ async function runBatchedTransactions(items, batchSize, transaction, logOptions)
                 batchIndex: nextBatchIndex,
                 batchSize: batch.length,
                 batchStartIndex: index,
+                retryCount,
                 totalItems: items.length,
                 configuredBatchSize: normalizedBatchSize
             }, {