codesesh 0.2.0 → 0.4.0

package/dist/{chunk-2UNXB2D3.js → chunk-EIIG7J6V.js}

@@ -10,18 +10,22 @@ 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 as dirname2 } 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";
+import { homedir as homedir3, platform as platform2 } from "os";
+import { join as join8 } from "path";
 var registrations = [];
 function registerAgent(reg) {
   registrations.push(reg);
@@ -306,6 +310,8 @@ var ClaudeCodeAgent = class extends BaseAgent {
     let totalCost = 0;
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
+    let totalCacheRead = 0;
+    let totalCacheCreate = 0;
     for (const record of parseJsonlLines(content)) {
       try {
         this.convertRecord(
@@ -323,6 +329,8 @@ var ClaudeCodeAgent = class extends BaseAgent {
       totalCost += msg.cost ?? 0;
       totalInputTokens += msg.tokens?.input ?? 0;
       totalOutputTokens += msg.tokens?.output ?? 0;
+      totalCacheRead += msg.tokens?.cache_read ?? 0;
+      totalCacheCreate += msg.tokens?.cache_create ?? 0;
     }
     return {
       id: meta.id,
@@ -336,7 +344,9 @@ var ClaudeCodeAgent = class extends BaseAgent {
         message_count: messages.length,
         total_input_tokens: totalInputTokens,
         total_output_tokens: totalOutputTokens,
-        total_cost: totalCost
+        total_cost: totalCost,
+        total_cache_read_tokens: totalCacheRead,
+        total_cache_create_tokens: totalCacheCreate
       },
       messages
     };
@@ -510,6 +520,9 @@ var ClaudeCodeAgent = class extends BaseAgent {
     let cwd = null;
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
+    let totalCacheReadTokens = 0;
+    let totalCacheCreateTokens = 0;
+    const modelUsageMap = {};
     for (const line of lines) {
       try {
         const data = JSON.parse(line);
@@ -531,8 +544,20 @@ var ClaudeCodeAgent = class extends BaseAgent {
           if (role === "assistant") {
             const usage = msg["usage"];
             if (usage && typeof usage === "object") {
-              totalInputTokens += (usage["input_tokens"] ?? 0) + (usage["cache_creation_input_tokens"] ?? 0) + (usage["cache_read_input_tokens"] ?? 0);
-              totalOutputTokens += usage["output_tokens"] ?? 0;
+              const inputTokens = usage["input_tokens"] ?? 0;
+              const cacheRead = usage["cache_read_input_tokens"] ?? 0;
+              const cacheCreate = usage["cache_creation_input_tokens"] ?? 0;
+              const outputTokens = usage["output_tokens"] ?? 0;
+              totalInputTokens += inputTokens + cacheRead + cacheCreate;
+              totalOutputTokens += outputTokens;
+              totalCacheReadTokens += cacheRead;
+              totalCacheCreateTokens += cacheCreate;
+              const m = msg["model"];
+              if (typeof m === "string" && m.trim()) {
+                const name = m.trim();
+                const msgTotal = inputTokens + cacheRead + cacheCreate + outputTokens;
+                modelUsageMap[name] = (modelUsageMap[name] ?? 0) + msgTotal;
+              }
             }
           }
         }
@@ -543,6 +568,7 @@ var ClaudeCodeAgent = class extends BaseAgent {
     const messageTitle = this.extractTitle(lines);
     const directoryTitle = basenameTitle(directory) || basenameTitle(projectDir);
     const title = resolveSessionTitle(explicitTitle, messageTitle, directoryTitle);
+    const hasModelUsage = Object.keys(modelUsageMap).length > 0;
     return {
       id: sessionId,
       slug: `claudecode/${sessionId}`,
@@ -554,8 +580,11 @@ var ClaudeCodeAgent = class extends BaseAgent {
         message_count: messageCount,
         total_input_tokens: totalInputTokens,
         total_output_tokens: totalOutputTokens,
-        total_cost: 0
-      }
+        total_cost: 0,
+        total_cache_read_tokens: totalCacheReadTokens,
+        total_cache_create_tokens: totalCacheCreateTokens
+      },
+      model_usage: hasModelUsage ? modelUsageMap : void 0
     };
   }
   extractTitle(lines) {
@@ -783,9 +812,13 @@ var ClaudeCodeAgent = class extends BaseAgent {
     const usage = msg["usage"];
     if (usage && typeof usage === "object" && !message.tokens) {
       const u = usage;
+      const cacheRead = u["cache_read_input_tokens"] ?? 0;
+      const cacheCreate = u["cache_creation_input_tokens"] ?? 0;
       message.tokens = {
-        input: (u["input_tokens"] ?? 0) + (u["cache_creation_input_tokens"] ?? 0) + (u["cache_read_input_tokens"] ?? 0),
-        output: u["output_tokens"] ?? 0
+        input: (u["input_tokens"] ?? 0) + cacheCreate + cacheRead,
+        output: u["output_tokens"] ?? 0,
+        cache_read: cacheRead,
+        cache_create: cacheCreate
       };
     }
   }
@@ -982,6 +1015,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;
 }
@@ -1340,7 +1386,7 @@ var KimiAgent = class extends BaseAgent {
   parseSessionDir(sessionDir) {
     try {
       const sessionId = basename3(sessionDir);
-      const projectHash = basename3(dirname2(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;
@@ -3072,6 +3118,16 @@ var CursorAgent = class extends BaseAgent {
           }
           const messageCount = messages.length;
           const directory = workspacePathMap.get(composerId) ?? "";
+          const modelUsageMap = {};
+          for (const msg of messages) {
+            if (msg.model) {
+              const msgTokens = (msg.tokens?.input ?? 0) + (msg.tokens?.output ?? 0);
+              if (msgTokens > 0) {
+                modelUsageMap[msg.model] = (modelUsageMap[msg.model] ?? 0) + msgTokens;
+              }
+            }
+          }
+          const hasModelUsage = Object.keys(modelUsageMap).length > 0;
           heads.push({
             id: sessionId,
             slug: `cursor/${sessionId}`,
@@ -3084,7 +3140,8 @@ var CursorAgent = class extends BaseAgent {
               total_input_tokens: composer.inputTokenCount ?? 0,
               total_output_tokens: composer.outputTokenCount ?? 0,
               total_cost: 0
-            }
+            },
+            model_usage: hasModelUsage ? modelUsageMap : void 0
           });
           this.composerCache.set(sessionId, composer);
           this.composerCache.set(`__mapping__${composerId}`, {
@@ -3492,89 +3549,438 @@ registerAgent({
   icon: "/icon/agent/cursor.svg",
   create: () => new CursorAgent()
 });
-var CACHE_VERSION = 2;
-var CACHE_FILENAME = "scan-cache.json";
+var CACHE_VERSION = 4;
+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;
@@ -3710,6 +4116,221 @@ async function scanSessions(options = {}, onProgress) {
 async function scanSessionsAsync(options = {}, onProgress) {
   return scanSessions(options, onProgress);
 }
+var BOOKMARK_DB_FILENAME = "state.db";
+var BOOKMARK_DB_VERSION = 1;
+function getStateDir() {
+  const p = platform2();
+  if (p === "darwin") {
+    return join8(homedir3(), "Library", "Application Support", "codesesh");
+  }
+  if (p === "win32") {
+    const appData = process.env.APPDATA ?? process.env.LOCALAPPDATA;
+    return join8(appData ?? join8(homedir3(), "AppData", "Roaming"), "codesesh");
+  }
+  return join8(process.env.XDG_DATA_HOME ?? join8(homedir3(), ".local", "share"), "codesesh");
+}
+function getStateDbPath() {
+  return join8(getStateDir(), BOOKMARK_DB_FILENAME);
+}
+function ensureSchema2(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS state_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS bookmarks (
+      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,
+      stats_json TEXT NOT NULL,
+      bookmarked_at INTEGER NOT NULL,
+      PRIMARY KEY (agent_name, session_id)
+    );
+  `);
+  const row = db.prepare("SELECT value FROM state_meta WHERE key = 'version'").get();
+  const version = Number(row?.value ?? 0);
+  if (version === BOOKMARK_DB_VERSION) return;
+  db.prepare(
+    `
+      INSERT INTO state_meta(key, value)
+      VALUES ('version', ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `
+  ).run(String(BOOKMARK_DB_VERSION));
+}
+function withStateDb(fn) {
+  const db = openDb(getStateDbPath());
+  if (!db) {
+    throw new Error("SQLite state database is unavailable");
+  }
+  try {
+    ensureSchema2(db);
+    return fn(db);
+  } finally {
+    db.close();
+  }
+}
+function toBookmarkRecord(row) {
+  return {
+    agentKey: String(row.agent_name ?? ""),
+    sessionId: String(row.session_id ?? ""),
+    fullPath: String(row.slug ?? ""),
+    title: String(row.title ?? ""),
+    directory: String(row.directory ?? ""),
+    time_created: Number(row.time_created ?? 0),
+    time_updated: row.time_updated == null ? void 0 : Number(row.time_updated),
+    stats: JSON.parse(String(row.stats_json ?? "{}")),
+    bookmarked_at: Number(row.bookmarked_at ?? 0)
+  };
+}
+function listBookmarks() {
+  return withStateDb((db) => {
+    const rows = db.prepare(
+      `
+          SELECT
+            agent_name,
+            session_id,
+            slug,
+            title,
+            directory,
+            time_created,
+            time_updated,
+            stats_json,
+            bookmarked_at
+          FROM bookmarks
+          ORDER BY COALESCE(time_updated, time_created) DESC, bookmarked_at DESC
+        `
+    ).all();
+    return rows.map(toBookmarkRecord);
+  });
+}
+function upsertBookmark(bookmark) {
+  return withStateDb((db) => {
+    const existing = db.prepare(
+      `
+          SELECT bookmarked_at
+          FROM bookmarks
+          WHERE agent_name = ? AND session_id = ?
+        `
+    ).get(bookmark.agentKey, bookmark.sessionId);
+    const bookmarkedAt = Number(existing?.bookmarked_at ?? Date.now());
+    db.prepare(
+      `
+        INSERT INTO bookmarks(
+          agent_name,
+          session_id,
+          slug,
+          title,
+          directory,
+          time_created,
+          time_updated,
+          stats_json,
+          bookmarked_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,
+          stats_json = excluded.stats_json
+      `
+    ).run(
+      bookmark.agentKey,
+      bookmark.sessionId,
+      bookmark.fullPath,
+      bookmark.title,
+      bookmark.directory,
+      bookmark.time_created,
+      bookmark.time_updated ?? null,
+      JSON.stringify(bookmark.stats),
+      bookmarkedAt
+    );
+    return { ...bookmark, bookmarked_at: bookmarkedAt };
+  });
+}
+function importBookmarks(bookmarks) {
+  return withStateDb((db) => {
+    const existingRows = db.prepare("SELECT agent_name, session_id, bookmarked_at FROM bookmarks").all();
+    const existingTimes = new Map(
+      existingRows.map((row) => [
+        `${String(row.agent_name ?? "")}:${String(row.session_id ?? "")}`,
+        Number(row.bookmarked_at ?? 0)
+      ])
+    );
+    const upsert = db.prepare(
+      `
+        INSERT INTO bookmarks(
+          agent_name,
+          session_id,
+          slug,
+          title,
+          directory,
+          time_created,
+          time_updated,
+          stats_json,
+          bookmarked_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,
+          stats_json = excluded.stats_json
+      `
+    );
+    const write = db.transaction(() => {
+      for (const bookmark of bookmarks) {
+        const key = `${bookmark.agentKey}:${bookmark.sessionId}`;
+        upsert.run(
+          bookmark.agentKey,
+          bookmark.sessionId,
+          bookmark.fullPath,
+          bookmark.title,
+          bookmark.directory,
+          bookmark.time_created,
+          bookmark.time_updated ?? null,
+          JSON.stringify(bookmark.stats),
+          existingTimes.get(key) ?? Date.now()
+        );
+      }
+    });
+    write();
+    const rows = db.prepare(
+      `
+          SELECT
+            agent_name,
+            session_id,
+            slug,
+            title,
+            directory,
+            time_created,
+            time_updated,
+            stats_json,
+            bookmarked_at
+          FROM bookmarks
+          ORDER BY COALESCE(time_updated, time_created) DESC, bookmarked_at DESC
+        `
+    ).all();
+    return rows.map(toBookmarkRecord);
+  });
+}
+function deleteBookmark(agentKey, sessionId) {
+  withStateDb((db) => {
+    db.prepare(
+      `
+        DELETE FROM bookmarks
+        WHERE agent_name = ? AND session_id = ?
+      `
+    ).run(agentKey, sessionId);
+  });
+}
 
 export {
   registerAgent,
@@ -3728,13 +4349,20 @@ export {
   resolveSessionTitle,
   perf,
   openDbReadOnly,
+  openDb,
   isSqliteAvailable,
   loadCachedSessions,
   saveCachedSessions,
   clearCache,
   getCacheInfo,
+  syncSessionSearchIndex,
+  searchSessions,
   filterSessions,
   scanSessions,
-  scanSessionsAsync
+  scanSessionsAsync,
+  listBookmarks,
+  upsertBookmark,
+  importBookmarks,
+  deleteBookmark
 };
-//# sourceMappingURL=chunk-2UNXB2D3.js.map
+//# sourceMappingURL=chunk-EIIG7J6V.js.map