@jingyi0605/codingns 0.1.0 → 0.1.2

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

@@ -5,6 +5,7 @@ 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 { SessionActivityAuthorityService } from "./session-activity-authority-service.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";
@@ -21,6 +22,7 @@ export class SessionHistoryService {
     providerRegistry;
     sessionSyncService;
     capabilityService;
+    sessionActivityAuthorityService;
     claudeCodeHomeDir;
     codexModelOptionsService;
     openCodeModelOptionsService;
@@ -28,7 +30,7 @@ export class SessionHistoryService {
     workspaceDiscoveryInflight = new Map();
     workspaceStateRefreshInflight = new Map();
     workspaceSessionRelations = new Map();
-    constructor(db, workspaceRepository, sessionBindingRepository, sessionChangedFileService, sessionIndexRepository, sessionMessageAttachmentService, sessionStateRepository, sessionStatusSnapshotRepository, config) {
+    constructor(db, workspaceRepository, sessionBindingRepository, sessionChangedFileService, sessionIndexRepository, sessionMessageAttachmentService, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService()) {
         this.db = db;
         this.workspaceRepository = workspaceRepository;
         this.sessionBindingRepository = sessionBindingRepository;
@@ -37,6 +39,7 @@ export class SessionHistoryService {
         this.sessionMessageAttachmentService = sessionMessageAttachmentService;
         this.sessionStateRepository = sessionStateRepository;
         this.sessionStatusSnapshotRepository = sessionStatusSnapshotRepository;
+        this.sessionActivityAuthorityService = sessionActivityAuthorityService;
         this.claudeCodeHomeDir = config.claudeCodeHomeDir;
         this.providerRegistry = new ProviderRegistry([
             new ClaudeCodeAdapter({ homeDir: config.claudeCodeHomeDir }),
@@ -345,10 +348,10 @@ export class SessionHistoryService {
             throw mapSessionProviderError(error);
         }
     }
-    async sendMessage(sessionId, content, clientRequestId) {
+    async sendMessage(sessionId, content, clientRequestId, permissionMode = null) {
         const binding = this.getBindingOrThrow(sessionId);
         const result = await this.sessionSyncService
-            .sendMessage(binding.provider, binding.providerSessionId, binding.rawStoreRef, content, clientRequestId)
+            .sendMessage(binding.provider, binding.providerSessionId, binding.rawStoreRef, content, clientRequestId, permissionMode)
             .catch((error) => {
             this.markSessionError(sessionId, "SEND_FAILED", error);
             throw mapSessionProviderError(error);
@@ -397,10 +400,14 @@ export class SessionHistoryService {
             resumedAt: current?.resumedAt ?? null
         });
         try {
-            await this.pullSessionHistory(sessionId, currentCursor, safeLimit, sentMessageIds, onEnvelope, "session.backfill")
-                .then((nextCursor) => {
-                currentCursor = nextCursor;
-            });
+            if (currentCursor === null) {
+                currentCursor = await this.pullRecentSessionHistory(sessionId, safeLimit, sentMessageIds, onEnvelope, "session.backfill");
+            }
+            else {
+                await this.pullSessionHistory(sessionId, currentCursor, safeLimit, sentMessageIds, onEnvelope, "session.backfill").then((nextCursor) => {
+                    currentCursor = nextCursor;
+                });
+            }
         }
         catch (error) {
             this.markSessionError(sessionId, "SUBSCRIBE_FAILED", error);
@@ -566,14 +573,14 @@ export class SessionHistoryService {
         if (!snapshot.providerSessionId || !snapshot.rawStoreRef) {
             return;
         }
-        const resolvedSnapshot = {
+        const resolvedSnapshot = normalizeSessionBindingSnapshot(sessionId, {
             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);
+        const duplicateBinding = this.findPendingBindingDuplicate(sessionId, workspaceId, currentBinding, resolvedSnapshot);
         this.db.transaction(() => {
             if (duplicateBinding) {
                 // 新建运行时会话会先写入 pending 绑定，后台发现链路可能在真 ID 回填前先落一条重复记录。
@@ -613,7 +620,8 @@ export class SessionHistoryService {
         const refreshStateCount = 10;
         try {
             const discoverStartedAt = Date.now();
-            const knownSessions = this.buildKnownSessionSummaries(this.sessionIndexRepository.listByWorkspace(workspaceId, userId), workspace.path);
+            const existingWorkspaceSessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
+            const knownSessions = this.buildKnownSessionSummaries(existingWorkspaceSessions, workspace.path);
             const discovery = await this.sessionSyncService
                 .discoverWorkspaceSessions(workspace.path, {
                 knownSessions
@@ -626,9 +634,22 @@ export class SessionHistoryService {
             const timestamp = nowIso();
             const discoveredSessionIds = new Map();
             const persistedSessions = [];
+            const claimedPendingSessionIds = new Set();
             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 exactExisting = this.sessionBindingRepository.findByProviderSession(session.provider, session.providerSessionId) ?? this.sessionBindingRepository.findByRawStoreRef(session.provider, session.rawStoreRef);
+                    // discover 只能补全当前工作区，不能把别的工作区已有会话偷过来重绑。
+                    if (exactExisting && exactExisting.workspaceId !== workspaceId) {
+                        continue;
+                    }
+                    const pendingDuplicate = exactExisting
+                        ?? findClaudePendingDiscoveryDuplicate(session, existingWorkspaceSessions, claimedPendingSessionIds);
+                    const existing = exactExisting ?? (pendingDuplicate
+                        ? this.sessionBindingRepository.findBySessionId(pendingDuplicate.sessionId)
+                        : null);
+                    if (pendingDuplicate && !exactExisting) {
+                        claimedPendingSessionIds.add(pendingDuplicate.sessionId);
+                    }
                     const currentSnapshot = existing
                         ? this.sessionStatusSnapshotRepository.findBySessionId(existing.sessionId)
                         : null;
@@ -746,6 +767,14 @@ export class SessionHistoryService {
         }
     }
     async readPage(sessionId, provider, providerSessionId, rawStoreRef, cursor, limit, direction = "forward", knownTotalMessageCount = null) {
+        if (shouldShortCircuitClaudePendingHistory(provider, providerSessionId, rawStoreRef)) {
+            return {
+                messages: [],
+                cursor,
+                nextCursor: null,
+                total: 0
+            };
+        }
         if (shouldShortCircuitMissingSyntheticCodexHistory(provider, rawStoreRef)) {
             return {
                 messages: [],
@@ -808,60 +837,38 @@ export class SessionHistoryService {
             if (!relation) {
                 return this.enrichSessionItem(item);
             }
-            return {
+            return this.enrichSessionItem({
                 ...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 {
+        const nextItem = relation
+            ? {
+                ...item,
+                parentSessionId: relation.parentSessionId,
+                isSubagent: relation.isSubagent,
+                subagentLabel: relation.subagentLabel
+            }
+            : {
                 ...item,
                 parentSessionId: item.parentSessionId ?? null,
                 isSubagent: item.isSubagent ?? false,
                 subagentLabel: item.subagentLabel ?? null
             };
-        }
-        return {
-            ...item,
-            parentSessionId: relation.parentSessionId,
-            isSubagent: relation.isSubagent,
-            subagentLabel: relation.subagentLabel
-        };
+        const resolution = this.sessionActivityAuthorityService.resolvePersistedSession(nextItem);
+        return applySessionActivityResolution(nextItem, resolution);
     }
     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
-                });
-            }
+            await this.publishHistoryEnvelope(sessionId, binding, page, sentMessageIds, onEnvelope, envelopeType);
             currentCursor = page.cursor;
             if (!page.nextCursor) {
                 return currentCursor;
@@ -869,6 +876,40 @@ export class SessionHistoryService {
         }
         return currentCursor;
     }
+    async pullRecentSessionHistory(sessionId, limit, sentMessageIds, onEnvelope, envelopeType) {
+        const binding = this.getBindingOrThrow(sessionId);
+        const knownTotalMessageCount = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.messageCount ?? null;
+        const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, null, limit, "backward", knownTotalMessageCount);
+        await this.publishHistoryEnvelope(sessionId, binding, page, sentMessageIds, onEnvelope, envelopeType);
+        return page.cursor;
+    }
+    async publishHistoryEnvelope(sessionId, binding, page, sentMessageIds, onEnvelope, envelopeType) {
+        const messages = page.messages.filter((message) => {
+            if (sentMessageIds.has(message.messageId)) {
+                return false;
+            }
+            sentMessageIds.add(message.messageId);
+            return true;
+        });
+        if (messages.length === 0) {
+            return;
+        }
+        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
+        });
+    }
     async syncSessionTitleFromProvider(sessionId, binding) {
         const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
         if (!currentIndex) {
@@ -1012,7 +1053,7 @@ export class SessionHistoryService {
         });
         remove(sessionIds);
     }
-    findPendingBindingDuplicate(sessionId, currentBinding, snapshot) {
+    findPendingBindingDuplicate(sessionId, workspaceId, currentBinding, snapshot) {
         if (!currentBinding || !isPendingBindingValue(currentBinding.providerSessionId)) {
             return null;
         }
@@ -1023,6 +1064,9 @@ export class SessionHistoryService {
         if (!existing || existing.sessionId === sessionId) {
             return null;
         }
+        if (existing.workspaceId !== workspaceId) {
+            throw new Error("SESSION_BINDING_WORKSPACE_CONFLICT");
+        }
         return existing;
     }
     mergeSessionIntoTarget(input) {
@@ -1214,7 +1258,9 @@ export class SessionHistoryService {
             .run(sessionId);
     }
     buildKnownSessionSummaries(sessions, workspacePath) {
-        return sessions.map((session) => {
+        return sessions
+            .filter((session) => !shouldSkipClaudePendingBinding(session))
+            .map((session) => {
             const stats = safeStat(session.rawStoreRef);
             return {
                 provider: session.provider,
@@ -1237,30 +1283,47 @@ export class SessionHistoryService {
         if (shouldPreserveRuntimeTerminalState(current, inspection)) {
             return current;
         }
+        const resolution = this.sessionActivityAuthorityService.observe(buildInspectionActivityObservation(sessionId, inspection, timestamp));
         const nextRecord = {
             sessionId,
             userId,
-            runningState: inspection.runningState,
-            activitySource: inspection.lastEventAt || inspection.completedAtCandidate ? "inferred" : "none",
+            runningState: mapResolvedRunningStateToStored(resolution.runningState, current),
+            activitySource: mapResolutionSourceToLegacyActivitySource(resolution.activityResolutionSource, inspection),
             favorite: current?.favorite ?? false,
-            lastEventAt: inspection.lastEventAt,
-            completedAt: inspection.completedAtCandidate,
+            lastEventAt: resolution.lastObservedAt ?? inspection.lastEventAt ?? current?.lastEventAt ?? null,
+            completedAt: isTerminalResolvedRunningState(resolution.runningState)
+                ? resolution.terminalAt ?? inspection.completedAtCandidate ?? current?.completedAt ?? null
+                : null,
             lastSeenAt: current?.lastSeenAt ?? null,
             updatedAt: timestamp
         };
         this.sessionStateRepository.upsert(nextRecord);
         const currentSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        const shouldClearRuntimeFailure = current?.runningState === "failed" && resolution.runningState !== "failed";
         this.sessionStatusSnapshotRepository.upsert({
             sessionId,
-            syncStatus: inspection.runningState === "failed" ? "error" : currentSnapshot?.syncStatus ?? "idle",
+            syncStatus: resolution.runningState === "failed"
+                ? "error"
+                : shouldClearRuntimeFailure
+                    ? "idle"
+                    : 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,
+            lastSyncAt: resolution.lastObservedAt
+                ?? resolution.terminalAt
+                ?? inspection.lastEventAt
+                ?? inspection.completedAtCandidate
+                ?? currentSnapshot?.lastSyncAt
+                ?? null,
+            lastErrorCode: resolution.runningState === "failed"
+                ? resolution.errorCode
+                : shouldClearRuntimeFailure
+                    ? null
+                    : currentSnapshot?.lastErrorCode ?? null,
+            lastErrorDetail: resolution.runningState === "failed"
+                ? resolution.detail
+                : shouldClearRuntimeFailure
+                    ? null
+                    : currentSnapshot?.lastErrorDetail ?? null,
             resumedAt: currentSnapshot?.resumedAt ?? null,
             updatedAt: timestamp
         });
@@ -1287,6 +1350,61 @@ export class SessionHistoryService {
         });
     }
 }
+function buildInspectionActivityObservation(sessionId, inspection, observedAt) {
+    return {
+        sessionId,
+        runId: null,
+        runningState: inspection.runningState,
+        source: hasInspectionEvidence(inspection) ? "inferred_log" : "unknown",
+        confidence: "weak",
+        detail: inspection.errorDetail,
+        errorCode: inspection.errorCode,
+        observedAt: inspection.completedAtCandidate ?? inspection.lastEventAt ?? observedAt
+    };
+}
+function hasInspectionEvidence(inspection) {
+    return inspection.runningState !== "idle"
+        || !!inspection.lastEventAt
+        || !!inspection.completedAtCandidate;
+}
+function applySessionActivityResolution(item, resolution) {
+    const runningState = resolution.runningState;
+    const shouldClearResolvedFailure = runningState !== "failed" && item.runningState === "failed";
+    const lastEventAt = resolution.lastObservedAt ?? item.lastEventAt;
+    const completedAt = isTerminalResolvedRunningState(runningState)
+        ? resolution.terminalAt ?? item.completedAt
+        : null;
+    const lastErrorCode = runningState === "failed"
+        ? resolution.errorCode ?? item.lastErrorCode
+        : shouldClearResolvedFailure
+            ? null
+            : item.lastErrorCode;
+    const lastErrorDetail = runningState === "failed"
+        ? resolution.detail ?? item.lastErrorDetail
+        : shouldClearResolvedFailure
+            ? null
+            : item.lastErrorDetail;
+    const syncStatus = runningState === "failed"
+        ? "error"
+        : shouldClearResolvedFailure && item.syncStatus === "error"
+            ? "idle"
+            : item.syncStatus;
+    return {
+        ...item,
+        syncStatus,
+        runningState,
+        activitySource: mapResolutionSourceToCompatibilitySource(resolution.activityResolutionSource),
+        activityResolutionSource: resolution.activityResolutionSource,
+        activityConfidence: resolution.activityConfidence,
+        runId: resolution.runId,
+        lastEventAt,
+        completedAt,
+        lastErrorCode,
+        lastErrorDetail,
+        watchdogTriggeredAt: resolution.watchdogTriggeredAt,
+        activityState: resolveActivityState(runningState, completedAt, item.lastSeenAt)
+    };
+}
 function clampLimit(limit) {
     if (!Number.isFinite(limit)) {
         return 50;
@@ -1439,6 +1557,18 @@ function pickLaterIso(left, right) {
 function buildProviderSessionKey(provider, providerSessionId) {
     return `${provider}::${providerSessionId}`;
 }
+function normalizeSessionBindingSnapshot(sessionId, snapshot) {
+    if (snapshot.provider !== "claude-code" ||
+        !(isPendingBindingValue(snapshot.providerSessionId) ||
+            isClaudePendingRuntimeRawStoreRef(snapshot.rawStoreRef))) {
+        return snapshot;
+    }
+    return {
+        provider: snapshot.provider,
+        providerSessionId: buildPendingBindingValue("claude-code", sessionId),
+        rawStoreRef: buildPendingBindingValue("claude-code", sessionId)
+    };
+}
 function shouldSkipClaudePendingBinding(binding) {
     if (binding.provider !== "claude-code") {
         return false;
@@ -1446,12 +1576,82 @@ function shouldSkipClaudePendingBinding(binding) {
     if (isPendingBindingValue(binding.providerSessionId)) {
         return true;
     }
-    const normalizedRawStoreRef = binding.rawStoreRef.replaceAll("\\", "/").toLowerCase();
-    return normalizedRawStoreRef.includes("/.pending-");
+    return isClaudePendingRuntimeRawStoreRef(binding.rawStoreRef);
 }
 function isPendingBindingValue(value) {
     return value.trim().toLowerCase().startsWith("pending://");
 }
+function buildPendingBindingValue(provider, sessionId) {
+    return `pending://${provider}/${sessionId}`;
+}
+function isClaudePendingRuntimeRawStoreRef(rawStoreRef) {
+    const normalizedRawStoreRef = rawStoreRef.replaceAll("\\", "/").toLowerCase();
+    return normalizedRawStoreRef.includes("/.pending-");
+}
+function shouldShortCircuitClaudePendingHistory(provider, providerSessionId, rawStoreRef) {
+    if (provider !== "claude-code") {
+        return false;
+    }
+    return isPendingBindingValue(providerSessionId) || isPendingBindingValue(rawStoreRef);
+}
+function findClaudePendingDiscoveryDuplicate(session, existingSessions, claimedSessionIds) {
+    if (session.provider !== "claude-code") {
+        return null;
+    }
+    if (isPendingBindingValue(session.providerSessionId)
+        || session.rawStoreRef.replaceAll("\\", "/").toLowerCase().includes("/.pending-")) {
+        return null;
+    }
+    const comparableTitle = normalizeClaudeComparableTitle(session.title);
+    if (!comparableTitle) {
+        return null;
+    }
+    const titleMatchedCandidates = existingSessions.filter((item) => {
+        if (claimedSessionIds.has(item.sessionId)) {
+            return false;
+        }
+        if (item.provider !== "claude-code" || !shouldSkipClaudePendingBinding(item)) {
+            return false;
+        }
+        if (normalizeClaudeComparableTitle(item.title) !== comparableTitle) {
+            return false;
+        }
+        return isCloseClaudeSessionTimestamp(item.lastMessageAt ?? item.createdAt, session.lastMessageAt);
+    });
+    if (titleMatchedCandidates.length === 1) {
+        return titleMatchedCandidates[0];
+    }
+    const activePendingCandidates = existingSessions.filter((item) => {
+        if (claimedSessionIds.has(item.sessionId)) {
+            return false;
+        }
+        if (item.provider !== "claude-code" || !shouldSkipClaudePendingBinding(item)) {
+            return false;
+        }
+        if (item.activitySource !== "runtime") {
+            return false;
+        }
+        if (item.runningState !== "starting" && item.runningState !== "running") {
+            return false;
+        }
+        return isCloseClaudeSessionTimestamp(item.lastMessageAt ?? item.lastEventAt ?? item.createdAt, session.lastMessageAt);
+    });
+    return activePendingCandidates.length === 1 ? activePendingCandidates[0] : null;
+}
+function normalizeClaudeComparableTitle(title) {
+    return title?.trim().replace(/\s+/g, " ").toLowerCase() ?? "";
+}
+function isCloseClaudeSessionTimestamp(left, right, maxGapMs = 2 * 60 * 1000) {
+    if (!left || !right) {
+        return true;
+    }
+    const leftAt = Date.parse(left);
+    const rightAt = Date.parse(right);
+    if (!Number.isFinite(leftAt) || !Number.isFinite(rightAt)) {
+        return true;
+    }
+    return Math.abs(leftAt - rightAt) <= maxGapMs;
+}
 function resolveDiscoveredArchiveState(existingArchived, discoveredArchived) {
     if (existingArchived) {
         return true;
@@ -1548,11 +1748,50 @@ function shouldPreserveRuntimeTerminalState(current, inspection) {
         return inspection.lastEventAt.localeCompare(current.lastEventAt) <= 0;
     }
     if (current.runningState === "starting" || current.runningState === "running") {
-        return inspection.lastEventAt.localeCompare(current.lastEventAt) < 0;
+        return inspection.lastEventAt.localeCompare(current.lastEventAt) <= 0;
     }
     return false;
 }
 function isTerminalRunningState(state) {
     return state === "completed" || state === "interrupted" || state === "failed";
 }
+function isTerminalResolvedRunningState(state) {
+    return state === "completed" || state === "interrupted" || state === "failed";
+}
+function mapResolvedRunningStateToStored(runningState, current) {
+    if (runningState !== "stale" && runningState !== "unknown") {
+        return runningState;
+    }
+    if (current?.runningState === "starting" || current?.runningState === "running") {
+        return current.runningState;
+    }
+    return "running";
+}
+function mapResolutionSourceToLegacyActivitySource(source, inspection) {
+    if (source === "authoritative_runtime" || source === "authoritative_provider_event") {
+        return "runtime";
+    }
+    if (inspection.lastEventAt || inspection.completedAtCandidate) {
+        return "inferred";
+    }
+    return "none";
+}
+function mapResolutionSourceToCompatibilitySource(source) {
+    if (source === "authoritative_runtime" || source === "authoritative_provider_event") {
+        return "runtime";
+    }
+    if (source === "inferred_log") {
+        return "inferred";
+    }
+    return "none";
+}
+function resolveActivityState(runningState, completedAt, lastSeenAt) {
+    if (runningState === "starting" || runningState === "running") {
+        return "running";
+    }
+    if (completedAt && (!lastSeenAt || completedAt > lastSeenAt)) {
+        return "completed_unread";
+    }
+    return "idle";
+}
 //# sourceMappingURL=session-history-service.js.map