sidekick-shared 0.22.0 → 0.23.1

package/dist/parsers/subagentScanner.js

@@ -93,7 +93,7 @@ const reportedMissing = new Set();
  * }
  * ```
  */
-function scanSubagentDir(sessionDir, sessionId, logger) {
+function scanSubagentDir(sessionDir, sessionId, logger, skipFiles = new Set()) {
     const log = logger || (() => { });
     const subagentsDir = path.join(sessionDir, sessionId, 'subagents');
     const results = [];
@@ -110,6 +110,8 @@ function scanSubagentDir(sessionDir, sessionId, logger) {
         const files = fs.readdirSync(subagentsDir);
         log(`[SubagentScanner] Found ${files.length} files: ${files.join(', ')}`);
         for (const file of files) {
+            if (skipFiles.has(file))
+                continue;
             const match = file.match(AGENT_FILE_PATTERN);
             if (!match) {
                 continue;
@@ -169,10 +171,7 @@ function parseAgentFile(filePath, agentId, log) {
                 // Extract token usage from assistant messages
                 if (event.type === 'assistant' && event.message?.usage) {
                     const usage = event.message.usage;
-                    inputTokens +=
-                        (usage.input_tokens || 0) +
-                            (usage.cache_creation_input_tokens || 0) +
-                            (usage.cache_read_input_tokens || 0);
+                    inputTokens += usage.input_tokens || 0;
                     outputTokens += usage.output_tokens || 0;
                 }
                 // Extract agent type and description from Task tool invocation

package/dist/parsers/subagentTraceParser.js

@@ -141,7 +141,7 @@ function parseAgentTrace(filePath, agentId) {
                 }
                 // Format tool summary
                 let toolSummary;
-                if (sessionEvent.type === 'tool_use' && sessionEvent.tool) {
+                if (sessionEvent.tool) {
                     toolSummary = (0, toolSummary_1.formatToolSummary)(sessionEvent.tool.name, sessionEvent.tool.input);
                 }
                 events.push({
@@ -155,10 +155,7 @@ function parseAgentTrace(filePath, agentId) {
                 // Extract token usage
                 if (raw.type === 'assistant' && raw.message?.usage) {
                     const usage = raw.message.usage;
-                    inputTokens +=
-                        (usage.input_tokens || 0) +
-                            (usage.cache_creation_input_tokens || 0) +
-                            (usage.cache_read_input_tokens || 0);
+                    inputTokens += usage.input_tokens || 0;
                     outputTokens += usage.output_tokens || 0;
                 }
                 // Extract tool calls
@@ -251,7 +248,7 @@ function linkTraces(traces) {
                 for (const match of matches) {
                     const childId = match[1];
                     const child = traceById.get(childId);
-                    if (child && child !== trace) {
+                    if (child && child !== trace && !child.parentToolUseId) {
                         child.parentToolUseId = trace.agentId;
                         trace.children.push(child);
                     }
@@ -274,7 +271,7 @@ function linkTraces(traces) {
                 continue; // Already linked
             for (const traceEvent of potential.events) {
                 const evt = traceEvent.event;
-                if (evt.type === 'tool_use' && evt.tool?.name === 'Task') {
+                if (evt.type === 'assistant' && evt.tool?.name === 'Task') {
                     const taskTime = new Date(evt.timestamp).getTime();
                     // Within 2 seconds before child start
                     if (taskTime <= childStart && childStart - taskTime < 2000) {

package/dist/paths.d.ts

@@ -30,6 +30,16 @@ export declare function encodeWorkspacePath(workspacePath: string): string;
  * Resolves symlinks, then encodes for use as a filename.
  */
 export declare function getProjectSlug(cwd?: string): string;
+export interface ProjectIdentity {
+    cwd: string;
+    resolvedCwd: string;
+    canonicalSlug: string;
+    legacySlug: string;
+    candidates: string[];
+    hasLegacyMismatch: boolean;
+}
+/** Resolves the canonical project identity used by all new readers and writers. */
+export declare function resolveProjectIdentity(cwd?: string): ProjectIdentity;
 /**
  * Derives a project slug WITHOUT resolving symlinks.
  * Matches the VS Code extension's behavior (encodeWorkspacePath on raw path).

package/dist/paths.js

@@ -43,6 +43,7 @@ exports.getProjectDataPath = getProjectDataPath;
 exports.getGlobalDataPath = getGlobalDataPath;
 exports.encodeWorkspacePath = encodeWorkspacePath;
 exports.getProjectSlug = getProjectSlug;
+exports.resolveProjectIdentity = resolveProjectIdentity;
 exports.getProjectSlugRaw = getProjectSlugRaw;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -86,15 +87,28 @@ function encodeWorkspacePath(workspacePath) {
  * Resolves symlinks, then encodes for use as a filename.
  */
 function getProjectSlug(cwd) {
-    const dir = cwd || process.cwd();
+    return resolveProjectIdentity(cwd).canonicalSlug;
+}
+/** Resolves the canonical project identity used by all new readers and writers. */
+function resolveProjectIdentity(cwd) {
+    const dir = path.resolve(cwd || process.cwd());
     let resolved;
     try {
         resolved = fs.realpathSync(dir);
     }
     catch {
-        resolved = path.resolve(dir);
+        resolved = dir;
     }
-    return encodeWorkspacePath(resolved);
+    const canonicalSlug = encodeWorkspacePath(resolved);
+    const legacySlug = encodeWorkspacePath(dir);
+    return {
+        cwd: dir,
+        resolvedCwd: resolved,
+        canonicalSlug,
+        legacySlug,
+        candidates: canonicalSlug === legacySlug ? [canonicalSlug] : [canonicalSlug, legacySlug],
+        hasLegacyMismatch: canonicalSlug !== legacySlug,
+    };
 }
 /**
  * Derives a project slug WITHOUT resolving symlinks.
@@ -102,6 +116,5 @@ function getProjectSlug(cwd) {
  * Use this when reading data written by the extension.
  */
 function getProjectSlugRaw(cwd) {
-    const dir = cwd || process.cwd();
-    return encodeWorkspacePath(path.resolve(dir));
+    return resolveProjectIdentity(cwd).legacySlug;
 }

package/dist/projectMigration.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview One-time migration of legacy raw-slug project stores.
+ *
+ * 0.23.0 switched all readers and writers to the canonical
+ * (symlink-resolved) project slug. Workspaces whose literal path differs
+ * from its realpath still hold pre-0.23 data under the legacy raw slug;
+ * this helper copies those stores to the canonical slug so they stay
+ * visible without any manual merge.
+ *
+ * @module projectMigration
+ */
+import { type ProjectIdentity } from './paths';
+/**
+ * Copies legacy raw-slug project stores to the canonical slug, once.
+ *
+ * Only copies when the canonical file does not exist yet, so it can never
+ * overwrite newer data; the legacy file is kept as a read-only fallback.
+ * Best-effort per store — a failed copy leaves that store on the legacy
+ * read path.
+ *
+ * @returns The canonical paths that were created (empty when none).
+ */
+export declare function migrateLegacyProjectStores(cwdOrIdentity: string | ProjectIdentity): string[];

package/dist/projectMigration.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * @fileoverview One-time migration of legacy raw-slug project stores.
+ *
+ * 0.23.0 switched all readers and writers to the canonical
+ * (symlink-resolved) project slug. Workspaces whose literal path differs
+ * from its realpath still hold pre-0.23 data under the legacy raw slug;
+ * this helper copies those stores to the canonical slug so they stay
+ * visible without any manual merge.
+ *
+ * @module projectMigration
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateLegacyProjectStores = migrateLegacyProjectStores;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const paths_1 = require("./paths");
+/** Project-scoped JSON store subdomains shared by the extension and CLI. */
+const PROJECT_STORE_SUBDOMAINS = [
+    'tasks',
+    'decisions',
+    'notifications',
+    'knowledge-notes',
+    'plans',
+];
+/**
+ * Copies legacy raw-slug project stores to the canonical slug, once.
+ *
+ * Only copies when the canonical file does not exist yet, so it can never
+ * overwrite newer data; the legacy file is kept as a read-only fallback.
+ * Best-effort per store — a failed copy leaves that store on the legacy
+ * read path.
+ *
+ * @returns The canonical paths that were created (empty when none).
+ */
+function migrateLegacyProjectStores(cwdOrIdentity) {
+    const identity = typeof cwdOrIdentity === 'string' ? (0, paths_1.resolveProjectIdentity)(cwdOrIdentity) : cwdOrIdentity;
+    if (!identity.hasLegacyMismatch)
+        return [];
+    const pairs = PROJECT_STORE_SUBDOMAINS.map((subdomain) => [
+        (0, paths_1.getProjectDataPath)(identity.legacySlug, subdomain),
+        (0, paths_1.getProjectDataPath)(identity.canonicalSlug, subdomain),
+    ]);
+    pairs.push([
+        path.join((0, paths_1.getConfigDir)(), 'handoffs', `${identity.legacySlug}-latest.md`),
+        path.join((0, paths_1.getConfigDir)(), 'handoffs', `${identity.canonicalSlug}-latest.md`),
+    ]);
+    const migrated = [];
+    for (const [legacyPath, canonicalPath] of pairs) {
+        try {
+            if (!fs.existsSync(legacyPath) || fs.existsSync(canonicalPath))
+                continue;
+            fs.mkdirSync(path.dirname(canonicalPath), { recursive: true });
+            fs.copyFileSync(legacyPath, canonicalPath, fs.constants.COPYFILE_EXCL);
+            migrated.push(canonicalPath);
+        }
+        catch {
+            // Best effort: an unmigrated store falls back to the legacy read path.
+        }
+    }
+    return migrated;
+}

package/dist/providerStatus.js

@@ -24,7 +24,7 @@ function fallbackState() {
  */
 async function fetchStatusPage(baseUrl) {
     try {
-        const statusRes = await fetch(`${baseUrl}/api/v2/status.json`);
+        const statusRes = await fetchWithTimeout(`${baseUrl}/api/v2/status.json`);
         if (!statusRes.ok)
             return fallbackState();
         const statusData = await statusRes.json();
@@ -36,7 +36,7 @@ async function fetchStatusPage(baseUrl) {
             return { indicator, description, affectedComponents: [], activeIncident: null, updatedAt };
         }
         // Degraded — fetch summary for components + incidents
-        const summaryRes = await fetch(`${baseUrl}/api/v2/summary.json`);
+        const summaryRes = await fetchWithTimeout(`${baseUrl}/api/v2/summary.json`);
         if (!summaryRes.ok) {
             return { indicator, description, affectedComponents: [], activeIncident: null, updatedAt };
         }
@@ -61,6 +61,17 @@ async function fetchStatusPage(baseUrl) {
         return fallbackState();
     }
 }
+async function fetchWithTimeout(url) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10_000);
+    timeout.unref();
+    try {
+        return await fetch(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 /**
  * Fetch current Claude API status from status.claude.com.
  *

package/dist/providers/claudeCode.js

@@ -46,6 +46,7 @@ exports.ClaudeCodeProvider = void 0;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const string_decoder_1 = require("string_decoder");
 const sessionContext_1 = require("../context/sessionContext");
 const jsonl_1 = require("../parsers/jsonl");
 const sessionPathResolver_1 = require("../parsers/sessionPathResolver");
@@ -97,6 +98,7 @@ class ClaudeCodeReader {
     filePosition = 0;
     events = [];
     _wasTruncated = false;
+    decoder = new string_decoder_1.StringDecoder('utf8');
     constructor(sessionPath) {
         this.sessionPath = sessionPath;
         this.parser = new jsonl_1.JsonlParser({
@@ -120,6 +122,7 @@ class ClaudeCodeReader {
                 this._wasTruncated = true;
                 this.filePosition = 0;
                 this.parser.reset();
+                this.decoder = new string_decoder_1.StringDecoder('utf8');
             }
             // No new content
             if (currentSize <= this.filePosition) {
@@ -129,11 +132,16 @@ class ClaudeCodeReader {
             const fd = fs.openSync(this.sessionPath, 'r');
             const bufferSize = currentSize - this.filePosition;
             const buffer = Buffer.alloc(bufferSize);
-            fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
-            fs.closeSync(fd);
-            const chunk = buffer.toString('utf-8');
+            let bytesRead = 0;
+            try {
+                bytesRead = fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            const chunk = this.decoder.write(buffer.subarray(0, bytesRead));
             this.parser.processChunk(chunk);
-            this.filePosition = currentSize;
+            this.filePosition += bytesRead;
         }
         catch (error) {
             console.error(`ClaudeCodeReader: error reading ${this.sessionPath}: ${error}`);
@@ -147,13 +155,18 @@ class ClaudeCodeReader {
     reset() {
         this.filePosition = 0;
         this.parser.reset();
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
         this._wasTruncated = false;
     }
     exists() {
         return fs.existsSync(this.sessionPath);
     }
     flush() {
+        const finalChunk = this.decoder.end();
+        if (finalChunk)
+            this.parser.processChunk(finalChunk);
         this.parser.flush();
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     getPosition() {
         return this.filePosition;
@@ -161,6 +174,7 @@ class ClaudeCodeReader {
     seekTo(position) {
         this.filePosition = position;
         this.parser.reset();
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     wasTruncated() {
         return this._wasTruncated;

package/dist/providers/codex.js

@@ -46,6 +46,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodexProvider = void 0;
 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 codexParser_1 = require("../parsers/codexParser");
@@ -131,6 +132,23 @@ function findRolloutFiles(dir) {
     }
     return results;
 }
+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;
+}
 function findRolloutFilesInConfiguredHomes() {
     const results = [];
     const seen = new Set();
@@ -148,7 +166,7 @@ function findRolloutFilesInConfiguredHomes() {
 function getSessionsDir() {
     const dirs = getSessionsDirs();
     for (const dir of dirs) {
-        if (findRolloutFiles(dir).length > 0) {
+        if (hasRolloutFile(dir)) {
             return dir;
         }
     }
@@ -430,6 +448,7 @@ class CodexReader {
     filePosition = 0;
     lineBuffer = '';
     _wasTruncated = false;
+    decoder = new string_decoder_1.StringDecoder('utf8');
     constructor(rolloutPath, onContextWindowLimit, onRateLimits, onTokenUsage) {
         this.rolloutPath = rolloutPath;
         this.onContextWindowLimit = onContextWindowLimit;
@@ -455,6 +474,7 @@ class CodexReader {
                 this.filePosition = 0;
                 this.lineBuffer = '';
                 this.parser.reset();
+                this.decoder = new string_decoder_1.StringDecoder('utf8');
             }
             // No new content
             if (currentSize <= this.filePosition)
@@ -463,10 +483,15 @@ class CodexReader {
             const fd = fs.openSync(this.rolloutPath, 'r');
             const bufferSize = currentSize - this.filePosition;
             const buffer = Buffer.alloc(bufferSize);
-            fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
-            fs.closeSync(fd);
-            const chunk = buffer.toString('utf-8');
-            this.filePosition = currentSize;
+            let bytesRead = 0;
+            try {
+                bytesRead = fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            const chunk = this.decoder.write(buffer.subarray(0, bytesRead));
+            this.filePosition += bytesRead;
             // Process lines
             const text = this.lineBuffer + chunk;
             const lines = text.split('\n');
@@ -497,11 +522,12 @@ class CodexReader {
             // Propagate last token usage snapshot to the provider
             const lastUsage = this.parser.getLastTokenUsage();
             if (lastUsage && this.onTokenUsage) {
+                const cacheReadTokens = lastUsage.cached_input_tokens || 0;
                 this.onTokenUsage({
-                    inputTokens: lastUsage.input_tokens || 0,
+                    inputTokens: Math.max(0, (lastUsage.input_tokens || 0) - cacheReadTokens),
                     outputTokens: lastUsage.output_tokens || 0,
                     cacheWriteTokens: 0,
-                    cacheReadTokens: lastUsage.cached_input_tokens || 0,
+                    cacheReadTokens,
                     reasoningTokens: lastUsage.reasoning_output_tokens || 0,
                     model: this.parser.getCurrentModel() || 'unknown',
                     timestamp: new Date(),
@@ -521,12 +547,14 @@ class CodexReader {
         this.filePosition = 0;
         this.lineBuffer = '';
         this.parser.reset();
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
         this._wasTruncated = false;
     }
     exists() {
         return fs.existsSync(this.rolloutPath);
     }
     flush() {
+        this.lineBuffer += this.decoder.end();
         // Process any remaining data in the line buffer
         if (this.lineBuffer.trim()) {
             try {
@@ -537,6 +565,7 @@ class CodexReader {
                 // Not a complete line yet
             }
         }
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     getPosition() {
         return this.filePosition;
@@ -544,6 +573,7 @@ class CodexReader {
     seekTo(position) {
         this.filePosition = position;
         this.lineBuffer = '';
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     wasTruncated() {
         return this._wasTruncated;
@@ -675,9 +705,10 @@ class CodexProvider {
         const db = this.ensureDb();
         if (db) {
             const cwdStats = db.getAllDistinctCwds();
+            const sessionsDir = getSessionsDir();
             for (const stat of cwdStats) {
                 seenCwds.set(stat.cwd, {
-                    dir: getSessionsDir(),
+                    dir: sessionsDir,
                     name: stat.cwd,
                     encodedName: stat.cwd,
                     sessionCount: stat.count,
@@ -971,11 +1002,9 @@ class CodexProvider {
         return this.lastTokenUsageData;
     }
     computeContextSize(usage) {
-        // OpenAI's input_tokens already includes cached_input_tokens (it's a subset,
-        // not additive like Anthropic's model). So inputTokens alone represents the
-        // full context window usage. This differs from OpenCode's formula which adds
-        // cacheWrite + cacheRead because Anthropic reports them separately.
-        return usage.inputTokens;
+        // Codex usage is normalized to the disjoint TokenUsage shape at the reader
+        // boundary, so reconstruct the full prompt/context from uncached + cached.
+        return usage.inputTokens + usage.cacheReadTokens;
     }
     // --- Rate limits (for vscode wrapper to build QuotaState) ---
     /** Get the last rate limits data received from token_count events. */

package/dist/providers/codexDatabase.d.ts

@@ -2,17 +2,7 @@
  * Read-only SQLite wrapper for Codex CLI's state database.
  * Ported from sidekick-vscode/src/services/providers/CodexDatabase.ts
  */
-export interface CodexDbThread {
-    id: string;
-    rollout_path: string;
-    cwd: string;
-    created_at: number;
-    updated_at: number;
-    title?: string;
-    tokens_used?: number;
-    first_user_message?: string;
-    forked_from_id?: string;
-}
+import type { CodexDbThread } from '../types/codex';
 export declare class CodexDatabase {
     private readonly dbPath;
     private sqlite3Available;

package/dist/providers/detect.js

@@ -100,6 +100,35 @@ function getMostRecentMtime(dir) {
         return 0;
     }
 }
+function getMostRecentFileMtime(dir, isCandidate, depth) {
+    if (depth < 0)
+        return 0;
+    let latest = 0;
+    try {
+        for (const entry of fs.readdirSync(dir)) {
+            const filePath = path.join(dir, entry);
+            try {
+                const stats = fs.statSync(filePath);
+                if (stats.isDirectory?.()) {
+                    latest = Math.max(latest, getMostRecentFileMtime(filePath, isCandidate, depth - 1));
+                }
+                else if (isCandidate(filePath)) {
+                    latest = Math.max(latest, stats.mtime.getTime());
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    catch {
+        return 0;
+    }
+    return latest;
+}
+function getClaudeActivityMtime(claudeBase) {
+    return getMostRecentFileMtime(claudeBase, (filePath) => filePath.endsWith('.jsonl'), 2);
+}
 function getOpenCodeActivityMtime() {
     const dataDir = (0, openCode_1.getOpenCodeDataDir)();
     const dbPath = path.join(dataDir, 'opencode.db');
@@ -123,7 +152,7 @@ function getCodexActivityMtime() {
         const dbMtime = getCodexStateDbMtime(codexHome);
         if (dbMtime > latest)
             latest = dbMtime;
-        const sessionsMtime = getMostRecentMtime(path.join(codexHome, 'sessions'));
+        const sessionsMtime = getMostRecentFileMtime(path.join(codexHome, 'sessions'), (filePath) => path.basename(filePath).startsWith('rollout-') && filePath.endsWith('.jsonl'), 4);
         if (sessionsMtime > latest)
             latest = sessionsMtime;
     }
@@ -151,7 +180,7 @@ function getAllDetectedProviders() {
     const hasCodex = codexHomes.some((codexHome) => fs.existsSync(path.join(codexHome, 'sessions')) || hasCodexStateDb(codexHome));
     const available = [];
     if (hasClaude)
-        available.push({ id: 'claude-code', mtime: getMostRecentMtime(claudeBase) });
+        available.push({ id: 'claude-code', mtime: getClaudeActivityMtime(claudeBase) });
     if (hasOpenCode)
         available.push({ id: 'opencode', mtime: getOpenCodeActivityMtime() });
     if (hasCodex)
@@ -172,7 +201,7 @@ function detectProvider(override) {
     const hasCodex = codexHomes.some((codexHome) => fs.existsSync(path.join(codexHome, 'sessions')) || hasCodexStateDb(codexHome));
     const available = [];
     if (hasClaude) {
-        available.push({ id: 'claude-code', mtime: getMostRecentMtime(claudeBase) });
+        available.push({ id: 'claude-code', mtime: getClaudeActivityMtime(claudeBase) });
     }
     if (hasOpenCode) {
         available.push({ id: 'opencode', mtime: getOpenCodeActivityMtime() });

package/dist/providers/openCodeDatabase.d.ts

@@ -2,37 +2,7 @@
  * Read-only SQLite wrapper for OpenCode's database.
  * Ported from sidekick-vscode/src/services/providers/OpenCodeDatabase.ts
  */
-export interface DbProject {
-    id: string;
-    worktree: string;
-    name: string | null;
-    sandboxes: string[];
-    time_created: number;
-    time_updated: number;
-}
-export interface DbSession {
-    id: string;
-    project_id: string;
-    title: string;
-    directory: string;
-    time_created: number;
-    time_updated: number;
-}
-export interface DbMessage {
-    id: string;
-    session_id: string;
-    time_created: number;
-    time_updated: number;
-    data: string;
-}
-export interface DbPart {
-    id: string;
-    message_id: string;
-    session_id: string;
-    time_created: number;
-    time_updated: number;
-    data: string;
-}
+import type { DbMessage, DbPart, DbProject, DbSession } from '../types/opencode';
 export interface OpenCodeDbRuntimeStatus {
     available: boolean;
     kind: 'available' | 'db_missing' | 'sqlite_missing' | 'sqlite_blocked' | 'query_failed';