sidekick-shared 0.25.0 → 0.26.1

package/dist/providers/codex.js

@@ -48,11 +48,12 @@ exports.findCodexRolloutFile = findCodexRolloutFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const string_decoder_1 = require("string_decoder");
-const EventAggregator_1 = require("../aggregation/EventAggregator");
 const sessionContext_1 = require("../context/sessionContext");
+const sessionStats_1 = require("../sessionStats");
 const codexParser_1 = require("../parsers/codexParser");
 const codexDatabase_1 = require("./codexDatabase");
 const codexProfiles_1 = require("../codexProfiles");
+const rolloutWalker_1 = require("./rolloutWalker");
 const diagnostics_1 = require("./diagnostics");
 const modelContext_1 = require("../modelContext");
 const observedContextWindows_1 = require("../observedContextWindows");
@@ -73,28 +74,6 @@ function getCodexHomes() {
 function getSessionsDirs() {
     return getCodexHomes().map((home) => path.join(home, 'sessions'));
 }
-/** Test if a filename is a Codex rollout file. */
-function isRolloutFile(filename) {
-    return filename.startsWith('rollout-') && filename.endsWith('.jsonl');
-}
-/**
- * Extract session UUID from a rollout filename.
- * Format: rollout-<timestamp>-<uuid>.jsonl -> <uuid>
- */
-function extractSessionId(filename) {
-    const base = path.basename(filename, '.jsonl');
-    // rollout-YYYYMMDD-HHMMSS-<uuid> or rollout-<timestamp>-<uuid>
-    const parts = base.split('-');
-    // The UUID is typically the last 5 segments (8-4-4-4-12)
-    if (parts.length >= 6) {
-        const possibleUuid = parts.slice(-5).join('-');
-        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(possibleUuid)) {
-            return possibleUuid;
-        }
-    }
-    // Fallback: use everything after "rollout-"
-    return base.replace(/^rollout-/, '');
-}
 /** Truncate a string to maxLen with ellipsis. */
 function truncate(text, maxLen) {
     const trimmed = text.trim().replace(/\s+/g, ' ');
@@ -103,102 +82,16 @@ function truncate(text, maxLen) {
     }
     return trimmed;
 }
-/**
- * Recursively find all rollout files under a directory.
- * Handles the YYYY/MM/DD subdirectory structure.
- */
+/** Every rollout under a directory, newest first (one capped walk). */
 function findRolloutFiles(dir) {
-    const results = [];
-    try {
-        if (!fs.existsSync(dir))
-            return results;
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                results.push(...findRolloutFiles(fullPath));
-            }
-            else if (entry.isFile() && isRolloutFile(entry.name)) {
-                try {
-                    const stats = fs.statSync(fullPath);
-                    if (stats.size > 0) {
-                        results.push({ path: fullPath, mtime: stats.mtime });
-                    }
-                }
-                catch {
-                    // Skip inaccessible files
-                }
-            }
-        }
-    }
-    catch {
-        // Skip inaccessible directories
-    }
-    return results;
+    return (0, rolloutWalker_1.walkRolloutFiles)([dir]);
 }
 function hasRolloutFile(dir) {
-    try {
-        if (!fs.existsSync(dir))
-            return false;
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory() && hasRolloutFile(fullPath))
-                return true;
-            if (entry.isFile() && isRolloutFile(entry.name))
-                return true;
-        }
-    }
-    catch {
-        return false;
-    }
-    return false;
+    return (0, rolloutWalker_1.walkRolloutFiles)([dir], { limit: 1 }).length > 0;
 }
