@jingyi0605/codingns 0.9.8 → 1.0.0-beta.1

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

@@ -7,6 +7,8 @@ import { createId } from "../../shared/utils/id.js";
 import { logPerformance } from "../../shared/utils/perf-log.js";
 import { isTerminalDebugEnabled, logTerminalDebug, terminalDebugNowMs } from "../../shared/utils/terminal-debug-log.js";
 import { nowIso } from "../../shared/utils/time.js";
+import { SessionDiscoveryDiagnosticsRepository } from "../../storage/repositories/session-discovery-diagnostics-repository.js";
+import { SessionSourceIndexRepository } from "../../storage/repositories/session-source-index-repository.js";
 import { inspectSessionActivity } from "./session-activity-inspector.js";
 import { SessionActivityAuthorityService } from "./session-activity-authority-service.js";
 import { buildSessionTitleFromContent, normalizeRuntimePromptTitle } from "./session-title-utils.js";
@@ -72,6 +74,8 @@ export class SessionHistoryService {
     capabilityService;
     sessionActivityAuthorityService;
     sessionForkRepository;
+    sessionSourceIndexRepository;
+    sessionDiscoveryDiagnosticsRepository;
     providerSessionDeleteCli;
     claudeCodeHomeDir;
     codexModelOptionsService;
@@ -87,6 +91,7 @@ export class SessionHistoryService {
     providerControlRepository;
     taskManager;
     workspaceDiscoveryStatuses = new Map();
+    sessionSourceIndexRepairScopes = new Map();
     workspaceStateRefreshStatuses = new Map();
     providerCapabilityCache = new Map();
     codexDirtyBindingRepairStates = new Map();
@@ -108,6 +113,8 @@ export class SessionHistoryService {
         this.sessionMessageOriginRepository = sessionMessageOriginRepository;
         this.sessionActivityAuthorityService = sessionActivityAuthorityService;
         this.sessionForkRepository = sessionForkRepository ?? new SessionForkRepository(db);
+        this.sessionSourceIndexRepository = new SessionSourceIndexRepository(db);
+        this.sessionDiscoveryDiagnosticsRepository = new SessionDiscoveryDiagnosticsRepository(db);
         this.providerSessionDeleteCli =
             adapterOverrides.providerSessionDeleteCli ?? new CodingnsProviderSessionDeleteCli(config);
         this.taskManager = taskManager;
@@ -185,6 +192,73 @@ export class SessionHistoryService {
     observeBackgroundTaskMetrics() {
         return this.taskManager.observe();
     }
+    listWorkspaceDiscoveryDiagnostics(workspaceId, userId, limit = 20) {
+        this.getDiscoverableWorkspaceForUserOrThrow(workspaceId, userId);
+        const normalizedLimit = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 20;
+        return this.sessionDiscoveryDiagnosticsRepository.listByWorkspaceId(workspaceId, normalizedLimit);
+    }
+    getWorkspaceDiscoveryStatusSummary(workspaceId) {
+        const status = this.workspaceDiscoveryStatuses.get(workspaceId);
+        if (!status) {
+            return null;
+        }
+        return {
+            phase: status.phase,
+            dirtyReasonCount: status.dirtyReasons.size,
+            isComplete: status.isComplete,
+            lastRequestedAt: status.lastRequestedAt,
+            lastStartedAt: status.lastStartedAt,
+            lastCompletedAt: status.lastCompletedAt,
+            lastFailedAt: status.lastFailedAt,
+            nextAllowedAt: status.nextAllowedAt
+        };
+    }
+    async repairSessionSourceIndex(input) {
+        const workspaceId = input.workspaceId.trim();
+        const userId = input.userId.trim();
+        this.getDiscoverableWorkspaceForUserOrThrow(workspaceId, userId);
+        const provider = normalizeOptionalText(input.provider);
+        if (provider && !this.providerRegistry.list().some((adapter) => adapter.providerId === provider)) {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "INVALID_INPUT",
+                detail: "provider 不存在或当前不受支持",
+                field: "provider"
+            });
+        }
+        const sourceKeys = normalizeDistinctTexts(input.sourceKeys);
+        const rawStoreRefs = normalizeDistinctTexts(input.rawStoreRefs);
+        const existingRecords = this.sessionSourceIndexRepository.listByWorkspaceId(workspaceId);
+        const matchedRecords = existingRecords.filter((record) => matchesSessionSourceIndexRepairScope(record, provider, sourceKeys, rawStoreRefs));
+        const deletedSourceKeys = matchedRecords.map((record) => record.sourceKey);
+        const clearedSourceCount = this.sessionSourceIndexRepository.deleteBySourceKeys(deletedSourceKeys);
+        this.sessionSourceIndexRepairScopes.set(workspaceId, {
+            provider,
+            sourceKeys: new Set(sourceKeys),
+            rawStoreRefs: new Set(rawStoreRefs)
+        });
+        const awaitDiscovery = input.awaitDiscovery === true;
+        if (awaitDiscovery) {
+            await this.discoverWorkspaceSessions(workspaceId, userId, {
+                force: true,
+                refreshStateMode: "deferred"
+            });
+        }
+        else {
+            this.requestWorkspaceDiscovery(workspaceId, userId, {
+                force: true,
+                refreshStateMode: "deferred"
+            });
+        }
+        return {
+            workspaceId,
+            provider,
+            sourceKeyCount: sourceKeys.length,
+            rawStoreRefCount: rawStoreRefs.length,
+            clearedSourceCount,
+            awaitDiscovery
+        };
+    }
     registerLiveActivityObservationResolver(resolver) {
         this.liveActivityObservationResolvers.add(resolver);
         let closed = false;
@@ -219,7 +293,7 @@ export class SessionHistoryService {
             this.taskManager.register({
                 taskType: HOST_TASK_TYPES.workspaceDiscovery,
                 executionLane: "host_background",
-                run: async ({ workspaceId, userId, refreshStateMode }, context) => this.runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode, context.signal)
+                run: async ({ workspaceId, userId, refreshStateMode }, context) => this.runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode, context.signal, context.taskId)
             });
         }
         if (!this.taskManager.has(HOST_TASK_TYPES.workspaceDiscoveryScan)) {
@@ -255,24 +329,21 @@ export class SessionHistoryService {
         }
     }
     async discoverWorkspaceSessions(workspaceId, userId, options) {
+        this.getDiscoverableWorkspaceForUserOrThrow(workspaceId, userId);
+        this.markWorkspaceDiscoveryRequested(workspaceId, "session_history.discover_workspace_sessions");
         const maxAgeMs = options?.maxAgeMs ?? 0;
         const force = options?.force ?? false;
         const discoveryStatus = this.workspaceDiscoveryStatuses.get(workspaceId);
-        const lastRefreshedAt = discoveryStatus?.refreshedAt ?? 0;
         const now = Date.now();
-        const isPartialCoolingDown = discoveryStatus?.isComplete === false &&
-            discoveryStatus.partialCooldownUntil !== null &&
-            now < discoveryStatus.partialCooldownUntil;
-        const isCompleteAndFresh = discoveryStatus?.isComplete === true &&
-            maxAgeMs > 0 &&
-            now - lastRefreshedAt <= maxAgeMs;
+        const isPartialCoolingDown = this.isWorkspaceDiscoveryPartialCoolingDown(discoveryStatus, now);
+        const isCompleteAndFresh = this.isWorkspaceDiscoveryCompleteAndFresh(discoveryStatus, maxAgeMs, now);
         if (!force &&
             discoveryStatus &&
             (isPartialCoolingDown || isCompleteAndFresh)) {
             this.taskManager.recordCacheHit(HOST_TASK_TYPES.workspaceDiscovery, workspaceId);
             return this.listWorkspaceSessions(workspaceId, userId);
         }
-        return this.taskManager.enqueue(HOST_TASK_TYPES.workspaceDiscovery, {
+        const handle = this.taskManager.enqueue(HOST_TASK_TYPES.workspaceDiscovery, {
             key: workspaceId,
             source: "session_history.discover_workspace_sessions",
             input: {
@@ -280,11 +351,22 @@ export class SessionHistoryService {
                 userId,
                 refreshStateMode: options?.refreshStateMode ?? "inline"
             }
-        }).promise;
+        });
+        if (options?.signal) {
+            return await awaitTaskHandleWithSignal(handle, options.signal);
+        }
+        return await handle.promise;
     }
     requestWorkspaceDiscovery(workspaceId, userId, options) {
         const maxAgeMs = options?.maxAgeMs ?? WORKSPACE_DISCOVERY_BACKGROUND_MAX_AGE_MS;
         const force = options?.force ?? false;
+        if (!this.isWorkspaceDiscoverableForUser(workspaceId, userId)) {
+            return;
+        }
+        const discoveryStatus = this.markWorkspaceDiscoveryRequested(workspaceId, "session_history.request_workspace_discovery");
+        if (!force && discoveryStatus.phase === "running") {
+            return;
+        }
         if (!force && !this.needsWorkspaceDiscovery(workspaceId, maxAgeMs)) {
             return;
         }
@@ -312,19 +394,27 @@ export class SessionHistoryService {
         });
     }
     needsWorkspaceDiscovery(workspaceId, maxAgeMs) {
-        if (maxAgeMs <= 0) {
-            return true;
-        }
         const discoveryStatus = this.workspaceDiscoveryStatuses.get(workspaceId);
         if (!discoveryStatus) {
             return true;
         }
+        if (discoveryStatus.phase === "running") {
+            return false;
+        }
+        if (discoveryStatus.phase === "failed") {
+            return true;
+        }
+        if (discoveryStatus.dirtyReasons.size > 0) {
+            return true;
+        }
         if (!discoveryStatus.isComplete &&
-            (discoveryStatus.partialCooldownUntil === null ||
-                Date.now() >= discoveryStatus.partialCooldownUntil)) {
+            !this.isWorkspaceDiscoveryPartialCoolingDown(discoveryStatus, Date.now())) {
+            return true;
+        }
+        if (maxAgeMs <= 0) {
             return true;
         }
-        return Date.now() - discoveryStatus.refreshedAt > maxAgeMs;
+        return !this.isWorkspaceDiscoveryCompleteAndFresh(discoveryStatus, maxAgeMs, Date.now());
     }
     async readSessionHistory(sessionId, cursor, limit, direction = "forward", userId) {
         const startedAt = Date.now();
@@ -1433,10 +1523,14 @@ export class SessionHistoryService {
             }
         }
     }
