codesesh 0.1.5 → 0.3.0

package/dist/{chunk-FG2FZIU5.js → chunk-UQI7CTEK.js}

@@ -2,7 +2,7 @@
 
 // ../core/dist/index.mjs
 import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
-import { join as join2, basename as basename2 } from "path";
+import { join as join2, basename as basename2, dirname } from "path";
 import { existsSync } from "fs";
 import { homedir, platform } from "os";
 import { join } from "path";
@@ -10,16 +10,18 @@ import { readFileSync } from "fs";
 import { basename } from "path";
 import { existsSync as existsSync3, statSync as statSync2 } from "fs";
 import { join as join3 } from "path";
+import { mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
 import { createRequire } from "module";
 import { createHash } from "crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { join as join4, basename as basename3, dirname } from "path";
+import { join as join4, basename as basename3, dirname as dirname3 } from "path";
 import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
 import { join as join5, basename as basename4 } from "path";
 import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
 import { join as join6, normalize } from "path";
 import { resolve, sep } from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync, mkdirSync } from "fs";
+import { existsSync as existsSync7, rmSync, unlinkSync } from "fs";
 import { join as join7 } from "path";
 import { homedir as homedir2 } from "os";
 var registrations = [];
@@ -205,6 +207,7 @@ var PerfTracer = class {
   }
 };
 var perf = new PerfTracer();