-function findRolloutFilesInConfiguredHomes() {
-    const results = [];
-    const seen = new Set();
-    for (const sessionsDir of getSessionsDirs()) {
-        for (const file of findRolloutFiles(sessionsDir)) {
-            if (seen.has(file.path))
-                continue;
-            seen.add(file.path);
-            results.push(file);
-        }
-    }
-    return results;
-}
-async function findRolloutFilesAsync(dir) {
-    const results = [];
-    let entries;
-    try {
-        entries = await fs.promises.readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return results;
-    }
-    for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            results.push(...(await findRolloutFilesAsync(fullPath)));
-        }
-        else if (entry.isFile() && isRolloutFile(entry.name)) {
-            try {
-                const stats = await fs.promises.stat(fullPath);
-                if (stats.size > 0) {
-                    results.push({
-                        path: fullPath,
-                        mtime: stats.mtime,
-                        sizeBytes: stats.size,
-                        sessionId: extractSessionId(entry.name),
-                    });
-                }
-            }
-            catch {
-                // Skip inaccessible files.
-            }
-        }
-        await new Promise((resolve) => setImmediate(resolve));
-    }
-    return results;
+/** Every rollout across the monitored homes, newest first, deduplicated by path. */
+function findRolloutFilesInConfiguredHomes(options = {}) {
+    return (0, rolloutWalker_1.walkRolloutFiles)(getSessionsDirs(), options);
 }
 /**
  * Locates the rollout file for a Codex session id by walking
@@ -218,41 +111,8 @@ function findCodexRolloutFile(sessionId, options = {}) {
     const sessionsDirs = options.codexHome
         ? [path.join(options.codexHome, 'sessions')]
         : getSessionsDirs();
-    let best = null;
-    for (const dir of sessionsDirs) {
-        for (const candidate of findRolloutFilesById(dir, normalizedId)) {
-            if (!best || candidate.mtimeMs > best.mtimeMs)
-                best = candidate;
-        }
-    }
-    return best?.path ?? null;
-}
-function findRolloutFilesById(dir, normalizedId) {
-    const results = [];
-    try {
-        if (!fs.existsSync(dir))
-            return results;
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                results.push(...findRolloutFilesById(fullPath, normalizedId));
-            }
-            else if (entry.isFile() &&
-                isRolloutFile(entry.name) &&
-                extractSessionId(entry.name).toLowerCase() === normalizedId) {
-                try {
-                    results.push({ path: fullPath, mtimeMs: fs.statSync(fullPath).mtimeMs });
-                }
-                catch {
-                    // Skip files that vanish between readdir and stat.
-                }
-            }
-        }
-    }
-    catch {
-        // Skip inaccessible directories.
-    }
-    return results;
+    // Name-only filter, one walk across the homes, newest modification first.
+    return (0, rolloutWalker_1.walkRolloutFiles)(sessionsDirs, { sessionId: normalizedId })[0]?.path ?? null;
 }
 /** Pick the best sessions directory for UI/search entrypoints. */
 function getSessionsDir() {
@@ -368,15 +228,28 @@ async function readSessionMetaAsync(rolloutPath) {
         await handle?.close().catch(() => undefined);
     }
 }
-/** Read the CWD from a rollout file's session_meta. Cached. */
+/**
+ * Read the CWD from a rollout file's session_meta. Cached per path, bounded
+ * so a long-lived host watching a large history cannot grow it without limit
+ * (insertion order doubles as an eviction order).
+ */
+const CWD_CACHE_LIMIT = 5000;
 const cwdCache = new Map();
+function rememberCwd(rolloutPath, cwd) {
+    if (!cwdCache.has(rolloutPath) && cwdCache.size >= CWD_CACHE_LIMIT) {
+        const oldest = cwdCache.keys().next().value;
+        if (oldest !== undefined)
+            cwdCache.delete(oldest);
+    }
+    cwdCache.set(rolloutPath, cwd);
+}
 function readSessionCwd(rolloutPath) {
     const cached = cwdCache.get(rolloutPath);
     if (cached !== undefined)
         return cached;
     const meta = readSessionMeta(rolloutPath);
     const cwd = meta?.cwd || null;
-    cwdCache.set(rolloutPath, cwd);
+    rememberCwd(rolloutPath, cwd);
     return cwd;
 }
 /** Async twin of readSessionCwd, sharing its cache so repeat listings do no content reads. */
@@ -386,7 +259,7 @@ async function readSessionCwdAsync(rolloutPath) {
         return cached;
     const meta = await readSessionMetaAsync(rolloutPath);
     const cwd = meta?.cwd || null;
-    cwdCache.set(rolloutPath, cwd);
+    rememberCwd(rolloutPath, cwd);
     return cwd;
 }
 /** Check if a session's CWD matches a workspace path. */