-    async runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode = "inline", signal) {
+    async runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode = "inline", signal, taskId) {
         const startedAt = Date.now();
         const debugStartedAtMs = terminalDebugNowMs();
-        const workspace = this.getWorkspaceForUserOrThrow(workspaceId, userId);
+        const workspace = this.getDiscoverableWorkspaceForUserOrThrow(workspaceId, userId);
+        const discoveryStatus = this.getOrCreateWorkspaceDiscoveryStatus(workspaceId);
+        discoveryStatus.phase = "running";
+        discoveryStatus.lastStartedAt = startedAt;
+        discoveryStatus.runningTaskId = taskId ?? `workspace.discovery:${workspaceId}:${startedAt}`;
         let discoverDurationMs = 0;
         let persistDurationMs = 0;
         let persistPass1DurationMs = 0;
@@ -1450,14 +1544,16 @@ export class SessionHistoryService {
         let listItemsDurationMs = 0;
         let refreshStateDurationMs = 0;
         const refreshStateCount = 10;
+        const activeRepairScope = this.sessionSourceIndexRepairScopes.get(workspaceId) ?? null;
         try {
             const discoverStartedAt = Date.now();
             const existingWorkspaceSessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
+            const existingWorkspaceSourceIndexes = this.sessionSourceIndexRepository.listByWorkspaceId(workspaceId);
             const enabledProviders = this.providerRegistry
                 .list()
                 .map((adapter) => adapter.providerId)
                 .filter((providerId) => this.isProviderEnabled(providerId));
-            const knownSessions = this.buildKnownSessionSummaries(existingWorkspaceSessions.filter((session) => enabledProviders.includes(session.provider)), workspace.path);
+            const knownSessions = this.buildKnownSessionSummaries(existingWorkspaceSessions.filter((session) => enabledProviders.includes(session.provider)), existingWorkspaceSourceIndexes.filter((record) => enabledProviders.includes(record.provider)), workspace.path, activeRepairScope);
             const discoveryHandle = this.taskManager.enqueue(HOST_TASK_TYPES.workspaceDiscoveryScan, {
                 key: workspaceId,
                 source: "session_history.workspace_discovery.scan",
@@ -1474,6 +1570,7 @@ export class SessionHistoryService {
             const sessions = discovery.sessions;
             discoverDurationMs = Date.now() - discoverStartedAt;
             const timestamp = nowIso();
+            this.persistDiscoveryDiagnostics(workspaceId, "session_history.workspace_discovery.scan", discovery, timestamp);
             const discoveredSessionIds = new Map();
             const persistedSessions = [];
             const claimedPendingSessionIds = new Set();
@@ -1642,6 +1739,7 @@ export class SessionHistoryService {
             persistPass2DurationMs = Date.now() - persistPass2StartedAt;
             persistPass2BatchCount = persistPass2Stats.batchCount;
             persistPass2MaxBatchMs = persistPass2Stats.maxBatchMs;
+            this.persistSessionSourceIndexRecords(workspaceId, workspace.path, sessions, existingWorkspaceSourceIndexes, timestamp);
             persistDurationMs = persistPass1DurationMs + relationMapDurationMs + persistPass2DurationMs;
             if (discovery.isComplete) {
                 const cleanupStartedAt = Date.now();
@@ -1655,11 +1753,19 @@ export class SessionHistoryService {
             listItemsDurationMs = Date.now() - listItemsStartedAt;
             const refreshCandidates = buildSessionStateRefreshCandidates(items, refreshStateCount);
             this.workspaceDiscoveryStatuses.set(workspaceId, {
+                ...discoveryStatus,
+                phase: discovery.isComplete ? "fresh" : "cooldown",
+                dirtyReasons: new Set(),
                 refreshedAt: Date.now(),
                 isComplete: discovery.isComplete,
                 partialCooldownUntil: discovery.isComplete
                     ? null
-                    : Date.now() + WORKSPACE_DISCOVERY_PARTIAL_COOLDOWN_MS
+                    : Date.now() + WORKSPACE_DISCOVERY_PARTIAL_COOLDOWN_MS,
+                lastCompletedAt: Date.now(),
+                nextAllowedAt: discovery.isComplete
+                    ? null
+                    : Date.now() + WORKSPACE_DISCOVERY_PARTIAL_COOLDOWN_MS,
+                runningTaskId: null
             });
             const refreshStateStartedAt = Date.now();
             if (refreshStateMode === "inline") {
@@ -1734,6 +1840,13 @@ export class SessionHistoryService {
             return nextItems;
         }
         catch (error) {
+            const failedAt = Date.now();
+            this.workspaceDiscoveryStatuses.set(workspaceId, {
+                ...discoveryStatus,
+                phase: "failed",
+                lastFailedAt: failedAt,
+                runningTaskId: null
+            });
             logPerformance("workspace.discover_sessions.failed", Date.now() - startedAt, {
                 workspaceId,
                 workspacePath: workspace.path,
@@ -1757,6 +1870,11 @@ export class SessionHistoryService {
             });
             throw error;
         }
+        finally {
+            if (activeRepairScope) {
+                this.sessionSourceIndexRepairScopes.delete(workspaceId);
+            }
+        }
     }
     async readPage(sessionId, provider, providerSessionId, rawStoreRef, cursor, limit, direction = "forward", knownTotalMessageCount = null) {
         if (shouldShortCircuitClaudePendingHistory(provider, providerSessionId, rawStoreRef)) {
@@ -2450,6 +2568,65 @@ export class SessionHistoryService {
         }
         return workspace;
     }
+    getOrCreateWorkspaceDiscoveryStatus(workspaceId) {
+        const existing = this.workspaceDiscoveryStatuses.get(workspaceId);
+        if (existing) {
+            return existing;
+        }
+        const created = {
+            phase: "fresh",
+            dirtyReasons: new Set(),
+            refreshedAt: 0,
+            isComplete: false,
+            partialCooldownUntil: null,
+            lastRequestedAt: null,
+            lastStartedAt: null,
+            lastCompletedAt: null,
+            lastFailedAt: null,
+            nextAllowedAt: null,
+            runningTaskId: null
+        };
+        this.workspaceDiscoveryStatuses.set(workspaceId, created);
+        return created;
+    }
+    markWorkspaceDiscoveryRequested(workspaceId, reason) {
+        const status = this.getOrCreateWorkspaceDiscoveryStatus(workspaceId);
+        status.lastRequestedAt = Date.now();
+        if (status.phase === "running") {
+            status.dirtyReasons.add(reason);
+        }
+        return status;
+    }
+    isWorkspaceDiscoveryPartialCoolingDown(status, now) {
+        return Boolean(status
+            && status.isComplete === false
+            && status.partialCooldownUntil !== null
+            && now < status.partialCooldownUntil);
+    }
+    isWorkspaceDiscoveryCompleteAndFresh(status, maxAgeMs, now) {
+        if (!status || !status.isComplete || maxAgeMs <= 0) {
+            return false;
+        }
+        return now - status.refreshedAt <= maxAgeMs;
+    }
+    isWorkspaceDiscoverableForUser(workspaceId, userId) {
+        const workspace = this.workspaceRepository.findById(workspaceId);
+        if (!workspace || workspace.removedAt || workspace.ownerUserId !== userId) {
+            return false;
+        }
+        return true;
+    }
+    getDiscoverableWorkspaceForUserOrThrow(workspaceId, userId) {
+        const workspace = this.getWorkspaceForUserOrThrow(workspaceId, userId);
+        if (workspace.removedAt) {
+            throw new AppError({
+                statusCode: 404,
+                errorCode: "WORKSPACE_NOT_FOUND",
+                detail: "工作区不存在"
+            });
+        }
+        return workspace;
+    }
     getBindingForUserOrThrow(sessionId, userId) {
         const binding = this.sessionBindingRepository.findBySessionIdForUser(sessionId, userId);
         if (!binding) {
@@ -3189,24 +3366,121 @@ export class SessionHistoryService {
             }
         }
     }
-    buildKnownSessionSummaries(sessions, workspacePath) {
-        return sessions
-            .filter((session) => !this.isPendingSessionAlias(session))
-            .filter((session) => !shouldSkipClaudePendingBinding(session))
-            .map((session) => {
+    buildKnownSessionSummaries(sessions, sourceIndexes, workspacePath, repairScope = null) {
+        const merged = new Map();
+        for (const session of sessions) {
+            if (this.isPendingSessionAlias(session) || shouldSkipClaudePendingBinding(session)) {
+                continue;
+            }
+            const sourceKey = buildSessionSourceKey(session.provider, session.providerSessionId, session.rawStoreRef);
+            if (shouldExcludeKnownSessionFromRepairScope(repairScope, session.provider, sourceKey, session.rawStoreRef)) {
+                continue;
+            }
             const stats = safeStat(session.rawStoreRef);
-            return {
+            const summary = {
                 provider: session.provider,
                 providerSessionId: session.providerSessionId,
                 title: session.title,
                 workspacePath,
                 rawStoreRef: session.rawStoreRef,
+                isArchived: session.isArchived,
                 lastMessageAt: session.lastMessageAt,
                 messageCount: session.messageCount,
                 sourceMtimeMs: stats?.mtimeMs,
                 sourceSizeBytes: stats?.size
             };
-        });
+            merged.set(buildKnownSessionSummaryKey(summary.provider, summary.providerSessionId, summary.rawStoreRef), summary);
+        }
+        for (const record of sourceIndexes) {
+            if (record.deletedAt) {
+                continue;
+            }
+            if (!record.providerSessionId || !record.rawStoreRef) {
+                continue;
+            }
+            if (shouldExcludeKnownSessionFromRepairScope(repairScope, record.provider, record.sourceKey, record.rawStoreRef)) {
+                continue;
+            }
+            const key = buildKnownSessionSummaryKey(record.provider, record.providerSessionId, record.rawStoreRef);
+            if (merged.has(key)) {
+                continue;
+            }
+            merged.set(key, {
+                provider: record.provider,
+                providerSessionId: record.providerSessionId,
+                title: record.title?.trim() || record.providerSessionId,
+                workspacePath: record.workspacePath?.trim() || workspacePath,
+                rawStoreRef: record.rawStoreRef,
+                isArchived: record.isArchivedHint ?? undefined,
+                lastMessageAt: record.lastMessageAt,
+                messageCount: Math.max(0, record.messageCount ?? 0),
+                sourceMtimeMs: record.fingerprintMtimeMs ?? undefined,
+                sourceSizeBytes: record.fingerprintSizeBytes ?? undefined
+            });
+        }
+        return [...merged.values()];
+    }
+    persistSessionSourceIndexRecords(workspaceId, workspacePath, sessions, existingSourceIndexes, timestamp) {
+        const existingByKey = new Map(existingSourceIndexes.map((record) => [record.sourceKey, record]));
+        for (const session of sessions) {
+            const sourceKind = inferSessionSourceKind(session.rawStoreRef);
+            const sourceKey = buildSessionSourceKey(session.provider, session.providerSessionId, session.rawStoreRef);
+            const stats = safeStat(session.rawStoreRef);
+            const existing = existingByKey.get(sourceKey);
+            this.sessionSourceIndexRepository.upsert({
+                sourceKey,
+                provider: session.provider,
+                sourceKind,
+                workspaceId,
+                providerSessionId: session.providerSessionId,
+                rawStoreRef: session.rawStoreRef,
+                workspacePath,
+                fingerprintMtimeMs: stats?.mtimeMs ?? existing?.fingerprintMtimeMs ?? null,
+                fingerprintSizeBytes: stats?.size ?? existing?.fingerprintSizeBytes ?? null,
+                fingerprintInode: existing?.fingerprintInode ?? null,
+                fingerprintVersion: existing?.fingerprintVersion ?? null,
+                title: session.title,
+                messageCount: session.messageCount,
+                lastMessageAt: session.lastMessageAt,
+                isArchivedHint: session.isArchived ?? existing?.isArchivedHint ?? null,
+                lastParsedAt: timestamp,
+                lastVerifiedAt: timestamp,
+                sampleDueAt: existing?.sampleDueAt ?? null,
+                deletedAt: null,
+                createdAt: existing?.createdAt ?? timestamp,
+                updatedAt: timestamp
+            });
+        }
+    }
+    persistDiscoveryDiagnostics(workspaceId, triggerSource, discovery, timestamp) {
+        try {
+            for (const entry of discovery.providerDiagnostics ?? []) {
+                const record = {
+                    id: createId(),
+                    workspaceId,
+                    triggerSource,
+                    provider: entry.provider,
+                    isComplete: entry.isComplete,
+                    status: entry.status,
+                    durationMs: Math.max(0, Math.round(entry.durationMs)),
+                    sessionCount: Math.max(0, entry.sessionCount),
+                    scannedFiles: Math.max(0, entry.scannedFiles ?? 0),
+                    skippedByFingerprint: Math.max(0, entry.skippedByMtimeSize ?? 0),
+                    parsedFiles: Math.max(0, entry.parsedFiles ?? 0),
+                    bytesRead: Math.max(0, entry.bytesRead ?? 0),
+                    createdAt: timestamp
+                };
+                this.sessionDiscoveryDiagnosticsRepository.insert(record);
+            }
+        }
+        catch (error) {
+            console.warn("[session-discovery-diagnostics-persist-failed]", {
+                workspaceId,
+                triggerSource,
+                providerCount: discovery.providerDiagnostics?.length ?? 0,
+                error
+            });
+        }
     }
     async refreshSessionState(sessionId, userId) {
         const binding = this.getBindingOrThrow(sessionId);
@@ -3783,6 +4057,67 @@ function pickLaterIso(left, right) {
 function buildProviderSessionKey(provider, providerSessionId) {
     return `${provider}::${providerSessionId}`;
 }
+function normalizeOptionalText(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : null;
+}
+function normalizeDistinctTexts(values) {
+    if (!Array.isArray(values)) {
+        return [];
+    }
+    const unique = new Set();
+    for (const value of values) {
+        const normalized = value?.trim();
+        if (normalized) {
+            unique.add(normalized);
+        }
+    }
+    return [...unique];
+}
+function matchesSessionSourceIndexRepairScope(record, provider, sourceKeys, rawStoreRefs) {
+    if (provider && record.provider !== provider) {
+        return false;
+    }
+    if (sourceKeys.length === 0 && rawStoreRefs.length === 0) {
+        return true;
+    }
+    return sourceKeys.includes(record.sourceKey)
+        || (record.rawStoreRef ? rawStoreRefs.includes(record.rawStoreRef) : false);
+}
+function shouldExcludeKnownSessionFromRepairScope(scope, provider, sourceKey, rawStoreRef) {
+    if (!scope) {
+        return false;
+    }
+    if (scope.provider && scope.provider !== provider) {
+        return false;
+    }
+    if (scope.sourceKeys.size === 0 && scope.rawStoreRefs.size === 0) {
+        return true;
+    }
+    return scope.sourceKeys.has(sourceKey) || scope.rawStoreRefs.has(rawStoreRef);
+}
+function buildKnownSessionSummaryKey(provider, providerSessionId, rawStoreRef) {
+    return `${provider}::${providerSessionId}::${rawStoreRef}`;
+}
+function buildSessionSourceKey(provider, providerSessionId, rawStoreRef) {
+    const normalizedRawStoreRef = rawStoreRef.trim();
+    if (normalizedRawStoreRef.length > 0) {
+        return `${provider}:raw:${normalizedRawStoreRef}`;
+    }
+    return `${provider}:session:${providerSessionId}`;
+}
+function inferSessionSourceKind(rawStoreRef) {
+    if (rawStoreRef.endsWith(".jsonl")) {
+        return "jsonl";
+    }
+    if (rawStoreRef.startsWith("opencode://") || rawStoreRef.startsWith("server://")) {
+        return "server_session";
+    }
+    if (rawStoreRef.endsWith(".sqlite") || rawStoreRef.includes(".sqlite:")) {
+        return "sqlite_row";
+    }
+    return "index_entry";
+}
 function normalizeSessionBindingSnapshot(sessionId, snapshot) {
     if (snapshot.provider !== "claude-code" ||
         !(isPendingBindingValue(snapshot.providerSessionId) ||