@threadbase-sh/scanner 0.7.2 → 0.8.1

package/dist/index.js

@@ -1,23 +1,25 @@
 // src/filters.ts
 function applySort(metas, order) {
   const out = [...metas];
+  const tie = (a, b) => a.id.localeCompare(b.id);
   switch (order) {
     case "recent":
-      out.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+      out.sort((a, b) => b.timestamp.localeCompare(a.timestamp) || tie(a, b));
       break;
     case "oldest":
-      out.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+      out.sort((a, b) => a.timestamp.localeCompare(b.timestamp) || tie(a, b));
       break;
     case "messages-desc":
-      out.sort((a, b) => b.messageCount - a.messageCount);
+      out.sort((a, b) => b.messageCount - a.messageCount || tie(a, b));
       break;
     case "messages-asc":
-      out.sort((a, b) => a.messageCount - b.messageCount);
+      out.sort((a, b) => a.messageCount - b.messageCount || tie(a, b));
       break;
     case "alpha":
       out.sort((a, b) => {
         const cmp = a.projectName.localeCompare(b.projectName);
-        return cmp !== 0 ? cmp : a.preview.localeCompare(b.preview);
+        if (cmp !== 0) return cmp;
+        return a.preview.localeCompare(b.preview) || tie(a, b);
       });
       break;
   }
@@ -142,6 +144,36 @@ function readGitBranch(projectPath) {
 
 // src/indexer.ts
 import FlexSearchModule from "flexsearch";
+
+// src/search-matches.ts
+function generateMatches(meta, query) {
+  const matches = [];
+  const lowerQuery = query.toLowerCase();
+  const fields = [
+    ["contentSnippet", meta.contentSnippet],
+    ["projectName", meta.projectName],
+    ["sessionId", meta.sessionId],
+    ["sessionName", meta.sessionName],
+    ["account", meta.account],
+    ["model", meta.model || ""],
+    ["gitBranch", meta.gitBranch || ""],
+    ["toolNames", meta.toolNames.join(" ")]
+  ];
+  for (const [field, value] of fields) {
+    const idx = value.toLowerCase().indexOf(lowerQuery);
+    if (idx !== -1) {
+      const start = Math.max(0, idx - 80);
+      const end = Math.min(value.length, idx + query.length + 120);
+      let snippet = value.slice(start, end);
+      if (start > 0) snippet = `...${snippet}`;
+      if (end < value.length) snippet = `${snippet}...`;
+      matches.push({ field, snippet });
+    }
+  }
+  return matches.length > 0 ? matches : [{ field: "preview", snippet: meta.preview }];
+}
+
+// src/indexer.ts
 var FlexSearch = FlexSearchModule.default ?? FlexSearchModule;
 var SearchIndexer = class {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -210,7 +242,7 @@ var SearchIndexer = class {
         seen.add(id);
         const meta = this.documents.get(id);
         if (!meta) continue;
-        const matches = this.generateMatches(meta, query);
+        const matches = generateMatches(meta, query);
         searchResults.push({ meta, score: 1, matches });
         if (searchResults.length >= limit) break;
       }
@@ -225,32 +257,6 @@ var SearchIndexer = class {
       matches: [{ field: "timestamp", snippet: meta.preview }]
     }));
   }
-  generateMatches(meta, query) {
-    const matches = [];
-    const lowerQuery = query.toLowerCase();
-    const fields = [
-      ["contentSnippet", meta.contentSnippet],
-      ["projectName", meta.projectName],
-      ["sessionId", meta.sessionId],
-      ["sessionName", meta.sessionName],
-      ["account", meta.account],
-      ["model", meta.model || ""],
-      ["gitBranch", meta.gitBranch || ""],
-      ["toolNames", meta.toolNames.join(" ")]
-    ];
-    for (const [field, value] of fields) {
-      const idx = value.toLowerCase().indexOf(lowerQuery);
-      if (idx !== -1) {
-        const start = Math.max(0, idx - 80);
-        const end = Math.min(value.length, idx + query.length + 120);
-        let snippet = value.slice(start, end);
-        if (start > 0) snippet = `...${snippet}`;
-        if (end < value.length) snippet = `${snippet}...`;
-        matches.push({ field, snippet });
-      }
-    }
-    return matches.length > 0 ? matches : [{ field: "preview", snippet: meta.preview }];
-  }
   getDocumentCount() {
     return this.documents.size;
   }
@@ -283,6 +289,46 @@ var SearchIndexer = class {
   }
 };
 