@@ -833,16 +706,15 @@ class CodexProvider {
             }
         }
         // File scan: look for any rollout file whose session_meta.cwd matches
+        // (newest first; the cwd read is cached per path).
         const files = findRolloutFilesInConfiguredHomes();
         if (files.length === 0) {
             this.recordDatabaseFallback('discoverSessionDirectory', true);
             return null;
         }
-        // Sort by mtime descending
-        files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
         for (const file of files) {
-            const meta = readSessionMeta(file.path);
-            if (meta && cwdMatches(meta.cwd, workspacePath)) {
+            const cwd = readSessionCwd(file.path);
+            if (cwd && cwdMatches(cwd, workspacePath)) {
                 this.recordDatabaseFallback('discoverSessionDirectory', true);
                 return path.dirname(file.path);
             }
@@ -863,12 +735,10 @@ class CodexProvider {
                 return thread.rollout_path;
             }
         }
-        // File scan fallback
-        const files = findRolloutFilesInConfiguredHomes();
-        files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        for (const file of files) {
-            const meta = readSessionMeta(file.path);
-            if (meta && cwdMatches(meta.cwd, workspacePath)) {
+        // File scan fallback (newest first; cwd reads are cached per path)
+        for (const file of findRolloutFilesInConfiguredHomes()) {
+            const cwd = readSessionCwd(file.path);
+            if (cwd && cwdMatches(cwd, workspacePath)) {
                 this.recordDatabaseFallback('findActiveSession', true);
                 return file.path;
             }
@@ -889,13 +759,11 @@ class CodexProvider {
                 return dbPaths;
             }
         }
-        // File scan
-        const files = findRolloutFilesInConfiguredHomes();
-        files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        const sessions = files
+        // File scan (newest first; cwd reads are cached per path)
+        const sessions = findRolloutFilesInConfiguredHomes()
             .filter((f) => {
-            const meta = readSessionMeta(f.path);
-            return meta && cwdMatches(meta.cwd, workspacePath);
+            const cwd = readSessionCwd(f.path);
+            return cwd !== null && cwdMatches(cwd, workspacePath);
         })
             .map((f) => f.path);
         this.recordDatabaseFallback('findAllSessions', true);
@@ -917,9 +785,7 @@ class CodexProvider {
         return this.findAllSessions(workspacePath);
     }
     findSessionsInDirectory(dir) {
-        const files = findRolloutFiles(dir);
-        files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        return files.map((f) => f.path);
+        return findRolloutFiles(dir).map((f) => f.path);
     }
     listAllSessionFiles() {
         const files = findRolloutFilesInConfiguredHomes();
@@ -927,23 +793,23 @@ class CodexProvider {
         return files;
     }
     async listSessionFilesAsync(workspacePath) {
-        const seen = new Set();
         const results = [];
-        for (const sessionsDir of getSessionsDirs()) {
-            for (const file of await findRolloutFilesAsync(sessionsDir)) {
-                if (seen.has(file.path))
+        // One capped walk across the homes (deduplicated, newest first).
+        for (const file of await (0, rolloutWalker_1.walkRolloutFilesAsync)(getSessionsDirs())) {
+            const info = { ...file };
+            if (workspacePath) {
+                const cwd = await readSessionCwdAsync(file.path);
+                if (!cwd || !cwdMatches(cwd, workspacePath))
                     continue;
-                seen.add(file.path);
-                if (workspacePath) {
-                    const cwd = await readSessionCwdAsync(file.path);
-                    if (!cwd || !cwdMatches(cwd, workspacePath))
-                        continue;
-                    file.workspacePath = cwd;
-                }
-                results.push(file);
+                info.workspacePath = cwd;
             }
+            results.push(info);
         }
-        return results.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+        // Filesystem enumeration bypasses the database, so record that here as
+        // the sync listing paths do; otherwise `getLastOperationStatus()` keeps
+        // describing whichever operation ran before this one.
+        this.recordDatabaseFallback('listSessionFilesAsync', true);
+        return results;
     }
     getAllProjectFolders(workspacePath) {
         const folders = [];
@@ -963,12 +829,17 @@ class CodexProvider {
                 });
             }
         }
-        // File scan supplement
+        // File scan supplement. When the index answered, only rollouts written
+        // after its last update can be missing from it, so older files are not
+        // opened; the cwd read itself is cached per path either way.
+        const indexedUpTo = db ? db.getDbMtime() : 0;
         for (const file of findRolloutFilesInConfiguredHomes()) {
-            const meta = readSessionMeta(file.path);
-            if (!meta?.cwd)
+            if (db && indexedUpTo > 0 && file.mtime.getTime() <= indexedUpTo)
+                continue;
+            const cwd = readSessionCwd(file.path);
+            if (!cwd)
                 continue;
-            const existing = seenCwds.get(meta.cwd);
+            const existing = seenCwds.get(cwd);
             if (existing) {
                 // Update mtime if newer
                 if (file.mtime > existing.lastModified) {
@@ -976,10 +847,10 @@ class CodexProvider {
                 }
             }
             else {
-                seenCwds.set(meta.cwd, {
+                seenCwds.set(cwd, {
                     dir: path.dirname(file.path),
-                    name: meta.cwd,
-                    encodedName: meta.cwd,
+                    name: cwd,
+                    encodedName: cwd,
                     sessionCount: 1,
                     lastModified: file.mtime,
                 });
@@ -1004,30 +875,36 @@ class CodexProvider {
     }
     // --- File identification ---
     isSessionFile(filename) {
-        return isRolloutFile(filename);
+        return (0, rolloutWalker_1.isRolloutFile)(filename);
     }
     getSessionId(sessionPath) {
-        return extractSessionId(path.basename(sessionPath));
+        return (0, rolloutWalker_1.extractRolloutSessionId)(path.basename(sessionPath));
     }
     encodeWorkspacePath(workspacePath) {
         // Codex doesn't encode workspace paths in directory names
         return workspacePath;
     }
-    extractSessionLabel(sessionPath) {
-        // DB first
+    /** Thread title or first user message from the SQLite index; null without it. */
+    extractSessionLabelFromDb(sessionPath) {
         const db = this.ensureDb();
-        if (db) {
-            const sessionId = this.getSessionId(sessionPath);
-            const thread = db.getThread(sessionId);
-            if (thread?.title) {
-                this.recordDatabaseFallback('extractSessionLabel', true);
-                return truncate(thread.title, 60);
-            }
-            if (thread?.first_user_message) {
-                this.recordDatabaseFallback('extractSessionLabel', true);
-                return truncate(thread.first_user_message, 60);
-            }
+        if (!db)
+            return null;
+        const sessionId = this.getSessionId(sessionPath);
+        const thread = db.getThread(sessionId);
+        if (thread?.title) {
+            this.recordDatabaseFallback('extractSessionLabel', true);
+            return truncate(thread.title, 60);
+        }
+        if (thread?.first_user_message) {
+            this.recordDatabaseFallback('extractSessionLabel', true);
+            return truncate(thread.first_user_message, 60);
         }
+        return null;
+    }
+    extractSessionLabel(sessionPath) {
+        const fromDb = this.extractSessionLabelFromDb(sessionPath);
+        if (fromDb)
+            return fromDb;
         // File fallback: parse first user message
         const label = extractFirstUserMessage(sessionPath);
         this.recordDatabaseFallback('extractSessionLabel', true);
@@ -1091,15 +968,13 @@ class CodexProvider {
             if (forkedThreads.length > 0)
                 return subagents;
         }
-        // Filesystem fallback: scan all rollout files for matching forked_from_id.
-        // Limited to recent files (last 50) to avoid excessive I/O.
-        const files = findRolloutFilesInConfiguredHomes();
-        files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        const filesToCheck = files.slice(0, 50);
-        for (const file of filesToCheck) {
+        // Filesystem fallback: scan recent rollout files for a matching
+        // forked_from_id. The walk stops after the 50 newest-dated files instead
+        // of enumerating the whole history and slicing afterwards.
+        for (const file of findRolloutFilesInConfiguredHomes({ limit: 50 })) {
             const meta = readSessionMeta(file.path);
             if (meta?.forked_from_id === sessionId) {
-                const childId = extractSessionId(path.basename(file.path));
+                const childId = (0, rolloutWalker_1.extractRolloutSessionId)(path.basename(file.path));
                 const stats = this.buildSubagentStats(childId, file.path, meta.source);
                 if (stats)
                     subagents.push(stats);
@@ -1227,52 +1102,12 @@ class CodexProvider {
     }
     // --- Stats ---
     readSessionStats(sessionPath) {
-        const sessionId = extractSessionId(path.basename(sessionPath));
-        const aggregator = new EventAggregator_1.EventAggregator({
-            providerId: 'codex',
-            computeContextSize: (usage) => usage.inputTokens,
+        // One reader pass computes stats and the label: the SQLite thread title is
+        // used when the index is available, otherwise the first user prompt comes
+        // from the events already read, so the rollout is never opened twice.
+        return (0, sessionStats_1.readSessionFileStats)(this, sessionPath, {
+            resolveLabel: () => this.extractSessionLabelFromDb(sessionPath),
         });
-        try {
-            const reader = this.createReader(sessionPath);
-            for (const event of reader.readAll()) {
-                aggregator.processEvent(event);
-            }
-        }
-        catch (err) {
-            // Return an empty stats shell below. Surface the cause under DEBUG so a
-            // malformed rollout doesn't fail silently during dashboard refreshes.
-            if (process.env.DEBUG)
-                console.error(`CodexProvider.readSessionStats: ${err}`);
-        }
-        const metrics = aggregator.getMetrics();
-        const modelUsage = {};
-        for (const model of metrics.modelStats) {
-            modelUsage[model.model] = { calls: model.calls, tokens: model.tokens };
-        }
-        const toolUsage = {};
-        for (const tool of metrics.toolStats) {
-            toolUsage[tool.name] = tool.successCount + tool.failureCount + tool.pendingCount;
-        }
-        return {
-            providerId: 'codex',
-            sessionId,
-            filePath: sessionPath,
-            label: this.extractSessionLabel(sessionPath),
-            startTime: metrics.sessionStartTime || '',
-            endTime: metrics.lastEventTime || '',
-            messageCount: metrics.messageCount,
-            tokens: {
-                input: metrics.tokens.inputTokens,
-                output: metrics.tokens.outputTokens,
-                cacheWrite: metrics.tokens.cacheWriteTokens,
-                cacheRead: metrics.tokens.cacheReadTokens,
-            },
-            modelUsage,
-            toolUsage,
-            compactionEstimate: metrics.compactionCount,
-            truncationCount: metrics.truncationCount,
-            reportedCost: metrics.tokens.reportedCost,
-        };
     }
     readSessionContextSnapshot(sessionPath, options = {}) {
         return (0, sessionContext_1.readSessionContextSnapshot)(this, sessionPath, options);

package/dist/providers/detect.d.ts

@@ -4,6 +4,8 @@
  * without VS Code dependency (no vscode.workspace.getConfiguration).
  */
 import type { ProviderId } from './types';
+/** Forget the memoised ranking. Test-only. */
+export declare function _resetProviderDetectionCache(): void;
 /**
  * Returns all provider IDs whose data directories exist on the filesystem.
  * Ordered by most-recent activity first.

package/dist/providers/detect.js

@@ -38,6 +38,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports._resetProviderDetectionCache = _resetProviderDetectionCache;
 exports.getAllDetectedProviders = getAllDetectedProviders;
 exports.detectProvider = detectProvider;
 const fs = __importStar(require("fs"));
@@ -169,11 +170,25 @@ function getProviderPaths() {
         codexHomes,
     };
 }
+/** Ranked detection results are reused within a process for this long. */
+const DETECTION_CACHE_TTL_MS = 5_000;
+let detectionCache = null;
+/** Forget the memoised ranking. Test-only. */
+function _resetProviderDetectionCache() {
+    detectionCache = null;
+}
 /**
- * Returns all provider IDs whose data directories exist on the filesystem.
- * Ordered by most-recent activity first.
+ * Providers with data on disk, most recently active first.
+ *
+ * Detection walks every provider's session corpus (a recursive stat over
+ * `~/.claude/projects`, every Codex home, and the OpenCode data dir), so the
+ * ranking is memoised briefly: the CLI resolves the provider several times per
+ * command and the extension asks again on every settings-driven re-detect.
  */
-function getAllDetectedProviders() {
+function rankDetectedProviders(now = Date.now()) {
+    if (detectionCache && now - detectionCache.at < DETECTION_CACHE_TTL_MS) {
+        return detectionCache.ranked;
+    }
     const { claudeBase, openCodeDbPath, openCodeStorageDir, codexHomes } = getProviderPaths();
     const hasClaude = fs.existsSync(claudeBase);
     const hasOpenCode = fs.existsSync(openCodeStorageDir) || fs.existsSync(openCodeDbPath);
@@ -186,7 +201,16 @@ function getAllDetectedProviders() {
     if (hasCodex)
         available.push({ id: 'codex', mtime: getCodexActivityMtime() });
     available.sort((a, b) => b.mtime - a.mtime);
-    return available.map((a) => a.id);
+    const ranked = available.map((a) => a.id);
+    detectionCache = { at: now, ranked };
+    return ranked;
+}
+/**
+ * Returns all provider IDs whose data directories exist on the filesystem.
+ * Ordered by most-recent activity first.
+ */
+function getAllDetectedProviders() {
+    return [...rankDetectedProviders()];
 }
 /**
  * Detects the most appropriate provider based on filesystem presence and recency.
@@ -195,24 +219,5 @@ function getAllDetectedProviders() {
 function detectProvider(override) {
     if (override && override !== 'auto')
         return override;
-    const { claudeBase, openCodeDbPath, openCodeStorageDir, codexHomes } = getProviderPaths();
-    const hasClaude = fs.existsSync(claudeBase);
-    const hasOpenCode = fs.existsSync(openCodeStorageDir) || fs.existsSync(openCodeDbPath);
-    const hasCodex = codexHomes.some((codexHome) => fs.existsSync(path.join(codexHome, 'sessions')) || hasCodexStateDb(codexHome));
-    const available = [];
-    if (hasClaude) {
-        available.push({ id: 'claude-code', mtime: getClaudeActivityMtime(claudeBase) });
-    }
-    if (hasOpenCode) {
-        available.push({ id: 'opencode', mtime: getOpenCodeActivityMtime() });
-    }
-    if (hasCodex) {
-        available.push({ id: 'codex', mtime: getCodexActivityMtime() });
-    }
-    if (available.length === 0)
-        return 'claude-code';
-    if (available.length === 1)
-        return available[0].id;
-    available.sort((a, b) => b.mtime - a.mtime);
-    return available[0].id;
+    return rankDetectedProviders()[0] ?? 'claude-code';
 }

package/dist/providers/factory.d.ts

@@ -5,6 +5,12 @@ export interface CreateSessionProvidersOptions {
 }
 export interface CreateSessionProvidersResult {
     providers: SessionProviderBase[];
+    /**
+     * Live, not a snapshot: the providers keep the emit closure and update
+     * entries in place (one per provider/kind/phase) as they run, so this array
+     * reflects the latest diagnostics whenever it is read. Copy it to freeze a
+     * point in time; use `onDiagnostic` to observe each emission.
+     */
     diagnostics: SessionProviderDiagnostic[];
 }
 /**

package/dist/providers/openCode.d.ts

@@ -78,6 +78,8 @@ export declare class OpenCodeProvider implements SessionProviderBase {
     isSessionFile(filename: string): boolean;
     getSessionId(sessionPath: string): string;
     encodeWorkspacePath(workspacePath: string): string;
+    /** Session title from the metadata cache or the database; null without either. */
+    private extractSessionLabelFromMetadata;
     extractSessionLabel(sessionPath: string): string | null;
     extractSessionLabelsAsync(sessionPaths: readonly string[]): Promise<Map<string, string | null>>;
     private extractSessionLabelFromFiles;