sidekick-shared 0.24.5 → 0.26.0

package/dist/providers/codex.js

@@ -48,11 +48,13 @@ 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");
 const usageNormalization_1 = require("../usageNormalization");
@@ -72,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, ' ');
@@ -102,68 +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;
+/** 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
@@ -183,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() {
@@ -298,15 +193,73 @@ function readSessionMeta(rolloutPath) {
     }
     return null;
 }
-/** Read the CWD from a rollout file's session_meta. Cached. */
+async function readSessionMetaAsync(rolloutPath) {
+    // Mirrors readSessionMeta()/readFirstLines(): chunk-read until the first
+    // line is complete under the same 256 KiB cap — session_meta carries
+    // `instructions` and can far exceed a single chunk.
+    const maxBytes = 256 * 1024;
+    const chunkSize = 64 * 1024;
+    let handle = null;
+    try {
+        handle = await fs.promises.open(rolloutPath, 'r');
+        const chunks = [];
+        let totalRead = 0;
+        let newlineFound = false;
+        while (totalRead < maxBytes && !newlineFound) {
+            const buffer = Buffer.alloc(Math.min(chunkSize, maxBytes - totalRead));
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, totalRead);
+            if (bytesRead === 0)
+                break;
+            const chunk = buffer.subarray(0, bytesRead);
+            chunks.push(chunk);
+            totalRead += bytesRead;
+            newlineFound = chunk.includes(0x0a);
+        }
+        const firstLine = Buffer.concat(chunks).toString('utf8').split('\n', 1)[0]?.trim();
+        if (!firstLine)
+            return null;
+        const parsed = JSON.parse(firstLine);
+        return parsed.type === 'session_meta' ? parsed.payload : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+/**
+ * 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. */
+async function readSessionCwdAsync(rolloutPath) {
+    const cached = cwdCache.get(rolloutPath);
+    if (cached !== undefined)
+        return cached;
+    const meta = await readSessionMetaAsync(rolloutPath);
+    const cwd = meta?.cwd || null;
+    rememberCwd(rolloutPath, cwd);
     return cwd;
 }
 /** Check if a session's CWD matches a workspace path. */
@@ -333,48 +286,65 @@ function normalizePath(input) {
  */
 function extractFirstUserMessage(rolloutPath) {
     try {
-        const lines = readFirstLines(rolloutPath, 20);
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const parsed = JSON.parse(trimmed);
-                // Check response_item with user message
-                if (parsed.type === 'response_item') {
-                    const payload = parsed.payload;
-                    if (payload.role === 'user') {
-                        const content = payload.content;
-                        if (typeof content === 'string' && content.trim() && !isSystemInjection(content)) {
-                            return truncate(content, 60);
-                        }
-                        if (Array.isArray(content)) {
-                            for (const part of content) {
-                                const p = part;
-                                if (p.text?.trim() && !isSystemInjection(p.text)) {
-                                    return truncate(p.text, 60);
-                                }
+        return extractFirstUserMessageFromLines(readFirstLines(rolloutPath, 20));
+    }
+    catch {
+        return null;
+    }
+}
+function extractFirstUserMessageFromLines(lines) {
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            // Check response_item with user message
+            if (parsed.type === 'response_item') {
+                const payload = parsed.payload;
+                if (payload.role === 'user') {
+                    const content = payload.content;
+                    if (typeof content === 'string' && content.trim() && !isSystemInjection(content)) {
+                        return truncate(content, 60);
+                    }
+                    if (Array.isArray(content)) {
+                        for (const part of content) {
+                            const p = part;
+                            if (p.text?.trim() && !isSystemInjection(p.text)) {
+                                return truncate(p.text, 60);
                             }
                         }
                     }
                 }
-                // Check event_msg with user_message
-                if (parsed.type === 'event_msg') {
-                    const payload = parsed.payload;
-                    if (payload.type === 'user_message' && payload.message?.trim()) {
-                        return truncate(payload.message, 60);
-                    }
-                }
             }
-            catch {
-                // Skip malformed lines
+            // Check event_msg with user_message
+            if (parsed.type === 'event_msg') {
+                const payload = parsed.payload;
+                if (payload.type === 'user_message' && payload.message?.trim()) {
+                    return truncate(payload.message, 60);
+                }
             }
         }
-        return null;
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return null;
+}
+async function extractFirstUserMessageAsync(rolloutPath) {
+    let handle = null;
+    try {
+        handle = await fs.promises.open(rolloutPath, 'r');
+        const buffer = Buffer.alloc(256 * 1024);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        return extractFirstUserMessageFromLines(buffer.toString('utf8', 0, bytesRead).split('\n').slice(0, 20));
     }
     catch {
         return null;
     }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
 }
 /** Extract searchable text from a rollout line. */
 function extractSearchableText(line) {
@@ -661,9 +631,14 @@ class CodexProvider {
     displayName = 'Codex CLI';
     db = null;
     dbInitialized = false;
+    dbStatus = { available: false, kind: 'db_missing' };
+    diagnostics;
     dynamicContextWindowLimit = null;
     lastRateLimitsData = null;
     lastTokenUsageData = null;
+    constructor(options = {}) {
+        this.diagnostics = new diagnostics_1.ProviderDiagnosticTracker(this.id, options);
+    }
     // --- Database ---
     /** Lazy-initialize database connection. */
     ensureDb() {
@@ -675,8 +650,34 @@ class CodexProvider {
         if (db.isAvailable() && db.open()) {
             this.db = db;
         }
+        if (typeof db.getRuntimeStatus === 'function') {
+            this.dbStatus = db.getRuntimeStatus();
+        }
         return this.db;
     }
+    async ensureDbAsync() {
+        if (this.db)
+            return this.db;
+        return new codexDatabase_1.CodexDatabase(getCodexHome());
+    }
+    /**
+     * Cache an async-created database only after an operation proved it usable.
+     * Sync paths treat a cached `db` as "open() succeeded", so adopting an
+     * unproven instance would silently disable their file fallbacks.
+     */
+    adoptDbIfAvailable(db) {
+        if (this.db || !db.getRuntimeStatus().available)
+            return;
+        this.db = db;
+        this.dbInitialized = true;
+    }
+    getRuntimeStatus() {
+        const db = this.ensureDb();
+        return db && typeof db.getRuntimeStatus === 'function' ? db.getRuntimeStatus() : this.dbStatus;
+    }
+    getLastOperationStatus() {
+        return this.diagnostics.getLastOperationStatus();
+    }
     // --- Path resolution ---
     getSessionDirectory(workspacePath) {
         // Codex doesn't use workspace-encoded directories like Claude Code.
@@ -686,10 +687,13 @@ class CodexProvider {
         if (db) {
             const thread = db.getMostRecentThread(workspacePath);
             if (thread?.rollout_path) {
+                this.recordDatabaseFallback('getSessionDirectory', true);
                 return path.dirname(thread.rollout_path);
             }
         }
-        return getSessionsDir();
+        const directory = getSessionsDir();
+        this.recordDatabaseFallback('getSessionDirectory', true);
+        return directory;
     }
     discoverSessionDirectory(workspacePath) {
         // DB: find latest rollout directory for this workspace
@@ -697,23 +701,28 @@ class CodexProvider {
         if (db) {
             const thread = db.getMostRecentThread(workspacePath);
             if (thread?.rollout_path && fs.existsSync(thread.rollout_path)) {
+                this.recordDatabaseFallback('discoverSessionDirectory', true);
                 return path.dirname(thread.rollout_path);
             }
         }
         // 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)
+        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);
             }
         }
         // Fallback: return the most relevant base sessions dir if one exists
-        return getSessionsDir();
+        const directory = getSessionsDir();
+        this.recordDatabaseFallback('discoverSessionDirectory', true);
+        return directory;
     }
     // --- Session discovery ---
     findActiveSession(workspacePath) {
@@ -722,18 +731,19 @@ class CodexProvider {
         if (db) {
             const thread = db.getMostRecentThread(workspacePath);
             if (thread?.rollout_path && fs.existsSync(thread.rollout_path)) {
+                this.recordDatabaseFallback('findActiveSession', true);
                 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;
             }
         }
+        this.recordDatabaseFallback('findActiveSession', true);
         return null;
     }
     findAllSessions(workspacePath) {
@@ -744,30 +754,62 @@ class CodexProvider {
             const dbPaths = threads
                 .filter((t) => t.rollout_path && fs.existsSync(t.rollout_path))
                 .map((t) => t.rollout_path);
-            if (dbPaths.length > 0)
+            if (dbPaths.length > 0) {
+                this.recordDatabaseFallback('findAllSessions', true);
                 return dbPaths;
+            }
         }
-        // File scan
-        const files = findRolloutFilesInConfiguredHomes();
-        files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        return 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);
+        return sessions;
+    }
+    findSessionById(_workspacePath, sessionId) {
+        try {
+            const found = findCodexRolloutFile(sessionId);
+            this.recordDatabaseFallback('findSessionById', true);
+            return found;
+        }
+        catch {
+            this.recordDatabaseFallback('findSessionById', false);
+            return null;
+        }
     }
     /** Backward-compatible alias for findAllSessions. */
     findSessionFiles(workspacePath) {
         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() {
-        return findRolloutFilesInConfiguredHomes();
+        const files = findRolloutFilesInConfiguredHomes();
+        this.recordDatabaseFallback('listAllSessionFiles', true);
+        return files;
+    }
+    async listSessionFilesAsync(workspacePath) {
+        const results = [];
+        // 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;
+                info.workspacePath = cwd;
+            }
+            results.push(info);
+        }
+        // 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 = [];
@@ -787,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) {
@@ -800,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,
                 });
@@ -823,32 +870,69 @@ class CodexProvider {
             }
             return b.lastModified.getTime() - a.lastModified.getTime();
         });
+        this.recordDatabaseFallback('getAllProjectFolders', true);
         return folders;
     }
     // --- 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)
-                return truncate(thread.title, 60);
-            if (thread?.first_user_message)
-                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
-        return extractFirstUserMessage(sessionPath);
+        const label = extractFirstUserMessage(sessionPath);
+        this.recordDatabaseFallback('extractSessionLabel', true);
+        return label;
+    }
+    async extractSessionLabelsAsync(sessionPaths) {
+        const results = new Map();
+        const byId = new Map(sessionPaths.map((sessionPath) => [this.getSessionId(sessionPath), sessionPath]));
+        const db = await this.ensureDbAsync();
+        const threads = await db.getThreadsByIdsAsync([...byId.keys()]);
+        for (const thread of threads) {
+            const sessionPath = byId.get(thread.id);
+            if (!sessionPath)
+                continue;
+            const label = thread.title ?? thread.first_user_message;
+            if (label)
+                results.set(sessionPath, truncate(label, 60));
+        }
+        this.dbStatus = db.getRuntimeStatus();
+        this.adoptDbIfAvailable(db);
+        for (const sessionPath of sessionPaths) {
+            if (!results.has(sessionPath)) {
+                results.set(sessionPath, await extractFirstUserMessageAsync(sessionPath));
+                await new Promise((resolve) => setImmediate(resolve));
+            }
+        }
+        this.recordDatabaseFallback('extractSessionLabelsAsync', true);
+        return results;
     }
     // --- Data reading ---
     createReader(sessionPath) {
@@ -884,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);
@@ -1015,54 +1097,17 @@ class CodexProvider {
     getProjectsBaseDir() {
         return getSessionsDir();
     }
+    getWatchRoots() {
+        return getSessionsDirs();
+    }
     // --- 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);
@@ -1094,9 +1139,28 @@ class CodexProvider {
         this.db?.close();
         this.db = null;
         this.dbInitialized = false;
+        this.dbStatus = { available: false, kind: 'db_missing' };
         this.dynamicContextWindowLimit = null;
         this.lastRateLimitsData = null;
         this.lastTokenUsageData = null;
     }
+    recordDatabaseFallback(operation, usable) {
+        if (!this.dbInitialized) {
+            this.diagnostics.available(operation);
+            return;
+        }
+        const status = this.getRuntimeStatus();
+        const diagnostic = (0, diagnostics_1.diagnosticFromRuntimeStatus)(this.id, 'query', status);
+        if (!diagnostic) {
+            this.diagnostics.available(operation);
+            return;
+        }
+        this.diagnostics.degraded(operation, status, {
+            kind: diagnostic.kind,
+            severity: diagnostic.severity,
+            phase: diagnostic.phase,
+            message: diagnostic.message,
+        }, usable);
+    }
 }
 exports.CodexProvider = CodexProvider;