agentel 0.2.5 → 0.2.8

package/src/search.js

@@ -12,8 +12,7 @@ const { canonicalRepo } = require("./repo");
 
 const INDEX_VERSION = 3;
 const INDEX_STALE_CHECK_TTL_MS = 5000;
-const SQLITE_QUERY_TIMEOUT_MS = 5000;
-const SQLITE_BUILD_BATCH_SIZE = 100;
+const SQLITE_BUILD_BATCH_SIZE = 500;
 const RIPGREP_SEARCH_TIMEOUT_MS = 8000;
 const RIPGREP_BATCH_FILE_COUNT = 200;
 const MARKDOWN_MATCHES_PER_FILE = 3;
@@ -33,6 +32,42 @@ const _ftsCache = {
   checkedAtMs: 0,
   available: false
 };
+// Read-only better-sqlite3 connection cache for the FTS sidecar. Reopened when
+// the file inode changes (atomic rename during rebuild). Prepared statements
+// are cached on the connection by SQL text.
+const _ftsReadConn = {
+  path: "",
+  mtimeMs: 0,
+  size: 0,
+  ino: 0,
+  db: null,
+  prepared: null
+};
+let _betterSqlite3 = null;
+let _betterSqlite3Loaded = false;
+let _betterSqlite3LoadError = null;
+
+/**
+ * Lazily load better-sqlite3. Returns the constructor or null when the native
+ * binding is unavailable; call sites then fall back to the legacy `sqlite3`
+ * subprocess path. The load attempt is cached so missing optional builds do
+ * not re-try `require()` on every query.
+ */
+function loadBetterSqlite3() {
+  if (_betterSqlite3Loaded) return _betterSqlite3;
+  _betterSqlite3Loaded = true;
+  try {
+    _betterSqlite3 = require("better-sqlite3");
+  } catch (error) {
+    _betterSqlite3 = null;
+    _betterSqlite3LoadError = error;
+  }
+  return _betterSqlite3;
+}
+
+function betterSqlite3LoadError() {
+  return _betterSqlite3LoadError;
+}
 
 function buildIndex(env = process.env) {
   const sessions = listSessions(env);
@@ -147,59 +182,65 @@ function escapeRegExp(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+const FTS_SCHEMA_SQL = [
+  "CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL);",
+  "CREATE TABLE docs(",
+  "  rowid INTEGER PRIMARY KEY,",
+  "  doc_id TEXT,",
+  "  session_id TEXT,",
+  "  provider TEXT,",
+  "  source_type TEXT,",
+  "  repo_canonical TEXT,",
+  "  repo_display TEXT,",
+  "  scope_canonical TEXT,",
+  "  cwd TEXT,",
+  "  title TEXT,",
+  "  started_at TEXT,",
+  "  occurred_at TEXT,",
+  "  role TEXT,",
+  "  event_id TEXT,",
+  "  event_kind TEXT,",
+  "  message_index INTEGER,",
+  "  path TEXT,",
+  "  matched_text TEXT",
+  ");",
+  "CREATE VIRTUAL TABLE docs_fts USING fts5(text, tokenize='unicode61', prefix='2 3 4');"
+].join("\n");
+
+function cleanupFtsTmpFiles(tmpPath) {
+  for (const file of [tmpPath, `${tmpPath}-journal`, `${tmpPath}-wal`, `${tmpPath}-shm`]) {
+    try {
+      fs.rmSync(file, { force: true });
+    } catch {
+      // Best effort cleanup before rebuilding the sidecar index.
+    }
+  }
+}
+
 function buildFtsIndex(index, env = process.env) {
   const ftsPath = paths(env).ftsIndex;
   const tmpPath = `${ftsPath}.${process.pid}.tmp`;
+  let handle = null;
   try {
     ensureDir(path.dirname(ftsPath));
-    for (const file of [tmpPath, `${tmpPath}-journal`, `${tmpPath}-wal`, `${tmpPath}-shm`]) {
-      try {
-        fs.rmSync(file, { force: true });
-      } catch {
-        // Best effort cleanup before rebuilding the sidecar index.
-      }
-    }
-    runSqliteScript(tmpPath, [
-      "PRAGMA journal_mode=OFF;",
-      "PRAGMA synchronous=OFF;",
-      "CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL);",
-      "CREATE TABLE docs(",
-      "  rowid INTEGER PRIMARY KEY,",
-      "  doc_id TEXT,",
-      "  session_id TEXT,",
-      "  provider TEXT,",
-      "  source_type TEXT,",
-      "  repo_canonical TEXT,",
-      "  repo_display TEXT,",
-      "  scope_canonical TEXT,",
-      "  cwd TEXT,",
-      "  title TEXT,",
-      "  started_at TEXT,",
-      "  occurred_at TEXT,",
-      "  role TEXT,",
-      "  event_id TEXT,",
-      "  event_kind TEXT,",
-      "  message_index INTEGER,",
-      "  path TEXT,",
-      "  matched_text TEXT",
-      ");",
-      "CREATE VIRTUAL TABLE docs_fts USING fts5(text, tokenize='unicode61', prefix='2 3 4');",
-      `INSERT INTO meta(key, value) VALUES ('version', ${sqliteString(String(INDEX_VERSION))});`,
-      `INSERT INTO meta(key, value) VALUES ('builtAt', ${sqliteString(index.builtAt || "")});`,
-      `INSERT INTO meta(key, value) VALUES ('docCount', ${sqliteString(String(index.docCount || 0))});`
-	    ].join("\n"));
-
-    insertFtsDocs(tmpPath, index.docs || [], 1);
-    runSqliteScript(tmpPath, "INSERT INTO docs_fts(docs_fts) VALUES('optimize');");
+    cleanupFtsTmpFiles(tmpPath);
+    handle = openFtsBuildDb(tmpPath);
+    execFtsBuildSql(handle, FTS_SCHEMA_SQL);
+    insertFtsMetaRows(handle, [
+      { key: "version", value: String(INDEX_VERSION) },
+      { key: "builtAt", value: index.builtAt || "" },
+      { key: "docCount", value: String(index.docCount || 0) }
+    ]);
+    insertFtsDocs(handle, tmpPath, index.docs || [], 1);
+    execFtsBuildSql(handle, "INSERT INTO docs_fts(docs_fts) VALUES('optimize');");
+    closeFtsBuildDb(handle);
+    handle = null;
     fs.renameSync(tmpPath, ftsPath);
     rememberFtsCache(ftsPath, true);
     return true;
   } catch {
-    try {
-      fs.rmSync(tmpPath, { force: true });
-    } catch {
-      // Ignore optional FTS cleanup failure.
-    }
+    if (handle) closeFtsBuildDb(handle);
+    cleanupFtsTmpFiles(tmpPath);
     try {
       fs.rmSync(ftsPath, { force: true });
     } catch {
@@ -216,43 +257,16 @@ function buildFtsIndexSummary(env = process.env) {
   const builtAt = new Date().toISOString();
   let docCount = 0;
   let totalLength = 0;
+  let handle = null;
   try {
     ensureDir(path.dirname(ftsPath));
-    for (const file of [tmpPath, `${tmpPath}-journal`, `${tmpPath}-wal`, `${tmpPath}-shm`]) {
-      try {
-        fs.rmSync(file, { force: true });
-      } catch {
-        // Best effort cleanup before rebuilding the sidecar index.
-      }
-    }
-    runSqliteScript(tmpPath, [
-      "PRAGMA journal_mode=OFF;",
-      "PRAGMA synchronous=OFF;",
-      "CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL);",
-      "CREATE TABLE docs(",
-      "  rowid INTEGER PRIMARY KEY,",
-      "  doc_id TEXT,",
-      "  session_id TEXT,",
-      "  provider TEXT,",
-      "  source_type TEXT,",
-      "  repo_canonical TEXT,",
-      "  repo_display TEXT,",
-      "  scope_canonical TEXT,",
-      "  cwd TEXT,",
-      "  title TEXT,",
-      "  started_at TEXT,",
-      "  occurred_at TEXT,",
-      "  role TEXT,",
-      "  event_id TEXT,",
-      "  event_kind TEXT,",
-      "  message_index INTEGER,",
-      "  path TEXT,",
-      "  matched_text TEXT",
-      ");",
-      "CREATE VIRTUAL TABLE docs_fts USING fts5(text, tokenize='unicode61', prefix='2 3 4');",
-      `INSERT INTO meta(key, value) VALUES ('version', ${sqliteString(String(INDEX_VERSION))});`,
-      `INSERT INTO meta(key, value) VALUES ('builtAt', ${sqliteString(builtAt)});`
-    ].join("\n"));
+    cleanupFtsTmpFiles(tmpPath);
+    handle = openFtsBuildDb(tmpPath);
+    execFtsBuildSql(handle, FTS_SCHEMA_SQL);
+    insertFtsMetaRows(handle, [
+      { key: "version", value: String(INDEX_VERSION) },
+      { key: "builtAt", value: builtAt }
+    ]);
 
     let batch = [];
     for (const session of listSessions(env)) {
@@ -278,25 +292,22 @@ function buildFtsIndexSummary(env = process.env) {
             length: tokens.length
           });
           if (batch.length >= SQLITE_BUILD_BATCH_SIZE) {
-            insertFtsDocs(tmpPath, batch, docCount - batch.length + 1);
+            insertFtsDocs(handle, tmpPath, batch, docCount - batch.length + 1);
             batch = [];
           }
         }
       }
     }
-    if (batch.length) insertFtsDocs(tmpPath, batch, docCount - batch.length + 1);
-    runSqliteScript(tmpPath, [
-      `INSERT INTO meta(key, value) VALUES ('docCount', ${sqliteString(String(docCount))});`,
-      "INSERT INTO docs_fts(docs_fts) VALUES('optimize');"
-    ].join("\n"));
+    if (batch.length) insertFtsDocs(handle, tmpPath, batch, docCount - batch.length + 1);
+    insertFtsMetaRows(handle, [{ key: "docCount", value: String(docCount) }]);
+    execFtsBuildSql(handle, "INSERT INTO docs_fts(docs_fts) VALUES('optimize');");
+    closeFtsBuildDb(handle);
+    handle = null;
     fs.renameSync(tmpPath, ftsPath);
     rememberFtsCache(ftsPath, true);
   } catch (error) {
-    try {
-      fs.rmSync(tmpPath, { force: true });
-    } catch {
-      // Ignore optional FTS cleanup failure.
-    }
+    if (handle) closeFtsBuildDb(handle);
+    cleanupFtsTmpFiles(tmpPath);
     try {
       fs.rmSync(ftsPath, { force: true });
     } catch {
@@ -314,62 +325,241 @@ function buildFtsIndexSummary(env = process.env) {
   };
 }
 
-function insertFtsDocs(dbPath, docs, rowidStart = 1) {
-  for (let start = 0; start < docs.length; start += SQLITE_BUILD_BATCH_SIZE) {
-    const statements = ["BEGIN;"];
-    const batch = docs.slice(start, start + SQLITE_BUILD_BATCH_SIZE);
-    for (let offset = 0; offset < batch.length; offset++) {
-      const rowid = rowidStart + start + offset;
-      const doc = batch[offset];
-      statements.push(
-        `INSERT INTO docs(rowid, doc_id, session_id, provider, source_type, repo_canonical, repo_display, scope_canonical, cwd, title, started_at, occurred_at, role, event_id, event_kind, message_index, path, matched_text) VALUES (` +
-          [
-            rowid,
-            sqliteString(doc.id || ""),
-            sqliteString(doc.sessionId || ""),
-            sqliteString(doc.provider || ""),
-            sqliteString(doc.sourceType || ""),
-            sqliteString(doc.repoCanonical || ""),
-            sqliteString(doc.repoDisplay || ""),
-            sqliteString(doc.scopeCanonical || ""),
-            sqliteString(doc.cwd || ""),
-            sqliteString(doc.title || ""),
-            sqliteString(doc.startedAt || ""),
-            sqliteString(doc.occurredAt || ""),
-            sqliteString(doc.role || ""),
-            sqliteString(doc.eventId || ""),
-            sqliteString(doc.eventKind || ""),
-            Number.isFinite(Number(doc.messageIndex)) ? Number(doc.messageIndex) : "NULL",
-            sqliteString(doc.path || ""),
-            sqliteString(doc.matchedText || "")
-          ].join(", ") +
-          ");"
-      );
-      statements.push(`INSERT INTO docs_fts(rowid, text) VALUES (${rowid}, ${sqliteString(doc.text || "")});`);
+const FTS_DOCS_INSERT_SQL =
+  "INSERT INTO docs(rowid, doc_id, session_id, provider, source_type, repo_canonical, repo_display, scope_canonical, cwd, title, started_at, occurred_at, role, event_id, event_kind, message_index, path, matched_text) " +
+  "VALUES (@rowid, @doc_id, @session_id, @provider, @source_type, @repo_canonical, @repo_display, @scope_canonical, @cwd, @title, @started_at, @occurred_at, @role, @event_id, @event_kind, @message_index, @path, @matched_text)";
+const FTS_FTS_INSERT_SQL = "INSERT INTO docs_fts(rowid, text) VALUES (@rowid, @text)";
+
+function docInsertParams(doc, rowid) {
+  return {
+    rowid,
+    doc_id: doc.id || "",
+    session_id: doc.sessionId || "",
+    provider: doc.provider || "",
+    source_type: doc.sourceType || "",
+    repo_canonical: doc.repoCanonical || "",
+    repo_display: doc.repoDisplay || "",
+    scope_canonical: doc.scopeCanonical || "",
+    cwd: doc.cwd || "",
+    title: doc.title || "",
+    started_at: doc.startedAt || "",
+    occurred_at: doc.occurredAt || "",
+    role: doc.role || "",
+    event_id: doc.eventId || "",
+    event_kind: doc.eventKind || "",
+    message_index: Number.isFinite(Number(doc.messageIndex)) ? Number(doc.messageIndex) : null,
+    path: doc.path || "",
+    matched_text: doc.matchedText || ""
+  };
+}
+
+function insertFtsMetaRows(handle, rows) {
+  if (handle.kind === "native") {
+    const stmt = handle.db.prepare("INSERT INTO meta(key, value) VALUES (?, ?)");
+    const insertMany = handle.db.transaction((items) => {
+      for (const row of items) stmt.run(row.key, row.value);
+    });
+    insertMany(rows);
+    return;
+  }
+  const sql = rows
+    .map((row) => `INSERT INTO meta(key, value) VALUES ('${String(row.key).replace(/'/g, "''")}', '${String(row.value).replace(/'/g, "''")}');`)
+    .join("\n");
+  legacyRunSqliteScript(handle.dbPath, sql);
+}
+
+function insertFtsDocs(handleOrPath, dbPathHint, docs, rowidStart = 1) {
+  // Backwards-compatible call shape: tests/external callers may pass
+  // (dbPath, docs, rowidStart). When the first argument looks like a path
+  // we open a short-lived build connection just for this batch.
+  let handle = handleOrPath && typeof handleOrPath === "object" && handleOrPath.kind ? handleOrPath : null;
+  let docsArg = docs;
+  let rowidArg = rowidStart;
+  let openedHere = false;
+  if (!handle) {
+    handle = openFtsBuildDb(handleOrPath);
+    openedHere = true;
+    docsArg = dbPathHint;
+    rowidArg = docs ?? 1;
+  }
+  try {
+    if (handle.kind === "native") {
+      const docStmt = handle.db.prepare(FTS_DOCS_INSERT_SQL);
+      const ftsStmt = handle.db.prepare(FTS_FTS_INSERT_SQL);
+      const insertMany = handle.db.transaction((items) => {
+        for (let offset = 0; offset < items.length; offset++) {
+          const rowid = rowidArg + offset;
+          const doc = items[offset];
+          docStmt.run(docInsertParams(doc, rowid));
+          ftsStmt.run({ rowid, text: doc.text || "" });
+        }
+      });
+      // Chunk to avoid pathological transaction sizes; better-sqlite3 handles
+      // ~10k inserts/transaction comfortably but we keep batches bounded for
+      // memory and progress observability.
+      for (let start = 0; start < docsArg.length; start += SQLITE_BUILD_BATCH_SIZE) {
+        const slice = docsArg.slice(start, start + SQLITE_BUILD_BATCH_SIZE);
+        insertMany(slice);
+        rowidArg += slice.length;
+      }
+      return;
     }
-    statements.push("COMMIT;");
-    runSqliteScript(dbPath, statements.join("\n"));
+    // Legacy spawn path. Same text-script semantics as before, just without
+    // the helper rename.
+    for (let start = 0; start < docsArg.length; start += SQLITE_BUILD_BATCH_SIZE) {
+      const statements = ["BEGIN;"];
+      const batch = docsArg.slice(start, start + SQLITE_BUILD_BATCH_SIZE);
+      for (let offset = 0; offset < batch.length; offset++) {
+        const rowid = rowidArg + start + offset;
+        const doc = batch[offset];
+        const sqlString = (value) => `'${String(value == null ? "" : value).replace(/'/g, "''")}'`;
+        statements.push(
+          "INSERT INTO docs(rowid, doc_id, session_id, provider, source_type, repo_canonical, repo_display, scope_canonical, cwd, title, started_at, occurred_at, role, event_id, event_kind, message_index, path, matched_text) VALUES (" +
+            [
+              rowid,
+              sqlString(doc.id || ""),
+              sqlString(doc.sessionId || ""),
+              sqlString(doc.provider || ""),
+              sqlString(doc.sourceType || ""),
+              sqlString(doc.repoCanonical || ""),
+              sqlString(doc.repoDisplay || ""),
+              sqlString(doc.scopeCanonical || ""),
+              sqlString(doc.cwd || ""),
+              sqlString(doc.title || ""),
+              sqlString(doc.startedAt || ""),
+              sqlString(doc.occurredAt || ""),
+              sqlString(doc.role || ""),
+              sqlString(doc.eventId || ""),
+              sqlString(doc.eventKind || ""),
+              Number.isFinite(Number(doc.messageIndex)) ? Number(doc.messageIndex) : "NULL",
+              sqlString(doc.path || ""),
+              sqlString(doc.matchedText || "")
+            ].join(", ") +
+            ");"
+        );
+        statements.push(`INSERT INTO docs_fts(rowid, text) VALUES (${rowid}, '${String(doc.text || "").replace(/'/g, "''")}');`);
+      }
+      statements.push("COMMIT;");
+      legacyRunSqliteScript(handle.dbPath, statements.join("\n"));
+    }
+  } finally {
+    if (openedHere) closeFtsBuildDb(handle);
+  }
+}
+
+/**
+ * Open a fresh write connection for index builds. Build paths run inside
+ * spawned child processes (`buildIndexInChild`) so the connection is
+ * short-lived and not cached.
+ */
+function openFtsBuildDb(dbPath) {
+  const Database = loadBetterSqlite3();
+  if (Database) {
+    const db = new Database(dbPath);
+    db.pragma("journal_mode = OFF");
+    db.pragma("synchronous = OFF");
+    db.pragma("temp_store = MEMORY");
+    db.pragma("locking_mode = EXCLUSIVE");
+    return { kind: "native", db };
+  }
+  return { kind: "spawn", dbPath };
+}
+
+function closeFtsBuildDb(handle) {
+  if (handle?.kind === "native") {
+    try { handle.db.close(); } catch { /* ignore */ }
+  }
+}
+
+function execFtsBuildSql(handle, sql) {
+  if (handle.kind === "native") {
+    handle.db.exec(sql);
+    return;
+  }
+  legacyRunSqliteScript(handle.dbPath, sql);
+}
+
+/**
+ * Open or reuse a read-only connection for the FTS sidecar. The connection is
+ * invalidated when the on-disk file's inode/size/mtime changes — the index
+ * rebuild atomically renames a fresh DB into place, so the inode flips and
+ * any stale prepared statements are dropped.
+ */
+function openFtsReadDb(ftsPath, stat) {
+  const Database = loadBetterSqlite3();
+  if (!Database) return null;
+  if (
+    _ftsReadConn.db &&
+    _ftsReadConn.path === ftsPath &&
+    _ftsReadConn.ino === stat.ino &&
+    _ftsReadConn.mtimeMs === stat.mtimeMs &&
+    _ftsReadConn.size === stat.size
+  ) {
+    return _ftsReadConn;
+  }
+  closeFtsReadDb();
+  let db;
+  try {
+    db = new Database(ftsPath, { readonly: true, fileMustExist: true });
+    db.pragma("query_only = ON");
+  } catch {
+    return null;
+  }
+  _ftsReadConn.path = ftsPath;
+  _ftsReadConn.ino = stat.ino;
+  _ftsReadConn.mtimeMs = stat.mtimeMs;
+  _ftsReadConn.size = stat.size;
+  _ftsReadConn.db = db;
+  _ftsReadConn.prepared = new Map();
+  return _ftsReadConn;
+}
+
+function closeFtsReadDb() {
+  if (_ftsReadConn.db) {
+    try { _ftsReadConn.db.close(); } catch { /* ignore */ }
+  }
+  _ftsReadConn.path = "";
+  _ftsReadConn.ino = 0;
+  _ftsReadConn.mtimeMs = 0;
+  _ftsReadConn.size = 0;
+  _ftsReadConn.db = null;
+  _ftsReadConn.prepared = null;
+}
+
+function prepareFtsStatement(conn, sql) {
+  let stmt = conn.prepared.get(sql);
+  if (!stmt) {
+    stmt = conn.db.prepare(sql);
+    conn.prepared.set(sql, stmt);
   }
+  return stmt;
 }
 
-function runSqliteScript(dbPath, script) {
+/**
+ * Last-resort fallback: spawn the system `sqlite3` binary. Only used when the
+ * better-sqlite3 native binding could not be loaded (older Node, missing build
+ * toolchain). Pricing this path stays in line with the pre-PR-1 behavior so
+ * users without a toolchain are not regressed.
+ */
+function legacyRunSqliteScript(dbPath, script) {
   const result = spawnSync("sqlite3", [dbPath], {
     argv0: "agentlog-sqlite",
     input: script,
     encoding: "utf8",
     maxBuffer: 1024 * 1024 * 20,
-    timeout: SQLITE_QUERY_TIMEOUT_MS
+    timeout: 5000
   });
   if (result.error) throw result.error;
   if (result.status !== 0) throw new Error(String(result.stderr || result.stdout || "sqlite3 failed").trim());
 }
 
-function sqliteJson(dbPath, query) {
-  const result = spawnSync("sqlite3", [dbPath, "-json", query], {
+function legacySqliteJson(dbPath, query, params = []) {
+  const inlined = inlineSqlParams(query, params);
+  const result = spawnSync("sqlite3", [dbPath, "-json", inlined], {
     argv0: "agentlog-sqlite",
     encoding: "utf8",
     maxBuffer: 1024 * 1024 * 20,
-    timeout: SQLITE_QUERY_TIMEOUT_MS
+    timeout: 5000
   });
   if (result.error || result.status !== 0) return null;
   try {
@@ -379,8 +569,21 @@ function sqliteJson(dbPath, query) {
   }
 }
 
-function sqliteString(value) {
-  return `'${String(value == null ? "" : value).replace(/'/g, "''")}'`;
+/**
+ * Substitute `?` placeholders for the legacy spawn fallback. Not used by the
+ * better-sqlite3 path — that path passes params directly to prepared
+ * statements. Quoting matches the prior `sqliteString` semantics.
+ */
+function inlineSqlParams(query, params) {
+  if (!params || !params.length) return query;
+  let index = 0;
+  return query.replace(/\?/g, () => {
+    if (index >= params.length) return "?";
+    const value = params[index++];
+    if (value == null) return "NULL";
+    if (typeof value === "number" && Number.isFinite(value)) return String(value);
+    return `'${String(value).replace(/'/g, "''")}'`;
+  });
 }
 
 function rememberFtsCache(ftsPath, available) {
@@ -395,6 +598,21 @@ function rememberFtsCache(ftsPath, available) {
   _ftsCache.size = stat?.size || 0;
   _ftsCache.checkedAtMs = Date.now();
   _ftsCache.available = Boolean(available && stat);
+  if (!available || !stat) closeFtsReadDb();
+}
+
+function readFtsMeta(ftsPath, stat) {
+  const conn = openFtsReadDb(ftsPath, stat);
+  if (conn) {
+    try {
+      const stmt = prepareFtsStatement(conn, "SELECT key, value FROM meta WHERE key IN ('version', 'docCount')");
+      return stmt.all();
+    } catch {
+      closeFtsReadDb();
+      return null;
+    }
+  }
+  return legacySqliteJson(ftsPath, "SELECT key, value FROM meta WHERE key IN ('version', 'docCount');");
 }
 
 function ftsIndexAvailable(env = process.env, options = {}) {
@@ -404,6 +622,7 @@ function ftsIndexAvailable(env = process.env, options = {}) {
     stat = fs.statSync(ftsPath);
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
+    closeFtsReadDb();
     return false;
   }
   if (
@@ -415,7 +634,7 @@ function ftsIndexAvailable(env = process.env, options = {}) {
   ) {
     return true;
   }
-  const rows = sqliteJson(ftsPath, "SELECT key, value FROM meta WHERE key IN ('version', 'docCount');");
+  const rows = readFtsMeta(ftsPath, stat);
   if (!rows || !rows.some((row) => row.key === "version" && Number(row.value) === INDEX_VERSION)) {
     rememberFtsCache(ftsPath, false);
     return false;
@@ -673,29 +892,26 @@ function searchFtsSessions(query, queryTokens, context, env = process.env) {
   if (!ftsIndexAvailable(env, { noStaleCheck: Boolean(context.options.noRebuild || context.options.allowStaleFts) })) return null;
   const matchQuery = ftsMatchQuery(query);
   if (!matchQuery) return [];
+  // Pull a single bounded prefix in rank order rather than paging with growing
+  // OFFSET. FTS5 with bm25 ORDER BY recomputes the entire ranked set per
+  // OFFSET query, which is quadratic for broad terms (e.g. "react*" matching
+  // 1700+ docs across 7 sessions). One query + JS dedupe is O(N) and stays
+  // under FTS_MAX_SCAN_ROWS to bound memory for catastrophically broad terms.
+  const scanLimit = Math.max(
+    Math.max(context.limit * 20, FTS_SEARCH_BATCH_SIZE),
+    Math.min(FTS_MAX_SCAN_ROWS, context.limit * 500)
+  );
+  const rows = ftsSearchRows(ftsPath, matchQuery, { limit: scanLimit, offset: 0, context });
+  if (!rows) return null;
   const bySession = new Map();
-  const batchSize = Math.max(context.limit * 20, FTS_SEARCH_BATCH_SIZE);
-  const maxScanRows = Math.max(batchSize, Math.min(FTS_MAX_SCAN_ROWS, context.limit * 500));
-  let offset = 0;
-  while (offset < maxScanRows && bySession.size < context.limit) {
-    const rows = ftsSearchRows(ftsPath, matchQuery, {
-      limit: Math.min(batchSize, maxScanRows - offset),
-      offset,
-      context
-    });
-    if (!rows) return null;
-    if (!rows.length) break;
-    offset += rows.length;
-    for (const row of rows) {
-      const doc = ftsRowToDoc(row);
-      if (!matchesSessionFilter(doc, { ...context.filter, includeWebChats: context.includeWebChats, since: context.since })) continue;
-      if (!context.options.repo && context.repo && doc.repoCanonical === context.repo) {
-        row.rank = Number(row.rank || 0) - 0.05;
-      }
-      if (!bySession.has(doc.sessionId)) bySession.set(doc.sessionId, { doc, row });
-      if (bySession.size >= context.limit) break;
+  for (const row of rows) {
+    const doc = ftsRowToDoc(row);
+    if (!matchesSessionFilter(doc, { ...context.filter, includeWebChats: context.includeWebChats, since: context.since })) continue;
+    if (!context.options.repo && context.repo && doc.repoCanonical === context.repo) {
+      row.rank = Number(row.rank || 0) - 0.05;
     }
-    if (rows.length < batchSize) break;
+    if (!bySession.has(doc.sessionId)) bySession.set(doc.sessionId, { doc, row });
+    if (bySession.size >= context.limit) break;
   }
   return [...bySession.values()].slice(0, context.limit).map(({ doc, row }) => ({
     session_id: doc.sessionId,
@@ -719,31 +935,55 @@ function searchFtsSessions(query, queryTokens, context, env = process.env) {
 }
 
 function ftsSearchRows(ftsPath, matchQuery, options) {
-  const clauses = [`docs_fts MATCH ${sqliteString(matchQuery)}`];
   const filter = options.context?.filter || {};
-  if (filter.provider) clauses.push(`d.provider = ${sqliteString(filter.provider)}`);
   const sourceTypes = filter.sourceTypes?.length ? filter.sourceTypes : filter.sourceType ? [filter.sourceType] : [];
-  if (sourceTypes.length) clauses.push(`d.source_type IN (${sourceTypes.map(sqliteString).join(", ")})`);
+  const params = [matchQuery];
+  const clauses = ["docs_fts MATCH ?"];
+  if (filter.provider) {
+    clauses.push("d.provider = ?");
+    params.push(filter.provider);
+  }
+  if (sourceTypes.length) {
+    clauses.push(`d.source_type IN (${sourceTypes.map(() => "?").join(", ")})`);
+    for (const value of sourceTypes) params.push(value);
+  }
   if (options.context?.since) {
-    const since = sqliteString(options.context.since.toISOString());
-    clauses.push(`(d.started_at >= ${since} OR (d.started_at = '' AND d.occurred_at >= ${since}))`);
+    const since = options.context.since.toISOString();
+    clauses.push("(d.started_at >= ? OR (d.started_at = '' AND d.occurred_at >= ?))");
+    params.push(since, since);
   }
-  return sqliteJson(
-    ftsPath,
-    [
-      "SELECT",
-      "  d.doc_id, d.session_id, d.provider, d.source_type, d.repo_canonical, d.repo_display,",
-      "  d.scope_canonical, d.cwd, d.title, d.started_at, d.occurred_at, d.role,",
-      "  d.event_id, d.event_kind, d.message_index, d.path, d.matched_text,",
-      "  snippet(docs_fts, 0, '', '', '...', 32) AS excerpt,",
-      "  bm25(docs_fts) AS rank",
-      "FROM docs_fts",
-      "JOIN docs d ON d.rowid = docs_fts.rowid",
-      `WHERE ${clauses.join(" AND ")}`,
-      "ORDER BY rank ASC, d.occurred_at DESC, d.started_at DESC",
-      `LIMIT ${Math.max(1, Number(options.limit) || FTS_SEARCH_BATCH_SIZE)} OFFSET ${Math.max(0, Number(options.offset) || 0)};`
-    ].join("\n")
-  );
+  const limit = Math.max(1, Number(options.limit) || FTS_SEARCH_BATCH_SIZE);
+  const offset = Math.max(0, Number(options.offset) || 0);
+  // LIMIT/OFFSET stay parameterized so a single prepared-statement shape
+  // covers every page; the filter shape varies by query so its SQL is built
+  // per call but the resulting prepared statement is cached on the connection.
+  const sql = [
+    "SELECT",
+    "  d.doc_id, d.session_id, d.provider, d.source_type, d.repo_canonical, d.repo_display,",
+    "  d.scope_canonical, d.cwd, d.title, d.started_at, d.occurred_at, d.role,",
+    "  d.event_id, d.event_kind, d.message_index, d.path, d.matched_text,",
+    "  snippet(docs_fts, 0, '', '', '...', 32) AS excerpt,",
+    "  bm25(docs_fts) AS rank",
+    "FROM docs_fts",
+    "JOIN docs d ON d.rowid = docs_fts.rowid",
+    `WHERE ${clauses.join(" AND ")}`,
+    "ORDER BY rank ASC, d.occurred_at DESC, d.started_at DESC",
+    "LIMIT ? OFFSET ?"
+  ].join("\n");
+  params.push(limit, offset);
+
+  let stat;
+  try { stat = fs.statSync(ftsPath); } catch { return null; }
+  const conn = openFtsReadDb(ftsPath, stat);
+  if (conn) {
+    try {
+      return prepareFtsStatement(conn, sql).all(...params);
+    } catch {
+      closeFtsReadDb();
+      return null;
+    }
+  }
+  return legacySqliteJson(ftsPath, sql, params);
 }
 
 function ftsRowToDoc(row) {
@@ -1103,6 +1343,7 @@ function normalizeProviderFilter(value) {
     codex: { provider: "codex" },
     codex_cli: { provider: "codex", sourceType: "codex-cli-history", sourceTypes: ["codex-cli-history", "cli-history"] },
     codex_desktop: { provider: "codex", sourceType: "codex-desktop-history", sourceTypes: ["codex-desktop-history"] },
+    codex_sdk: { provider: "codex", sourceType: "codex-sdk-history", sourceTypes: ["codex-sdk-history"] },
     cursor: { provider: "cursor" },
     cline: { provider: "cline", sourceType: "cline-task-history", sourceTypes: ["cline-task-history"] },
     opencode: { provider: "opencode", sourceTypes: ["opencode-cli-history", "opencode-cli-sqlite-history", "opencode-desktop-history", "opencode-desktop-sqlite-history", "opencode-web-sqlite-history", "opencode-history", "opencode-sqlite-history"] },