+var RECENT_SESSION_REVALIDATION_WINDOW_MS = 24 * 60 * 60 * 1e3;
 function parseTimestampMs(data) {
   const raw = String(data["timestamp"] ?? "").trim();
   if (!raw) return 0;
@@ -348,17 +351,30 @@ var ClaudeCodeAgent = class extends BaseAgent {
     if (!this.basePath) {
       return { hasChanges: false, timestamp: Date.now() };
     }
-    const changedIds = [];
-    for (const session of cachedSessions) {
+    const now = Date.now();
+    const changedIds = /* @__PURE__ */ new Set();
+    const recentSessions = cachedSessions.filter(
+      (session) => now - session.time_created <= RECENT_SESSION_REVALIDATION_WINDOW_MS
+    );
+    for (const session of recentSessions) {
+      changedIds.add(session.id);
       const meta = this.sessionMetaMap.get(session.id);
       if (!meta) continue;
+      delete this.sessionsIndexCache[basename2(dirname(meta.sourcePath))];
+    }
+    for (const session of cachedSessions) {
+      const meta = this.sessionMetaMap.get(session.id);
+      if (!meta) {
+        changedIds.add(session.id);
+        continue;
+      }
       try {
         const stat = statSync(meta.sourcePath);
         if (stat.mtimeMs > sinceTimestamp) {
-          changedIds.push(session.id);
+          changedIds.add(session.id);
         }
       } catch {
-        changedIds.push(session.id);
+        changedIds.add(session.id);
       }
     }
     try {
@@ -368,14 +384,14 @@ var ClaudeCodeAgent = class extends BaseAgent {
       }
       const hasNewFiles = totalFiles > cachedSessions.length;
       return {
-        hasChanges: changedIds.length > 0 || hasNewFiles,
-        changedIds,
+        hasChanges: changedIds.size > 0 || hasNewFiles,
+        changedIds: Array.from(changedIds),
         timestamp: Date.now()
       };
     } catch {
       return {
-        hasChanges: changedIds.length > 0,
-        changedIds,
+        hasChanges: changedIds.size > 0,
+        changedIds: Array.from(changedIds),
         timestamp: Date.now()
       };
     }
@@ -968,6 +984,19 @@ function openDbReadOnly(dbPath) {
     return null;
   }
 }
+function openDb(dbPath) {
+  if (!DatabaseConstructor) return null;
+  try {
+    mkdirSync(dirname2(dbPath), { recursive: true });
+    const db = DatabaseConstructor(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    db.pragma("foreign_keys = ON");
+    return db;
+  } catch {
+    return null;
+  }
+}
 function isSqliteAvailable() {
   return DatabaseConstructor !== null;
 }
@@ -1024,6 +1053,7 @@ var OpenCodeAgent = class extends BaseAgent {
         const timeUpdated = Number(row.time_updated ?? timeCreated);
         const slug = `opencode/${id}`;
         const directory = String(row.directory ?? "");
+        const stats = hasMessageTable ? this.readSessionStats(db, id) : null;
         heads.push({
           id,
           slug,
@@ -1032,10 +1062,10 @@ var OpenCodeAgent = class extends BaseAgent {
           time_created: timeCreated,
           time_updated: timeUpdated,
           stats: {
-            message_count: Number(row.message_count ?? 0),
-            total_input_tokens: 0,
-            total_output_tokens: 0,
-            total_cost: 0
+            message_count: stats?.message_count ?? Number(row.message_count ?? 0),
+            total_input_tokens: stats?.total_input_tokens ?? 0,
+            total_output_tokens: stats?.total_output_tokens ?? 0,
+            total_cost: stats?.total_cost ?? 0
           }
         });
         if (this.dbPath) {
@@ -1088,6 +1118,30 @@ var OpenCodeAgent = class extends BaseAgent {
   incrementalScan(_cachedSessions, _changedIds) {
     return this.scan();
   }
+  readSessionStats(db, sessionId) {
+    try {
+      const rows = db.prepare("SELECT data FROM message WHERE session_id = ? ORDER BY time_created ASC").all(sessionId);
+      let totalCost = 0;
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      for (const row of rows) {
+        const msgData = JSON.parse(String(row.data ?? "{}"));
+        const cost = Number(msgData.cost ?? 0);
+        const tokens = msgData.tokens;
+        totalCost += cost;
+        totalInputTokens += Number(tokens?.input ?? 0);
+        totalOutputTokens += Number(tokens?.output ?? 0);
+      }
+      return {
+        message_count: rows.length,
+        total_input_tokens: totalInputTokens,
+        total_output_tokens: totalOutputTokens,
+        total_cost: totalCost
+      };
+    } catch {
+      return null;
+    }
+  }
   getSessionData(sessionId) {
     if (!this.dbPath) {
       this.dbPath = this.findDbPath();
@@ -1301,7 +1355,7 @@ var KimiAgent = class extends BaseAgent {
   parseSessionDir(sessionDir) {
     try {
       const sessionId = basename3(sessionDir);
-      const projectHash = basename3(dirname(sessionDir));
+      const projectHash = basename3(dirname3(sessionDir));
       const contextFile = join4(sessionDir, "context.jsonl");
       const wireFile = join4(sessionDir, "wire.jsonl");
       if (!existsSync4(contextFile) && !existsSync4(wireFile)) return null;
@@ -1351,6 +1405,7 @@ var KimiAgent = class extends BaseAgent {
         perf.end(parseMarker);
         if (!meta) continue;
         this.sessionMetaMap.set(meta.id, meta);
+        const stats = this.extractStats(meta.sourcePath);
         heads.push({
           id: meta.id,
           slug: `kimi/${meta.id}`,
@@ -1358,12 +1413,7 @@ var KimiAgent = class extends BaseAgent {
           directory: meta.cwd,
           time_created: meta.createdAt,
           time_updated: meta.createdAt,
-          stats: {
-            message_count: 0,
-            total_input_tokens: 0,
-            total_output_tokens: 0,
-            total_cost: 0
-          }
+          stats
         });
       } catch {
       }
@@ -1421,6 +1471,7 @@ var KimiAgent = class extends BaseAgent {
         if (!meta) continue;
         if (changedIds.includes(meta.id)) {
           this.sessionMetaMap.set(meta.id, meta);
+          const stats = this.extractStats(meta.sourcePath);
           sessionMap.set(meta.id, {
             id: meta.id,
             slug: `kimi/${meta.id}`,
@@ -1428,12 +1479,7 @@ var KimiAgent = class extends BaseAgent {
             directory: meta.cwd,
             time_created: meta.createdAt,
             time_updated: meta.createdAt,
-            stats: {
-              message_count: 0,
-              total_input_tokens: 0,
-              total_output_tokens: 0,
-              total_cost: 0
-            }
+            stats
           });
         }
       } catch {
@@ -1861,6 +1907,7 @@ var CODEX_TOOL_TITLE_MAP = {
   spawn_agent: "subagent",
   subagent: "subagent"
 };
+var RECENT_SESSION_REVALIDATION_WINDOW_MS2 = 24 * 60 * 60 * 1e3;
 function extractSessionId(filename) {
   const stem = basename4(filename, ".jsonl");
   const parts = stem.split("-");
@@ -1878,6 +1925,9 @@ function parseTimestampMs2(data) {
     return 0;
   }
 }
+function extractModelName(raw) {
+  return typeof raw === "string" && raw.trim() ? raw.trim() : null;
+}
 function normalizeTitleText3(text) {
   const line = text.split("\n").find((l) => l.trim());
   return line?.trim().slice(0, 80) || "";
@@ -2051,34 +2101,43 @@ var CodexAgent = class extends BaseAgent {
     if (!this.basePath) {
       return { hasChanges: false, timestamp: Date.now() };
     }
-    const changedIds = [];
+    const now = Date.now();
+    const changedIds = /* @__PURE__ */ new Set();
+    const currentFiles = this.listRolloutFiles();
+    const currentIds = new Set(currentFiles.map((file) => extractSessionId(file)));
+    const cachedIds = new Set(cachedSessions.map((session) => session.id));
+    const recentIds = cachedSessions.filter((session) => now - session.time_created <= RECENT_SESSION_REVALIDATION_WINDOW_MS2).map((session) => session.id);
+    for (const sessionId of recentIds) {
+      changedIds.add(sessionId);
+    }
     for (const session of cachedSessions) {
       const meta = this.sessionMetaMap.get(session.id);
-      if (!meta) continue;
+      if (!currentIds.has(session.id)) {
+        changedIds.add(session.id);
+        continue;
+      }
+      if (!meta) {
+        changedIds.add(session.id);
+        continue;
+      }
       try {
         const stat = statSync4(meta.sourcePath);
         if (stat.mtimeMs > sinceTimestamp) {
-          changedIds.push(session.id);
+          changedIds.add(session.id);
         }
       } catch {
-        changedIds.push(session.id);
+        changedIds.add(session.id);
       }
     }
-    try {
-      const allFiles = this.listRolloutFiles();
-      const hasNewFiles = allFiles.length > cachedSessions.length;
-      return {
-        hasChanges: changedIds.length > 0 || hasNewFiles,
-        changedIds,
-        timestamp: Date.now()
-      };
-    } catch {
-      return {
-        hasChanges: changedIds.length > 0,
-        changedIds,
-        timestamp: Date.now()
-      };
+    const hasAddedSessions = currentFiles.some((file) => !cachedIds.has(extractSessionId(file)));
+    if (recentIds.length > 0) {
+      this.sessionIndexCache.clear();
     }
+    return {
+      hasChanges: changedIds.size > 0 || hasAddedSessions,
+      changedIds: Array.from(changedIds),
+      timestamp: Date.now()
+    };
   }
   /**
    * 增量扫描
@@ -2086,10 +2145,19 @@ var CodexAgent = class extends BaseAgent {
   incrementalScan(cachedSessions, changedIds) {
     if (!this.basePath) return cachedSessions;
     const sessionMap = new Map(cachedSessions.map((s) => [s.id, s]));
-    for (const file of this.listRolloutFiles()) {
+    const changedSet = new Set(changedIds);
+    const currentFiles = this.listRolloutFiles();
+    const currentIds = new Set(currentFiles.map((file) => extractSessionId(file)));
+    for (const session of cachedSessions) {
+      if (!currentIds.has(session.id)) {
+        sessionMap.delete(session.id);
+        this.sessionMetaMap.delete(session.id);
+      }
+    }
+    for (const file of currentFiles) {
       try {
         const sessionId = extractSessionId(file);
-        if (changedIds.includes(sessionId)) {
+        if (changedSet.has(sessionId)) {
           const head = this.parseSessionHead(file);
           if (head) {
             sessionMap.set(head.id, head);
@@ -2108,7 +2176,7 @@ var CodexAgent = class extends BaseAgent {
       } catch {
       }
     }
-    for (const file of this.listRolloutFiles()) {
+    for (const file of currentFiles) {
       try {
         const sessionId = extractSessionId(file);
         if (!sessionMap.has(sessionId)) {
@@ -2144,13 +2212,18 @@ var CodexAgent = class extends BaseAgent {
     let currentAssistantIndex = null;
     let latestAssistantTextIndex = null;
     let pendingPlan = null;
+    let activeModel = meta.model;
     let prevCumulativeTotal = 0;
     let prevInput = 0;
-    let prevCached = 0;
     let prevOutput = 0;
     let prevReasoning = 0;
     for (const record of parseJsonlLines(content)) {
       try {
+        const recordType = String(record["type"] ?? "");
+        if (recordType === "turn_context") {
+          const payload = record["payload"] ?? {};
+          activeModel = extractModelName(payload["model"]) ?? activeModel;
+        }
         const result = this.convertRecord(
           record,
           messages,
@@ -2163,7 +2236,12 @@ var CodexAgent = class extends BaseAgent {
         currentAssistantIndex = result.currentAssistantIndex;
         latestAssistantTextIndex = result.latestAssistantTextIndex;
         pendingPlan = result.pendingPlan;
-        const recordType = String(record["type"] ?? "");
+        if (currentAssistantIndex !== null && activeModel) {
+          const message = messages[currentAssistantIndex];
+          if (message?.role === "assistant" && !message.model) {
+            message.model = activeModel;
+          }
+        }
         if (recordType === "event_msg") {
           const payload = record["payload"] ?? {};
           if (String(payload["type"] ?? "") === "token_count") {
@@ -2175,33 +2253,29 @@ var CodexAgent = class extends BaseAgent {
               prevCumulativeTotal = cumulativeTotal;
               const lastUsage = info?.["last_token_usage"];
               let inputTokens = 0;
-              let cachedInputTokens = 0;
               let outputTokens = 0;
               let reasoningTokens = 0;
               if (lastUsage) {
                 inputTokens = Number(lastUsage["input_tokens"] ?? 0);
-                cachedInputTokens = Number(lastUsage["cached_input_tokens"] ?? 0);
                 outputTokens = Number(lastUsage["output_tokens"] ?? 0);
                 reasoningTokens = Number(lastUsage["reasoning_output_tokens"] ?? 0);
               } else if (cumulativeTotal > 0 && totalUsage) {
                 inputTokens = Number(totalUsage["input_tokens"] ?? 0) - prevInput;
-                cachedInputTokens = Number(totalUsage["cached_input_tokens"] ?? 0) - prevCached;
                 outputTokens = Number(totalUsage["output_tokens"] ?? 0) - prevOutput;
                 reasoningTokens = Number(totalUsage["reasoning_output_tokens"] ?? 0) - prevReasoning;
                 prevInput = Number(totalUsage["input_tokens"] ?? 0);
-                prevCached = Number(totalUsage["cached_input_tokens"] ?? 0);
                 prevOutput = Number(totalUsage["output_tokens"] ?? 0);
                 prevReasoning = Number(totalUsage["reasoning_output_tokens"] ?? 0);
               }
-              const uncachedInput = Math.max(0, inputTokens - cachedInputTokens);
-              if (uncachedInput || outputTokens || reasoningTokens) {
-                totalInputTokens += uncachedInput;
+              const totalInput = Math.max(0, inputTokens);
+              if (totalInput || outputTokens || reasoningTokens) {
+                totalInputTokens += totalInput;
                 totalOutputTokens += outputTokens + reasoningTokens;
                 for (let i = messages.length - 1; i >= 0; i--) {
                   const msg = messages[i];
                   if (msg.role === "assistant" && !msg.tokens) {
                     msg.tokens = {
-                      input: uncachedInput,
+                      input: totalInput,
                       output: outputTokens + reasoningTokens
                     };
                     break;
@@ -2277,6 +2351,7 @@ var CodexAgent = class extends BaseAgent {
     }
   }
   getTitleForSession(sessionId) {
+    this.loadSessionIndex();
     return this.sessionIndexCache.get(sessionId) ?? null;
   }
   // ---- Session head parsing ----
@@ -2292,7 +2367,7 @@ var CodexAgent = class extends BaseAgent {
       return null;
     }
     const payload = firstRecord["payload"] ?? {};
-    const createdAt = parseTimestampMs2(payload) || statSync4(filePath).mtimeMs;
+    const createdAt = parseTimestampMs2(firstRecord) || parseTimestampMs2(payload) || statSync4(filePath).mtimeMs;
     const indexTitle = this.getTitleForSession(sessionId);
     const messageTitle = this.extractTitleFromLines(lines);
     const directoryTitle = basenameTitle(payload["cwd"] ? String(payload["cwd"]) : null);
@@ -2304,7 +2379,6 @@ var CodexAgent = class extends BaseAgent {
     let totalOutputTokens = 0;
     let scanPrevCumulativeTotal = 0;
     let scanPrevInput = 0;
-    let scanPrevCached = 0;
     let scanPrevOutput = 0;
     let scanPrevReasoning = 0;
     const COUNTED_TYPES = /* @__PURE__ */ new Set(["message", "function_call", "function_call_output"]);
@@ -2312,10 +2386,13 @@ var CodexAgent = class extends BaseAgent {
       try {
         const data = JSON.parse(line);
         const recordType = String(data["type"] ?? "");
-        if (recordType === "session_meta") {
-          const p = data["payload"] ?? {};
-          const ts = parseTimestampMs2(p);
-          if (ts > updatedAt) updatedAt = ts;
+        const recordTs = parseTimestampMs2(data) || parseTimestampMs2(data["payload"] ?? {});
+        if (recordTs > updatedAt) updatedAt = recordTs;
+        if (recordType === "session_meta" || recordType === "turn_context") {
+          const payload2 = data["payload"] ?? {};
+          if (!model) {
+            model = extractModelName(payload2["model"]);
+          }
           continue;
         }
         if (recordType === "response_item") {
@@ -2340,26 +2417,22 @@ var CodexAgent = class extends BaseAgent {
               scanPrevCumulativeTotal = cumulativeTotal;
               const lastUsage = info?.["last_token_usage"];
               let inputTokens = 0;
-              let cachedInputTokens = 0;
               let outputTokens = 0;
               let reasoningTokens = 0;
               if (lastUsage) {
                 inputTokens = Number(lastUsage["input_tokens"] ?? 0);
-                cachedInputTokens = Number(lastUsage["cached_input_tokens"] ?? 0);
                 outputTokens = Number(lastUsage["output_tokens"] ?? 0);
                 reasoningTokens = Number(lastUsage["reasoning_output_tokens"] ?? 0);
               } else if (cumulativeTotal > 0 && totalUsage) {
                 inputTokens = Number(totalUsage["input_tokens"] ?? 0) - scanPrevInput;
-                cachedInputTokens = Number(totalUsage["cached_input_tokens"] ?? 0) - scanPrevCached;
                 outputTokens = Number(totalUsage["output_tokens"] ?? 0) - scanPrevOutput;
                 reasoningTokens = Number(totalUsage["reasoning_output_tokens"] ?? 0) - scanPrevReasoning;
                 scanPrevInput = Number(totalUsage["input_tokens"] ?? 0);
-                scanPrevCached = Number(totalUsage["cached_input_tokens"] ?? 0);
                 scanPrevOutput = Number(totalUsage["output_tokens"] ?? 0);
                 scanPrevReasoning = Number(totalUsage["reasoning_output_tokens"] ?? 0);
               }
-              const uncachedInput = Math.max(0, inputTokens - cachedInputTokens);
-              totalInputTokens += uncachedInput;
+              const totalInput = Math.max(0, inputTokens);
+              totalInputTokens += totalInput;
               totalOutputTokens += outputTokens + reasoningTokens;
             }
           }
@@ -3002,7 +3075,12 @@ var CursorAgent = class extends BaseAgent {
           const title = this.extractTitle(composer);
           const createdAt = composer.createdAt ?? 0;
           const updatedAt = composer.updatedAt ?? createdAt;
-          const messages = this.loadMessagesFromBubbles(db, composerId, sessionId);
+          const messages = this.loadMessagesFromBubbles(
+            db,
+            composerId,
+            sessionId,
+            composer.modelConfig?.modelName ?? composer.model ?? null
+          );
           const hasSubagents = Array.isArray(composer.subagentInfos) && composer.subagentInfos.length > 0;
           if (messages.length === 0 && !hasSubagents) {
             continue;
@@ -3114,7 +3192,12 @@ var CursorAgent = class extends BaseAgent {
       const title = this.extractTitle(composer);
       const createdAt = composer.createdAt ?? 0;
       const updatedAt = composer.updatedAt ?? createdAt;
-      const messages = this.loadMessagesFromBubbles(db, composerId, resolvedSessionId);
+      const messages = this.loadMessagesFromBubbles(
+        db,
+        composerId,
+        resolvedSessionId,
+        composer.modelConfig?.modelName ?? composer.model ?? null
+      );
       let totalInputTokens = 0;
       let totalOutputTokens = 0;
       for (const msg of messages) {
@@ -3222,11 +3305,11 @@ var CursorAgent = class extends BaseAgent {
     }
   }
   /** Load messages from bubbles (like agent-dump) */
-  loadMessagesFromBubbles(db, composerId, _sessionId) {
+  loadMessagesFromBubbles(db, composerId, _sessionId, initialModelName) {
     const messages = [];
     try {
       const rows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE ? ORDER BY rowid ASC").all(`bubbleId:${composerId}:%`);
-      let activeModelName = null;
+      let activeModelName = initialModelName;
       let messageIndex = 0;
       for (const row of rows) {
         try {
@@ -3241,7 +3324,7 @@ var CursorAgent = class extends BaseAgent {
           } else if (bubble.timestamp) {
             timestampMs = bubble.timestamp;
           }
-          if (role === "user" && bubble.modelInfo?.modelName) {
+          if (bubble.modelInfo?.modelName) {
             activeModelName = bubble.modelInfo.modelName;
           }
           const inputTokens = bubble.tokenCount?.inputTokens ?? 0;
@@ -3265,7 +3348,7 @@ var CursorAgent = class extends BaseAgent {
             time_created: timestampMs,
             time_completed: null,
             mode: role === "assistant" && parts.some((p) => p.type === "tool") ? "tool" : null,
-            model: activeModelName,
+            model: bubble.modelInfo?.modelName ?? activeModelName,
             provider: null,
             tokens: { input: inputTokens, output: outputTokens },
             cost: 0,
@@ -3424,89 +3507,438 @@ registerAgent({
   icon: "/icon/agent/cursor.svg",
   create: () => new CursorAgent()
 });
-var CACHE_VERSION = 2;
-var CACHE_FILENAME = "scan-cache.json";
+var CACHE_VERSION = 3;
+var CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
+var CACHE_FILENAME = "codesesh.db";
+var LEGACY_CACHE_FILENAME = "scan-cache.json";
+function getCacheDir() {
+  return join7(homedir2(), ".cache", "codesesh");
+}
 function getCachePath() {
-  return join7(homedir2(), ".cache", "codesesh", CACHE_FILENAME);
+  return join7(getCacheDir(), CACHE_FILENAME);
 }
-function ensureCacheDir() {
-  const cacheDir = join7(homedir2(), ".cache", "codesesh");
-  if (!existsSync7(cacheDir)) {
-    mkdirSync(cacheDir, { recursive: true });
-  }
+function getLegacyCachePath() {
+  return join7(getCacheDir(), LEGACY_CACHE_FILENAME);
 }
-function loadCachedSessions(agentName) {
+function hasCacheStorage() {
+  return existsSync7(getCachePath());
+}
+function withCacheDb(fn) {
+  const db = openDb(getCachePath());
+  if (!db) return null;
   try {
-    const cachePath = getCachePath();
-    if (!existsSync7(cachePath)) return null;
-    const data = JSON.parse(readFileSync6(cachePath, "utf-8"));
-    if (data.version !== CACHE_VERSION) return null;
-    const entry = data.entries[agentName];
-    if (!entry) return null;
-    const CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
-    if (Date.now() - entry.timestamp > CACHE_TTL) return null;
-    return { sessions: entry.sessions, meta: entry.meta || {}, timestamp: entry.timestamp };
+    ensureSchema(db);
+    return fn(db);
   } catch {
     return null;
+  } finally {
+    db.close();
   }
 }
-function saveCachedSessions(agentName, sessions, meta = {}) {
-  try {
-    ensureCacheDir();
-    const cachePath = getCachePath();
-    let data;
-    if (existsSync7(cachePath)) {
-      try {
-        data = JSON.parse(readFileSync6(cachePath, "utf-8"));
-        if (data.version !== CACHE_VERSION) {
-          data = { version: CACHE_VERSION, entries: {}, lastScanTime: 0 };
-        }
-      } catch {
-        data = { version: CACHE_VERSION, entries: {}, lastScanTime: 0 };
-      }
-    } else {
-      data = { version: CACHE_VERSION, entries: {}, lastScanTime: 0 };
+function ensureSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS cache_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_cache (
+      agent_name TEXT PRIMARY KEY,
+      timestamp INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS cached_sessions (
+      agent_name TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      session_json TEXT NOT NULL,
+      meta_json TEXT,
+      PRIMARY KEY (agent_name, session_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS session_documents (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_name TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      title TEXT NOT NULL,
+      directory TEXT NOT NULL,
+      time_created INTEGER NOT NULL,
+      time_updated INTEGER,
+      activity_time INTEGER NOT NULL,
+      content_text TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      indexed_at INTEGER NOT NULL,
+      UNIQUE(agent_name, session_id)
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS session_documents_fts USING fts5(
+      title,
+      content_text,
+      content='session_documents',
+      content_rowid='id'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS session_documents_ai AFTER INSERT ON session_documents BEGIN
+      INSERT INTO session_documents_fts(rowid, title, content_text)
+      VALUES (new.id, new.title, new.content_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS session_documents_ad AFTER DELETE ON session_documents BEGIN
+      INSERT INTO session_documents_fts(session_documents_fts, rowid, title, content_text)
+      VALUES ('delete', old.id, old.title, old.content_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS session_documents_au AFTER UPDATE ON session_documents BEGIN
+      INSERT INTO session_documents_fts(session_documents_fts, rowid, title, content_text)
+      VALUES ('delete', old.id, old.title, old.content_text);
+      INSERT INTO session_documents_fts(rowid, title, content_text)
+      VALUES (new.id, new.title, new.content_text);
+    END;
+  `);
+  const versionRow = db.prepare("SELECT value FROM cache_meta WHERE key = 'version'").get();
+  const version = Number(versionRow?.value ?? 0);
+  if (version === CACHE_VERSION) {
+    return;
+  }
+  db.exec(`
+    DELETE FROM agent_cache;
+    DELETE FROM cached_sessions;
+    DELETE FROM session_documents;
+    INSERT INTO session_documents_fts(session_documents_fts) VALUES ('rebuild');
+    INSERT INTO cache_meta(key, value)
+    VALUES ('version', '${CACHE_VERSION}')
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value;
+  `);
+}
+function sessionContentHash(session) {
+  return JSON.stringify([
+    session.slug,
+    session.title,
+    session.directory,
+    session.time_created,
+    session.time_updated ?? session.time_created,
+    session.stats.message_count,
+    session.stats.total_input_tokens,
+    session.stats.total_output_tokens,
+    session.stats.total_cost,
+    session.stats.total_tokens ?? 0
+  ]);
+}
+function escapeFtsTerm(value) {
+  return value.replaceAll('"', '""');
+}
+function toFtsQuery(input) {
+  const tokens = input.match(/"[^"]+"|\S+/g) ?? [];
+  return tokens.map((token) => {
+    if (/^OR$/i.test(token)) {
+      return "OR";
     }
-    data.entries[agentName] = {
-      sessions,
-      meta,
-      timestamp: Date.now(),
-      version: CACHE_VERSION
-    };
-    data.lastScanTime = Date.now();
-    writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+    if (token.startsWith('"') && token.endsWith('"')) {
+      return `"${escapeFtsTerm(token.slice(1, -1))}"`;
+    }
+    return `"${escapeFtsTerm(token)}"`;
+  }).join(" ");
+}
+function appendPlainText(value, chunks) {
+  if (value == null) return;
+  if (typeof value === "string") {
+    const normalized = value.trim();
+    if (normalized) {
+      chunks.push(normalized);
+    }
+    return;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    chunks.push(String(value));
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      appendPlainText(item, chunks);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    for (const nested of Object.values(value)) {
+      appendPlainText(nested, chunks);
+    }
+  }
+}
+function buildSessionContent(session) {
+  const chunks = [];
+  appendPlainText(session.title, chunks);
+  for (const message of session.messages) {
+    chunks.push(message.role);
+    appendPlainText(message.agent, chunks);
+    appendPlainText(message.model, chunks);
+    for (const part of message.parts) {
+      appendPlainText(part.type, chunks);
+      appendPlainText(part.title, chunks);
+      appendPlainText(part.nickname, chunks);
+      appendPlainText(part.tool, chunks);
+      appendPlainText(part.text, chunks);
+      appendPlainText(part.input, chunks);
+      appendPlainText(part.output, chunks);
+      appendPlainText(part.state, chunks);
+    }
+  }
+  return chunks.join("\n");
+}
+function deleteLegacyCacheFile() {
+  const legacyPath = getLegacyCachePath();
+  if (!existsSync7(legacyPath)) {
+    return;
+  }
+  try {
+    unlinkSync(legacyPath);
   } catch {
   }
 }
+function loadCachedSessions(agentName) {
+  if (!hasCacheStorage()) {
+    return null;
+  }
+  return withCacheDb((db) => {
+    const timestampRow = db.prepare("SELECT timestamp AS value FROM agent_cache WHERE agent_name = ?").get(agentName);
+    const timestamp = Number(timestampRow?.value ?? 0);
+    if (!timestamp || Date.now() - timestamp > CACHE_TTL) {
+      return null;
+    }
+    const rows = db.prepare(
+      `
+          SELECT session_json, meta_json
+          FROM cached_sessions
+          WHERE agent_name = ?
+          ORDER BY rowid
+        `
+    ).all(agentName);
+    const sessions = [];
+    const meta = {};
+    for (const row of rows) {
+      if (!row.session_json) {
+        continue;
+      }
+      const session = JSON.parse(row.session_json);
+      sessions.push(session);
+      if (row.meta_json) {
+        meta[session.id] = JSON.parse(row.meta_json);
+      }
+    }
+    return { sessions, meta, timestamp };
+  });
+}
+function saveCachedSessions(agentName, sessions, meta = {}) {
+  withCacheDb((db) => {
+    const deleteAgent = db.prepare("DELETE FROM agent_cache WHERE agent_name = ?");
+    const deleteSessions = db.prepare("DELETE FROM cached_sessions WHERE agent_name = ?");
+    const upsertAgent = db.prepare(`
+      INSERT INTO agent_cache(agent_name, timestamp)
+      VALUES (?, ?)
+      ON CONFLICT(agent_name) DO UPDATE SET timestamp = excluded.timestamp
+    `);
+    const insertSession = db.prepare(`
+      INSERT INTO cached_sessions(agent_name, session_id, session_json, meta_json)
+      VALUES (?, ?, ?, ?)
+    `);
+    const write = db.transaction(() => {
+      const timestamp = Date.now();
+      deleteAgent.run(agentName);
+      deleteSessions.run(agentName);
+      upsertAgent.run(agentName, timestamp);
+      for (const session of sessions) {
+        insertSession.run(
+          agentName,
+          session.id,
+          JSON.stringify(session),
+          meta[session.id] ? JSON.stringify(meta[session.id]) : null
+        );
+      }
+    });
+    write();
+    deleteLegacyCacheFile();
+  });
+}
 function clearCache() {
-  try {
-    const cachePath = getCachePath();
-    if (existsSync7(cachePath)) {
-      const data = {
-        version: CACHE_VERSION,
-        entries: {},
-        lastScanTime: 0
-      };
-      writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  if (!hasCacheStorage()) {
+    deleteLegacyCacheFile();
+    return;
+  }
+  withCacheDb((db) => {
+    db.exec(`
+      DELETE FROM agent_cache;
+      DELETE FROM cached_sessions;
+    `);
+  });
+  deleteLegacyCacheFile();
+  const cachePath = getCachePath();
+  const walPath = `${cachePath}-wal`;
+  const shmPath = `${cachePath}-shm`;
+  for (const filePath of [walPath, shmPath]) {
+    if (!existsSync7(filePath)) {
+      continue;
+    }
+    try {
+      rmSync(filePath, { force: true });
+    } catch {
     }
-  } catch {
   }
 }
 function getCacheInfo() {
-  try {
-    const cachePath = getCachePath();
-    if (!existsSync7(cachePath)) {
-      return { lastScanTime: null, size: 0 };
-    }
-    const data = JSON.parse(readFileSync6(cachePath, "utf-8"));
-    const size = Object.values(data.entries).reduce((sum, entry) => sum + entry.sessions.length, 0);
-    return {
-      lastScanTime: data.lastScanTime || null,
-      size
-    };
-  } catch {
+  if (!hasCacheStorage()) {
     return { lastScanTime: null, size: 0 };
   }
+  const info = withCacheDb((db) => {
+    const timestampRow = db.prepare("SELECT MAX(timestamp) AS value FROM agent_cache").get();
+    const sizeRow = db.prepare("SELECT COUNT(*) AS value FROM cached_sessions").get();
+    const lastScanTime = Number(timestampRow?.value ?? 0) || null;
+    const size = Number(sizeRow?.value ?? 0);
+    return { lastScanTime, size };
+  });
+  return info ?? { lastScanTime: null, size: 0 };
+}
+function syncSessionSearchIndex(agentName, sessions, loadSessionData) {
+  if (!hasCacheStorage()) {
+    return;
+  }
+  withCacheDb((db) => {
+    const existingRows = db.prepare(
+      "SELECT session_id, content_hash FROM session_documents WHERE agent_name = ? ORDER BY id"
+    ).all(agentName);
+    const existingMap = new Map(
+      existingRows.map((row) => [String(row.session_id), String(row.content_hash ?? "")])
+    );
+    const sessionMap = new Map(sessions.map((session) => [session.id, session]));
+    const toDelete = existingRows.map((row) => String(row.session_id)).filter((sessionId) => !sessionMap.has(sessionId));
+    const toUpsert = sessions.filter(
+      (session) => existingMap.get(session.id) !== sessionContentHash(session)
+    );
+    const loaded = toUpsert.map((session) => {
+      try {
+        const data = loadSessionData(session.id);
+        return {
+          session,
+          contentText: buildSessionContent(data),
+          contentHash: sessionContentHash(session)
+        };
+      } catch {
+        return null;
+      }
+    }).filter((entry) => entry !== null);
+    const deleteRow = db.prepare(
+      "DELETE FROM session_documents WHERE agent_name = ? AND session_id = ?"
+    );
+    const upsertRow = db.prepare(`
+      INSERT INTO session_documents(
+        agent_name,
+        session_id,
+        slug,
+        title,
+        directory,
+        time_created,
+        time_updated,
+        activity_time,
+        content_text,
+        content_hash,
+        indexed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(agent_name, session_id) DO UPDATE SET
+        slug = excluded.slug,
+        title = excluded.title,
+        directory = excluded.directory,
+        time_created = excluded.time_created,
+        time_updated = excluded.time_updated,
+        activity_time = excluded.activity_time,
+        content_text = excluded.content_text,
+        content_hash = excluded.content_hash,
+        indexed_at = excluded.indexed_at
+    `);
+    const write = db.transaction(() => {
+      for (const sessionId of toDelete) {
+        deleteRow.run(agentName, sessionId);
+      }
+      for (const entry of loaded) {
+        const activityTime = entry.session.time_updated ?? entry.session.time_created;
+        upsertRow.run(
+          agentName,
+          entry.session.id,
+          entry.session.slug,
+          entry.session.title,
+          entry.session.directory,
+          entry.session.time_created,
+          entry.session.time_updated ?? null,
+          activityTime,
+          entry.contentText,
+          entry.contentHash,
+          Date.now()
+        );
+      }
+    });
+    write();
+  });
+}
+function searchSessions(query, options = {}) {
+  const normalizedQuery = query.trim();
+  if (!normalizedQuery || !hasCacheStorage()) {
+    return [];
+  }
+  const ftsQuery = toFtsQuery(normalizedQuery);
+  const results = withCacheDb((db) => {
+    const rows = db.prepare(
+      `
+          SELECT
+            d.agent_name,
+            d.session_id,
+            d.slug,
+            d.title,
+            d.directory,
+            d.time_created,
+            d.time_updated,
+            COALESCE(
+              NULLIF(snippet(session_documents_fts, 1, '<mark>', '</mark>', ' \u2026 ', 18), ''),
+              highlight(session_documents_fts, 0, '<mark>', '</mark>')
+            ) AS snippet
+          FROM session_documents_fts
+          JOIN session_documents d ON d.id = session_documents_fts.rowid
+          WHERE session_documents_fts MATCH ?
+            AND (? IS NULL OR d.agent_name = ?)
+            AND (? IS NULL OR LOWER(d.directory) LIKE ?)
+            AND (? IS NULL OR d.activity_time >= ?)
+            AND (? IS NULL OR d.activity_time <= ?)
+          ORDER BY bm25(session_documents_fts, 8.0, 1.0), d.activity_time DESC
+          LIMIT ?
+        `
+    ).all(
+      ftsQuery,
+      options.agent ?? null,
+      options.agent ?? null,
+      options.cwd?.toLowerCase() ?? null,
+      options.cwd ? `%${options.cwd.toLowerCase()}%` : null,
+      options.from ?? null,
+      options.from ?? null,
+      options.to ?? null,
+      options.to ?? null,
+      options.limit ?? 50
+    );
+    return rows.map((row) => ({
+      agentName: String(row.agent_name),
+      session: {
+        id: String(row.session_id),
+        slug: String(row.slug),
+        title: String(row.title),
+        directory: String(row.directory),
+        time_created: Number(row.time_created),
+        time_updated: row.time_updated == null ? void 0 : Number(row.time_updated),
+        stats: {
+          message_count: 0,
+          total_input_tokens: 0,
+          total_output_tokens: 0,
+          total_cost: 0
+        }
+      },
+      snippet: String(row.snippet ?? "")
+    }));
+  });
+  return results ?? [];
 }
 function isPathScopeMatch(queryPath, sessionPath) {
   if (!sessionPath) return false;
@@ -3531,9 +3963,18 @@ function filterSessions(sessions, options) {
   }
   return result;
 }
+function buildAgentCacheMeta(agent) {
+  const metaMap = agent.getSessionMetaMap?.();
+  const meta = {};
+  if (!metaMap) return meta;
+  for (const [id, data] of metaMap.entries()) {
+    meta[id] = { id, ...data };
+  }
+  return meta;
+}
 async function scanAgentSmart(agent, options, onProgress) {
   const useCache = options.useCache ?? true;
-  const smartRefresh = options.smartRefresh ?? true;
+  const canValidateCache = Boolean(agent.checkForChanges && agent.incrementalScan);
   if (useCache) {
     const cached = loadCachedSessions(agent.name);
     if (cached !== null) {
@@ -3544,16 +3985,39 @@ async function scanAgentSmart(agent, options, onProgress) {
         }
         agent.setSessionMetaMap(metaMap);
       }
-      agent.isAvailable();
+      const isAvail = agent.isAvailable();
+      if (!isAvail) {
+        return null;
+      }
       onProgress?.({
         agent: agent.name,
         phase: "cache",
         cachedCount: cached.sessions.length
       });
-      if (smartRefresh && agent.checkForChanges) {
-        setTimeout(async () => {
-          await refreshAgentAsync(agent, cached.sessions, cached.timestamp, onProgress);
-        }, 0);
+      if (canValidateCache) {
+        onProgress?.({ agent: agent.name, phase: "checking" });
+        const checkResult = await Promise.resolve(
+          agent.checkForChanges(cached.timestamp, cached.sessions)
+        );
+        if (checkResult.hasChanges) {
+          onProgress?.({
+            agent: agent.name,
+            phase: "incremental",
+            changedCount: checkResult.changedIds?.length
+          });
+          const updatedSessions = await Promise.resolve(
+            agent.incrementalScan(cached.sessions, checkResult.changedIds || [])
+          );
+          saveCachedSessions(agent.name, updatedSessions, buildAgentCacheMeta(agent));
+          onProgress?.({
+            agent: agent.name,
+            phase: "complete",
+            newCount: updatedSessions.length
+          });
+          const filtered2 = filterSessions(updatedSessions, options);
+          return { agent, heads: filtered2, fromCache: true, refreshed: true };
+        }
+        onProgress?.({ agent: agent.name, phase: "complete", newCount: cached.sessions.length });
       }
       const filtered = filterSessions(cached.sessions, options);
       return { agent, heads: filtered, fromCache: true };
@@ -3561,41 +4025,6 @@ async function scanAgentSmart(agent, options, onProgress) {
   }
   return scanAgentFull(agent, options, onProgress);
 }
-async function refreshAgentAsync(agent, cachedSessions, cacheTimestamp, onProgress) {
-  try {
-    onProgress?.({ agent: agent.name, phase: "checking" });
-    const checkResult = await Promise.resolve(
-      agent.checkForChanges(cacheTimestamp, cachedSessions)
-    );
-    if (!checkResult.hasChanges) {
-      onProgress?.({ agent: agent.name, phase: "complete" });
-      return;
-    }
-    onProgress?.({
-      agent: agent.name,
-      phase: "incremental",
-      changedCount: checkResult.changedIds?.length
-    });
-    const updatedSessions = await Promise.resolve(
-      agent.incrementalScan(cachedSessions, checkResult.changedIds || [])
-    );
-    const metaMap = agent.getSessionMetaMap?.();
-    const meta = {};
-    if (metaMap) {
-      for (const [id, data] of metaMap.entries()) {
-        meta[id] = { id, ...data };
-      }
-    }
-    saveCachedSessions(agent.name, updatedSessions, meta);
-    onProgress?.({
-      agent: agent.name,
-      phase: "complete",
-      newCount: updatedSessions.length
-    });
-  } catch (err) {
-    console.error(`[${agent.name}] Background refresh failed:`, err);
-  }
-}
 async function scanAgentFull(agent, options, onProgress) {
   const availMarker = perf.start(`agent:${agent.name}:isAvailable`);
   const isAvail = agent.isAvailable();
@@ -3607,13 +4036,7 @@ async function scanAgentFull(agent, options, onProgress) {
     const scanMarker = perf.start(`agent:${agent.name}:scan`);
     const heads = agent.scan();
     perf.end(scanMarker);
-    const metaMap = agent.getSessionMetaMap?.();
-    const meta = {};
-    if (metaMap) {
-      for (const [id, data] of metaMap.entries()) {
-        meta[id] = { id, ...data };
-      }
-    }
+    const meta = buildAgentCacheMeta(agent);
     saveCachedSessions(agent.name, heads, meta);
     onProgress?.({ agent: agent.name, phase: "complete", newCount: heads.length });
     const filtered = filterSessions(heads, options);
@@ -3669,12 +4092,16 @@ export {
   resolveSessionTitle,
   perf,
   openDbReadOnly,
+  openDb,
   isSqliteAvailable,
   loadCachedSessions,
   saveCachedSessions,
   clearCache,
   getCacheInfo,
+  syncSessionSearchIndex,
+  searchSessions,
+  filterSessions,
   scanSessions,
   scanSessionsAsync
 };
-//# sourceMappingURL=chunk-FG2FZIU5.js.map
+//# sourceMappingURL=chunk-UQI7CTEK.js.map