+// src/persistent/sidecar.ts
+import { readFileSync as readFileSync2, writeFileSync } from "fs";
+var SIDECAR_VERSION = 1;
+function sidecarPath(jsonlPath) {
+  return `${jsonlPath}.idx.json`;
+}
+function buildSidecar(meta, cursor, updatedAt) {
+  return {
+    version: SIDECAR_VERSION,
+    sourcePath: meta.filePath,
+    sizeBytes: cursor.sizeBytes,
+    mtimeMs: cursor.mtimeMs,
+    lastIndexedOffset: cursor.offset,
+    lastIndexedLine: cursor.line,
+    messageCount: meta.messageCount,
+    projectPath: meta.projectPath,
+    projectName: meta.projectName,
+    branch: meta.gitBranch,
+    firstSentAt: meta.firstMessage?.timestamp ?? null,
+    firstSentText: meta.firstMessage?.text ?? null,
+    lastSentAt: meta.lastMessage?.timestamp ?? null,
+    lastSentText: meta.lastMessage?.text ?? null,
+    updatedAt
+  };
+}
+function writeSidecar(jsonlPath, sidecar) {
+  try {
+    writeFileSync(sidecarPath(jsonlPath), JSON.stringify(sidecar, null, 2));
+  } catch (err) {
+    getLogger().warn({ jsonlPath, err }, "sidecar: write failed");
+  }
+}
+function readSidecar(jsonlPath) {
+  try {
+    return JSON.parse(readFileSync2(sidecarPath(jsonlPath), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
 // src/profiles.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
@@ -324,48 +370,272 @@ async function saveProfiles(profiles, configPath) {
   getLogger().debug({ configPath, count: profiles.length }, "profiles: saved");
 }
 
-// src/scanner.ts
-import { statSync } from "fs";
+// src/providers/codex-cli.ts
+import fg from "fast-glob";
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
+import { basename } from "path";
+import { createInterface } from "readline";
 
-// src/cache.ts
-var LRUCache = class {
-  map = /* @__PURE__ */ new Map();
-  capacity;
-  constructor(capacity) {
-    this.capacity = capacity;
+// src/tags.ts
+var SYSTEM_TAGS = [
+  "system-reminder",
+  "command-name",
+  "command-message",
+  "command-args",
+  "ide_selection",
+  "ide_opened_file",
+  "local-command-stdout",
+  "local-command-caveat",
+  "retrieval_status",
+  "task_id",
+  "task_type",
+  "task-id",
+  "task-notification",
+  "fast_mode_info",
+  "persisted-output",
+  "tool_use_error",
+  "user-prompt-submit-hook",
+  "thinking",
+  "ask_user",
+  "teammate-message"
+];
+var SYSTEM_TAG_RE = new RegExp(`<(${SYSTEM_TAGS.join("|")})[^>]*>[\\s\\S]*?<\\/\\1>`, "g");
+function cleanSystemTags(text) {
+  return text.replace(SYSTEM_TAG_RE, "").replace(/[^\S\n]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+// src/providers/provider.ts
+var CLAUDE_CODE_PROVIDER = "claude-code";
+var CODEX_CLI_PROVIDER = "codex-cli";
+
+// src/providers/codex-cli.ts
+var CodexCliProvider = class {
+  name = CODEX_CLI_PROVIDER;
+  async discover(roots) {
+    const log = getLogger();
+    const results = [];
+    for (const root of roots) {
+      let paths;
+      try {
+        paths = await fg(["**/rollout-*.jsonl", "**/*.jsonl"], {
+          cwd: root,
+          absolute: true,
+          dot: false,
+          unique: true
+        });
+      } catch (err) {
+        log.warn({ root, err }, "codex discovery: glob failed");
+        continue;
+      }
+      for (const filePath of paths) {
+        try {
+          const s = await stat(filePath);
+          if (s.size > 0) results.push({ filePath, account: "codex" });
+        } catch (err) {
+          log.warn({ filePath, err }, "codex discovery: stat failed");
+        }
+      }
+    }
+    return results;
   }
-  get(key) {
-    const value = this.map.get(key);
-    if (value === void 0) return void 0;
-    this.map.delete(key);
-    this.map.set(key, value);
-    return value;
+  // Codex rollout lines carry distinctive top-level types.
+  canParse(_filePath, sample) {
+    for (const line of sample.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const e = JSON.parse(line);
+        if (e.type === "session_meta" || e.type === "response_item" || e.type === "event_msg") {
+          return true;
+        }
+        if (e.type === "user" || e.type === "assistant") return false;
+      } catch {
+      }
+    }
+    return false;
   }
-  set(key, value) {
-    this.map.delete(key);
-    this.map.set(key, value);
-    if (this.map.size > this.capacity) {
-      const oldest = this.map.keys().next();
-      if (!oldest.done) this.map.delete(oldest.value);
+  createEmptyAccumulator() {
+    return {
+      sessionId: "",
+      cwd: "",
+      gitBranch: null,
+      model: null,
+      latestTimestamp: "",
+      messageCount: 0,
+      lastMessageSender: "user",
+      firstUser: null,
+      lastUser: null,
+      lastAssistant: null,
+      toolNames: [],
+      previewParts: [],
+      previewLength: 0,
+      snippetParts: [],
+      snippetLength: 0
+    };
+  }
+  reduceEntry(acc, entry, tier) {
+    reduceCodexEntry(acc, entry, tier);
+  }
+  finalize(acc, filePath, account, tier) {
+    return finalizeCodexMeta(acc, filePath, account, tier);
+  }
+};
+var asString = (v) => typeof v === "string" ? v : "";
+function extractCodexText(content) {
+  if (typeof content === "string") return cleanSystemTags(content);
+  if (!Array.isArray(content)) return "";
+  return content.map((item) => {
+    if (typeof item === "string") return item;
+    const t = item?.type;
+    if ((t === "input_text" || t === "output_text" || t === "text") && item?.text) {
+      return item.text;
     }
+    return "";
+  }).filter(Boolean).map(cleanSystemTags).join(" ");
+}
+function reduceCodexEntry(acc, entry, tier) {
+  const ts = asString(entry.timestamp);
+  if (ts && (!acc.latestTimestamp || ts > acc.latestTimestamp)) acc.latestTimestamp = ts;
+  const payload = entry.payload;
+  if (!payload || typeof payload !== "object") return;
+  const type = entry.type;
+  if (type === "session_meta") {
+    if (!acc.sessionId) acc.sessionId = asString(payload.id);
+    if (!acc.cwd) acc.cwd = asString(payload.cwd);
+    const git = payload.git;
+    if (acc.gitBranch === null && git?.branch) acc.gitBranch = asString(git.branch) || null;
+    return;
   }
-  has(key) {
-    return this.map.has(key);
+  if (acc.model === null && payload.model) acc.model = asString(payload.model) || null;
+  if (type !== "response_item") return;
+  const ptype = payload.type;
+  if (ptype === "function_call" || ptype === "custom_tool_call") {
+    const name = asString(payload.name);
+    if (name && !acc.toolNames.includes(name)) acc.toolNames.push(name);
+    return;
   }
-  delete(key) {
-    return this.map.delete(key);
+  if (ptype !== "message") return;
+  const role = payload.role;
+  if (role !== "user" && role !== "assistant") return;
+  const text = extractCodexText(payload.content);
+  if (!text) return;
+  const sender = role;
+  acc.messageCount++;
+  acc.lastMessageSender = sender;
+  const snapshot = { text: text.slice(0, 200), timestamp: ts };
+  if (sender === "user") {
+    if (!acc.firstUser) acc.firstUser = snapshot;
+    acc.lastUser = snapshot;
+  } else {
+    acc.lastAssistant = snapshot;
   }
-  clear() {
-    this.map.clear();
+  if (acc.previewLength < tier.previewMax) {
+    acc.previewParts.push(text);
+    acc.previewLength += text.length;
   }
-  get size() {
-    return this.map.size;
+  if (acc.snippetLength < tier.snippetMax) {
+    const remaining = tier.snippetMax - acc.snippetLength;
+    const chunk = text.length > remaining ? text.slice(0, remaining) : text;
+    acc.snippetParts.push(chunk);
+    acc.snippetLength += chunk.length;
   }
-};
+}
+function finalizeCodexMeta(acc, filePath, account, tier) {
+  if (acc.messageCount === 0) return null;
+  const sessionId = acc.sessionId || basename(filePath, ".jsonl");
+  const projectPath = acc.cwd;
+  const kind = acc.lastAssistant === null && acc.toolNames.length > 0 ? "task" : "conversation";
+  return {
+    id: filePath,
+    filePath,
+    provider: CODEX_CLI_PROVIDER,
+    kind,
+    externalSessionId: acc.sessionId || void 0,
+    sessionId,
+    sessionName: "",
+    projectPath,
+    projectName: getShortProjectName(projectPath),
+    account,
+    timestamp: acc.latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    messageCount: acc.messageCount,
+    lastMessageSender: acc.lastMessageSender,
+    preview: acc.previewParts.join(" ").slice(0, tier.previewMax),
+    contentSnippet: acc.snippetParts.join(" "),
+    gitBranch: acc.gitBranch,
+    model: acc.model,
+    isSubagent: false,
+    parentSessionId: null,
+    isTeammate: false,
+    teamName: null,
+    toolNames: acc.toolNames,
+    firstMessage: acc.firstUser,
+    lastMessage: acc.lastAssistant ?? acc.lastUser,
+    lastPrompt: acc.lastUser?.text || void 0
+  };
+}
+function getShortProjectName(fullPath) {
+  return fullPath.split("/").filter(Boolean).slice(-3).join("/");
+}
+async function parseCodexConversation(filePath, account) {
+  const log = getLogger();
+  const messages = [];
+  const textParts = [];
+  let sessionId = "";
+  let cwd = "";
+  let latestTimestamp = "";
+  let lastUserText = "";
+  const rl = createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const ts = asString(entry.timestamp);
+      if (ts && (!latestTimestamp || ts > latestTimestamp)) latestTimestamp = ts;
+      const payload = entry.payload;
+      if (!payload || typeof payload !== "object") continue;
+      if (entry.type === "session_meta") {
+        if (!sessionId) sessionId = asString(payload.id);
+        if (!cwd) cwd = asString(payload.cwd);
+        continue;
+      }
+      if (entry.type !== "response_item" || payload.type !== "message") continue;
+      const role = payload.role;
+      if (role !== "user" && role !== "assistant") continue;
+      const text = extractCodexText(payload.content);
+      if (!text) continue;
+      messages.push({ role, text, timestamp: ts });
+      textParts.push(text);
+      if (role === "user") lastUserText = text;
+    }
+  } catch (err) {
+    log.warn({ filePath, err }, "parseCodexConversation: read failed");
+    return null;
+  }
+  if (messages.length === 0) return null;
+  return {
+    id: filePath,
+    filePath,
+    projectPath: cwd,
+    projectName: getShortProjectName(cwd),
+    sessionId: sessionId || basename(filePath, ".jsonl"),
+    sessionName: "",
+    messages,
+    fullText: textParts.join(" "),
+    timestamp: latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    messageCount: messages.length,
+    account,
+    lastPrompt: lastUserText || void 0
+  };
+}
 
 // src/discovery.ts
-import fg from "fast-glob";
-import { stat } from "fs/promises";
+import fg2 from "fast-glob";
+import { stat as stat2 } from "fs/promises";
 var EXCLUDED_SEGMENTS = ["/memory/", "/tool-results/"];
 var STAT_CONCURRENCY = 32;
 async function discoverJsonlFiles(dirs, onProgress) {
@@ -374,7 +644,7 @@ async function discoverJsonlFiles(dirs, onProgress) {
   for (const { projectsDir, account } of dirs) {
     let filePaths;
     try {
-      filePaths = await fg("**/*.jsonl", {
+      filePaths = await fg2("**/*.jsonl", {
         cwd: projectsDir,
         absolute: true,
         dot: false
@@ -392,7 +662,7 @@ async function discoverJsonlFiles(dirs, onProgress) {
       const statted = await Promise.all(
         chunk.map(async (filePath) => {
           try {
-            const s = await stat(filePath);
+            const s = await stat2(filePath);
             return { filePath, size: s.size };
           } catch (err) {
             log.warn({ filePath, err }, "discovery: stat failed");
@@ -429,64 +699,115 @@ async function discoverJsonlFiles(dirs, onProgress) {
   return results;
 }
 
+// src/persistent/metadata-reducer.ts
+import { basename as basename3, dirname as dirname2, join as join3 } from "path";
+
 // src/parser.ts
-import { createReadStream } from "fs";
-import { basename, dirname as dirname2, join as join3 } from "path";
-import { createInterface } from "readline";
+import { createReadStream as createReadStream2 } from "fs";
+import { basename as basename2 } from "path";
+import { createInterface as createInterface2 } from "readline";
 
-// src/tags.ts
-var SYSTEM_TAGS = [
-  "system-reminder",
-  "command-name",
-  "command-message",
-  "command-args",
-  "ide_selection",
-  "ide_opened_file",
-  "local-command-stdout",
-  "local-command-caveat",
-  "retrieval_status",
-  "task_id",
-  "task_type",
-  "task-id",
-  "task-notification",
-  "fast_mode_info",
-  "persisted-output",
-  "tool_use_error",
-  "user-prompt-submit-hook",
-  "thinking",
-  "ask_user",
-  "teammate-message"
-];
-var SYSTEM_TAG_RE = new RegExp(`<(${SYSTEM_TAGS.join("|")})[^>]*>[\\s\\S]*?<\\/\\1>`, "g");
-function cleanSystemTags(text) {
-  return text.replace(SYSTEM_TAG_RE, "").replace(/[^\S\n]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+// src/persistent/conversation-reducer.ts
+function initialConvState() {
+  return {
+    cwd: "",
+    sessionId: "",
+    sessionName: "",
+    latestTimestamp: "",
+    lastPrompt: "",
+    pendingToolUses: {},
+    teamInfo: {}
+  };
+}
+function reduceConvLine(state, entry) {
+  if (entry.cwd && !state.cwd) state.cwd = entry.cwd;
+  if (entry.sessionId && !state.sessionId) state.sessionId = entry.sessionId;
+  if (entry.slug && !state.sessionName) state.sessionName = entry.slug;
+  if (entry.timestamp) {
+    const ts = entry.timestamp;
+    if (!state.latestTimestamp || ts > state.latestTimestamp) state.latestTimestamp = ts;
+  }
+  const type = entry.type;
+  if (type === "last-prompt") {
+    if (entry.lastPrompt && !state.lastPrompt) state.lastPrompt = entry.lastPrompt;
+    return null;
+  }
+  if (type !== "user" && type !== "assistant") return null;
+  if (entry.isMeta) return null;
+  const msg = entry.message;
+  const toolUseBlocks = extractToolUseBlocks(msg?.content);
+  for (const block of toolUseBlocks) state.pendingToolUses[block.id] = block;
+  const hasToolUseResult = type === "user" && entry.toolUseResult != null;
+  const isToolResultOnly = hasToolUseResult && isOnlyToolResultContent(msg?.content);
+  const content = extractTextContent(msg?.content);
+  const thinking = type === "assistant" ? extractThinking(msg?.content) : null;
+  const hasThinking = !!(thinking?.content || thinking?.signature);
+  if (!(content || isToolResultOnly || toolUseBlocks.length > 0 || hasThinking)) return null;
+  const metadata = {};
+  if (msg?.model) metadata.model = msg.model;
+  if (msg?.stop_reason !== void 0) metadata.stopReason = msg.stop_reason;
+  if (entry.gitBranch) metadata.gitBranch = entry.gitBranch;
+  if (entry.version) metadata.version = entry.version;
+  const usage = msg?.usage;
+  if (usage) {
+    if (usage.input_tokens) metadata.inputTokens = usage.input_tokens;
+    if (usage.output_tokens) metadata.outputTokens = usage.output_tokens;
+    if (usage.cache_read_input_tokens) metadata.cacheReadTokens = usage.cache_read_input_tokens;
+    if (usage.cache_creation_input_tokens)
+      metadata.cacheCreationTokens = usage.cache_creation_input_tokens;
+  }
+  const toolUseNames = extractToolUseNames(msg?.content);
+  if (toolUseNames.length > 0) metadata.toolUses = toolUseNames;
+  if (toolUseBlocks.length > 0) metadata.toolUseBlocks = toolUseBlocks;
+  if (isToolResultOnly) {
+    const pending = new Map(Object.entries(state.pendingToolUses));
+    const toolResultBlocks = extractToolResultBlocks(msg?.content, pending);
+    if (toolResultBlocks.length > 0) metadata.toolResults = toolResultBlocks;
+  }
+  if (entry.teamName) {
+    metadata.teamName = entry.teamName;
+    if (!state.teamInfo[metadata.teamName] && content) {
+      const info = parseTeammateMessageTag(content);
+      if (info) state.teamInfo[metadata.teamName] = info;
+    }
+  }
+  const thinkingContent = thinking?.content || void 0;
+  const thinkingSignature = thinking?.signature || void 0;
+  const hasMetadata = Object.keys(metadata).length > 0;
+  return {
+    role: type,
+    text: content || "",
+    timestamp: entry.timestamp || "",
+    uuid: entry.uuid || void 0,
+    metadata: hasMetadata ? metadata : void 0,
+    isToolResult: isToolResultOnly || void 0,
+    isThinking: thinkingContent || thinkingSignature ? true : void 0,
+    thinkingContent,
+    thinkingSignature,
+    parentUuid: entry.parentUuid !== void 0 ? entry.parentUuid : void 0,
+    requestId: type === "assistant" ? entry.requestId : void 0,
+    promptId: type === "user" ? entry.promptId : void 0,
+    isSidechain: typeof entry.isSidechain === "boolean" ? entry.isSidechain : void 0,
+    permissionMode: type === "user" ? entry.permissionMode : void 0,
+    hasImages: hasImageBlocks(msg?.content) || void 0,
+    attachment: entry.attachment !== void 0 ? entry.attachment : void 0
+  };
+}
+function applyTeamInfo(messages, state) {
+  if (Object.keys(state.teamInfo).length === 0) return;
+  for (const m of messages) {
+    const name = m.metadata?.teamName;
+    if (name && state.teamInfo[name] && m.metadata) m.metadata.teamInfo = state.teamInfo[name];
+  }
 }
 
 // src/parser.ts
 async function parseMeta(filePath, account, tier) {
   const log = getLogger();
   log.trace({ filePath, account, tier: tier.name }, "parseMeta: start");
-  let sessionId = "";
-  let badJsonLines = 0;
-  let sessionName = "";
-  let latestTimestamp = "";
-  let cwd = "";
-  let teamName = "";
-  let model = null;
-  let messageCount = 0;
-  let lastMessageSender = "user";
-  let isTeammate = false;
-  let firstUserSeen = false;
-  let firstMessage = null;
-  let lastMessage = null;
-  let lastPrompt = "";
-  const toolNameSet = /* @__PURE__ */ new Set();
-  const previewParts = [];
-  const snippetParts = [];
-  let snippetLength = 0;
-  let previewLength = 0;
-  const fileStream = createReadStream(filePath);
-  const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+  const state = initialReducerState();
+  const fileStream = createReadStream2(filePath);
+  const rl = createInterface2({ input: fileStream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
       if (!line.trim()) continue;
@@ -494,121 +815,35 @@ async function parseMeta(filePath, account, tier) {
       try {
         entry = JSON.parse(line);
       } catch {
-        badJsonLines++;
+        state.badJsonLines++;
         continue;
       }
-      if (entry.cwd && !cwd) cwd = entry.cwd;
-      if (entry.sessionId && !sessionId) sessionId = entry.sessionId;
-      if (entry.slug && !sessionName) sessionName = entry.slug;
-      if (entry.teamName && !teamName) teamName = entry.teamName;
-      if (entry.timestamp) {
-        const ts = entry.timestamp;
-        if (!latestTimestamp || ts > latestTimestamp) latestTimestamp = ts;
-      }
-      const type = entry.type;
-      if (type === "last-prompt") {
-        if (entry.lastPrompt && !lastPrompt) lastPrompt = entry.lastPrompt;
-        continue;
-      }
-      if (type !== "user" && type !== "assistant") continue;
-      if (entry.isMeta) continue;
-      if (model === null) {
-        const msg2 = entry.message;
-        if (msg2?.model) model = msg2.model;
-      }
-      if (type === "user" && !firstUserSeen) {
-        firstUserSeen = true;
-        if (isTeammateContent(entry.message?.content)) {
-          isTeammate = true;
-        }
-      }
-      const msg = entry.message;
-      const content = extractTextContent(msg?.content);
-      const hasToolUseResult = type === "user" && entry.toolUseResult != null;
-      const isOnlyToolResult = hasToolUseResult && isOnlyToolResultContent(msg?.content);
-      collectToolNames(msg?.content, toolNameSet);
-      if (content || isOnlyToolResult) {
-        messageCount++;
-        lastMessageSender = type;
-        if (content) {
-          const ts = entry.timestamp || "";
-          if (!firstMessage) {
-            firstMessage = { text: content.slice(0, 200), timestamp: ts };
-          }
-          lastMessage = { text: content.slice(0, 200), timestamp: ts };
-          if (previewLength < tier.previewMax) {
-            previewParts.push(content);
-            previewLength += content.length;
-          }
-          if (snippetLength < tier.snippetMax) {
-            const remaining = tier.snippetMax - snippetLength;
-            const chunk = content.length > remaining ? content.slice(0, remaining) : content;
-            snippetParts.push(chunk);
-            snippetLength += chunk.length;
-          }
-        }
-      }
+      reduceLine(state, entry, tier);
     }
   } catch (err) {
     log.warn({ filePath, err }, "parseMeta: read failed");
     return null;
   }
-  if (badJsonLines > 0) {
-    log.warn({ filePath, badJsonLines }, "parseMeta: skipped malformed JSON lines");
-  }
-  if (messageCount === 0) {
-    log.trace({ filePath }, "parseMeta: no messages");
-    return null;
-  }
-  const isSubagent = filePath.includes("/subagents/");
-  let parentSessionId = null;
-  if (isSubagent) {
-    const uuidDir = dirname2(dirname2(filePath));
-    parentSessionId = join3(dirname2(uuidDir), `${basename(uuidDir)}.jsonl`);
+  if (state.badJsonLines > 0) {
+    log.warn(
+      { filePath, badJsonLines: state.badJsonLines },
+      "parseMeta: skipped malformed JSON lines"
+    );
   }
-  const projectPath = cwd;
-  const preview = previewParts.join(" ").slice(0, tier.previewMax);
-  return {
-    id: filePath,
-    filePath,
-    sessionId: sessionId || basename(filePath, ".jsonl"),
-    sessionName,
-    projectPath,
-    projectName: getShortProjectName(projectPath),
-    account,
-    timestamp: latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
-    messageCount,
-    lastMessageSender,
-    preview,
-    contentSnippet: snippetParts.join(" "),
-    gitBranch: null,
-    model,
-    isSubagent,
-    parentSessionId,
-    isTeammate,
-    teamName: teamName || null,
-    toolNames: Array.from(toolNameSet),
-    firstMessage,
-    lastMessage,
-    lastPrompt: lastPrompt || void 0
-  };
+  const meta = finalizeMeta(state, filePath, account, tier);
+  if (!meta) log.trace({ filePath }, "parseMeta: no messages");
+  return meta;
 }
 async function parseConversation(filePath, account) {
   const log = getLogger();
   log.trace({ filePath, account }, "parseConversation: start");
   const messages = [];
   let badJsonLines = 0;
-  let sessionId = "";
-  let sessionName = "";
-  let latestTimestamp = "";
-  let cwd = "";
   const textParts = [];
-  const pendingToolUses = /* @__PURE__ */ new Map();
-  const teamInfoMap = /* @__PURE__ */ new Map();
   const turnDurations = [];
-  let lastPrompt = "";
-  const fileStream = createReadStream(filePath);
-  const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+  const state = initialConvState();
+  const fileStream = createReadStream2(filePath);
+  const rl = createInterface2({ input: fileStream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
       if (!line.trim()) continue;
@@ -619,91 +854,18 @@ async function parseConversation(filePath, account) {
         badJsonLines++;
         continue;
       }
-      if (entry.cwd && !cwd) cwd = entry.cwd;
-      if (entry.sessionId && !sessionId) sessionId = entry.sessionId;
-      if (entry.slug && !sessionName) sessionName = entry.slug;
-      if (entry.timestamp) {
-        const ts = entry.timestamp;
-        if (!latestTimestamp || ts > latestTimestamp) latestTimestamp = ts;
-      }
-      const type = entry.type;
-      if (type === "last-prompt") {
-        if (entry.lastPrompt && !lastPrompt) lastPrompt = entry.lastPrompt;
-        continue;
-      }
-      if (type === "system") {
-        if (entry.subtype === "turn_duration" && typeof entry.durationMs === "number") {
-          turnDurations.push({
-            durationMs: entry.durationMs,
-            messageCount: entry.messageCount || 0,
-            uuid: entry.uuid
-          });
-        }
+      if (entry.type === "system" && entry.subtype === "turn_duration" && typeof entry.durationMs === "number") {
+        turnDurations.push({
+          durationMs: entry.durationMs,
+          messageCount: entry.messageCount || 0,
+          uuid: entry.uuid
+        });
         continue;
       }
-      if (type !== "user" && type !== "assistant") continue;
-      if (entry.isMeta) continue;
-      const msg = entry.message;
-      const toolUseBlocks = extractToolUseBlocks(msg?.content);
-      for (const block of toolUseBlocks) {
-        pendingToolUses.set(block.id, block);
-      }
-      const hasToolUseResult = type === "user" && entry.toolUseResult != null;
-      const isToolResultOnly = hasToolUseResult && isOnlyToolResultContent(msg?.content);
-      const content = extractTextContent(msg?.content);
-      const thinking = type === "assistant" ? extractThinking(msg?.content) : null;
-      const hasThinking = !!(thinking?.content || thinking?.signature);
-      if (content || isToolResultOnly || toolUseBlocks.length > 0 || hasThinking) {
-        const metadata = {};
-        if (msg?.model) metadata.model = msg.model;
-        if (msg?.stop_reason !== void 0) metadata.stopReason = msg.stop_reason;
-        if (entry.gitBranch) metadata.gitBranch = entry.gitBranch;
-        if (entry.version) metadata.version = entry.version;
-        const usage = msg?.usage;
-        if (usage) {
-          if (usage.input_tokens) metadata.inputTokens = usage.input_tokens;
-          if (usage.output_tokens) metadata.outputTokens = usage.output_tokens;
-          if (usage.cache_read_input_tokens)
-            metadata.cacheReadTokens = usage.cache_read_input_tokens;
-          if (usage.cache_creation_input_tokens)
-            metadata.cacheCreationTokens = usage.cache_creation_input_tokens;
-        }
-        const toolUseNames = extractToolUseNames(msg?.content);
-        if (toolUseNames.length > 0) metadata.toolUses = toolUseNames;
-        if (toolUseBlocks.length > 0) metadata.toolUseBlocks = toolUseBlocks;
-        if (isToolResultOnly) {
-          const toolResultBlocks = extractToolResultBlocks(msg?.content, pendingToolUses);
-          if (toolResultBlocks.length > 0) metadata.toolResults = toolResultBlocks;
-        }
-        if (entry.teamName) {
-          metadata.teamName = entry.teamName;
-          if (!teamInfoMap.has(metadata.teamName) && content) {
-            const info = parseTeammateMessageTag(content);
-            if (info) teamInfoMap.set(metadata.teamName, info);
-          }
-        }
-        const thinkingContent = thinking?.content || void 0;
-        const thinkingSignature = thinking?.signature || void 0;
-        const hasMetadata = Object.keys(metadata).length > 0;
-        messages.push({
-          role: type,
-          text: content || "",
-          timestamp: entry.timestamp || "",
-          uuid: entry.uuid || void 0,
-          metadata: hasMetadata ? metadata : void 0,
-          isToolResult: isToolResultOnly || void 0,
-          isThinking: thinkingContent || thinkingSignature ? true : void 0,
-          thinkingContent,
-          thinkingSignature,
-          parentUuid: entry.parentUuid !== void 0 ? entry.parentUuid : void 0,
-          requestId: type === "assistant" ? entry.requestId : void 0,
-          promptId: type === "user" ? entry.promptId : void 0,
-          isSidechain: typeof entry.isSidechain === "boolean" ? entry.isSidechain : void 0,
-          permissionMode: type === "user" ? entry.permissionMode : void 0,
-          hasImages: hasImageBlocks(msg?.content) || void 0,
-          attachment: entry.attachment !== void 0 ? entry.attachment : void 0
-        });
-        if (content) textParts.push(content);
+      const message = reduceConvLine(state, entry);
+      if (message) {
+        messages.push(message);
+        if (message.text) textParts.push(message.text);
       }
     }
   } catch (err) {
@@ -718,28 +880,21 @@ async function parseConversation(filePath, account) {
     return null;
   }
   log.debug({ filePath, messageCount: messages.length }, "parseConversation: complete");
-  if (teamInfoMap.size > 0) {
-    for (const msg of messages) {
-      if (msg.metadata?.teamName) {
-        const info = teamInfoMap.get(msg.metadata.teamName);
-        if (info) msg.metadata.teamInfo = info;
-      }
-    }
-  }
+  applyTeamInfo(messages, state);
   return {
     id: filePath,
     filePath,
-    projectPath: cwd,
-    projectName: getShortProjectName(cwd),
-    sessionId: sessionId || basename(filePath, ".jsonl"),
-    sessionName,
+    projectPath: state.cwd,
+    projectName: getShortProjectName2(state.cwd),
+    sessionId: state.sessionId || basename2(filePath, ".jsonl"),
+    sessionName: state.sessionName,
     messages,
     fullText: textParts.join(" "),
-    timestamp: latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    timestamp: state.latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
     messageCount: messages.length,
     account,
     turnDurations: turnDurations.length > 0 ? turnDurations : void 0,
-    lastPrompt: lastPrompt || void 0
+    lastPrompt: state.lastPrompt || void 0
   };
 }
 function extractTextContent(content) {
@@ -832,13 +987,294 @@ function parseTeammateMessageTag(content) {
   const color = attrs.match(/color="([^"]*)"/)?.[1];
   return { teammateId: id, summary, color };
 }
-function getShortProjectName(fullPath) {
+function getShortProjectName2(fullPath) {
   const parts = fullPath.split("/").filter(Boolean);
   return parts.slice(-3).join("/");
 }
 
-// src/tiers.ts
-var DEFAULT_TIERS = {
+// src/persistent/metadata-reducer.ts
+function initialReducerState() {
+  return {
+    sessionId: "",
+    sessionName: "",
+    latestTimestamp: "",
+    cwd: "",
+    teamName: "",
+    model: null,
+    messageCount: 0,
+    lastMessageSender: "user",
+    isTeammate: false,
+    firstUserSeen: false,
+    firstMessage: null,
+    lastMessage: null,
+    lastPrompt: "",
+    pageMessageCount: 0,
+    toolNames: [],
+    previewParts: [],
+    snippetParts: [],
+    previewLength: 0,
+    snippetLength: 0,
+    badJsonLines: 0
+  };
+}
+function reduceLine(state, entry, tier) {
+  if (entry.cwd && !state.cwd) state.cwd = entry.cwd;
+  if (entry.sessionId && !state.sessionId) state.sessionId = entry.sessionId;
+  if (entry.slug && !state.sessionName) state.sessionName = entry.slug;
+  if (entry.teamName && !state.teamName) state.teamName = entry.teamName;
+  if (entry.timestamp) {
+    const ts = entry.timestamp;
+    if (!state.latestTimestamp || ts > state.latestTimestamp) state.latestTimestamp = ts;
+  }
+  const type = entry.type;
+  if (type === "last-prompt") {
+    if (entry.lastPrompt && !state.lastPrompt) state.lastPrompt = entry.lastPrompt;
+    return;
+  }
+  if (type !== "user" && type !== "assistant") return;
+  if (entry.isMeta) return;
+  const msg = entry.message;
+  if (state.model === null && msg?.model) state.model = msg.model;
+  if (type === "user" && !state.firstUserSeen) {
+    state.firstUserSeen = true;
+    if (isTeammateContent(msg?.content)) state.isTeammate = true;
+  }
+  const content = extractTextContent(msg?.content);
+  const hasToolUseResult = type === "user" && entry.toolUseResult != null;
+  const isOnlyToolResult = hasToolUseResult && isOnlyToolResultContent(msg?.content);
+  const toolSet = new Set(state.toolNames);
+  collectToolNames(msg?.content, toolSet);
+  state.toolNames = Array.from(toolSet);
+  const toolUseBlocks = extractToolUseBlocks(msg?.content);
+  const thinking = type === "assistant" ? extractThinking(msg?.content) : null;
+  const hasThinking = !!(thinking?.content || thinking?.signature);
+  if (content || isOnlyToolResult || toolUseBlocks.length > 0 || hasThinking) {
+    state.pageMessageCount++;
+  }
+  if (content || isOnlyToolResult) {
+    state.messageCount++;
+    state.lastMessageSender = type;
+    if (content) {
+      const ts = entry.timestamp || "";
+      if (!state.firstMessage) state.firstMessage = { text: content.slice(0, 200), timestamp: ts };
+      state.lastMessage = { text: content.slice(0, 200), timestamp: ts };
+      if (state.previewLength < tier.previewMax) {
+        state.previewParts.push(content);
+        state.previewLength += content.length;
+      }
+      if (state.snippetLength < tier.snippetMax) {
+        const remaining = tier.snippetMax - state.snippetLength;
+        const chunk = content.length > remaining ? content.slice(0, remaining) : content;
+        state.snippetParts.push(chunk);
+        state.snippetLength += chunk.length;
+      }
+    }
+  }
+}
+function finalizeMeta(state, filePath, account, tier) {
+  if (state.messageCount === 0) return null;
+  const isSubagent = filePath.includes("/subagents/");
+  let parentSessionId = null;
+  if (isSubagent) {
+    const uuidDir = dirname2(dirname2(filePath));
+    parentSessionId = join3(dirname2(uuidDir), `${basename3(uuidDir)}.jsonl`);
+  }
+  const projectPath = state.cwd;
+  return {
+    id: filePath,
+    filePath,
+    provider: CLAUDE_CODE_PROVIDER,
+    sessionId: state.sessionId || basename3(filePath, ".jsonl"),
+    sessionName: state.sessionName,
+    projectPath,
+    projectName: getShortProjectName3(projectPath),
+    account,
+    timestamp: state.latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    messageCount: state.messageCount,
+    lastMessageSender: state.lastMessageSender,
+    preview: state.previewParts.join(" ").slice(0, tier.previewMax),
+    contentSnippet: state.snippetParts.join(" "),
+    gitBranch: null,
+    model: state.model,
+    isSubagent,
+    parentSessionId,
+    isTeammate: state.isTeammate,
+    teamName: state.teamName || null,
+    toolNames: state.toolNames,
+    firstMessage: state.firstMessage,
+    lastMessage: state.lastMessage,
+    lastPrompt: state.lastPrompt || void 0
+  };
+}
+function getShortProjectName3(fullPath) {
+  const parts = fullPath.split("/").filter(Boolean);
+  return parts.slice(-3).join("/");
+}
+
+// src/providers/threadbase.ts
+var ThreadbaseProvider = class {
+  name = CLAUDE_CODE_PROVIDER;
+  // Roots are passed as "<projectsDir>\0<account>" so the scanner can carry the
+  // per-root account through the shared interface. The scanner builds these.
+  async discover(roots) {
+    const dirs = roots.map((r) => {
+      const [projectsDir, account = "default"] = r.split("\0");
+      return { projectsDir, account };
+    });
+    return discoverJsonlFiles(dirs);
+  }
+  // Threadbase JSONL has top-level type "user"/"assistant" with a cwd/sessionId.
+  canParse(_filePath, sample) {
+    for (const line of sample.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const e = JSON.parse(line);
+        if (e.type === "user" || e.type === "assistant") return true;
+        if (e.type === "session_meta" || e.type === "response_item") return false;
+      } catch {
+      }
+    }
+    return false;
+  }
+  createEmptyAccumulator() {
+    return initialReducerState();
+  }
+  reduceEntry(acc, entry, tier) {
+    reduceLine(acc, entry, tier);
+  }
+  finalize(acc, filePath, account, tier) {
+    return finalizeMeta(acc, filePath, account, tier);
+  }
+};
+
+// src/scanner.ts
+import { EventEmitter } from "events";
+import { closeSync as closeSync2, openSync as openSync2, readSync as readSync2, statSync as statSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+
+// src/cache.ts
+var LRUCache = class {
+  map = /* @__PURE__ */ new Map();
+  capacity;
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  get(key) {
+    const value = this.map.get(key);
+    if (value === void 0) return void 0;
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    this.map.delete(key);
+    this.map.set(key, value);
+    if (this.map.size > this.capacity) {
+      const oldest = this.map.keys().next();
+      if (!oldest.done) this.map.delete(oldest.value);
+    }
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+};
+
+// src/persistent/cursor.ts
+import { createHash } from "crypto";
+import { closeSync, openSync, readSync, statSync } from "fs";
+var FP_BYTES = 4096;
+function fingerprint(filePath, size) {
+  const hash = createHash("sha1");
+  hash.update(String(size));
+  const fd = openSync(filePath, "r");
+  try {
+    const head = Buffer.alloc(Math.min(FP_BYTES, size));
+    if (head.length > 0) {
+      readSync(fd, head, 0, head.length, 0);
+      hash.update(head);
+    }
+    if (size > FP_BYTES) {
+      const tailLen = Math.min(FP_BYTES, size);
+      const tail = Buffer.alloc(tailLen);
+      readSync(fd, tail, 0, tailLen, size - tailLen);
+      hash.update(tail);
+    }
+  } finally {
+    closeSync(fd);
+  }
+  return hash.digest("hex");
+}
+function classify(filePath, existing) {
+  let stat3;
+  try {
+    const s = statSync(filePath);
+    stat3 = { size: s.size, mtimeMs: s.mtimeMs };
+  } catch {
+    return { change: "vanished" };
+  }
+  if (!existing || existing.status !== "active" || existing.last_indexed_offset === 0) {
+    return { change: "reindex", stat: stat3 };
+  }
+  if (stat3.size < existing.last_indexed_offset) {
+    return { change: "reindex", stat: stat3 };
+  }
+  if (stat3.size === existing.size_bytes && stat3.mtimeMs === existing.mtime_ms) {
+    return { change: "unchanged", stat: stat3 };
+  }
+  if (stat3.size === existing.last_indexed_offset) {
+    const fp = fingerprint(filePath, stat3.size);
+    if (existing.content_fingerprint && fp !== existing.content_fingerprint) {
+      return { change: "reindex", stat: stat3 };
+    }
+    return { change: "unchanged", stat: stat3 };
+  }
+  return { change: "appended", stat: stat3 };
+}
+
+// src/providers/parse.ts
+import { createReadStream as createReadStream3 } from "fs";
+import { createInterface as createInterface3 } from "readline";
+async function parseMetaWithProvider(provider, filePath, account, tier) {
+  const log = getLogger();
+  const acc = provider.createEmptyAccumulator();
+  const rl = createInterface3({
+    input: createReadStream3(filePath),
+    crlfDelay: Infinity
+  });
+  try {
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      try {
+        provider.reduceEntry(acc, entry, tier);
+      } catch (err) {
+        log.warn({ filePath, provider: provider.name, err }, "provider reduce threw; line skipped");
+      }
+    }
+  } catch (err) {
+    log.warn({ filePath, provider: provider.name, err }, "provider parse: read failed");
+    return null;
+  }
+  return provider.finalize(acc, filePath, account, tier);
+}
+
+// src/tiers.ts
+var DEFAULT_TIERS = {
   standard: { name: "standard", previewMax: 200, snippetMax: 5e3 },
   full: { name: "full", previewMax: 1200, snippetMax: 5e4 }
 };
@@ -852,28 +1288,1108 @@ function resolveTier(tierName, customTiers) {
   return tier;
 }
 
-// src/scanner.ts
+// src/persistent/db.ts
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname as dirname3 } from "path";
+
+// src/persistent/schema.ts
+var SCHEMA_VERSION = 3;
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS conversation_files (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+
+  absolute_path TEXT NOT NULL UNIQUE,
+  parent_dir TEXT NOT NULL,
+  file_name TEXT NOT NULL,
+
+  account TEXT NOT NULL DEFAULT 'default',
+
+  size_bytes INTEGER NOT NULL DEFAULT 0,
+  mtime_ms INTEGER NOT NULL DEFAULT 0,
+
+  last_indexed_offset INTEGER NOT NULL DEFAULT 0,
+  last_indexed_line INTEGER NOT NULL DEFAULT 0,
+
+  reducer_state TEXT,
+
+  content_fingerprint TEXT,
+
+  status TEXT NOT NULL DEFAULT 'active',
+
+  last_indexed_at TEXT,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  deleted_at TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_conversation_files_status ON conversation_files(status);
+CREATE INDEX IF NOT EXISTS idx_conversation_files_parent_dir ON conversation_files(parent_dir);
+CREATE INDEX IF NOT EXISTS idx_conversation_files_account ON conversation_files(account);
+
+CREATE TABLE IF NOT EXISTS conversations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+
+  file_id INTEGER NOT NULL UNIQUE,
+
+  source_path TEXT NOT NULL UNIQUE,
+  -- Which provider produced this row. Canonical identity is (provider,
+  -- source_path); session_id stays non-unique across providers too.
+  provider TEXT NOT NULL DEFAULT 'claude-code',
+  kind TEXT,
+  external_session_id TEXT,
+  session_id TEXT NOT NULL,
+  session_name TEXT,
+
+  project_path TEXT,
+  project_name TEXT,
+  account TEXT NOT NULL DEFAULT 'default',
+  branch TEXT,
+
+  preview TEXT,
+  content_snippet TEXT,
+
+  message_count INTEGER NOT NULL DEFAULT 0,
+  -- Count of messages parseConversation() produces (broader than message_count;
+  -- includes tool_use-only and thinking-only lines). The total for bounded paging.
+  page_message_count INTEGER NOT NULL DEFAULT 0,
+  last_message_sender TEXT NOT NULL DEFAULT 'user',
+  timestamp TEXT,
+
+  -- Monotonic write counter; the highest value is the most recently indexed
+  -- row. Drives last-writer-wins resolution for shared session_ids (matching
+  -- the in-memory sessionId map), at the sub-second precision updated_at lacks.
+  index_seq INTEGER NOT NULL DEFAULT 0,
+
+  first_sent_at TEXT,
+  first_sent_text TEXT,
+
+  last_sent_at TEXT,
+  last_sent_text TEXT,
+
+  model TEXT,
+  is_subagent INTEGER NOT NULL DEFAULT 0,
+  parent_session_id TEXT,
+  is_teammate INTEGER NOT NULL DEFAULT 0,
+  team_name TEXT,
+  tool_names_json TEXT,
+  last_prompt TEXT,
+
+  status TEXT NOT NULL DEFAULT 'active',
+
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+  FOREIGN KEY (file_id) REFERENCES conversation_files(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_conversations_session_id ON conversations(session_id);
+CREATE INDEX IF NOT EXISTS idx_conversations_provider_session ON conversations(provider, session_id);
+CREATE INDEX IF NOT EXISTS idx_conversations_provider_recent ON conversations(provider, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_conversations_provider_project_branch ON conversations(provider, project_path, branch);
+CREATE INDEX IF NOT EXISTS idx_conversations_recent ON conversations(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_conversations_project_recent ON conversations(project_path, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_conversations_project_branch_recent ON conversations(project_path, branch, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_conversations_account_recent ON conversations(account, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_conversations_subagent_recent ON conversations(is_subagent, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_conversations_team_recent ON conversations(team_name, timestamp DESC);
+
+-- Full-text search index over conversation content + metadata. Kept separate
+-- from the metadata tables so list-screen queries stay small and fast.
+-- source_path is UNINDEXED (stored, not tokenized) and links back to a
+-- conversations row. One FTS row per conversation, replaced on each upsert.
+CREATE VIRTUAL TABLE IF NOT EXISTS conversation_messages_fts USING fts5(
+  source_path UNINDEXED,
+  content,
+  project_name,
+  session_id,
+  session_name,
+  account,
+  model,
+  branch,
+  tool_names,
+  tokenize = 'unicode61'
+);
+
+-- Seek index for large conversations: every N messages, record the byte offset
+-- where the next message's line begins plus the parser's cross-line state
+-- (pending tool_use blocks, team info) needed to resume an equivalent parse
+-- from that point. Lets getConversationPage() read a window near the end of a
+-- huge file without parsing from byte 0.
+CREATE TABLE IF NOT EXISTS message_checkpoints (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  source_path TEXT NOT NULL,
+  message_index INTEGER NOT NULL,
+  byte_offset INTEGER NOT NULL,
+  line_number INTEGER NOT NULL,
+  parser_state TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_message_checkpoints_lookup
+  ON message_checkpoints(source_path, message_index);
+`;
+
+// src/persistent/migrations.ts
+function runMigrations(db) {
+  const current = db.pragma("user_version", { simple: true });
+  if (current >= SCHEMA_VERSION) return;
+  const log = getLogger();
+  log.info({ from: current, to: SCHEMA_VERSION }, "migrations: applying");
+  if (current >= 1 && current < 2 && tableExists(db, "conversations")) {
+    for (const [col, ddl] of [
+      [
+        "provider",
+        // Keep the historical DEFAULT 'threadbase' — v2→v3 below updates these rows.
+        "ALTER TABLE conversations ADD COLUMN provider TEXT NOT NULL DEFAULT 'threadbase'"
+      ],
+      ["kind", "ALTER TABLE conversations ADD COLUMN kind TEXT"],
+      ["external_session_id", "ALTER TABLE conversations ADD COLUMN external_session_id TEXT"]
+    ]) {
+      if (!hasColumn(db, "conversations", col)) db.exec(ddl);
+    }
+  }
+  if (current >= 1 && current < 3 && tableExists(db, "conversations")) {
+    db.exec("UPDATE conversations SET provider = 'claude-code' WHERE provider = 'threadbase'");
+  }
+  db.exec(SCHEMA_SQL);
+  db.pragma(`user_version = ${SCHEMA_VERSION}`);
+}
+function tableExists(db, table) {
+  return db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table) !== void 0;
+}
+function hasColumn(db, table, column) {
+  const cols = db.prepare(`PRAGMA table_info(${table})`).all();
+  return cols.some((c) => c.name === column);
+}
+
+// src/persistent/db.ts
+function openDatabase(dbPath) {
+  if (dbPath !== ":memory:") {
+    mkdirSync(dirname3(dbPath), { recursive: true });
+  }
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma("temp_store = MEMORY");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db);
+  getLogger().debug({ dbPath }, "db: opened");
+  return db;
+}
+
+// src/persistent/jsonl-tail-reader.ts
+import { createReadStream as createReadStream4 } from "fs";
+async function tailReduce(filePath, startOffset, startLine, state, tier) {
+  const stream = createReadStream4(filePath, { start: startOffset, encoding: "utf8" });
+  let buffer = "";
+  let offset = startOffset;
+  let line = startLine;
+  let parsedLines = 0;
+  for await (const chunk of stream) {
+    buffer += chunk;
+    let nl;
+    while ((nl = buffer.indexOf("\n")) >= 0) {
+      const lineWithNewline = buffer.slice(0, nl + 1);
+      const text = lineWithNewline.trimEnd();
+      buffer = buffer.slice(nl + 1);
+      if (text.length > 0) {
+        try {
+          reduceLine(state, JSON.parse(text), tier);
+        } catch {
+          state.badJsonLines++;
+        }
+        parsedLines++;
+      }
+      offset += Buffer.byteLength(lineWithNewline, "utf8");
+      line++;
+    }
+  }
+  return { newOffset: offset, newLine: line, parsedLines, badJsonLines: state.badJsonLines };
+}
+
+// src/persistent/paged-reader.ts
+import { createReadStream as createReadStream5 } from "fs";
+var CHECKPOINT_INTERVAL = 500;
+async function streamMessages(filePath, startOffset, startLine, state, onMessage) {
+  const stream = createReadStream5(filePath, { start: startOffset, encoding: "utf8" });
+  let buffer = "";
+  let offset = startOffset;
+  let line = startLine;
+  for await (const chunk of stream) {
+    buffer += chunk;
+    let nl;
+    while ((nl = buffer.indexOf("\n")) >= 0) {
+      const lineWithNewline = buffer.slice(0, nl + 1);
+      const text = lineWithNewline.trimEnd();
+      buffer = buffer.slice(nl + 1);
+      offset += Buffer.byteLength(lineWithNewline, "utf8");
+      line += 1;
+      if (text.length === 0) continue;
+      let entry;
+      try {
+        entry = JSON.parse(text);
+      } catch {
+        continue;
+      }
+      const message = reduceConvLine(state, entry);
+      if (message && onMessage(message, offset, line)) {
+        stream.destroy();
+        return;
+      }
+    }
+  }
+}
+async function buildCheckpoints(filePath, interval = CHECKPOINT_INTERVAL) {
+  const checkpoints = [];
+  const state = initialConvState();
+  let index = 0;
+  await streamMessages(filePath, 0, 0, state, (_msg, nextOffset, nextLine) => {
+    index += 1;
+    if (index % interval === 0) {
+      checkpoints.push({
+        messageIndex: index,
+        byteOffset: nextOffset,
+        lineNumber: nextLine,
+        state: structuredClone(state)
+      });
+    }
+    return false;
+  });
+  return checkpoints;
+}
+async function readPage(filePath, total, options, floor) {
+  const beforeIndex = options.beforeIndex ?? total;
+  const fromIndex = Math.max(0, beforeIndex - options.limit);
+  const state = floor ? structuredClone(floor.state) : initialConvState();
+  const startOffset = floor ? floor.byteOffset : 0;
+  const startLine = floor ? floor.lineNumber : 0;
+  let index = floor ? floor.messageIndex : 0;
+  const window = [];
+  await streamMessages(filePath, startOffset, startLine, state, (message) => {
+    const current = index;
+    index += 1;
+    if (current >= fromIndex && current < beforeIndex) window.push(message);
+    return index >= beforeIndex;
+  });
+  applyTeamInfo(window, state);
+  return { messages: window, total, fromIndex };
+}
+
+// src/persistent/repositories/checkpoints.repo.ts
+var CheckpointsRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  replaceAll(sourcePath, checkpoints) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM message_checkpoints WHERE source_path = ?").run(sourcePath);
+      const insert = this.db.prepare(
+        `INSERT INTO message_checkpoints
+           (source_path, message_index, byte_offset, line_number, parser_state)
+         VALUES (?, ?, ?, ?, ?)`
+      );
+      for (const c of checkpoints) {
+        insert.run(sourcePath, c.messageIndex, c.byteOffset, c.lineNumber, JSON.stringify(c.state));
+      }
+    });
+    tx();
+  }
+  // The latest checkpoint at or before `messageIndex`, or null if none (read
+  // from the file start). Lets a page seek to the nearest prior anchor.
+  floor(sourcePath, messageIndex) {
+    const row = this.db.prepare(
+      `SELECT message_index, byte_offset, line_number, parser_state
+         FROM message_checkpoints
+         WHERE source_path = ? AND message_index <= ?
+         ORDER BY message_index DESC LIMIT 1`
+    ).get(sourcePath, messageIndex);
+    return row ? toCheckpoint(row) : null;
+  }
+  count(sourcePath) {
+    return this.db.prepare("SELECT COUNT(*) AS n FROM message_checkpoints WHERE source_path = ?").get(sourcePath).n;
+  }
+  remove(sourcePath) {
+    this.db.prepare("DELETE FROM message_checkpoints WHERE source_path = ?").run(sourcePath);
+  }
+};
+function toCheckpoint(row) {
+  return {
+    messageIndex: row.message_index,
+    byteOffset: row.byte_offset,
+    lineNumber: row.line_number,
+    state: JSON.parse(row.parser_state)
+  };
+}
+
+// src/persistent/repositories/conversation-files.repo.ts
+import { basename as basename4, dirname as dirname4 } from "path";
+var ConversationFilesRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  getByPath(absolutePath) {
+    return this.db.prepare("SELECT * FROM conversation_files WHERE absolute_path = ?").get(absolutePath);
+  }
+  // Insert a freshly-discovered file at offset 0; returns its row id. Existing
+  // path is left untouched (returns the existing id) so a re-discovery is safe.
+  ensure(absolutePath, account) {
+    const existing = this.getByPath(absolutePath);
+    if (existing) return existing.id;
+    const info = this.db.prepare(
+      `INSERT INTO conversation_files (absolute_path, parent_dir, file_name, account)
+         VALUES (?, ?, ?, ?)`
+    ).run(absolutePath, dirname4(absolutePath), basename4(absolutePath), account);
+    return Number(info.lastInsertRowid);
+  }
+  // Advance the cursor + persisted reducer state after a successful index pass.
+  updateCursor(id, fields) {
+    this.db.prepare(
+      `UPDATE conversation_files
+         SET size_bytes = ?, mtime_ms = ?, last_indexed_offset = ?, last_indexed_line = ?,
+             reducer_state = ?, content_fingerprint = ?, status = ?,
+             last_indexed_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
+         WHERE id = ?`
+    ).run(
+      fields.sizeBytes,
+      fields.mtimeMs,
+      fields.offset,
+      fields.line,
+      fields.reducerState,
+      fields.fingerprint,
+      fields.status ?? "active",
+      id
+    );
+  }
+  // Reset the cursor to 0 for a truncated/replaced file before a full reindex.
+  resetCursor(id) {
+    this.db.prepare(
+      `UPDATE conversation_files
+         SET last_indexed_offset = 0, last_indexed_line = 0, reducer_state = NULL,
+             status = 'needs_reindex', updated_at = CURRENT_TIMESTAMP
+         WHERE id = ?`
+    ).run(id);
+  }
+  setStatus(id, status) {
+    const deletedAt = status === "deleted" ? "CURRENT_TIMESTAMP" : "deleted_at";
+    this.db.prepare(
+      `UPDATE conversation_files
+         SET status = ?, deleted_at = ${deletedAt}, updated_at = CURRENT_TIMESTAMP
+         WHERE id = ?`
+    ).run(status, id);
+  }
+  allActivePaths() {
+    const rows = this.db.prepare("SELECT absolute_path FROM conversation_files WHERE status != 'deleted'").all();
+    return rows.map((r) => r.absolute_path);
+  }
+};
+
+// src/persistent/repositories/conversations.repo.ts
+function rowToMeta(row) {
+  return {
+    id: row.source_path,
+    filePath: row.source_path,
+    provider: row.provider ?? CLAUDE_CODE_PROVIDER,
+    kind: row.kind ?? void 0,
+    externalSessionId: row.external_session_id ?? void 0,
+    sessionId: row.session_id,
+    sessionName: row.session_name ?? "",
+    projectPath: row.project_path ?? "",
+    projectName: row.project_name ?? "",
+    account: row.account,
+    timestamp: row.timestamp ?? "",
+    messageCount: row.message_count,
+    lastMessageSender: row.last_message_sender,
+    preview: row.preview ?? "",
+    contentSnippet: row.content_snippet ?? "",
+    gitBranch: row.branch,
+    model: row.model,
+    isSubagent: row.is_subagent === 1,
+    parentSessionId: row.parent_session_id,
+    isTeammate: row.is_teammate === 1,
+    teamName: row.team_name,
+    toolNames: row.tool_names_json ? JSON.parse(row.tool_names_json) : [],
+    firstMessage: row.first_sent_text ? { text: row.first_sent_text, timestamp: row.first_sent_at ?? "" } : null,
+    lastMessage: row.last_sent_text ? { text: row.last_sent_text, timestamp: row.last_sent_at ?? "" } : null,
+    lastPrompt: row.last_prompt ?? void 0
+  };
+}
+var ConversationsRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  // Upsert by file_id (1 file = 1 conversation). Keyed on the unique file_id so
+  // a re-index overwrites the prior summary in place.
+  upsert(fileId, meta, pageMessageCount = meta.messageCount) {
+    this.db.prepare(
+      `INSERT INTO conversations (
+           file_id, source_path, provider, kind, external_session_id,
+           session_id, session_name, project_path, project_name,
+           account, branch, preview, content_snippet, message_count, page_message_count,
+           last_message_sender,
+           timestamp, index_seq, first_sent_at, first_sent_text, last_sent_at, last_sent_text,
+           model, is_subagent, parent_session_id, is_teammate, team_name, tool_names_json,
+           last_prompt, status, updated_at
+         ) VALUES (
+           @file_id, @source_path, @provider, @kind, @external_session_id,
+           @session_id, @session_name, @project_path, @project_name,
+           @account, @branch, @preview, @content_snippet, @message_count, @page_message_count,
+           @last_message_sender,
+           @timestamp,
+           (SELECT COALESCE(MAX(index_seq), 0) + 1 FROM conversations),
+           @first_sent_at, @first_sent_text, @last_sent_at, @last_sent_text,
+           @model, @is_subagent, @parent_session_id, @is_teammate, @team_name, @tool_names_json,
+           @last_prompt, 'active', CURRENT_TIMESTAMP
+         )
+         ON CONFLICT(file_id) DO UPDATE SET
+           source_path = excluded.source_path,
+           provider = excluded.provider,
+           kind = excluded.kind,
+           external_session_id = excluded.external_session_id,
+           session_id = excluded.session_id,
+           session_name = excluded.session_name,
+           project_path = excluded.project_path,
+           project_name = excluded.project_name,
+           account = excluded.account,
+           branch = excluded.branch,
+           preview = excluded.preview,
+           content_snippet = excluded.content_snippet,
+           message_count = excluded.message_count,
+           page_message_count = excluded.page_message_count,
+           last_message_sender = excluded.last_message_sender,
+           timestamp = excluded.timestamp,
+           first_sent_at = excluded.first_sent_at,
+           first_sent_text = excluded.first_sent_text,
+           last_sent_at = excluded.last_sent_at,
+           last_sent_text = excluded.last_sent_text,
+           model = excluded.model,
+           is_subagent = excluded.is_subagent,
+           parent_session_id = excluded.parent_session_id,
+           is_teammate = excluded.is_teammate,
+           team_name = excluded.team_name,
+           tool_names_json = excluded.tool_names_json,
+           last_prompt = excluded.last_prompt,
+           status = 'active',
+           index_seq = (SELECT COALESCE(MAX(index_seq), 0) + 1 FROM conversations),
+           updated_at = CURRENT_TIMESTAMP`
+    ).run({
+      file_id: fileId,
+      source_path: meta.id,
+      provider: meta.provider ?? CLAUDE_CODE_PROVIDER,
+      kind: meta.kind ?? null,
+      external_session_id: meta.externalSessionId ?? null,
+      session_id: meta.sessionId,
+      session_name: meta.sessionName || null,
+      project_path: meta.projectPath || null,
+      project_name: meta.projectName || null,
+      account: meta.account,
+      branch: meta.gitBranch,
+      preview: meta.preview || null,
+      content_snippet: meta.contentSnippet || null,
+      message_count: meta.messageCount,
+      page_message_count: pageMessageCount,
+      last_message_sender: meta.lastMessageSender,
+      timestamp: meta.timestamp || null,
+      first_sent_at: meta.firstMessage?.timestamp ?? null,
+      first_sent_text: meta.firstMessage?.text ?? null,
+      last_sent_at: meta.lastMessage?.timestamp ?? null,
+      last_sent_text: meta.lastMessage?.text ?? null,
+      model: meta.model,
+      is_subagent: meta.isSubagent ? 1 : 0,
+      parent_session_id: meta.parentSessionId,
+      is_teammate: meta.isTeammate ? 1 : 0,
+      team_name: meta.teamName,
+      tool_names_json: JSON.stringify(meta.toolNames),
+      last_prompt: meta.lastPrompt ?? null
+    });
+  }
+  getBySourcePath(sourcePath) {
+    const row = this.db.prepare("SELECT * FROM conversations WHERE source_path = ? AND status = 'active'").get(sourcePath);
+    return row ? rowToMeta(row) : null;
+  }
+  // Dual lookup matching scanner.getConversation: resolve by source_path (the
+  // canonical id) first, then by session_id.
+  //
+  // session_id is NOT unique (see schema header) — the sessionId form is a
+  // compatibility convenience. Resolution is deterministic and matches the
+  // in-memory scanner: among active rows sharing the session_id, newest
+  // timestamp wins, index_seq breaks sub-second ties (precision updated_at
+  // lacks), then source_path ascending. Collision-safe callers should use
+  // getAllBySessionId() instead.
+  getByIdOrSession(id) {
+    const direct = this.getBySourcePath(id);
+    if (direct) return direct;
+    const row = this.db.prepare(
+      `SELECT * FROM conversations WHERE session_id = ? AND status = 'active'
+         ORDER BY COALESCE(timestamp, '') DESC, index_seq DESC, source_path ASC LIMIT 1`
+    ).get(id);
+    return row ? rowToMeta(row) : null;
+  }
+  // All active conversations sharing a session_id, newest first (same ordering
+  // as getByIdOrSession). Collision-safe counterpart to the convenience
+  // getByIdOrSession() sessionId lookup.
+  getAllBySessionId(sessionId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM conversations WHERE session_id = ? AND status = 'active'
+         ORDER BY COALESCE(timestamp, '') DESC, index_seq DESC, source_path ASC`
+    ).all(sessionId);
+    return rows.map(rowToMeta);
+  }
+  // All active metas (unsorted/unfiltered) — callers apply the existing
+  // filters/view transforms. Used by scan() before SQL filtering is wired in.
+  allActive() {
+    const rows = this.db.prepare("SELECT * FROM conversations WHERE status = 'active'").all();
+    return rows.map(rowToMeta);
+  }
+  // Most recent active conversations, newest first. Backs the empty-query
+  // search path (mirrors the in-memory indexer's getRecent).
+  recent(limit) {
+    const rows = this.db.prepare(
+      `SELECT * FROM conversations WHERE status = 'active'
+         ORDER BY COALESCE(timestamp, '') DESC, source_path ASC LIMIT ?`
+    ).all(limit);
+    return rows.map(rowToMeta);
+  }
+  distinctProjects() {
+    const rows = this.db.prepare(
+      `SELECT DISTINCT project_path FROM conversations
+         WHERE status = 'active' AND project_path IS NOT NULL AND project_path != ''
+         ORDER BY project_path ASC`
+    ).all();
+    return rows.map((r) => r.project_path);
+  }
+  deleteByFileId(fileId) {
+    this.db.prepare(
+      "UPDATE conversations SET status = 'deleted', updated_at = CURRENT_TIMESTAMP WHERE file_id = ?"
+    ).run(fileId);
+  }
+  // The parseConversation message total for a file (for bounded paging), or 0
+  // if not indexed.
+  pageMessageCount(sourcePath) {
+    const row = this.db.prepare(
+      "SELECT page_message_count AS n FROM conversations WHERE source_path = ? AND status = 'active'"
+    ).get(sourcePath);
+    return row?.n ?? 0;
+  }
+  count() {
+    return this.db.prepare("SELECT COUNT(*) AS n FROM conversations WHERE status = 'active'").get().n;
+  }
+};
+
+// src/persistent/repositories/fts.repo.ts
+var FtsRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  upsert(meta) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM conversation_messages_fts WHERE source_path = ?").run(meta.id);
+      this.db.prepare(
+        `INSERT INTO conversation_messages_fts
+             (source_path, content, project_name, session_id, session_name, account, model, branch, tool_names)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        meta.id,
+        meta.contentSnippet ?? "",
+        meta.projectName ?? "",
+        meta.sessionId ?? "",
+        meta.sessionName ?? "",
+        meta.account ?? "",
+        meta.model ?? "",
+        meta.gitBranch ?? "",
+        meta.toolNames.join(" ")
+      );
+    });
+    tx();
+  }
+  remove(sourcePath) {
+    this.db.prepare("DELETE FROM conversation_messages_fts WHERE source_path = ?").run(sourcePath);
+  }
+  // Ranked source_paths matching the query, best first. Returns [] on an empty
+  // query (callers fall back to a recency listing).
+  search(query, limit) {
+    const match = toMatchQuery(query);
+    if (!match) return [];
+    const rows = this.db.prepare(
+      `SELECT source_path FROM conversation_messages_fts
+         WHERE conversation_messages_fts MATCH ?
+         ORDER BY rank
+         LIMIT ?`
+    ).all(match, limit);
+    return rows.map((r) => r.source_path);
+  }
+  count() {
+    return this.db.prepare("SELECT COUNT(*) AS n FROM conversation_messages_fts").get().n;
+  }
+};
+function toMatchQuery(query) {
+  const terms = query.trim().split(/\s+/).map((t) => t.replace(/"/g, "").trim()).filter(Boolean);
+  if (terms.length === 0) return "";
+  return terms.map((t) => `"${t}"*`).join(" AND ");
+}
+
+// src/persistent/index-engine.ts
 var BATCH_SIZE = 12;
+var PersistentEngine = class {
+  db;
+  files;
+  conversations;
+  fts;
+  checkpoints;
+  // When true, write a portable <file>.idx.json sidecar next to each indexed
+  // JSONL. Off by default.
+  sidecar;
+  constructor(dbPath, options = {}) {
+    this.db = openDatabase(dbPath);
+    this.files = new ConversationFilesRepo(this.db);
+    this.conversations = new ConversationsRepo(this.db);
+    this.fts = new FtsRepo(this.db);
+    this.checkpoints = new CheckpointsRepo(this.db);
+    this.sidecar = options.sidecar ?? false;
+  }
+  close() {
+    this.db.close();
+  }
+  // Discover all JSONL files under the active profiles, (re)parse files that
+  // changed since the last index, and upsert their metadata. Returns the number
+  // of files seen on disk this pass (the scan "scanned" count).
+  async indexAll(activeProfiles, options) {
+    const log = getLogger();
+    const tier = resolveTier(options.tier ?? "standard", options.tiers);
+    const enabled = options.providers ?? [CLAUDE_CODE_PROVIDER];
+    const discovered = [];
+    if (enabled.includes(CLAUDE_CODE_PROVIDER)) {
+      const configDirs = activeProfiles.map((p) => ({
+        projectsDir: getProjectsDir(p),
+        account: p.id
+      }));
+      for (const f of await discoverJsonlFiles(configDirs)) discovered.push(f);
+    }
+    const codex = new CodexCliProvider();
+    if (enabled.includes(CODEX_CLI_PROVIDER) && (options.codexRoots?.length ?? 0) > 0) {
+      for (const f of await codex.discover(options.codexRoots)) {
+        discovered.push({ ...f, provider: codex });
+      }
+    }
+    let scanned = 0;
+    const gitBranchMemo = /* @__PURE__ */ new Map();
+    const resolveGitBranch = (projectPath) => {
+      if (gitBranchMemo.has(projectPath)) {
+        return gitBranchMemo.get(projectPath) ?? null;
+      }
+      const branch = readGitBranch(projectPath);
+      gitBranchMemo.set(projectPath, branch);
+      return branch;
+    };
+    for (let i = 0; i < discovered.length; i += BATCH_SIZE) {
+      const batch = discovered.slice(i, i + BATCH_SIZE);
+      const results = await Promise.all(
+        batch.map(async ({ filePath, account, provider }) => {
+          const meta = await this.indexFile(
+            filePath,
+            account,
+            tier.name,
+            options.tiers,
+            resolveGitBranch,
+            false,
+            provider
+          );
+          return meta;
+        })
+      );
+      const kept = results.filter((m) => m != null);
+      if (kept.length > 0) options.onBatch?.(kept);
+      scanned += batch.length;
+      options.onProgress?.(scanned, discovered.length);
+    }
+    const seen = new Set(discovered.map((d) => d.filePath));
+    for (const path of this.files.allActivePaths()) {
+      if (!seen.has(path)) this.markDeleted(path);
+    }
+    log.info({ scanned, indexed: this.conversations.count() }, "persistent: indexAll complete");
+    return { scanned };
+  }
+  // (Re)index a single file. Classifies the change vs. the persisted cursor:
+  // unchanged → return the stored summary; appended → resume the fold and read
+  // only new bytes; reindex/force → fold from offset 0. Writes the summary +
+  // cursor + reducer state in one transaction so a crash never leaves a
+  // half-written row or an over-advanced cursor.
+  async indexFile(filePath, account, tierName, customTiers, resolveGitBranch, force = false, provider) {
+    const log = getLogger();
+    const tier = resolveTier(tierName, customTiers);
+    const existing = this.files.getByPath(filePath);
+    const { change, stat: stat3 } = classify(filePath, existing);
+    if (change === "vanished" || !stat3) {
+      this.markDeleted(filePath);
+      return null;
+    }
+    if (change === "unchanged" && !force) {
+      return this.conversations.getBySourcePath(filePath);
+    }
+    if (provider && provider.name !== CLAUDE_CODE_PROVIDER) {
+      return this.indexFileWithProvider(provider, filePath, account, tier, stat3, resolveGitBranch);
+    }
+    const resume = change === "appended" && !force && existing?.reducer_state;
+    const state = resume ? JSON.parse(existing.reducer_state) : initialReducerState();
+    const startOffset = resume ? existing.last_indexed_offset : 0;
+    const startLine = resume ? existing.last_indexed_line : 0;
+    let result;
+    try {
+      result = await tailReduce(filePath, startOffset, startLine, state, tier);
+    } catch (err) {
+      log.warn({ filePath, err }, "persistent: tail read failed");
+      return null;
+    }
+    const meta = finalizeMeta(state, filePath, account, tier);
+    if (!meta) {
+      this.markDeleted(filePath);
+      return null;
+    }
+    meta.gitBranch = resolveGitBranch(meta.projectPath);
+    const fp = stat3.size > 0 ? fingerprint(filePath, stat3.size) : null;
+    const fileId = this.files.ensure(filePath, account);
+    const upsert = this.db.transaction(() => {
+      this.conversations.upsert(fileId, meta, state.pageMessageCount);
+      this.fts.upsert(meta);
+      this.checkpoints.remove(filePath);
+      this.files.updateCursor(fileId, {
+        sizeBytes: stat3.size,
+        mtimeMs: stat3.mtimeMs,
+        // Advance only to the last fully-parsed line; a trailing partial line
+        // is left for the next pass.
+        offset: result.newOffset,
+        line: result.newLine,
+        reducerState: JSON.stringify(state),
+        fingerprint: fp,
+        status: "active"
+      });
+    });
+    upsert();
+    if (this.sidecar) {
+      writeSidecar(
+        filePath,
+        buildSidecar(
+          meta,
+          {
+            sizeBytes: stat3.size,
+            mtimeMs: stat3.mtimeMs,
+            offset: result.newOffset,
+            line: result.newLine
+          },
+          (/* @__PURE__ */ new Date()).toISOString()
+        )
+      );
+    }
+    log.debug(
+      { filePath, change, bytesRead: result.newOffset - startOffset, msgs: meta.messageCount },
+      "persistent: indexed file"
+    );
+    return meta;
+  }
+  // Index a non-Threadbase provider file: full reparse from offset 0 through the
+  // provider's reducer/finalize, then the same upsert + FTS write + cursor bump
+  // the Threadbase path uses. The cursor records size/mtime (and offset = size)
+  // so the next pass classifies an unchanged file as "unchanged" and skips it;
+  // any change reparses from 0 again. No reducer_state is persisted.
+  async indexFileWithProvider(provider, filePath, account, tier, stat3, resolveGitBranch) {
+    const log = getLogger();
+    const meta = await parseMetaWithProvider(provider, filePath, account, tier);
+    if (!meta) {
+      this.markDeleted(filePath);
+      return null;
+    }
+    if (meta.gitBranch === null && meta.projectPath) {
+      meta.gitBranch = resolveGitBranch(meta.projectPath);
+    }
+    const fp = stat3.size > 0 ? fingerprint(filePath, stat3.size) : null;
+    const fileId = this.files.ensure(filePath, account);
+    const upsert = this.db.transaction(() => {
+      this.conversations.upsert(fileId, meta, meta.messageCount);
+      this.fts.upsert(meta);
+      this.checkpoints.remove(filePath);
+      this.files.updateCursor(fileId, {
+        sizeBytes: stat3.size,
+        mtimeMs: stat3.mtimeMs,
+        // offset = size marks the file fully consumed (non-zero so the next pass
+        // can classify it "unchanged"); no resumable reducer state is kept.
+        offset: stat3.size,
+        line: 0,
+        reducerState: null,
+        fingerprint: fp,
+        status: "active"
+      });
+    });
+    upsert();
+    log.debug(
+      { filePath, provider: provider.name, msgs: meta.messageCount },
+      "persistent: indexed provider file"
+    );
+    return meta;
+  }
+  markDeleted(filePath) {
+    const existing = this.files.getByPath(filePath);
+    if (!existing) return;
+    const tx = this.db.transaction(() => {
+      this.conversations.deleteByFileId(existing.id);
+      this.fts.remove(filePath);
+      this.checkpoints.remove(filePath);
+      this.files.setStatus(existing.id, "deleted");
+    });
+    tx();
+  }
+  // ── Query helpers (read straight from SQLite) ───────────────────────────
+  allActive() {
+    return this.conversations.allActive();
+  }
+  getByIdOrSession(id) {
+    return this.conversations.getByIdOrSession(id);
+  }
+  getAllBySessionId(sessionId) {
+    return this.conversations.getAllBySessionId(sessionId);
+  }
+  // Ranked metas matching the FTS query, best first. Empty query returns the
+  // most recent conversations (mirroring the in-memory indexer's empty-query
+  // behavior). Resolves each FTS hit to its active conversation row.
+  searchMetas(query, limit) {
+    if (!query.trim()) {
+      return this.conversations.recent(limit);
+    }
+    const paths = this.fts.search(query, limit);
+    const metas = [];
+    for (const path of paths) {
+      const meta = this.conversations.getBySourcePath(path);
+      if (meta) metas.push(meta);
+    }
+    return metas;
+  }
+  getProjects() {
+    return this.conversations.distinctProjects();
+  }
+  // Bounded conversation page: read only the requested window from the file,
+  // seeking from the nearest checkpoint. Returns null if the id can't be
+  // resolved to an indexed conversation. For conversations large enough to span
+  // a checkpoint interval, checkpoints are built lazily on first access and
+  // reused thereafter. Smaller conversations read from the start (cheap).
+  async getPage(id, options) {
+    const meta = this.conversations.getByIdOrSession(id);
+    if (!meta) return null;
+    const filePath = meta.filePath;
+    const total = this.conversations.pageMessageCount(filePath);
+    if (total > CHECKPOINT_INTERVAL && this.checkpoints.count(filePath) === 0) {
+      const built = await buildCheckpoints(filePath);
+      if (built.length > 0) this.checkpoints.replaceAll(filePath, built);
+    }
+    const beforeIndex = options.beforeIndex ?? total;
+    const fromIndex = Math.max(0, beforeIndex - options.limit);
+    const floor = this.checkpoints.floor(filePath, fromIndex);
+    return readPage(filePath, total, options, floor);
+  }
+};
+
+// src/watcher/file-watcher.ts
+import chokidar from "chokidar";
+var EXCLUDED_SEGMENTS2 = ["/memory/", "/tool-results/"];
+var FileWatcher = class {
+  constructor(profiles, onEvent, options = {}) {
+    this.profiles = profiles;
+    this.onEvent = onEvent;
+    this.debounceMs = options.debounceMs ?? 400;
+  }
+  profiles;
+  onEvent;
+  watchers = [];
+  timers = /* @__PURE__ */ new Map();
+  debounceMs;
+  // Resolves once every underlying chokidar watcher has finished its initial
+  // scan, so the caller knows subsequent FS changes will be observed.
+  async start() {
+    const log = getLogger();
+    const ready = [];
+    for (const profile of this.profiles) {
+      const dir = getProjectsDir(profile);
+      const watcher = chokidar.watch(dir, {
+        ignoreInitial: true,
+        ignored: (p) => EXCLUDED_SEGMENTS2.some((seg) => p.includes(seg)),
+        awaitWriteFinish: { stabilityThreshold: this.debounceMs, pollInterval: 100 }
+      });
+      watcher.on("add", (p) => this.dispatch(p, profile.id, "add")).on("change", (p) => this.dispatch(p, profile.id, "change")).on("unlink", (p) => this.dispatch(p, profile.id, "unlink"));
+      ready.push(new Promise((resolve) => watcher.once("ready", () => resolve())));
+      this.watchers.push(watcher);
+      log.debug({ dir, account: profile.id }, "watcher: watching");
+    }
+    await Promise.all(ready);
+  }
+  async stop() {
+    for (const t of this.timers.values()) clearTimeout(t);
+    this.timers.clear();
+    await Promise.all(this.watchers.map((w) => w.close()));
+    this.watchers = [];
+  }
+  dispatch(filePath, account, type) {
+    if (!filePath.endsWith(".jsonl")) return;
+    const existing = this.timers.get(filePath);
+    if (existing) clearTimeout(existing);
+    this.timers.set(
+      filePath,
+      setTimeout(() => {
+        this.timers.delete(filePath);
+        this.onEvent({ filePath, account, type });
+      }, this.debounceMs)
+    );
+  }
+};
+
+// src/watcher/index-queue.ts
+var IndexQueue = class {
+  constructor(process2) {
+    this.process = process2;
+  }
+  process;
+  pending = /* @__PURE__ */ new Map();
+  running = false;
+  idleResolvers = [];
+  enqueue(job) {
+    this.pending.set(job.filePath, job);
+    void this.drain();
+  }
+  // Resolves when the queue has fully drained — useful for tests and for a
+  // clean shutdown.
+  onIdle() {
+    if (!this.running && this.pending.size === 0) return Promise.resolve();
+    return new Promise((resolve) => this.idleResolvers.push(resolve));
+  }
+  get size() {
+    return this.pending.size;
+  }
+  async drain() {
+    if (this.running) return;
+    this.running = true;
+    const log = getLogger();
+    while (this.pending.size > 0) {
+      const [path, job] = this.pending.entries().next().value;
+      this.pending.delete(path);
+      try {
+        await this.process(job);
+      } catch (err) {
+        log.warn({ filePath: job.filePath, err }, "index-queue: job failed");
+      }
+    }
+    this.running = false;
+    const resolvers = this.idleResolvers;
+    this.idleResolvers = [];
+    for (const r of resolvers) r();
+  }
+};
+
+// src/scanner.ts
+var BATCH_SIZE2 = 12;
 var DEFAULT_CONFIG_PATH = "~/.config/threadbase-scanner";
+function defaultDbPath() {
+  return process.env.TB_SCANNER_DB ?? join4(homedir2(), ".config", "threadbase-scanner", "index.db");
+}
 var ConversationScanner = class {
   metadataCache = /* @__PURE__ */ new Map();
   conversationLRU;
+  // session_id is NOT unique, so this maps a sessionId to every active meta that
+  // carries it. Resolution picks deterministically (newest timestamp, then path
+  // ascending) so dropping one file never hides another with the same id.
   sessionIdIndex = /* @__PURE__ */ new Map();
   projects = /* @__PURE__ */ new Set();
   indexer = new SearchIndexer();
   // Tier the most recent scan() ran with, so refreshFile() re-parses a single
   // file at the same content depth. Defaults to the standard tier.
   lastTier = resolveTier("standard");
+  // null when persistent mode is disabled (legacy in-memory path). Lazily
+  // opened on first use so merely constructing a scanner never touches disk.
+  dbPath;
+  sidecarEnabled;
+  engineInstance = null;
+  emitter = new EventEmitter();
+  watcher = null;
+  queue = null;
+  periodicTimer = null;
   constructor(options) {
     this.conversationLRU = new LRUCache(options?.conversationCacheSize ?? 5);
+    if (options?.persistent === false) {
+      this.dbPath = null;
+      this.sidecarEnabled = false;
+    } else {
+      this.dbPath = options?.persistent?.dbPath ?? defaultDbPath();
+      this.sidecarEnabled = options?.persistent?.sidecar ?? false;
+    }
+  }
+  get persistent() {
+    return this.dbPath !== null;
+  }
+  engine() {
+    if (!this.engineInstance) {
+      this.engineInstance = new PersistentEngine(this.dbPath, {
+        sidecar: this.sidecarEnabled
+      });
+    }
+    return this.engineInstance;
+  }
+  // Release the SQLite connection. No-op in legacy mode. Safe to call
+  // repeatedly. Stops the watcher first if one is running; call unwatch()
+  // explicitly beforehand if you need to await watcher teardown.
+  close() {
+    if (this.watcher || this.queue || this.periodicTimer) void this.unwatch();
+    this.engineInstance?.close();
+    this.engineInstance = null;
   }
   async scan(options = {}) {
-    const log = getLogger();
-    const startedAt = Date.now();
     const profiles = await this.resolveProfiles(options.profiles);
     const activeProfiles = profiles.filter((p) => p.enabled && p.scanHistory !== false);
-    const tier = resolveTier(options.tier ?? "standard", options.tiers);
-    this.lastTier = tier;
+    this.lastTier = resolveTier(options.tier ?? "standard", options.tiers);
+    if (this.persistent) {
+      return this.scanPersistent(activeProfiles, options);
+    }
+    return this.scanInMemory(activeProfiles, options);
+  }
+  // SQLite-backed scan: (re)index changed files into the DB, then query all
+  // active metas and run the identical filter/sort/view/paginate pipeline as
+  // the in-memory path — guaranteeing an identical ScanResult shape.
+  async scanPersistent(activeProfiles, options) {
+    const log = getLogger();
+    const startedAt = Date.now();
+    const engine = this.engine();
+    const { scanned } = await engine.indexAll(activeProfiles, options);
+    const allMetas = engine.allActive();
+    const { conversations, total } = this.finalize(allMetas, options);
+    log.info(
+      { scanned, kept: allMetas.length, filteredTotal: total, elapsedMs: Date.now() - startedAt },
+      "scan: complete (persistent)"
+    );
+    return { conversations, total, scanned };
+  }
+  // Apply include/project/account/since filters, sort, view transform, and
+  // pagination. Shared by both backends so results never diverge.
+  finalize(allMetas, options) {
+    let filtered = allMetas;
+    if (options.include && options.include !== "all") {
+      filtered = applyIncludeFilter(filtered, options.include);
+    }
+    if (options.project) filtered = applyProjectFilter(filtered, options.project);
+    if (options.account) filtered = applyAccountFilter(filtered, options.account);
+    if (options.since) filtered = applySinceFilter(filtered, options.since);
+    filtered = applySort(filtered, options.sort ?? "recent");
+    const total = filtered.length;
+    const conversations = this.transformView(filtered, options);
+    if (Array.isArray(conversations)) {
+      const limit = options.limit ?? 50;
+      const offset = options.offset ?? 0;
+      return { conversations: applyPagination(conversations, limit, offset).items, total };
+    }
+    return { conversations, total };
+  }
+  async scanInMemory(activeProfiles, options) {
+    const log = getLogger();
+    const startedAt = Date.now();
+    const tier = this.lastTier;
     log.info(
       {
         activeProfiles: activeProfiles.length,
@@ -889,11 +2405,7 @@ var ConversationScanner = class {
     this.sessionIdIndex.clear();
     this.projects.clear();
     this.indexer.clear();
-    const configDirs = activeProfiles.map((p) => ({
-      projectsDir: getProjectsDir(p),
-      account: p.id
-    }));
-    const files = await discoverJsonlFiles(configDirs);
+    const files = await this.discoverWithProviders(activeProfiles, options);
     const totalFiles = files.length;
     let scanned = 0;
     let parseFailures = 0;
@@ -908,15 +2420,15 @@ var ConversationScanner = class {
       return branch;
     };
     const { statCache } = options;
-    for (let i = 0; i < files.length; i += BATCH_SIZE) {
-      const batch = files.slice(i, i + BATCH_SIZE);
+    for (let i = 0; i < files.length; i += BATCH_SIZE2) {
+      const batch = files.slice(i, i + BATCH_SIZE2);
       const results = await Promise.all(
-        batch.map(async ({ filePath, account }) => {
+        batch.map(async ({ filePath, account, provider }) => {
           if (statCache) {
             const cached = statCache.get(filePath);
             if (cached) {
               try {
-                const s = statSync(filePath);
+                const s = statSync2(filePath);
                 if (s.mtimeMs === cached.stat.mtimeMs && s.size === cached.stat.size) {
                   return cached.meta;
                 }
@@ -925,14 +2437,14 @@ var ConversationScanner = class {
             }
           }
           try {
-            const meta = await parseMeta(filePath, account, tier);
-            if (meta) {
+            const meta = await parseMetaWithProvider(provider, filePath, account, tier);
+            if (meta && meta.gitBranch === null && meta.projectPath) {
               meta.gitBranch = resolveGitBranch(meta.projectPath);
             }
             return meta;
           } catch (err) {
             parseFailures++;
-            log.warn({ filePath, account, err }, "scan: parseMeta threw");
+            log.warn({ filePath, account, provider: provider.name, err }, "scan: parse threw");
             return null;
           }
         })
@@ -941,7 +2453,7 @@ var ConversationScanner = class {
       for (const meta of results) {
         if (meta && meta.messageCount > 0) {
           this.metadataCache.set(meta.id, meta);
-          this.sessionIdIndex.set(meta.sessionId, meta);
+          this.addToSessionIndex(meta);
           this.projects.add(meta.projectPath);
           allMetas.push(meta);
           batchMetas.push(meta);
@@ -955,22 +2467,7 @@ var ConversationScanner = class {
       log.debug({ scanned, totalFiles, batchKept: batchMetas.length }, "scan: batch complete");
       options.onProgress?.(scanned, totalFiles);
     }
-    let filtered = allMetas;
-    if (options.include && options.include !== "all") {
-      filtered = applyIncludeFilter(filtered, options.include);
-    }
-    if (options.project) {
-      filtered = applyProjectFilter(filtered, options.project);
-    }
-    if (options.account) {
-      filtered = applyAccountFilter(filtered, options.account);
-    }
-    if (options.since) {
-      filtered = applySinceFilter(filtered, options.since);
-    }
-    filtered = applySort(filtered, options.sort ?? "recent");
-    const total = filtered.length;
-    const conversations = this.transformView(filtered, options);
+    const { conversations, total } = this.finalize(allMetas, options);
     const elapsedMs = Date.now() - startedAt;
     log.info(
       {
@@ -983,25 +2480,36 @@ var ConversationScanner = class {
       },
       "scan: complete"
     );
-    if (Array.isArray(conversations)) {
-      const limit = options.limit ?? 50;
-      const offset = options.offset ?? 0;
-      const paginated = applyPagination(conversations, limit, offset);
-      return { conversations: paginated.items, total, scanned };
-    }
     return { conversations, total, scanned };
   }
   async search(query, options = {}) {
     const log = getLogger();
     log.debug({ query, indexSize: this.indexer.getDocumentCount() }, "search: start");
-    if (this.indexer.getDocumentCount() === 0) {
-      log.debug("search: index empty, triggering scan");
-      await this.scan({ ...options, limit: void 0, offset: void 0 });
+    let results;
+    if (this.persistent) {
+      const engine = this.engine();
+      if (engine.conversations.count() === 0) {
+        log.debug("search: persistent index empty, triggering scan");
+        const profiles = await this.resolveProfiles(options.profiles);
+        const activeProfiles = profiles.filter((p) => p.enabled && p.scanHistory !== false);
+        await engine.indexAll(activeProfiles, { ...options, limit: void 0, offset: void 0 });
+      }
+      const metas = engine.searchMetas(query, (options.limit ?? 50) * 2);
+      results = query.trim() ? metas.map((meta) => ({ meta, score: 1, matches: generateMatches(meta, query) })) : metas.map((meta) => ({
+        meta,
+        score: 1,
+        matches: [{ field: "timestamp", snippet: meta.preview }]
+      }));
+    } else {
+      if (this.indexer.getDocumentCount() === 0) {
+        log.debug("search: index empty, triggering scan");
+        await this.scan({ ...options, limit: void 0, offset: void 0 });
+      }
+      results = this.indexer.search(query, {
+        fields: options.fields,
+        limit: (options.limit ?? 50) * 2
+      });
     }
-    let results = this.indexer.search(query, {
-      fields: options.fields,
-      limit: (options.limit ?? 50) * 2
-    });
     if (options.include && options.include !== "all") {
       results = results.filter((r) => {
         switch (options.include) {
@@ -1025,6 +2533,11 @@ var ConversationScanner = class {
     if (options.account) {
       results = results.filter((r) => r.meta.account === options.account);
     }
+    if (options.provider) {
+      results = results.filter(
+        (r) => (r.meta.provider ?? CLAUDE_CODE_PROVIDER) === options.provider
+      );
+    }
     if (options.since) {
       const cutoff = parseSinceCutoff(options.since);
       results = results.filter((r) => new Date(r.meta.timestamp).getTime() >= cutoff.getTime());
@@ -1042,14 +2555,14 @@ var ConversationScanner = class {
       log.debug({ id }, "getConversation: cache hit");
       return cached;
     }
-    const meta = this.metadataCache.get(id) ?? this.sessionIdIndex.get(id);
+    const meta = this.persistent ? this.engine().getByIdOrSession(id) : this.metadataCache.get(id) ?? this.resolveSessionId(id);
     if (!meta) {
       log.debug({ id }, "getConversation: not found in metadata");
       return null;
     }
     log.debug({ id, filePath: meta.filePath }, "getConversation: cache miss, parsing");
     try {
-      const conversation = await parseConversation(meta.filePath, meta.account);
+      const conversation = meta.provider === CODEX_CLI_PROVIDER ? await parseCodexConversation(meta.filePath, meta.account) : await parseConversation(meta.filePath, meta.account);
       if (conversation) {
         this.conversationLRU.set(id, conversation);
       }
@@ -1069,14 +2582,18 @@ var ConversationScanner = class {
   // (fromIndex > 0). Returns null when the id can't be resolved/parsed — the
   // same contract as getConversation.
   //
-  // Strategy: parse-once-then-slice. This delegates to getConversation, which
-  // parses the full conversation and caches it in conversationLRU, then slices
-  // the window. Message indices are therefore identical to a full
-  // parseConversation() by construction (same parse, same messages array).
-  // Repeated page requests for the same id reuse the single cached parse. The
-  // bounded-memory win (not holding all messages) is deferred — see
-  // docs/plans/2026-06-10-paged-conversation-parse.md.
+  // Persistent mode: a true bounded read — the engine seeks from the nearest
+  // checkpoint and parses only the requested window (checkpoints are built
+  // lazily for large conversations). Windowed message indices are proven
+  // identical to parseConversation().messages.slice(...) by the paged-reader
+  // equivalence test.
+  //
+  // Legacy mode: parse-once-then-slice via getConversation (cached in the LRU),
+  // which is identical by construction.
   async getConversationPage(id, options) {
+    if (this.persistent) {
+      return this.engine().getPage(id, options);
+    }
     const conversation = await this.getConversation(id);
     if (!conversation) return null;
     const { messages } = conversation;
@@ -1121,6 +2638,30 @@ var ConversationScanner = class {
   // dropped from all indexes.
   async refreshFile(filePath, account) {
     const log = getLogger();
+    if (this.persistent) {
+      const engine = this.engine();
+      const previous2 = engine.getByIdOrSession(filePath);
+      const resolvedAccount2 = account ?? previous2?.account ?? "default";
+      const evict2 = (m) => {
+        if (!m) return;
+        this.conversationLRU.delete(m.id);
+        this.conversationLRU.delete(m.sessionId);
+      };
+      evict2(previous2);
+      const provider = await this.resolveProviderForFile(filePath, previous2);
+      const meta2 = await engine.indexFile(
+        filePath,
+        resolvedAccount2,
+        this.lastTier.name,
+        void 0,
+        readGitBranch,
+        true,
+        provider
+      );
+      evict2(meta2);
+      log.debug({ filePath, kept: !!meta2 }, "refreshFile: updated persistent index");
+      return meta2;
+    }
     const previous = this.metadataCache.get(filePath);
     const resolvedAccount = account ?? previous?.account ?? "default";
     let meta = null;
@@ -1140,18 +2681,16 @@ var ConversationScanner = class {
     if (!meta || meta.messageCount === 0) {
       if (previous) {
         this.metadataCache.delete(previous.id);
-        this.sessionIdIndex.delete(previous.sessionId);
+        this.removeFromSessionIndex(previous);
         this.indexer.removeDocument(previous.id);
       }
       log.debug({ filePath }, "refreshFile: dropped (no parseable messages)");
       return null;
     }
     meta.gitBranch = readGitBranch(meta.projectPath);
-    if (previous && previous.sessionId !== meta.sessionId) {
-      this.sessionIdIndex.delete(previous.sessionId);
-    }
+    if (previous) this.removeFromSessionIndex(previous);
     this.metadataCache.set(meta.id, meta);
-    this.sessionIdIndex.set(meta.sessionId, meta);
+    this.addToSessionIndex(meta);
     this.projects.add(meta.projectPath);
     if (previous) {
       this.indexer.updateDocument(meta);
@@ -1165,17 +2704,208 @@ var ConversationScanner = class {
     return meta;
   }
   getMetadataCache() {
+    if (this.persistent) {
+      const map = /* @__PURE__ */ new Map();
+      for (const meta of this.engine().allActive()) map.set(meta.id, meta);
+      return map;
+    }
     return this.metadataCache;
   }
+  // Collision-safe sessionId lookup. session_id is NOT unique (the parser falls
+  // back to the file basename, and resumed/subagent sessions repeat ids), so
+  // getConversation(sessionId) is a convenience that resolves to one match;
+  // this returns every active conversation sharing the id, newest first.
+  getConversationsBySessionId(sessionId) {
+    if (this.persistent) {
+      return this.engine().getAllBySessionId(sessionId);
+    }
+    return this.sortBySessionPriority(this.sessionIdIndex.get(sessionId) ?? []);
+  }
   getProjects() {
+    const source = this.persistent ? this.engine().getProjects() : this.projects;
     const normalized = /* @__PURE__ */ new Set();
-    for (const p of this.projects) {
+    for (const p of source) {
       normalized.add(p.replace(/\/+$/, ""));
     }
     return Array.from(normalized).sort();
   }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  // Start watching the active profiles' project dirs. A filesystem watcher
+  // feeds debounced, path-deduplicated index jobs through a single-writer
+  // queue; a periodic full rescan backstops any events the watcher misses
+  // (sleep/wake, network FS, restarts). Emits "change" per indexed file.
+  // Persistent mode only — throws in legacy mode (no durable index to update).
+  async watch(options = {}) {
+    if (!this.persistent) {
+      throw new Error("watch() requires persistent mode; construct with persistent enabled");
+    }
+    if (this.watcher) return;
+    const profiles = await this.resolveProfiles(options.profiles);
+    const activeProfiles = profiles.filter((p) => p.enabled && p.scanHistory !== false);
+    this.queue = new IndexQueue(async (job) => {
+      try {
+        const meta = await this.refreshFile(job.filePath, job.account);
+        this.emitter.emit("change", {
+          filePath: job.filePath,
+          account: job.account,
+          meta,
+          reason: job.reason
+        });
+      } catch (err) {
+        this.emitter.emit("error", err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+    this.watcher = new FileWatcher(
+      activeProfiles,
+      (e) => {
+        this.queue?.enqueue({
+          filePath: e.filePath,
+          account: e.account,
+          reason: "watcher"
+        });
+      },
+      { debounceMs: options.debounceMs }
+    );
+    await this.watcher.start();
+    const periodicMs = options.periodicMs ?? 6e4;
+    if (periodicMs > 0) {
+      this.periodicTimer = setInterval(() => {
+        void this.periodicReconcile(activeProfiles);
+      }, periodicMs);
+      this.periodicTimer.unref?.();
+    }
+    getLogger().info({ profiles: activeProfiles.length, periodicMs }, "watch: started");
+  }
+  // Periodic correctness backstop: re-discover all files and enqueue them
+  // through the same queue the watcher uses, so any add/change the watcher
+  // missed still gets indexed and emits a "change" event. Vanished files
+  // (active in the DB but no longer on disk) are enqueued too — refreshFile
+  // drops them. Routing through the queue (not a direct scan) keeps event
+  // emission and single-writer serialization unified.
+  async periodicReconcile(activeProfiles) {
+    if (!this.queue) return;
+    try {
+      const engine = this.engine();
+      const configDirs = activeProfiles.map((p) => ({
+        projectsDir: getProjectsDir(p),
+        account: p.id
+      }));
+      const discovered = await discoverJsonlFiles(configDirs);
+      const seen = /* @__PURE__ */ new Set();
+      for (const { filePath, account } of discovered) {
+        seen.add(filePath);
+        const { change } = classify(filePath, engine.files.getByPath(filePath));
+        if (change !== "unchanged") {
+          this.queue.enqueue({ filePath, account, reason: "periodic" });
+        }
+      }
+      for (const path of engine.files.allActivePaths()) {
+        if (!seen.has(path)) {
+          this.queue.enqueue({ filePath: path, account: "default", reason: "periodic" });
+        }
+      }
+    } catch (err) {
+      this.emitter.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  // Stop watching and drain any in-flight index jobs.
+  async unwatch() {
+    if (this.periodicTimer) {
+      clearInterval(this.periodicTimer);
+      this.periodicTimer = null;
+    }
+    if (this.watcher) {
+      await this.watcher.stop();
+      this.watcher = null;
+    }
+    if (this.queue) {
+      await this.queue.onIdle();
+      this.queue = null;
+    }
+  }
+  // ── Provider plumbing (in-memory path) ──────────────────────────────────
+  // Build the flat parse worklist for the enabled providers. Threadbase
+  // discovers under the active profiles' project dirs; Codex discovers under
+  // the explicit codexRoots (opt-in — no default home scan).
+  async discoverWithProviders(activeProfiles, options) {
+    const enabled = options.providers ?? [CLAUDE_CODE_PROVIDER];
+    const work = [];
+    if (enabled.includes(CLAUDE_CODE_PROVIDER)) {
+      const provider = new ThreadbaseProvider();
+      const roots = activeProfiles.map((p) => `${getProjectsDir(p)}\0${p.id}`);
+      for (const f of await provider.discover(roots)) {
+        work.push({ ...f, provider });
+      }
+    }
+    if (enabled.includes(CODEX_CLI_PROVIDER) && (options.codexRoots?.length ?? 0) > 0) {
+      const provider = new CodexCliProvider();
+      for (const f of await provider.discover(options.codexRoots)) {
+        work.push({ ...f, provider });
+      }
+    }
+    return work;
+  }
+  // Resolve which provider should (re)parse a file. Stored metadata wins; for a
+  // file the index has not seen, sniff the first lines with each non-Threadbase
+  // provider's canParse. Returns undefined for Threadbase (the engine's default
+  // tail-read path).
+  async resolveProviderForFile(filePath, previous) {
+    if (previous?.provider === CODEX_CLI_PROVIDER) return new CodexCliProvider();
+    if (previous?.provider) return void 0;
+    let sample = "";
+    try {
+      const fd = openSync2(filePath, "r");
+      try {
+        const buf = Buffer.alloc(8192);
+        const n = readSync2(fd, buf, 0, buf.length, 0);
+        sample = buf.subarray(0, n).toString("utf8");
+      } finally {
+        closeSync2(fd);
+      }
+    } catch {
+      return void 0;
+    }
+    const codex = new CodexCliProvider();
+    if (codex.canParse(filePath, sample)) return codex;
+    return void 0;
+  }
+  addToSessionIndex(meta) {
+    const list = this.sessionIdIndex.get(meta.sessionId);
+    if (list) {
+      const i = list.findIndex((m) => m.id === meta.id);
+      if (i >= 0) list[i] = meta;
+      else list.push(meta);
+    } else {
+      this.sessionIdIndex.set(meta.sessionId, [meta]);
+    }
+  }
+  removeFromSessionIndex(meta) {
+    const list = this.sessionIdIndex.get(meta.sessionId);
+    if (!list) return;
+    const next = list.filter((m) => m.id !== meta.id);
+    if (next.length > 0) this.sessionIdIndex.set(meta.sessionId, next);
+    else this.sessionIdIndex.delete(meta.sessionId);
+  }
+  // Deterministic single-result sessionId resolution: newest timestamp first,
+  // tie-broken by absolute path ascending.
+  resolveSessionId(sessionId) {
+    return this.sortBySessionPriority(this.sessionIdIndex.get(sessionId) ?? [])[0];
+  }
+  sortBySessionPriority(metas) {
+    return [...metas].sort((a, b) => {
+      if (a.timestamp !== b.timestamp) return a.timestamp < b.timestamp ? 1 : -1;
+      return a.filePath < b.filePath ? -1 : a.filePath > b.filePath ? 1 : 0;
+    });
+  }
   async resolveProfiles(profiles) {
-    if (profiles && profiles.length > 0) return profiles;
+    if (profiles) return profiles;
     return loadProfiles(DEFAULT_CONFIG_PATH);
   }
   transformView(metas, options) {
@@ -1250,9 +2980,11 @@ async function getConversation(id, options, scanner) {
   return (scanner ?? getDefaultScanner()).getConversation(id, options);
 }
 export {
+  CodexCliProvider,
   ConversationScanner,
   DEFAULT_TIERS,
   SearchIndexer,
+  ThreadbaseProvider,
   VALID_SORT_ORDERS,
   applyAccountFilter,
   applyIncludeFilter,
@@ -1268,12 +3000,14 @@ export {
   getProjectsDir,
   loadProfiles,
   readGitBranch,
+  readSidecar,
   resetDefaultScanner,
   resolveConfigDir,
   resolveTier,
   saveProfiles,
   scan,
   search,
-  setLogger
+  setLogger,
+  sidecarPath
 };
 //# sourceMappingURL=index.js.map