yepanywhere 0.5.2 → 0.6.0

package/dist/indexes/SessionIndexService.js

@@ -14,9 +14,14 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { DEFAULT_PROVIDER, } from "../../bundled/@yep-anywhere/shared/dist/index.js";
 import { getLogger } from "../logging/logger.js";
-const logger = getLogger();
+import { getProjectIdentityKey } from "../projects/paths.js";
+import { readCodexRolloutMetadata, } from "../sessions/codex-discovery.js";
+import { getCodexRolloutDiscoveryIdentity, getCodexRolloutSessionId, } from "../utils/codexRolloutFiles.js";
+import { SessionDiscoveryIndex } from "./SessionDiscoveryIndex.js";
 const LOG_CACHE_PERF = process.env.SESSION_INDEX_LOG_PERF === "true";
-const CURRENT_VERSION = 1;
+const DEFAULT_SUMMARY_PARSE_CONCURRENCY = 1;
+const DEFAULT_WARMUP_PROGRESS_LOG_INTERVAL_MS = 5000;
+const CURRENT_VERSION = 2;
 /**
  * Claude-specific session index service.
  *
@@ -34,11 +39,27 @@ export class SessionIndexService {
     fullValidationIntervalMs;
     writeLockTimeoutMs;
     writeLockStaleMs;
+    summaryParseConcurrency;
+    warmupProgressLogIntervalMs;
     lastFullValidationAt = new Map();
     dirtyDirs = new Set();
     dirtySessionsByDir = new Map();
+    /** Scopes with a persisted index file (loaded or written this run). */
+    persistedIndexScopes = new Set();
+    /** In-flight background full validations, keyed by validation key. */
+    backgroundValidations = new Map();
+    /** Serializes background validations to bound concurrent I/O. */
+    backgroundValidationChain = Promise.resolve();
     inFlightSessionLoads = new Map();
+    inFlightSessionSummaryLoads = new Map();
     inFlightTitleLoads = new Map();
