sidekick-shared 0.24.5 → 0.26.0

package/dist/providers/openCode.js

@@ -57,9 +57,11 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const sessionContext_1 = require("../context/sessionContext");
+const sessionStats_1 = require("../sessionStats");
 const openCodeParser_1 = require("../parsers/openCodeParser");
 const openCodeDatabase_1 = require("./openCodeDatabase");
 const zaiQuota_1 = require("../zaiQuota");
+const diagnostics_1 = require("./diagnostics");
 const modelContext_1 = require("../modelContext");
 // ---------------------------------------------------------------------------
 // Helper functions
@@ -169,6 +171,25 @@ function makeDbSessionPath(dataDir, projectId, sessionId) {
 function isDbSessionPath(sessionPath) {
     return sessionPath.includes(path.sep + DB_SESSION_PREFIX + path.sep);
 }
+/**
+ * Whether a session recorded in `sessionDirectory` belongs to `workspacePath`.
+ *
+ * A session started inside the workspace (the workspace itself or any
+ * subdirectory, e.g. a monorepo package) matches. A session started in a
+ * *parent* of the workspace does not: a sub-package workspace must not list
+ * every session of the enclosing repo as its own.
+ */
+function workspaceMatches(sessionDirectory, workspacePath) {
+    const session = path
+        .resolve(sessionDirectory)
+        .replace(/[\\/]+$/, '')
+        .toLowerCase();
+    const workspace = path
+        .resolve(workspacePath)
+        .replace(/[\\/]+$/, '')
+        .toLowerCase();
+    return session === workspace || session.startsWith(workspace + path.sep);
+}
 /** Extract project ID from a synthetic DB session path. */
 function extractProjectIdFromDbPath(sessionPath) {
     const prefix = path.sep + DB_SESSION_PREFIX + path.sep;
@@ -310,18 +331,15 @@ function normalizePath(input) {
         return path.resolve(input);
     }
 }
-// ---------------------------------------------------------------------------
-// File-based reader (legacy fallback)
-// ---------------------------------------------------------------------------
-/**
- * Incremental reader for file-based OpenCode sessions.
- *
- * Tracks which message IDs have been seen and reads new messages
- * plus their parts on each readNew() call.
- */
+function messageCreatedMs(message) {
+    const created = message.time?.created;
+    const ms = typeof created === 'number' ? created : Date.parse(String(created ?? ''));
+    return Number.isFinite(ms) ? ms : 0;
+}
 class OpenCodeFileReader {
     sessionId;
     seenMessages = new Map();
+    pendingSkip = 0;
     storageBase;
     constructor(sessionId) {
         this.sessionId = sessionId;
@@ -338,47 +356,47 @@ class OpenCodeFileReader {
         catch {
             return [];
         }
-        const newEvents = [];
+        const entries = [];
         for (const file of messageFiles) {
             const msgId = path.basename(file, '.json');
             const messagePath = path.join(messageDir, file);
             const message = readJsonSafe(messagePath);
             if (!message)
                 continue;
-            let messageMtimeMs = 0;
+            let mtimeMs = 0;
             try {
-                messageMtimeMs = fs.statSync(messagePath).mtimeMs;
+                mtimeMs = fs.statSync(messagePath).mtimeMs;
             }
             catch {
-                messageMtimeMs = 0;
+                mtimeMs = 0;
             }
-            const partDir = path.join(this.storageBase, 'part', msgId);
-            let parts = [];
-            if (fs.existsSync(partDir)) {
-                try {
-                    parts = fs
-                        .readdirSync(partDir)
-                        .filter((f) => f.endsWith('.json'))
-                        .map((f) => readJsonSafe(path.join(partDir, f)))
-                        .filter((p) => p !== null);
-                }
-                catch {
-                    // Skip unreadable part directories
-                }
+            const parts = this.readParts(msgId);
+            entries.push({ msgId, message, mtimeMs, parts, partIds: new Set(parts.map((p) => p.id)) });
+        }
+        if (this.pendingSkip > 0) {
+            // A position for this reader is a message count (see getPosition()), so a
+            // seek marks the oldest N messages as already seen without emitting them.
+            const ordered = [...entries].sort((a, b) => messageCreatedMs(a.message) - messageCreatedMs(b.message) ||
+                a.msgId.localeCompare(b.msgId));
+            for (const entry of ordered.slice(0, this.pendingSkip)) {
+                this.seenMessages.set(entry.msgId, { partIds: entry.partIds, mtimeMs: entry.mtimeMs });
             }
-            const partIds = new Set(parts.map((part) => part.id));
-            const previous = this.seenMessages.get(msgId);
+            this.pendingSkip = 0;
+        }
+        const newEvents = [];
+        for (const entry of entries) {
+            const previous = this.seenMessages.get(entry.msgId);
             const isNewMessage = !previous;
             let hasNewParts = false;
             if (previous) {
-                if (previous.mtimeMs !== messageMtimeMs) {
+                if (previous.mtimeMs !== entry.mtimeMs) {
                     hasNewParts = true;
                 }
-                else if (partIds.size !== previous.partIds.size) {
+                else if (entry.partIds.size !== previous.partIds.size) {
                     hasNewParts = true;
                 }
                 else {
-                    for (const partId of partIds) {
+                    for (const partId of entry.partIds) {
                         if (!previous.partIds.has(partId)) {
                             hasNewParts = true;
                             break;
@@ -387,19 +405,36 @@ class OpenCodeFileReader {
                 }
             }
             if (isNewMessage || hasNewParts) {
-                newEvents.push(...(0, openCodeParser_1.convertOpenCodeMessage)(message, parts));
-                this.seenMessages.set(msgId, { partIds, mtimeMs: messageMtimeMs });
+                newEvents.push(...(0, openCodeParser_1.convertOpenCodeMessage)(entry.message, entry.parts));
+                this.seenMessages.set(entry.msgId, { partIds: entry.partIds, mtimeMs: entry.mtimeMs });
             }
         }
         // Sort by timestamp
         return newEvents.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
     }
+    readParts(msgId) {
+        const partDir = path.join(this.storageBase, 'part', msgId);
+        if (!fs.existsSync(partDir))
+            return [];
+        try {
+            return fs
+                .readdirSync(partDir)
+                .filter((f) => f.endsWith('.json'))
+                .map((f) => readJsonSafe(path.join(partDir, f)))
+                .filter((p) => p !== null);
+        }
+        catch {
+            // Skip unreadable part directories
+            return [];
+        }
+    }
     readAll() {
         this.reset();
         return this.readNew();
     }
     reset() {
         this.seenMessages.clear();
+        this.pendingSkip = 0;
     }
     exists() {
         return fs.existsSync(path.join(this.storageBase, 'message', this.sessionId));
@@ -410,8 +445,10 @@ class OpenCodeFileReader {
     getPosition() {
         return this.seenMessages.size;
     }
-    seekTo(_position) {
-        // File-backed reader does not support seeking — full replay required
+    seekTo(position) {
+        // Positions are message counts (getPosition()), so the next readNew() marks
+        // the oldest `position` messages as seen and emits only what follows.
+        this.pendingSkip = Number.isFinite(position) && position > 0 ? Math.floor(position) : 0;
     }
     wasTruncated() {
         return false; // JSON files don't truncate
@@ -426,11 +463,15 @@ class OpenCodeFileReader {
  * Uses time_updated timestamps to track which data has been seen,
  * querying only for newer messages/parts on each readNew() call.
  */
+/** How long a database-backed reader trusts its last session-row check. */
+const DB_EXISTS_MEMO_MS = 30_000;
 class OpenCodeDbReader {
     sessionId;
     db;
     lastTimeUpdated = 0;
     hasReadOnce = false;
+    existsCheckedAtMs = 0;
+    existsResult = true;
     constructor(sessionId, db) {
         this.sessionId = sessionId;
         this.db = db;
@@ -616,10 +657,22 @@ class OpenCodeDbReader {
         this.hasReadOnce = false;
     }
     exists() {
-        // DB-backed sessions are durable rows rather than ephemeral files.
-        // Treat transient sqlite timeout/read failures as "still exists" so
-        // SessionMonitor does not flap into discovery mode.
-        return true;
+        // DB-backed sessions are durable rows rather than ephemeral files. The row
+        // check costs a sqlite3 subprocess, so it is memoised, and a transient
+        // query failure still reports "exists" so SessionMonitor does not flap
+        // into discovery mode.
+        const now = Date.now();
+        if (now - this.existsCheckedAtMs < DB_EXISTS_MEMO_MS)
+            return this.existsResult;
+        this.existsCheckedAtMs = now;
+        try {
+            const row = this.db.getSession(this.sessionId);
+            this.existsResult = row !== null || this.db.getRuntimeStatus().kind === 'query_failed';
+        }
+        catch {
+            this.existsResult = true;
+        }
+        return this.existsResult;
     }
     flush() {
         // No-op for DB reading
@@ -650,10 +703,14 @@ class OpenCodeProvider {
     db = null;
     dbInitialized = false;
     dbStatus = { available: false, kind: 'db_missing' };
+    diagnostics;
     /** Cache of session metadata populated during listing */
     sessionMetaCache = new Map();
     /** Runtime-reported context window limit (overrides static map when set). */
     dynamicContextWindowLimit = null;
+    constructor(options = {}) {
+        this.diagnostics = new diagnostics_1.ProviderDiagnosticTracker(this.id, options);
+    }
     /** Lazy-initialize the database connection. */
     ensureDb() {
         if (this.dbInitialized)
@@ -667,12 +724,31 @@ class OpenCodeProvider {
         this.dbStatus = db.getRuntimeStatus();
         return this.db;
     }
+    async ensureDbAsync() {
+        if (this.db)
+            return this.db;
+        return new openCodeDatabase_1.OpenCodeDatabase(getOpenCodeDataDir());
+    }
+    /**
+     * 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 cut them off from the file-storage fallback.
+     */
+    adoptDbIfAvailable(db) {
+        if (this.db || !db.getRuntimeStatus().available)
+            return;
+        this.db = db;
+        this.dbInitialized = true;
+    }
     getRuntimeStatus() {
         const db = this.ensureDb();
         if (db)
             return db.getRuntimeStatus();
         return this.dbStatus;
     }
+    getLastOperationStatus() {
+        return this.diagnostics.getLastOperationStatus();
+    }
     canMonitorDirectory(dir) {
         if (fs.existsSync(dir))
             return true;
@@ -738,8 +814,10 @@ class OpenCodeProvider {
         const db = this.ensureDb();
         const dbStatus = this.getRuntimeStatus();
         const projectId = resolveProjectId(workspacePath, db, dbStatus);
-        if (!projectId)
+        if (!projectId) {
+            this.recordDatabaseStatus('findActiveSession', dbStatus.kind === 'db_missing');
             return null;
+        }
         // DB primary
         if (db) {
             const session = db.getMostRecentSession(projectId);
@@ -749,14 +827,18 @@ class OpenCodeProvider {
                     title: session.title,
                     timeUpdated: session.time_updated,
                 });
+                this.recordDatabaseStatus('findActiveSession', true);
                 return syntheticPath;
             }
         }
         if (dbStatus.kind !== 'db_missing') {
+            this.recordDatabaseStatus('findActiveSession', dbStatus.available);
             return null;
         }
         // File fallback
-        return this.findActiveSessionFromFiles(projectId);
+        const result = this.findActiveSessionFromFiles(projectId);
+        this.recordDatabaseStatus('findActiveSession', true);
+        return result;
     }
     findActiveSessionFromFiles(projectId) {
         const sessionDir = path.join(getStorageDir(), 'session', projectId);
@@ -817,18 +899,64 @@ class OpenCodeProvider {
         const db = this.ensureDb();
         const dbStatus = this.getRuntimeStatus();
         const projectId = resolveProjectId(workspacePath, db, dbStatus);
-        if (!projectId)
+        if (!projectId) {
+            this.recordDatabaseStatus('findAllSessions', dbStatus.kind === 'db_missing');
             return [];
+        }
         // DB primary
         if (db) {
-            return this.mapDbSessions(projectId);
+            const sessions = this.mapDbSessions(projectId);
+            this.recordDatabaseStatus('findAllSessions', true);
+            return sessions;
         }
         if (dbStatus.kind !== 'db_missing') {
+            this.recordDatabaseStatus('findAllSessions', dbStatus.available);
             return [];
         }
         // File fallback
         const sessionDir = path.join(getStorageDir(), 'session', projectId);
-        return this.findSessionsInDirectoryFromFiles(sessionDir);
+        const sessions = this.findSessionsInDirectoryFromFiles(sessionDir);
+        this.recordDatabaseStatus('findAllSessions', true);
+        return sessions;
+    }
+    findSessionById(workspacePath, sessionId) {
+        const normalizedId = sessionId.trim();
+        if (!normalizedId || path.basename(normalizedId) !== normalizedId)
+            return null;
+        try {
+            const db = this.ensureDb();
+            if (db) {
+                const session = db.getSession(normalizedId);
+                if (session && workspaceMatches(session.directory, workspacePath)) {
+                    const syntheticPath = makeDbSessionPath(getOpenCodeDataDir(), session.project_id, session.id);
+                    this.sessionMetaCache.set(syntheticPath, {
+                        title: session.title,
+                        timeUpdated: session.time_updated,
+                    });
+                    this.recordDatabaseStatus('findSessionById', true);
+                    return syntheticPath;
+                }
+            }
+            const projectId = resolveProjectId(workspacePath, db, this.getRuntimeStatus());
+            if (projectId) {
+                const candidate = path.join(getStorageDir(), 'session', projectId, `${normalizedId}.json`);
+                try {
+                    if (fs.statSync(candidate).isFile()) {
+                        this.recordDatabaseStatus('findSessionById', true);
+                        return candidate;
+                    }
+                }
+                catch {
+                    // Missing legacy session is a normal miss.
+                }
+            }
+            this.recordDatabaseStatus('findSessionById', true);
+            return null;
+        }
+        catch {
+            this.recordDatabaseStatus('findSessionById', false);
+            return null;
+        }
     }
     findSessionsInDirectory(dir) {
         const db = this.ensureDb();
@@ -837,7 +965,9 @@ class OpenCodeProvider {
         if (db && dir.includes(path.sep + DB_SESSION_PREFIX + path.sep)) {
             const projectId = extractProjectIdFromDbPath(dir + path.sep + 'dummy.json');
             if (projectId) {
-                return this.mapDbSessions(projectId);
+                const sessions = this.mapDbSessions(projectId);
+                this.recordDatabaseStatus('findSessionsInDirectory', true);
+                return sessions;
             }
         }
         // For a DB-backed directory path ending with the project ID,
@@ -845,14 +975,19 @@ class OpenCodeProvider {
         if (db) {
             const dirName = path.basename(dir);
             if (db.hasProject(dirName)) {
-                return this.mapDbSessions(dirName);
+                const sessions = this.mapDbSessions(dirName);
+                this.recordDatabaseStatus('findSessionsInDirectory', true);
+                return sessions;
             }
         }
         if (dbStatus.kind !== 'db_missing') {
+            this.recordDatabaseStatus('findSessionsInDirectory', dbStatus.available);
             return [];
         }
         // File fallback
-        return this.findSessionsInDirectoryFromFiles(dir);
+        const sessions = this.findSessionsInDirectoryFromFiles(dir);
+        this.recordDatabaseStatus('findSessionsInDirectory', true);
+        return sessions;
     }
     findSessionsInDirectoryFromFiles(dir) {
         try {
@@ -879,6 +1014,159 @@ class OpenCodeProvider {
             return [];
         }
     }
+    listAllSessionFiles() {
+        try {
+            const db = this.ensureDb();
+            if (db) {
+                const dataDir = getOpenCodeDataDir();
+                const files = db.getAllSessions().map((session) => {
+                    const syntheticPath = makeDbSessionPath(dataDir, session.project_id, session.id);
+                    this.sessionMetaCache.set(syntheticPath, {
+                        title: session.title,
+                        timeUpdated: session.time_updated,
+                    });
+                    return {
+                        path: syntheticPath,
+                        mtime: new Date(session.time_updated),
+                        label: session.title ?? undefined,
+                        sizeBytes: 0,
+                        sessionId: session.id,
+                        workspacePath: session.directory,
+                        createdAt: new Date(session.time_created),
+                    };
+                });
+                this.recordDatabaseStatus('listAllSessionFiles', true);
+                return files;
+            }
+            if (this.getRuntimeStatus().kind !== 'db_missing') {
+                this.recordDatabaseStatus('listAllSessionFiles', true);
+                return [];
+            }
+            const root = path.join(getStorageDir(), 'session');
+            const results = [];
+            let projectDirs = [];
+            try {
+                projectDirs = fs.readdirSync(root, { withFileTypes: true });
+            }
+            catch {
+                this.recordDatabaseStatus('listAllSessionFiles', true);
+                return [];
+            }
+            for (const entry of projectDirs) {
+                if (!entry.isDirectory())
+                    continue;
+                for (const sessionPath of this.findSessionsInDirectoryFromFiles(path.join(root, entry.name))) {
+                    try {
+                        const stats = fs.statSync(sessionPath);
+                        results.push({
+                            path: sessionPath,
+                            mtime: stats.mtime,
+                            sizeBytes: stats.size,
+                            sessionId: path.basename(sessionPath, '.json'),
+                        });
+                    }
+                    catch {
+                        // Session vanished between listing and stat.
+                    }
+                }
+            }
+            this.recordDatabaseStatus('listAllSessionFiles', true);
+            return results.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+        }
+        catch {
+            this.recordDatabaseStatus('listAllSessionFiles', false);
+            return [];
+        }
+    }
+    async listSessionFilesAsync(workspacePath) {
+        const db = await this.ensureDbAsync();
+        const sessions = await db.getAllSessionsAsync();
+        this.dbStatus = db.getRuntimeStatus();
+        this.adoptDbIfAvailable(db);
+        if (this.dbStatus.available) {
+            const dataDir = getOpenCodeDataDir();
+            const files = [];
+            for (const session of sessions) {
+                if (workspacePath && !workspaceMatches(session.directory, workspacePath))
+                    continue;
+                const syntheticPath = makeDbSessionPath(dataDir, session.project_id, session.id);
+                this.sessionMetaCache.set(syntheticPath, {
+                    title: session.title,
+                    timeUpdated: session.time_updated,
+                });
+                files.push({
+                    path: syntheticPath,
+                    mtime: new Date(session.time_updated),
+                    label: session.title ?? undefined,
+                    sizeBytes: 0,
+                    sessionId: session.id,
+                    workspacePath: session.directory,
+                    createdAt: new Date(session.time_created),
+                });
+            }
+            this.recordDatabaseStatus('listSessionFilesAsync', true);
+            return files;
+        }
+        const root = path.join(getStorageDir(), 'session');
+        const results = [];
+        let projectDirs = [];
+        try {
+            projectDirs = await fs.promises.readdir(root, { withFileTypes: true });
+        }
+        catch {
+            this.recordDatabaseStatus('listSessionFilesAsync', true);
+            return [];
+        }
+        for (const project of projectDirs) {
+            if (!project.isDirectory())
+                continue;
+            let entries = [];
+            try {
+                entries = await fs.promises.readdir(path.join(root, project.name), {
+                    withFileTypes: true,
+                });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isFile() || !entry.name.endsWith('.json'))
+                    continue;
+                const sessionPath = path.join(root, project.name, entry.name);
+                try {
+                    const [stat, raw] = await Promise.all([
+                        fs.promises.stat(sessionPath),
+                        workspacePath ? fs.promises.readFile(sessionPath, 'utf8') : Promise.resolve(null),
+                    ]);
+                    let session = null;
+                    if (raw !== null) {
+                        try {
+                            session = JSON.parse(raw);
+                        }
+                        catch {
+                            continue;
+                        }
+                        const directory = session.directory;
+                        if (directory && !workspaceMatches(directory, workspacePath))
+                            continue;
+                    }
+                    results.push({
+                        path: sessionPath,
+                        mtime: stat.mtime,
+                        sizeBytes: stat.size,
+                        sessionId: path.basename(entry.name, '.json'),
+                        workspacePath: session?.directory,
+                    });
+                }
+                catch {
+                    // Skip inaccessible sessions.
+                }
+                await new Promise((resolve) => setImmediate(resolve));
+            }
+        }
+        this.recordDatabaseStatus('listSessionFilesAsync', true);
+        return results.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    }
     getAllProjectFolders(workspacePath) {
         const db = this.ensureDb();
         const folders = [];
@@ -917,14 +1205,19 @@ class OpenCodeProvider {
                 }
                 return b.lastModified.getTime() - a.lastModified.getTime();
             });
-            if (folders.length > 0)
+            if (folders.length > 0) {
+                this.recordDatabaseStatus('getAllProjectFolders', true);
                 return folders;
+            }
         }
         if (dbStatus.kind !== 'db_missing') {
+            this.recordDatabaseStatus('getAllProjectFolders', dbStatus.available);
             return [];
         }
         // File fallback
-        return this.getAllProjectFoldersFromFiles(workspacePath);
+        const fallback = this.getAllProjectFoldersFromFiles(workspacePath);
+        this.recordDatabaseStatus('getAllProjectFolders', true);
+        return fallback;
     }
     getAllProjectFoldersFromFiles(workspacePath) {
         const folders = [];
@@ -1019,23 +1312,79 @@ class OpenCodeProvider {
         const db = this.ensureDb();
         return resolveProjectId(workspacePath, db, this.getRuntimeStatus()) || workspacePath;
     }
-    extractSessionLabel(sessionPath) {
-        const db = this.ensureDb();
-        const sessionId = this.getSessionId(sessionPath);
+    /** Session title from the metadata cache or the database; null without either. */
+    extractSessionLabelFromMetadata(sessionPath) {
         // Check metadata cache first
         const cached = this.sessionMetaCache.get(sessionPath);
         if (cached?.title) {
             return truncateTitle(cached.title);
         }
         // DB lookup
+        const db = this.ensureDb();
         if (db) {
-            const session = db.getSession(sessionId);
+            const session = db.getSession(this.getSessionId(sessionPath));
             if (session?.title) {
+                this.recordDatabaseStatus('extractSessionLabel', true);
                 return truncateTitle(session.title);
             }
         }
+        return null;
+    }
+    extractSessionLabel(sessionPath) {
+        const fromMetadata = this.extractSessionLabelFromMetadata(sessionPath);
+        if (fromMetadata)
+            return fromMetadata;
         // File fallback
-        return this.extractSessionLabelFromFiles(sessionPath, sessionId);
+        const sessionId = this.getSessionId(sessionPath);
+        const label = this.extractSessionLabelFromFiles(sessionPath, sessionId);
+        this.recordDatabaseStatus('extractSessionLabel', label !== null || !isDbSessionPath(sessionPath));
+        return label;
+    }
+    async extractSessionLabelsAsync(sessionPaths) {
+        const results = new Map();
+        const unresolved = [];
+        for (const sessionPath of sessionPaths) {
+            const cached = this.sessionMetaCache.get(sessionPath);
+            if (cached)
+                results.set(sessionPath, cached.title ? truncateTitle(cached.title) : null);
+            else
+                unresolved.push(sessionPath);
+        }
+        if (unresolved.length > 0 && (!this.dbInitialized || this.dbStatus.available)) {
+            const db = await this.ensureDbAsync();
+            const byId = new Map(unresolved.map((item) => [this.getSessionId(item), item]));
+            const sessions = await db.getSessionsByIdsAsync([...byId.keys()]);
+            this.dbStatus = db.getRuntimeStatus();
+            this.adoptDbIfAvailable(db);
+            for (const session of sessions) {
+                const sessionPath = byId.get(session.id);
+                if (!sessionPath)
+                    continue;
+                this.sessionMetaCache.set(sessionPath, {
+                    title: session.title,
+                    timeUpdated: session.time_updated,
+                });
+                results.set(sessionPath, session.title ? truncateTitle(session.title) : null);
+            }
+        }
+        for (const sessionPath of unresolved) {
+            if (results.has(sessionPath))
+                continue;
+            if (isDbSessionPath(sessionPath)) {
+                results.set(sessionPath, null);
+                continue;
+            }
+            try {
+                const session = JSON.parse(await fs.promises.readFile(sessionPath, 'utf8'));
+                results.set(sessionPath, session.title ? truncateTitle(session.title) : null);
+            }
+            catch {
+                results.set(sessionPath, null);
+            }
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        this.recordDatabaseStatus('extractSessionLabelsAsync', true);
+        return results;
     }
     extractSessionLabelFromFiles(sessionPath, sessionId) {
         if (isDbSessionPath(sessionPath))
@@ -1343,80 +1692,18 @@ class OpenCodeProvider {
     getProjectsBaseDir() {
         return path.join(getStorageDir(), 'session');
     }
+    getWatchRoots() {
+        return [getOpenCodeDataDir(), this.getProjectsBaseDir()];
+    }
     // --- Stats ---
     readSessionStats(sessionPath) {
-        const sessionId = path.basename(sessionPath, '.json');
-        const db = this.ensureDb();
-        let messageCount = 0;
-        let startTime = '';
-        let endTime = '';
-        const tokens = { input: 0, output: 0, cacheWrite: 0, cacheRead: 0 };
-        const modelUsage = {};
-        const toolUsage = {};
-        let reportedCost = 0;
-        if (db) {
-            const messages = db.getMessagesForSession(sessionId);
-            const parts = db.getPartsForSession(sessionId);
-            for (const msg of messages) {
-                try {
-                    const data = JSON.parse(msg.data);
-                    const role = data.role;
-                    if (role === 'assistant' || role === 'user')
-                        messageCount++;
-                    const msgTokens = data.tokens;
-                    const cache = msgTokens?.cache;
-                    if (msgTokens) {
-                        tokens.input += msgTokens.input || 0;
-                        tokens.output += msgTokens.output || 0;
-                        tokens.cacheRead += cache?.read || 0;
-                        tokens.cacheWrite += cache?.write || 0;
-                    }
-                    if (data.cost)
-                        reportedCost += data.cost || 0;
-                    const modelId = data.modelID || 'unknown';
-                    if (role === 'assistant' && msgTokens) {
-                        if (!modelUsage[modelId])
-                            modelUsage[modelId] = { calls: 0, tokens: 0 };
-                        modelUsage[modelId].calls++;
-                        modelUsage[modelId].tokens +=
-                            (msgTokens.input || 0) + (msgTokens.output || 0);
-                    }
-                }
-                catch {
-                    /* skip */
-                }
-                if (!startTime)
-                    startTime = new Date(msg.time_created).toISOString();
-                endTime = new Date(msg.time_updated || msg.time_created).toISOString();
-            }
-            for (const part of parts) {
-                try {
-                    const data = JSON.parse(part.data);
-                    if (data.type === 'tool' || data.type === 'tool-invocation') {
-                        const toolName = data.tool || 'unknown';
-                        toolUsage[toolName] = (toolUsage[toolName] || 0) + 1;
-                    }
-                }
-                catch {
-                    /* skip */
-                }
-            }
-        }
-        return {
-            providerId: 'opencode',
-            sessionId,
-            filePath: sessionPath,
-            label: this.extractSessionLabel(sessionPath),
-            startTime,
-            endTime,
-            messageCount,
-            tokens,
-            modelUsage,
-            toolUsage,
-            compactionEstimate: 0,
-            truncationCount: 0,
-            reportedCost,
-        };
+        // One reader pass (database-backed or file-backed) feeds the shared
+        // aggregator, so compaction and truncation counts are real instead of the
+        // hardcoded zeros the direct SQLite read returned, and a session that
+        // cannot be read reports `availability: 'unavailable'` instead of zeros.
+        return (0, sessionStats_1.readSessionFileStats)(this, sessionPath, {
+            resolveLabel: () => this.extractSessionLabelFromMetadata(sessionPath),
+        });
     }
     readSessionContextSnapshot(sessionPath, options = {}) {
         return (0, sessionContext_1.readSessionContextSnapshot)(this, sessionPath, options);
@@ -1453,6 +1740,37 @@ class OpenCodeProvider {
         }
         return null;
     }
+    async getSessionMetadataAsync(sessionPath) {
+        if (!isDbSessionPath(sessionPath)) {
+            try {
+                return { mtime: (await fs.promises.stat(sessionPath)).mtime };
+            }
+            catch {
+                return null;
+            }
+        }
+        const cached = this.sessionMetaCache.get(sessionPath);
+        try {
+            const db = await this.ensureDbAsync();
+            const sessionId = this.getSessionId(sessionPath);
+            const session = (await db.getSessionsByIdsAsync([sessionId]))[0];
+            this.dbStatus = db.getRuntimeStatus();
+            this.adoptDbIfAvailable(db);
+            if (session) {
+                this.sessionMetaCache.set(sessionPath, {
+                    title: session.title,
+                    timeUpdated: session.time_updated,
+                });
+                this.recordDatabaseStatus('getSessionMetadataAsync', true);
+                return { mtime: new Date(session.time_updated) };
+            }
+            this.recordDatabaseStatus('getSessionMetadataAsync', cached !== undefined);
+        }
+        catch {
+            this.recordDatabaseStatus('getSessionMetadataAsync', cached !== undefined);
+        }
+        return cached ? { mtime: new Date(cached.timeUpdated) } : null;
+    }
     /**
      * Returns the latest assistant message's token snapshot for context window sizing.
      * Cumulative session totals are derived from readNew() events processed by SessionMonitor.
@@ -1599,9 +1917,25 @@ class OpenCodeProvider {
         this.db?.close();
         this.db = null;
         this.dbInitialized = false;
+        this.dbStatus = { available: false, kind: 'db_missing' };
         this.sessionMetaCache.clear();
         this.dynamicContextWindowLimit = null;
     }
+    recordDatabaseStatus(operation, usable) {
+        const status = this.db?.getRuntimeStatus() ?? this.dbStatus;
+        const diagnostic = (0, diagnostics_1.diagnosticFromRuntimeStatus)(this.id, 'query', status);
+        if (!diagnostic || status.kind === 'db_missing') {
+            // A genuinely absent OpenCode DB is expected for legacy file storage.
+            this.diagnostics.available(operation);
+            return;
+        }
+        this.diagnostics.degraded(operation, status, {
+            kind: diagnostic.kind,
+            severity: diagnostic.severity,
+            phase: diagnostic.phase,
+            message: diagnostic.message,
+        }, usable);
+    }
     // --- z.ai (GLM Coding Plan) compatibility quota derivation ---
     /**
      * Derives a z.ai coding-plan `QuotaState` from OpenCode assistant turns