+    inFlightSummaryParses = new Map();
+    codexDiscoveryIndexes = new Map();
+    summaryParseQueue = [];
+    activeSummaryParses = 0;
+    warmupJobs = new Map();
+    recentWarmupJobs = [];
+    warmupProgressTimer = null;
     cacheStats = {
         requests: 0,
         fastHits: 0,
@@ -49,6 +70,7 @@ export class SessionIndexService {
         totalDurationMs: 0,
     };
     unsubscribeEventBus = null;
+    eventBus = null;
     constructor(options = {}) {
         const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
         this.dataDir =
@@ -59,7 +81,11 @@ export class SessionIndexService {
         this.fullValidationIntervalMs = Math.max(0, options.fullValidationIntervalMs ?? 0);
         this.writeLockTimeoutMs = Math.max(0, options.writeLockTimeoutMs ?? 2000);
         this.writeLockStaleMs = Math.max(1000, options.writeLockStaleMs ?? 10000);
+        this.summaryParseConcurrency = Math.max(1, Math.floor(options.summaryParseConcurrency ?? DEFAULT_SUMMARY_PARSE_CONCURRENCY));
+        this.warmupProgressLogIntervalMs = Math.max(1000, options.warmupProgressLogIntervalMs ??
+            DEFAULT_WARMUP_PROGRESS_LOG_INTERVAL_MS);
         if (options.eventBus) {
+            this.eventBus = options.eventBus;
             this.unsubscribeEventBus = options.eventBus.subscribe((event) => {
                 if (event.type !== "file-change")
                     return;
@@ -79,7 +105,7 @@ export class SessionIndexService {
             const firstKey = this.indexCache.keys().next().value;
             if (firstKey) {
                 this.indexCache.delete(firstKey);
-                logger.debug(`[SessionIndexService] Evicted cache entry for ${firstKey} (cache size: ${this.indexCache.size})`);
+                getLogger().debug(`[SessionIndexService] Evicted cache entry for ${firstKey} (cache size: ${this.indexCache.size})`);
             }
             else {
                 break;
@@ -147,6 +173,7 @@ export class SessionIndexService {
             if (parsed.version === CURRENT_VERSION &&
                 parsed.projectId === projectId) {
                 this.indexCache.set(cacheKey, parsed);
+                this.persistedIndexScopes.add(cacheKey);
                 this.evictIfNeeded();
                 return parsed;
             }
@@ -163,7 +190,7 @@ export class SessionIndexService {
         catch (error) {
             // File doesn't exist or is invalid - start fresh
             if (error.code !== "ENOENT") {
-                logger.warn({ err: error }, `[SessionIndexService] Failed to load index for ${scopeKey}, starting fresh`);
+                getLogger().warn({ err: error }, `[SessionIndexService] Failed to load index for ${scopeKey}, starting fresh`);
             }
             const fresh = {
                 version: CURRENT_VERSION,
@@ -217,12 +244,13 @@ export class SessionIndexService {
                 await fs.writeFile(tempPath, content, "utf-8");
                 await fs.rename(tempPath, indexPath);
             });
+            this.persistedIndexScopes.add(scopeKey);
         }
         catch (error) {
             await fs.unlink(tempPath).catch(() => {
                 // Best-effort cleanup for failed atomic writes.
             });
-            logger.error({ err: error }, `[SessionIndexService] Failed to save index for ${scopeKey}`);
+            getLogger().error({ err: error }, `[SessionIndexService] Failed to save index for ${scopeKey}`);
             throw error;
         }
     }
@@ -294,11 +322,23 @@ export class SessionIndexService {
         return `${this.getScopeKey(sessionDir, reader)}::${projectId}::${sessionId}`;
     }
     markSessionDirty(sessionDir, sessionId, reader) {
-        const scopeKey = this.getScopeKey(sessionDir, reader);
+        this.markSessionDirtyByScopeKey(this.getScopeKey(sessionDir, reader), sessionId);
+    }
+    markSessionDirtyByScopeKey(scopeKey, sessionId) {
         const current = this.dirtySessionsByDir.get(scopeKey) ?? new Set();
         current.add(sessionId);
         this.dirtySessionsByDir.set(scopeKey, current);
     }
+    clearSessionDirty(sessionDir, sessionId, reader) {
+        const scopeKey = this.getScopeKey(sessionDir, reader);
+        const dirty = this.dirtySessionsByDir.get(scopeKey);
+        if (!dirty)
+            return;
+        dirty.delete(sessionId);
+        if (dirty.size === 0) {
+            this.dirtySessionsByDir.delete(scopeKey);
+        }
+    }
     markDirDirty(sessionDir, reader) {
         this.dirtyDirs.add(this.getScopeKey(sessionDir, reader));
     }
@@ -320,6 +360,27 @@ export class SessionIndexService {
             }
         }
     }
+    markLoadedCodexSessionDirty(sessionId, changeType) {
+        // Only loaded indexes can prove membership, so scopes known solely from
+        // validation timestamps or dirty marks can never match here.
+        let marked = false;
+        for (const [scopeKey, index] of this.indexCache) {
+            if (!scopeKey.startsWith("codex::"))
+                continue;
+            if (!index.sessions[sessionId])
+                continue;
+            this.markCodexScopeDirty(scopeKey, sessionId, changeType);
+            marked = true;
+        }
+        return marked;
+    }
+    markCodexScopeDirty(scopeKey, sessionId, changeType) {
+        if (changeType === "create" || changeType === "delete") {
+            this.dirtyDirs.add(scopeKey);
+            return;
+        }
+        this.markSessionDirtyByScopeKey(scopeKey, sessionId);
+    }
     buildSummariesFromIndex(index, projectId, options) {
         const summaries = [];
         const activeAfterMs = options?.activeAfterMs;
@@ -330,23 +391,28 @@ export class SessionIndexService {
                 Date.parse(cached.updatedAt) < activeAfterMs) {
                 continue;
             }
-            summaries.push({
-                id: sessionId,
-                projectId,
-                title: cached.title,
-                fullTitle: cached.fullTitle,
-                createdAt: cached.createdAt,
-                updatedAt: cached.updatedAt,
-                messageCount: cached.messageCount,
-                ownership: { owner: "none" },
-                contextUsage: cached.contextUsage,
-                provider: cached.provider ?? DEFAULT_PROVIDER,
-                model: cached.model,
-            });
+            summaries.push(this.toSessionSummary(sessionId, cached, projectId));
         }
         summaries.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
         return summaries;
     }
+    toSessionSummary(sessionId, cached, projectId) {
+        return {
+            id: sessionId,
+            projectId,
+            title: cached.title,
+            fullTitle: cached.fullTitle,
+            createdAt: cached.createdAt,
+            updatedAt: cached.updatedAt,
+            messageCount: cached.messageCount,
+            ownership: { owner: "none" },
+            contextUsage: cached.contextUsage,
+            provider: cached.provider ?? DEFAULT_PROVIDER,
+            model: cached.model,
+            parentSessionId: cached.parentSessionId,
+            lastAgentText: cached.lastAgentText,
+        };
+    }
     toCachedSummary(summary, mtime, size) {
         return {
             title: summary.title,
@@ -359,6 +425,8 @@ export class SessionIndexService {
             fileMtime: mtime,
             provider: summary.provider,
             model: summary.model,
+            parentSessionId: summary.parentSessionId,
+            lastAgentText: summary.lastAgentText,
         };
     }
     toEmptyCachedSummary(mtime, size) {
@@ -375,7 +443,7 @@ export class SessionIndexService {
             provider: DEFAULT_PROVIDER,
         };
     }
-    recordCallStats(mode, durationMs, statCalls, parseCalls, sessionDir) {
+    recordCallStats(mode, durationMs, statCalls, parseCalls, sessionDir, details = {}) {
         this.cacheStats.requests += 1;
         this.cacheStats.statCalls += statCalls;
         this.cacheStats.parseCalls += parseCalls;
@@ -387,7 +455,240 @@ export class SessionIndexService {
         if (mode === "full")
             this.cacheStats.fullScans += 1;
         if (LOG_CACHE_PERF || durationMs >= 250) {
-            logger.info(`[SessionIndexService] mode=${mode} dir=${sessionDir} durationMs=${durationMs} statCalls=${statCalls} parseCalls=${parseCalls}`);
+            getLogger().info({
+                event: "session_index_perf",
+                mode,
+                sessionDir,
+                durationMs,
+                statCalls,
+                parseCalls,
+                ...details,
+            }, "SESSION_INDEX: performance");
+        }
+    }
+    snapshotWarmupJob(job, now = Date.now()) {
+        return {
+            key: job.key,
+            status: job.status,
+            scopeKey: job.scopeKey,
+            validationKey: job.validationKey,
+            sessionDir: job.sessionDir,
+            projectId: job.projectId,
+            startedAt: new Date(job.startedAtMs).toISOString(),
+            updatedAt: new Date(job.updatedAtMs).toISOString(),
+            ...(job.completedAtMs
+                ? { completedAt: new Date(job.completedAtMs).toISOString() }
+                : {}),
+            elapsedMs: now - job.startedAtMs,
+            totalFiles: job.totalFiles,
+            completedFiles: job.completedFiles,
+            cacheHits: job.cacheHits,
+            cacheMisses: job.cacheMisses,
+            cacheMissBytes: job.cacheMissBytes,
+            parsedBytes: job.parsedBytes,
+            parseCalls: job.parseCalls,
+            activeParses: job.activeParses,
+            queuedParses: job.queuedParses,
+            coalescedParses: job.coalescedParses,
+            ...(job.lastSessionId ? { lastSessionId: job.lastSessionId } : {}),
+            ...(job.lastFilePath ? { lastFilePath: job.lastFilePath } : {}),
+            ...(job.error ? { error: job.error } : {}),
+        };
+    }
+    startWarmupJob(args) {
+        const now = Date.now();
+        const existing = this.warmupJobs.get(args.validationKey);
+        if (existing && existing.status === "running") {
+            existing.updatedAtMs = now;
+            return existing;
+        }
+        const job = {
+            key: args.validationKey,
+            status: "running",
+            scopeKey: args.scopeKey,
+            validationKey: args.validationKey,
+            sessionDir: args.sessionDir,
+            projectId: args.projectId,
+            startedAtMs: now,
+            updatedAtMs: now,
+            lastLoggedAtMs: 0,
+            totalFiles: 0,
+            completedFiles: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            cacheMissBytes: 0,
+            parsedBytes: 0,
+            parseCalls: 0,
+            activeParses: 0,
+            queuedParses: 0,
+            coalescedParses: 0,
+        };
+        this.warmupJobs.set(job.key, job);
+        this.ensureWarmupProgressTimer();
+        this.logWarmupProgress(job, "start", true);
+        return job;
+    }
+    updateWarmupJob(jobKey, update) {
+        const job = this.warmupJobs.get(jobKey);
+        if (job?.status !== "running")
+            return;
+        const now = Date.now();
+        update(job, now);
+        job.updatedAtMs = now;
+    }
+    completeWarmupJob(jobKey) {
+        const job = this.warmupJobs.get(jobKey);
+        if (job?.status !== "running")
+            return;
+        const now = Date.now();
+        job.status = "completed";
+        job.completedAtMs = now;
+        job.updatedAtMs = now;
+        this.logWarmupProgress(job, "complete", true);
+        this.rememberCompletedWarmupJob(job, now);
+    }
+    failWarmupJob(jobKey, error) {
+        const job = this.warmupJobs.get(jobKey);
+        if (job?.status !== "running")
+            return;
+        const now = Date.now();
+        job.status = "failed";
+        job.error = error instanceof Error ? error.message : String(error);
+        job.completedAtMs = now;
+        job.updatedAtMs = now;
+        this.logWarmupProgress(job, "failed", true);
+        this.rememberCompletedWarmupJob(job, now);
+    }
+    rememberCompletedWarmupJob(job, now) {
+        this.warmupJobs.delete(job.key);
+        this.recentWarmupJobs.unshift(this.snapshotWarmupJob(job, now));
+        this.recentWarmupJobs = this.recentWarmupJobs.slice(0, 20);
+        if (this.warmupJobs.size === 0) {
+            this.stopWarmupProgressTimer();
+        }
+    }
+    ensureWarmupProgressTimer() {
+        if (this.warmupProgressTimer)
+            return;
+        this.warmupProgressTimer = setInterval(() => {
+            const now = Date.now();
+            for (const job of this.warmupJobs.values()) {
+                this.logWarmupProgress(job, "progress", false, now);
+            }
+            if (this.warmupJobs.size === 0) {
+                this.stopWarmupProgressTimer();
+            }
+        }, this.warmupProgressLogIntervalMs);
+        this.warmupProgressTimer.unref?.();
+    }
+    stopWarmupProgressTimer() {
+        if (!this.warmupProgressTimer)
+            return;
+        clearInterval(this.warmupProgressTimer);
+        this.warmupProgressTimer = null;
+    }
+    logWarmupProgress(job, phase, force, now = Date.now()) {
+        if (!force &&
+            now - job.lastLoggedAtMs < this.warmupProgressLogIntervalMs) {
+            return;
+        }
+        job.lastLoggedAtMs = now;
+        getLogger().info({
+            event: "session_index_warmup_progress",
+            phase,
+            summaryParseConcurrency: this.summaryParseConcurrency,
+            globalActiveParses: this.activeSummaryParses,
+            globalQueuedParses: this.summaryParseQueue.length,
+            ...this.snapshotWarmupJob(job, now),
+        }, "SESSION_INDEX: warmup progress");
+    }
+    enqueueSummaryParse(args) {
+        const parseKey = `${args.scopeKey}::${args.sessionId}::${args.mtime}::${args.size}`;
+        const existing = this.inFlightSummaryParses.get(parseKey);
+        if (existing) {
+            this.updateWarmupJob(args.validationKey, (job) => {
+                job.coalescedParses += 1;
+                job.lastSessionId = args.sessionId;
+                job.lastFilePath = args.filePath;
+            });
+            return existing.then((summary) => {
+                this.updateWarmupJob(args.validationKey, (job) => {
+                    job.completedFiles += 1;
+                    job.parsedBytes += args.size;
+                    job.lastSessionId = args.sessionId;
+                    job.lastFilePath = args.filePath;
+                });
+                return summary;
+            });
+        }
+        const promise = new Promise((resolve, reject) => {
+            const task = {
+                key: parseKey,
+                jobKey: args.validationKey,
+                sessionId: args.sessionId,
+                filePath: args.filePath,
+                size: args.size,
+                run: () => args.reader.getSessionSummary(args.sessionId, args.projectId),
+                resolve,
+                reject,
+            };
+            this.summaryParseQueue.push(task);
+            this.updateWarmupJob(args.validationKey, (job) => {
+                job.queuedParses += 1;
+                job.lastSessionId = args.sessionId;
+                job.lastFilePath = args.filePath;
+            });
+            this.drainSummaryParseQueue();
+        });
+        this.inFlightSummaryParses.set(parseKey, promise);
+        promise.then(() => {
+            if (this.inFlightSummaryParses.get(parseKey) === promise) {
+                this.inFlightSummaryParses.delete(parseKey);
+            }
+        }, () => {
+            if (this.inFlightSummaryParses.get(parseKey) === promise) {
+                this.inFlightSummaryParses.delete(parseKey);
+            }
+        });
+        return promise;
+    }
+    drainSummaryParseQueue() {
+        while (this.activeSummaryParses < this.summaryParseConcurrency &&
+            this.summaryParseQueue.length > 0) {
+            const task = this.summaryParseQueue.shift();
+            if (!task)
+                return;
+            this.activeSummaryParses += 1;
+            this.updateWarmupJob(task.jobKey, (job) => {
+                job.queuedParses = Math.max(0, job.queuedParses - 1);
+                job.activeParses += 1;
+                job.parseCalls += 1;
+                job.lastSessionId = task.sessionId;
+                job.lastFilePath = task.filePath;
+            });
+            void (async () => {
+                try {
+                    const summary = await task.run();
+                    this.updateWarmupJob(task.jobKey, (job) => {
+                        job.completedFiles += 1;
+                        job.parsedBytes += task.size;
+                        job.lastSessionId = task.sessionId;
+                        job.lastFilePath = task.filePath;
+                    });
+                    task.resolve(summary);
+                }
+                catch (error) {
+                    this.failWarmupJob(task.jobKey, error);
+                    task.reject(error);
+                }
+                finally {
+                    this.activeSummaryParses = Math.max(0, this.activeSummaryParses - 1);
+                    this.updateWarmupJob(task.jobKey, (job) => {
+                        job.activeParses = Math.max(0, job.activeParses - 1);
+                    });
+                    this.drainSummaryParseQueue();
+                }
+            })();
         }
     }
     /**
@@ -415,11 +716,7 @@ export class SessionIndexService {
             return;
         }
         if (event.provider === "codex") {
-            // Codex indexes are project-scoped over a shared sessions tree
-            // (codex::<sessionsDir>::<projectPath>), so a raw file event does not
-            // tell us which project scope owns the changed session. Mark all loaded
-            // Codex scopes dirty and let the next request reconcile via listSessionFiles.
-            this.markMatchingScopesDirty("codex::");
+            this.handleCodexFileChange(event);
             return;
         }
         if (event.provider === "gemini") {
@@ -427,6 +724,84 @@ export class SessionIndexService {
             this.markMatchingScopesDirty("gemini::");
         }
     }
+    handleCodexFileChange(event) {
+        const sessionId = getCodexRolloutSessionId(event.relativePath);
+        if (!sessionId) {
+            this.markMatchingScopesDirty("codex::");
+            return;
+        }
+        if (this.markLoadedCodexSessionDirty(sessionId, event.changeType)) {
+            return;
+        }
+        void this.resolveAndMarkCodexFileChange(event, sessionId);
+    }
+    async resolveAndMarkCodexFileChange(event, sessionId) {
+        try {
+            const resolved = await this.resolveCodexFileChange(event);
+            if (resolved && !resolved.isSubagent) {
+                this.markCodexScopeDirty(resolved.scopeKey, resolved.sessionId, event.changeType);
+                return;
+            }
+        }
+        catch (error) {
+            getLogger().debug({ err: error, filePath: event.path }, "[SessionIndexService] Failed to resolve Codex file change");
+        }
+        if (!this.markLoadedCodexSessionDirty(sessionId, event.changeType)) {
+            this.markMatchingScopesDirty("codex::");
+        }
+    }
+    async resolveCodexFileChange(event) {
+        const sessionsDir = this.getCodexSessionsDirForEvent(event);
+        const discoveryIndex = this.getCodexDiscoveryIndex(sessionsDir);
+        const identity = getCodexRolloutDiscoveryIdentity(sessionsDir, event.path);
+        if (event.changeType === "delete") {
+            const record = await discoveryIndex.getRecord(identity.shardKey, identity.key);
+            if (!record)
+                return null;
+            await discoveryIndex.removeRecord(identity.shardKey, identity.key);
+            void discoveryIndex.flush();
+            return this.codexMetadataToDirtyScope(sessionsDir, record.metadata);
+        }
+        const metadata = await readCodexRolloutMetadata({
+            sessionsDir,
+            filePath: event.path,
+            discoveryIndex,
+        });
+        void discoveryIndex.flush();
+        if (!metadata)
+            return null;
+        return this.codexMetadataToDirtyScope(sessionsDir, metadata);
+    }
+    codexMetadataToDirtyScope(sessionsDir, metadata) {
+        return {
+            sessionId: metadata.id,
+            scopeKey: `codex::${sessionsDir}::${getProjectIdentityKey(metadata.cwd)}`,
+            isSubagent: metadata.isSubagent,
+        };
+    }
+    getCodexDiscoveryIndex(sessionsDir) {
+        const resolvedSessionsDir = path.resolve(sessionsDir);
+        let discoveryIndex = this.codexDiscoveryIndexes.get(resolvedSessionsDir);
+        if (!discoveryIndex) {
+            discoveryIndex = new SessionDiscoveryIndex({
+                baseDir: path.join(this.dataDir, "session-discovery"),
+                provider: "codex",
+                sourceRoot: resolvedSessionsDir,
+            });
+            this.codexDiscoveryIndexes.set(resolvedSessionsDir, discoveryIndex);
+        }
+        return discoveryIndex;
+    }
+    getCodexSessionsDirForEvent(event) {
+        const relativeDir = path.dirname(event.relativePath.replace(/\\/g, "/"));
+        let current = path.resolve(path.dirname(event.path));
+        if (relativeDir === ".")
+            return current;
+        for (const _segment of relativeDir.split("/")) {
+            current = path.dirname(current);
+        }
+        return current;
+    }
     async applyIncrementalDirtyUpdates(sessionDir, projectId, reader, index) {
         const scopeKey = this.getScopeKey(sessionDir, reader);
         const dirty = this.dirtySessionsByDir.get(scopeKey);
@@ -436,46 +811,82 @@ export class SessionIndexService {
         let indexChanged = false;
         let statCalls = 0;
         let parseCalls = 0;
-        for (const sessionId of Array.from(dirty)) {
-            const cached = index.sessions[sessionId];
-            if (cached) {
-                statCalls += 1;
-                const changed = await reader.getSessionSummaryIfChanged(sessionId, projectId, cached.fileMtime, cached.indexedBytes);
-                if (!changed)
+        let warmupJobKey = null;
+        let warmupJobCacheMissBytes = 0;
+        const incrementalValidationKey = `${scopeKey}::incremental`;
+        try {
+            for (const sessionId of Array.from(dirty)) {
+                const cached = index.sessions[sessionId];
+                if (cached) {
+                    statCalls += 1;
+                    const changed = await reader.getSessionSummaryIfChanged(sessionId, projectId, cached.fileMtime, cached.indexedBytes);
+                    if (!changed)
+                        continue;
+                    parseCalls += 1;
+                    index.sessions[sessionId] = this.toCachedSummary(changed.summary, changed.mtime, changed.size);
+                    indexChanged = true;
                     continue;
-                parseCalls += 1;
-                index.sessions[sessionId] = this.toCachedSummary(changed.summary, changed.mtime, changed.size);
-                indexChanged = true;
-                continue;
-            }
-            parseCalls += 1;
-            const summary = await reader.getSessionSummary(sessionId, projectId);
-            const filePath = (await reader.getSessionFilePath?.(sessionId)) ??
-                path.join(sessionDir, `${sessionId}.jsonl`);
-            if (summary) {
+                }
+                const filePath = (await reader.getSessionFilePath?.(sessionId)) ??
+                    path.join(sessionDir, `${sessionId}.jsonl`);
+                let stats;
                 try {
-                    const stats = await fs.stat(filePath);
+                    stats = await fs.stat(filePath);
                     statCalls += 1;
-                    index.sessions[sessionId] = this.toCachedSummary(summary, stats.mtimeMs, stats.size);
-                    indexChanged = true;
                 }
                 catch {
-                    // Ignore race where file disappeared after read.
+                    if (index.sessions[sessionId]) {
+                        delete index.sessions[sessionId];
+                        indexChanged = true;
+                    }
+                    continue;
+                }
+                parseCalls += 1;
+                warmupJobCacheMissBytes += stats.size;
+                if (!warmupJobKey) {
+                    const job = this.startWarmupJob({
+                        scopeKey,
+                        validationKey: incrementalValidationKey,
+                        sessionDir,
+                        projectId,
+                    });
+                    warmupJobKey = job.key;
+                    this.updateWarmupJob(job.key, (current) => {
+                        current.totalFiles = dirty.size;
+                    });
+                }
+                this.updateWarmupJob(warmupJobKey, (current) => {
+                    current.cacheMisses += 1;
+                    current.cacheMissBytes = warmupJobCacheMissBytes;
+                });
+                const summary = await this.enqueueSummaryParse({
+                    sessionDir,
+                    projectId,
+                    reader,
+                    scopeKey,
+                    validationKey: warmupJobKey,
+                    sessionId,
+                    filePath,
+                    size: stats.size,
+                    mtime: stats.mtimeMs,
+                });
+                if (summary) {
+                    index.sessions[sessionId] = this.toCachedSummary(summary, stats.mtimeMs, stats.size);
+                    indexChanged = true;
+                    continue;
                 }
-                continue;
-            }
-            try {
-                const stats = await fs.stat(filePath);
-                statCalls += 1;
                 index.sessions[sessionId] = this.toEmptyCachedSummary(stats.mtimeMs, stats.size);
                 indexChanged = true;
             }
-            catch {
-                if (index.sessions[sessionId]) {
-                    delete index.sessions[sessionId];
-                    indexChanged = true;
-                }
+        }
+        catch (error) {
+            if (warmupJobKey) {
+                this.failWarmupJob(warmupJobKey, error);
             }
+            throw error;
+        }
+        if (warmupJobKey) {
+            this.completeWarmupJob(warmupJobKey);
         }
         this.dirtySessionsByDir.delete(scopeKey);
         return { indexChanged, statCalls, parseCalls };
@@ -486,6 +897,11 @@ export class SessionIndexService {
         let indexChanged = false;
         let statCalls = 0;
         let parseCalls = 0;
+        let totalFiles = 0;
+        let cacheHits = 0;
+        let cacheMissBytes = 0;
+        let largestCacheMisses = [];
+        let warmupJobKey = null;
         try {
             // Enumerate session files — delegate to reader if it supports custom
             // enumeration (e.g., Gemini JSON where session ID is inside the file),
@@ -503,16 +919,21 @@ export class SessionIndexService {
                     filePath: path.join(sessionDir, f),
                 }));
             }
+            totalFiles = sessionFiles.length;
             const STAT_BATCH = 100;
             const allStats = Array.from({
                 length: sessionFiles.length,
             });
             for (let b = 0; b < sessionFiles.length; b += STAT_BATCH) {
                 const end = Math.min(b + STAT_BATCH, sessionFiles.length);
-                const batch = await Promise.all(sessionFiles
-                    .slice(b, end)
-                    .map((f) => fs.stat(f.filePath).catch(() => null)));
-                statCalls += batch.length;
+                const batch = await Promise.all(sessionFiles.slice(b, end).map((f) => {
+                    // A shared container file (e.g. a provider database) is not
+                    // statted: its mtime/size cannot validate individual sessions.
+                    if (f.sharedFilePath)
+                        return Promise.resolve(null);
+                    statCalls += 1;
+                    return fs.stat(f.filePath).catch(() => null);
+                }));
                 for (let j = 0; j < batch.length; j++) {
                     allStats[b + j] = batch[j] ?? null;
                 }
@@ -524,6 +945,41 @@ export class SessionIndexService {
                     continue;
                 const sessionId = entry.sessionId;
                 seenSessionIds.add(sessionId);
+                if (entry.sharedFilePath) {
+                    // Validate through the reader's own cheap change check (e.g. a DB
+                    // row's updated-time + message count). Stat-based comparison can
+                    // never hit for these entries — the container's mtime moves on any
+                    // write while the cached mtime/size are row-derived — which made
+                    // every full validation re-summarize every DB session.
+                    const cachedShared = index.sessions[sessionId];
+                    const changed = await reader.getSessionSummaryIfChanged(sessionId, projectId, cachedShared?.fileMtime ?? -1, cachedShared?.indexedBytes ?? -1);
+                    if (changed) {
+                        parseCalls += 1;
+                        index.sessions[sessionId] = this.toCachedSummary(changed.summary, changed.mtime, changed.size);
+                        indexChanged = true;
+                        if (options?.activeAfterMs === undefined ||
+                            Date.parse(changed.summary.updatedAt) >= options.activeAfterMs) {
+                            summaries.push(changed.summary);
+                        }
+                        continue;
+                    }
+                    if (cachedShared) {
+                        cacheHits += 1;
+                        if (cachedShared.isEmpty)
+                            continue;
+                        if (options?.activeAfterMs !== undefined &&
+                            Date.parse(cachedShared.updatedAt) < options.activeAfterMs) {
+                            continue;
+                        }
+                        summaries.push(this.toSessionSummary(sessionId, cachedShared, projectId));
+                        continue;
+                    }
+                    // Unknown session that yields no summary (e.g. still empty): cache
+                    // the emptiness so later validations stay row-level cheap.
+                    index.sessions[sessionId] = this.toEmptyCachedSummary(-1, -1);
+                    indexChanged = true;
+                    continue;
+                }
                 const stats = allStats[i];
                 if (!stats)
                     continue;
@@ -533,33 +989,66 @@ export class SessionIndexService {
                 if (cached &&
                     cached.fileMtime === mtime &&
                     cached.indexedBytes === size) {
+                    cacheHits += 1;
                     if (cached.isEmpty)
                         continue;
                     if (options?.activeAfterMs !== undefined &&
                         Date.parse(cached.updatedAt) < options.activeAfterMs) {
                         continue;
                     }
-                    summaries.push({
-                        id: sessionId,
-                        projectId,
-                        title: cached.title,
-                        fullTitle: cached.fullTitle,
-                        createdAt: cached.createdAt,
-                        updatedAt: cached.updatedAt,
-                        messageCount: cached.messageCount,
-                        ownership: { owner: "none" },
-                        contextUsage: cached.contextUsage,
-                        provider: cached.provider ?? DEFAULT_PROVIDER,
-                        model: cached.model,
-                    });
+                    summaries.push(this.toSessionSummary(sessionId, cached, projectId));
                 }
                 else {
-                    cacheMisses.push({ sessionId, mtime, size });
+                    cacheMissBytes += size;
+                    cacheMisses.push({
+                        sessionId,
+                        filePath: entry.filePath,
+                        mtime,
+                        size,
+                    });
                 }
             }
-            for (const { sessionId, mtime, size } of cacheMisses) {
+            largestCacheMisses = cacheMisses
+                .slice()
+                .sort((a, b) => b.size - a.size)
+                .slice(0, 5)
+                .map(({ sessionId, filePath, mtime, size }) => ({
+                sessionId,
+                filePath,
+                mtime,
+                size,
+            }));
+            if (cacheMisses.length > 0) {
+                const scopeKey = this.getScopeKey(sessionDir, reader);
+                const validationKey = this.getValidationKey(sessionDir, reader, options);
+                const job = this.startWarmupJob({
+                    scopeKey,
+                    validationKey,
+                    sessionDir,
+                    projectId,
+                });
+                warmupJobKey = job.key;
+                this.updateWarmupJob(job.key, (current) => {
+                    current.totalFiles = totalFiles;
+                    current.completedFiles = cacheHits;
+                    current.cacheHits = cacheHits;
+                    current.cacheMisses = cacheMisses.length;
+                    current.cacheMissBytes = cacheMissBytes;
+                });
+            }
+            for (const { sessionId, filePath, mtime, size } of cacheMisses) {
                 parseCalls += 1;
-                const summary = await reader.getSessionSummary(sessionId, projectId);
+                const summary = await this.enqueueSummaryParse({
+                    sessionDir,
+                    projectId,
+                    reader,
+                    scopeKey: this.getScopeKey(sessionDir, reader),
+                    validationKey: warmupJobKey ?? this.getValidationKey(sessionDir, reader, options),
+                    sessionId,
+                    filePath,
+                    size,
+                    mtime,
+                });
                 if (summary) {
                     if (options?.activeAfterMs === undefined ||
                         Date.parse(summary.updatedAt) >= options.activeAfterMs) {
@@ -573,22 +1062,50 @@ export class SessionIndexService {
                     indexChanged = true;
                 }
             }
+            if (warmupJobKey) {
+                this.completeWarmupJob(warmupJobKey);
+            }
             for (const sessionId of Object.keys(index.sessions)) {
                 if (!options?.activeAfterMs && !seenSessionIds.has(sessionId)) {
                     delete index.sessions[sessionId];
                     indexChanged = true;
                 }
             }
-            if (indexChanged) {
+            // Persist even a no-change (possibly empty) index: a scope with no
+            // index file would otherwise block a request in-line again on the
+            // first list after every server restart.
+            if (indexChanged ||
+                !this.persistedIndexScopes.has(this.getScopeKey(sessionDir, reader))) {
                 await this.saveIndex(sessionDir, reader);
             }
             summaries.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
             this.lastFullValidationAt.set(this.getValidationKey(sessionDir, reader, options), Date.now());
             this.clearDirDirtyState(sessionDir, reader);
-            return { summaries, statCalls, parseCalls };
+            return {
+                summaries,
+                statCalls,
+                parseCalls,
+                totalFiles,
+                cacheHits,
+                cacheMisses: cacheMisses.length,
+                cacheMissBytes,
+                largestCacheMisses,
+            };
         }
-        catch {
-            return { summaries: [], statCalls, parseCalls };
+        catch (error) {
+            if (warmupJobKey) {
+                this.failWarmupJob(warmupJobKey, error);
+            }
+            return {
+                summaries: [],
+                statCalls,
+                parseCalls,
+                totalFiles,
+                cacheHits,
+                cacheMisses: parseCalls,
+                cacheMissBytes,
+                largestCacheMisses,
+            };
         }
     }
     getDebugStats() {
@@ -602,6 +1119,16 @@ export class SessionIndexService {
             dirtySessionCount,
         };
     }
+    getWarmupStatus() {
+        const now = Date.now();
+        return {
+            summaryParseConcurrency: this.summaryParseConcurrency,
+            activeParses: this.activeSummaryParses,
+            queuedParses: this.summaryParseQueue.length,
+            activeJobs: Array.from(this.warmupJobs.values()).map((job) => this.snapshotWarmupJob(job, now)),
+            recentJobs: this.recentWarmupJobs,
+        };
+    }
     /**
      * Get sessions using the cache, only re-parsing files that have changed.
      * This is the main entry point for listing sessions with caching.
@@ -639,7 +1166,11 @@ export class SessionIndexService {
         // Fast path: no dirty signals and recent full validation.
         if (!fullValidationDue && !hasDirDirty && !hasDirtySessions) {
             const summaries = this.buildSummariesFromIndex(index, projectId, options);
-            this.recordCallStats("fast", Date.now() - start, 0, 0, sessionDir);
+            this.recordCallStats("fast", Date.now() - start, 0, 0, sessionDir, {
+                scopeKey,
+                validationKey,
+                indexedSessions: Object.keys(index.sessions).length,
+            });
             return summaries;
         }
         // Incremental path: only specific sessions are dirty.
@@ -649,13 +1180,149 @@ export class SessionIndexService {
                 await this.saveIndex(sessionDir, reader);
             }
             const summaries = this.buildSummariesFromIndex(index, projectId, options);
-            this.recordCallStats("incremental", Date.now() - start, incremental.statCalls, incremental.parseCalls, sessionDir);
+            this.recordCallStats("incremental", Date.now() - start, incremental.statCalls, incremental.parseCalls, sessionDir, {
+                scopeKey,
+                validationKey,
+                dirtySessions: dirtySessions?.size ?? 0,
+                indexedSessions: Object.keys(index.sessions).length,
+            });
+            return summaries;
+        }
+        // Full validation is due only because the TTL lapsed (no directory-level
+        // dirty signal). The TTL walk is a consistency backstop for missed
+        // watcher events, so a scope that already has a previously validated
+        // (this run) or persisted index serves it immediately and revalidates in
+        // the background — a fresh browser window after server idle must not pay
+        // the walk in-line. Background-discovered changes reach clients as
+        // session-updated/session-created bus events. Directory-dirty scopes
+        // (watcher saw a create/delete) still validate in-line, and interval <= 0
+        // keeps its validate-every-request contract. First-ever scans (no usable
+        // index) also still block: there is nothing to serve.
+        const canServeStaleWhileRevalidating = this.fullValidationIntervalMs > 0 &&
+            !hasDirDirty &&
+            (lastFullValidation > 0 || this.persistedIndexScopes.has(scopeKey));
+        if (canServeStaleWhileRevalidating) {
+            let statCalls = 0;
+            let parseCalls = 0;
+            if (hasDirtySessions) {
+                const incremental = await this.applyIncrementalDirtyUpdates(sessionDir, projectId, reader, index);
+                statCalls = incremental.statCalls;
+                parseCalls = incremental.parseCalls;
+                if (incremental.indexChanged) {
+                    await this.saveIndex(sessionDir, reader);
+                }
+            }
+            this.scheduleBackgroundValidation(sessionDir, projectId, reader, options);
+            const summaries = this.buildSummariesFromIndex(index, projectId, options);
+            this.recordCallStats("fast", Date.now() - start, statCalls, parseCalls, sessionDir, {
+                scopeKey,
+                validationKey,
+                staleWhileRevalidate: true,
+                indexedSessions: Object.keys(index.sessions).length,
+            });
             return summaries;
         }
         const full = await this.runFullValidation(sessionDir, projectId, reader, index, options);
-        this.recordCallStats("full", Date.now() - start, full.statCalls, full.parseCalls, sessionDir);
+        this.recordCallStats("full", Date.now() - start, full.statCalls, full.parseCalls, sessionDir, {
+            scopeKey,
+            validationKey,
+            indexedSessions: Object.keys(index.sessions).length,
+            totalFiles: full.totalFiles,
+            cacheHits: full.cacheHits,
+            cacheMisses: full.cacheMisses,
+            cacheMissBytes: full.cacheMissBytes,
+            largestCacheMisses: full.largestCacheMisses,
+        });
         return full.summaries;
     }
+    /**
+     * Queue a background full validation for a scope/options variant, deduped
+     * while one is pending and serialized across scopes so a burst of
+     * stale-served requests (the per-project walk behind /api/sessions) does
+     * not stampede the filesystem.
+     */
+    scheduleBackgroundValidation(sessionDir, projectId, reader, options) {
+        const validationKey = this.getValidationKey(sessionDir, reader, options);
+        if (this.backgroundValidations.has(validationKey)) {
+            return;
+        }
+        const run = this.backgroundValidationChain
+            .then(() => this.runBackgroundValidation(sessionDir, projectId, reader, options))
+            .catch((error) => {
+            getLogger().warn({ err: error }, `[SessionIndexService] Background validation failed for ${validationKey}`);
+        })
+            .finally(() => {
+            this.backgroundValidations.delete(validationKey);
+        });
+        this.backgroundValidations.set(validationKey, run);
+        this.backgroundValidationChain = run;
+    }
+    async runBackgroundValidation(sessionDir, projectId, reader, options) {
+        const validationKey = this.getValidationKey(sessionDir, reader, options);
+        // A queued validation may have been satisfied while waiting in the chain.
+        const lastFullValidation = this.lastFullValidationAt.get(validationKey) ?? 0;
+        if (lastFullValidation > 0 &&
+            Date.now() - lastFullValidation < this.fullValidationIntervalMs) {
+            return;
+        }
+        const start = Date.now();
+        const scopeKey = this.getScopeKey(sessionDir, reader);
+        const index = await this.loadIndex(sessionDir, projectId, reader);
+        const before = new Map(Object.entries(index.sessions));
+        const full = await this.runFullValidation(sessionDir, projectId, reader, index, options);
+        this.recordCallStats("full", Date.now() - start, full.statCalls, full.parseCalls, sessionDir, {
+            scopeKey,
+            validationKey,
+            background: true,
+            indexedSessions: Object.keys(index.sessions).length,
+            totalFiles: full.totalFiles,
+            cacheHits: full.cacheHits,
+            cacheMisses: full.cacheMisses,
+            cacheMissBytes: full.cacheMissBytes,
+            largestCacheMisses: full.largestCacheMisses,
+        });
+        this.emitBackgroundIndexChanges(index, before, projectId);
+    }
+    /**
+     * Emit bus events for sessions a background validation changed, so clients
+     * that were served a stale response converge without refetching. Unchanged
+     * entries keep their object identity through runFullValidation (only
+     * changed rows are reassigned), so reference comparison is exact. Deleted
+     * sessions have no removal event; they disappear on the next refetch.
+     */
+    emitBackgroundIndexChanges(index, before, projectId) {
+        if (!this.eventBus) {
+            return;
+        }
+        const timestamp = new Date().toISOString();
+        for (const [sessionId, cached] of Object.entries(index.sessions)) {
+            if (cached.isEmpty)
+                continue;
+            const previous = before.get(sessionId);
+            if (previous === cached)
+                continue;
+            if (!previous || previous.isEmpty) {
+                this.eventBus.emit({
+                    type: "session-created",
+                    session: this.toSessionSummary(sessionId, cached, projectId),
+                    timestamp,
+                });
+                continue;
+            }
+            this.eventBus.emit({
+                type: "session-updated",
+                sessionId,
+                projectId,
+                title: cached.title,
+                messageCount: cached.messageCount,
+                updatedAt: cached.updatedAt,
+                contextUsage: cached.contextUsage,
+                model: cached.model,
+                lastAgentText: cached.lastAgentText,
+                timestamp,
+            });
+        }
+    }
     /**
      * Invalidate the cache for a specific session.
      * Call this when you know a session file has been modified.
@@ -672,6 +1339,7 @@ export class SessionIndexService {
      */
     clearCache(sessionDir) {
         this.indexCache.delete(sessionDir);
+        this.persistedIndexScopes.delete(sessionDir);
         this.clearDirDirtyState(sessionDir);
         this.lastFullValidationAt.delete(sessionDir);
     }
@@ -682,56 +1350,158 @@ export class SessionIndexService {
         return this.dataDir;
     }
     /**
-     * Get just the title for a single session, using cache when possible.
-     * More efficient than getSessionsWithCache when you only need one session.
+     * Get one session summary, using cached metadata when the indexed file stats
+     * still match. This is the cache-first single-session companion to
+     * getSessionsWithCache.
      */
-    async getSessionTitle(sessionDir, projectId, sessionId, reader) {
+    async getSessionSummaryWithCache(sessionDir, projectId, sessionId, reader) {
         const loadKey = this.getTitleLoadKey(sessionDir, projectId, sessionId, reader);
-        const inFlight = this.inFlightTitleLoads.get(loadKey);
+        const inFlight = this.inFlightSessionSummaryLoads.get(loadKey);
         if (inFlight)
             return inFlight;
-        const promise = this.getSessionTitleInternal(sessionDir, projectId, sessionId, reader);
-        this.inFlightTitleLoads.set(loadKey, promise);
+        const promise = this.getSessionSummaryWithCacheInternal(sessionDir, projectId, sessionId, reader);
+        this.inFlightSessionSummaryLoads.set(loadKey, promise);
         try {
             return await promise;
         }
         finally {
-            if (this.inFlightTitleLoads.get(loadKey) === promise) {
-                this.inFlightTitleLoads.delete(loadKey);
+            if (this.inFlightSessionSummaryLoads.get(loadKey) === promise) {
+                this.inFlightSessionSummaryLoads.delete(loadKey);
             }
         }
     }
-    async getSessionTitleInternal(sessionDir, projectId, sessionId, reader) {
+    async getSessionSummaryWithCacheInternal(sessionDir, projectId, sessionId, reader) {
+        const scopeKey = this.getScopeKey(sessionDir, reader);
         const index = await this.loadIndex(sessionDir, projectId, reader);
         const cached = index.sessions[sessionId];
+        const dirtySessions = this.dirtySessionsByDir.get(scopeKey);
+        const isDirty = dirtySessions?.has(sessionId) ?? false;
         const filePath = (await reader.getSessionFilePath?.(sessionId)) ??
             path.join(sessionDir, `${sessionId}.jsonl`);
+        let stats;
         try {
-            const stats = await fs.stat(filePath);
-            const mtime = stats.mtimeMs;
-            const size = stats.size;
-            if (cached &&
-                cached.fileMtime === mtime &&
-                cached.indexedBytes === size) {
-                if (cached.isEmpty)
-                    return null;
-                return cached.title;
-            }
-            const summary = await reader.getSessionSummary(sessionId, projectId);
+            stats = await fs.stat(filePath);
+        }
+        catch {
+            // Some readers can resolve a session across fallback locations even when
+            // they do not expose a concrete file path for the index. Preserve that
+            // behavior, but skip caching because we have no reliable mtime/size key.
+            try {
+                const summary = await reader.getSessionSummary(sessionId, projectId);
+                if (summary) {
+                    this.clearSessionDirty(sessionDir, sessionId, reader);
+                    return summary;
+                }
+            }
+            catch {
+                // Fall through to clear any stale indexed entry below.
+            }
+            if (cached) {
+                delete index.sessions[sessionId];
+                await this.saveIndex(sessionDir, reader).catch(() => {
+                    // Save failures are already logged by saveIndex.
+                });
+            }
+            this.clearSessionDirty(sessionDir, sessionId, reader);
+            return null;
+        }
+        const mtime = stats.mtimeMs;
+        const size = stats.size;
+        if (cached &&
+            !isDirty &&
+            cached.fileMtime === mtime &&
+            cached.indexedBytes === size) {
+            return cached.isEmpty
+                ? null
+                : this.toSessionSummary(sessionId, cached, projectId);
+        }
+        const validationKey = `${scopeKey}::single:${sessionId}`;
+        try {
+            const summary = await this.enqueueSummaryParse({
+                sessionDir,
+                projectId,
+                reader,
+                scopeKey,
+                validationKey,
+                sessionId,
+                filePath,
+                size,
+                mtime,
+            });
             if (summary) {
                 index.sessions[sessionId] = this.toCachedSummary(summary, mtime, size);
+                this.clearSessionDirty(sessionDir, sessionId, reader);
                 await this.saveIndex(sessionDir, reader);
-                return summary.title;
+                return summary;
             }
             index.sessions[sessionId] = this.toEmptyCachedSummary(mtime, size);
+            this.clearSessionDirty(sessionDir, sessionId, reader);
             await this.saveIndex(sessionDir, reader);
         }
         catch {
-            // File error - return null
+            // Reader errors should not break callers that only need display metadata.
         }
         return null;
     }
+    /**
+     * Get one session summary only if the existing index row is fresh.
+     *
+     * Unlike getSessionSummaryWithCache, this method never parses on a cache miss.
+     * It is for lightweight routes that can fall back to provider head metadata
+     * without creating full-summary parse churn.
+     */
+    async getCachedSessionSummary(sessionDir, projectId, sessionId, reader) {
+        const scopeKey = this.getScopeKey(sessionDir, reader);
+        const index = await this.loadIndex(sessionDir, projectId, reader);
+        const cached = index.sessions[sessionId];
+        if (!cached || cached.isEmpty) {
+            return null;
+        }
+        const dirtySessions = this.dirtySessionsByDir.get(scopeKey);
+        if (dirtySessions?.has(sessionId)) {
+            return null;
+        }
+        const filePath = (await reader.getSessionFilePath?.(sessionId)) ??
+            path.join(sessionDir, `${sessionId}.jsonl`);
+        let stats;
+        try {
+            stats = await fs.stat(filePath);
+        }
+        catch {
+            return null;
+        }
+        if (cached.fileMtime !== stats.mtimeMs ||
+            cached.indexedBytes !== stats.size) {
+            return null;
+        }
+        return this.toSessionSummary(sessionId, cached, projectId);
+    }
+    /**
+     * Get just the title for a single session, using cache when possible.
+     * More efficient than getSessionsWithCache when you only need one session.
+     */
+    async getSessionTitle(sessionDir, projectId, sessionId, reader) {
+        const loadKey = this.getTitleLoadKey(sessionDir, projectId, sessionId, reader);
+        const inFlight = this.inFlightTitleLoads.get(loadKey);
+        if (inFlight)
+            return inFlight;
+        const promise = this.getSessionTitleInternal(sessionDir, projectId, sessionId, reader);
+        this.inFlightTitleLoads.set(loadKey, promise);
+        try {
+            return await promise;
+        }
+        finally {
+            if (this.inFlightTitleLoads.get(loadKey) === promise) {
+                this.inFlightTitleLoads.delete(loadKey);
+            }
+        }
+    }
+    async getSessionTitleInternal(sessionDir, projectId, sessionId, reader) {
+        const summary = await this.getSessionSummaryWithCache(sessionDir, projectId, sessionId, reader);
+        return summary?.title ?? null;
+    }
     dispose() {
+        this.stopWarmupProgressTimer();
         this.unsubscribeEventBus?.();
         this.unsubscribeEventBus = null;
     }