@threadbase-sh/scanner 0.9.4 → 0.10.1

package/dist/index.cjs

@@ -43,12 +43,14 @@ __export(index_exports, {
   applySinceFilter: () => applySinceFilter,
   applySort: () => applySort,
   cleanSystemTags: () => cleanSystemTags,
+  createJsonlParseState: () => initialConvState,
   createLogger: () => createLogger,
   detectDefaultProfile: () => detectDefaultProfile,
   getConversation: () => getConversation,
   getLogger: () => getLogger,
   getProjectsDir: () => getProjectsDir,
   loadProfiles: () => loadProfiles,
+  parseJsonlLine: () => parseJsonlLine,
   readGitBranch: () => readGitBranch,
   readSidecar: () => readSidecar,
   resetDefaultScanner: () => resetDefaultScanner,
@@ -353,94 +355,137 @@ var SearchIndexer = class {
   }
 };
 
-// src/persistent/sidecar.ts
+// src/parser.ts
 var import_fs2 = require("fs");
-var SIDECAR_VERSION = 1;
-function sidecarPath(jsonlPath) {
-  return `${jsonlPath}.idx.json`;
-}
-function buildSidecar(meta, cursor, updatedAt) {
+var import_path3 = require("path");
+var import_readline = require("readline");
+
+// src/persistent/metadata-reducer.ts
+var import_path2 = require("path");
+
+// src/providers/provider.ts
+var CLAUDE_CODE_PROVIDER = "claude-code";
+var CODEX_CLI_PROVIDER = "codex-cli";
+
+// src/persistent/metadata-reducer.ts
+function initialReducerState() {
   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
+    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 writeSidecar(jsonlPath, sidecar) {
-  try {
-    (0, import_fs2.writeFileSync)(sidecarPath(jsonlPath), JSON.stringify(sidecar, null, 2));
-  } catch (err) {
-    getLogger().warn({ jsonlPath, err }, "sidecar: write failed");
+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;
   }
-}
-function readSidecar(jsonlPath) {
-  try {
-    return JSON.parse((0, import_fs2.readFileSync)(sidecarPath(jsonlPath), "utf-8"));
-  } catch {
-    return null;
+  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;
+      }
+    }
   }
 }
-
-// src/profiles.ts
-var import_promises = require("fs/promises");
-var import_os = require("os");
-var import_path2 = require("path");
-var PROFILES_FILE = "profiles.json";
-function resolveConfigDir(configDir) {
-  return configDir.replace(/^~/, (0, import_os.homedir)());
-}
-function getProjectsDir(profile) {
-  return (0, import_path2.join)(resolveConfigDir(profile.configDir), "projects");
-}
-async function detectDefaultProfile() {
+function finalizeMeta(state, filePath, account, tier) {
+  if (state.messageCount === 0) return null;
+  const isSubagent = filePath.includes("/subagents/");
+  let parentSessionId = null;
+  if (isSubagent) {
+    const uuidDir = (0, import_path2.dirname)((0, import_path2.dirname)(filePath));
+    parentSessionId = (0, import_path2.join)((0, import_path2.dirname)(uuidDir), `${(0, import_path2.basename)(uuidDir)}.jsonl`);
+  }
+  const projectPath = state.cwd;
   return {
-    id: "default",
-    label: "Default",
-    configDir: (0, import_path2.join)((0, import_os.homedir)(), ".claude"),
-    enabled: true,
-    emoji: "\u{1F916}"
+    id: filePath,
+    filePath,
+    provider: CLAUDE_CODE_PROVIDER,
+    sessionId: state.sessionId || (0, import_path2.basename)(filePath, ".jsonl"),
+    sessionName: state.sessionName,
+    projectPath,
+    projectName: getShortProjectName(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
   };
 }
-async function loadProfiles(configPath) {
-  const log = getLogger();
-  try {
-    const resolved = resolveConfigDir(configPath);
-    const data = await (0, import_promises.readFile)((0, import_path2.join)(resolved, PROFILES_FILE), "utf-8");
-    const profiles = JSON.parse(data);
-    log.debug({ configPath, count: profiles.length }, "profiles: loaded");
-    return profiles;
-  } catch (err) {
-    log.debug({ configPath, err }, "profiles: load failed, using default");
-    const defaultProfile = await detectDefaultProfile();
-    return [defaultProfile];
-  }
-}
-async function saveProfiles(profiles, configPath) {
-  const resolved = resolveConfigDir(configPath);
-  await (0, import_promises.mkdir)(resolved, { recursive: true });
-  await (0, import_promises.writeFile)((0, import_path2.join)(resolved, PROFILES_FILE), JSON.stringify(profiles, null, 2));
-  getLogger().debug({ configPath, count: profiles.length }, "profiles: saved");
+function getShortProjectName(fullPath) {
+  const parts = fullPath.split("/").filter(Boolean);
+  return parts.slice(-3).join("/");
 }
 
-// src/providers/codex-cli.ts
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_fs3 = require("fs");
-var import_promises2 = require("fs/promises");
-var import_path3 = require("path");
-var import_readline = require("readline");
-
 // src/tags.ts
 var SYSTEM_TAGS = [
   "system-reminder",
@@ -469,46 +514,427 @@ 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;
+// src/parser.ts
+async function parseMeta(filePath, account, tier) {
+  const log = getLogger();
+  log.trace({ filePath, account, tier: tier.name }, "parseMeta: start");
+  const state = initialReducerState();
+  const fileStream = (0, import_fs2.createReadStream)(filePath);
+  const rl = (0, import_readline.createInterface)({ input: fileStream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
       try {
-        paths = await (0, import_fast_glob.default)(["**/rollout-*.jsonl", "**/*.jsonl"], {
-          cwd: root,
-          absolute: true,
-          dot: false,
-          unique: true
-        });
-      } catch (err) {
-        log.warn({ root, err }, "codex discovery: glob failed");
+        entry = JSON.parse(line);
+      } catch {
+        state.badJsonLines++;
         continue;
       }
-      for (const filePath of paths) {
-        try {
-          const s = await (0, import_promises2.stat)(filePath);
-          if (s.size > 0) results.push({ filePath, account: "codex" });
-        } catch (err) {
-          log.warn({ filePath, err }, "codex discovery: stat failed");
-        }
-      }
+      reduceLine(state, entry, tier);
     }
-    return results;
+  } catch (err) {
+    log.warn({ filePath, err }, "parseMeta: read failed");
+    return null;
   }
-  // Codex rollout lines carry distinctive top-level types.
-  canParse(_filePath, sample) {
-    for (const line of sample.split("\n")) {
+  if (state.badJsonLines > 0) {
+    log.warn(
+      { filePath, badJsonLines: state.badJsonLines },
+      "parseMeta: skipped malformed JSON lines"
+    );
+  }
+  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;
+  const textParts = [];
+  const turnDurations = [];
+  const state = initialConvState();
+  const fileStream = (0, import_fs2.createReadStream)(filePath);
+  const rl = (0, import_readline.createInterface)({ input: fileStream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
       if (!line.trim()) continue;
+      let entry;
       try {
-        const e = JSON.parse(line);
+        entry = JSON.parse(line);
+      } catch {
+        badJsonLines++;
+        continue;
+      }
+      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;
+      }
+      const message = reduceConvLine(state, entry);
+      if (message) {
+        messages.push(message);
+        if (message.text) textParts.push(message.text);
+      }
+    }
+  } catch (err) {
+    log.warn({ filePath, err }, "parseConversation: read failed");
+    return null;
+  }
+  if (badJsonLines > 0) {
+    log.warn({ filePath, badJsonLines }, "parseConversation: skipped malformed JSON lines");
+  }
+  if (messages.length === 0) {
+    log.trace({ filePath }, "parseConversation: no messages");
+    return null;
+  }
+  log.debug({ filePath, messageCount: messages.length }, "parseConversation: complete");
+  applyTeamInfo(messages, state);
+  return {
+    id: filePath,
+    filePath,
+    projectPath: state.cwd,
+    projectName: getShortProjectName2(state.cwd),
+    sessionId: state.sessionId || (0, import_path3.basename)(filePath, ".jsonl"),
+    sessionName: state.sessionName,
+    messages,
+    fullText: textParts.join(" "),
+    timestamp: state.latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    messageCount: messages.length,
+    account,
+    turnDurations: turnDurations.length > 0 ? turnDurations : void 0,
+    lastPrompt: state.lastPrompt || void 0
+  };
+}
+function extractTextContent(content) {
+  if (!content) return "";
+  if (typeof content === "string") return cleanSystemTags(content);
+  if (Array.isArray(content)) {
+    return content.map((item) => {
+      if (typeof item === "string") return item;
+      if (item?.type === "text" && item?.text) return item.text;
+      if (item?.type === "tool_result" && typeof item?.content === "string") return item.content;
+      return "";
+    }).filter(Boolean).map(cleanSystemTags).join(" ");
+  }
+  return "";
+}
+function extractToolUseNames(content) {
+  if (!Array.isArray(content)) return [];
+  return content.filter((item) => item?.type === "tool_use" && item?.name).map((item) => item.name);
+}
+function extractToolUseBlocks(content) {
+  if (!Array.isArray(content)) return [];
+  return content.filter((item) => item?.type === "tool_use" && item?.name && item?.id).map((item) => ({
+    id: item.id,
+    name: item.name,
+    input: item.input || {}
+  }));
+}
+var TOOL_NAME_TO_TYPE = {
+  Edit: "edit",
+  Write: "write",
+  Read: "read",
+  Bash: "bash",
+  Grep: "grep",
+  Glob: "glob",
+  Agent: "taskAgent",
+  TaskCreate: "taskCreate",
+  TaskUpdate: "taskUpdate"
+};
+function extractToolResultBlocks(content, pendingToolUses) {
+  if (!Array.isArray(content)) return [];
+  return content.filter((item) => item?.type === "tool_result" && item?.tool_use_id).map((item) => {
+    const toolName = pendingToolUses.get(item.tool_use_id)?.name ?? "";
+    return {
+      toolUseId: item.tool_use_id,
+      type: TOOL_NAME_TO_TYPE[toolName] ?? "generic",
+      content: typeof item.content === "string" ? { text: item.content } : item.content ?? {},
+      isError: typeof item.is_error === "boolean" ? item.is_error : void 0
+    };
+  });
+}
+function collectToolNames(content, toolSet) {
+  if (!Array.isArray(content)) return;
+  for (const item of content) {
+    if (item?.type === "tool_use" && item?.name) {
+      toolSet.add(item.name);
+    }
+  }
+}
+function isOnlyToolResultContent(content) {
+  if (!Array.isArray(content)) return false;
+  return content.length > 0 && content.every((item) => item?.type === "tool_result");
+}
+function isTeammateContent(content) {
+  const raw = typeof content === "string" ? content : Array.isArray(content) ? content.map(
+    (item) => typeof item === "string" ? item : item?.type === "text" ? item.text ?? "" : ""
+  ).join("") : "";
+  return raw.includes("<teammate-message");
+}
+function extractThinking(content) {
+  if (!Array.isArray(content)) return { content: "", signature: "" };
+  const blocks = content.filter((item) => item?.type === "thinking");
+  return {
+    content: blocks.map((b) => b.thinking).filter(Boolean).join("\n\n"),
+    signature: blocks.map((b) => b.signature).filter(Boolean).join("")
+  };
+}
+function hasImageBlocks(content) {
+  if (!Array.isArray(content)) return false;
+  return content.some(
+    (item) => item?.type === "image" && (item?.source?.type === "base64" || item?.file?.base64 !== void 0)
+  );
+}
+function parseTeammateMessageTag(content) {
+  const match = content.match(/<teammate-message\s+([^>]*)>/);
+  if (!match) return null;
+  const attrs = match[1];
+  const id = attrs.match(/teammate_id="([^"]*)"/)?.[1];
+  if (!id) return null;
+  const summary = attrs.match(/summary="([^"]*)"/)?.[1];
+  const color = attrs.match(/color="([^"]*)"/)?.[1];
+  return { teammateId: id, summary, color };
+}
+function getShortProjectName2(fullPath) {
+  const parts = fullPath.split("/").filter(Boolean);
+  return parts.slice(-3).join("/");
+}
+
+// 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;
+      for (const block of toolResultBlocks) delete state.pendingToolUses[block.toolUseId];
+    }
+  }
+  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 parseJsonlLine(line, state = initialConvState()) {
+  const text = line.trimEnd();
+  if (text.trim().length === 0) return null;
+  let entry;
+  try {
+    entry = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  return reduceConvLine(state, entry);
+}
+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/persistent/sidecar.ts
+var import_fs3 = require("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 {
+    (0, import_fs3.writeFileSync)(sidecarPath(jsonlPath), JSON.stringify(sidecar, null, 2));
+  } catch (err) {
+    getLogger().warn({ jsonlPath, err }, "sidecar: write failed");
+  }
+}
+function readSidecar(jsonlPath) {
+  try {
+    return JSON.parse((0, import_fs3.readFileSync)(sidecarPath(jsonlPath), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/profiles.ts
+var import_promises = require("fs/promises");
+var import_os = require("os");
+var import_path4 = require("path");
+var PROFILES_FILE = "profiles.json";
+function resolveConfigDir(configDir) {
+  return configDir.replace(/^~/, (0, import_os.homedir)());
+}
+function getProjectsDir(profile) {
+  return (0, import_path4.join)(resolveConfigDir(profile.configDir), "projects");
+}
+async function detectDefaultProfile() {
+  return {
+    id: "default",
+    label: "Default",
+    configDir: (0, import_path4.join)((0, import_os.homedir)(), ".claude"),
+    enabled: true,
+    emoji: "\u{1F916}"
+  };
+}
+async function loadProfiles(configPath) {
+  const log = getLogger();
+  try {
+    const resolved = resolveConfigDir(configPath);
+    const data = await (0, import_promises.readFile)((0, import_path4.join)(resolved, PROFILES_FILE), "utf-8");
+    const profiles = JSON.parse(data);
+    log.debug({ configPath, count: profiles.length }, "profiles: loaded");
+    return profiles;
+  } catch (err) {
+    log.debug({ configPath, err }, "profiles: load failed, using default");
+    const defaultProfile = await detectDefaultProfile();
+    return [defaultProfile];
+  }
+}
+async function saveProfiles(profiles, configPath) {
+  const resolved = resolveConfigDir(configPath);
+  await (0, import_promises.mkdir)(resolved, { recursive: true });
+  await (0, import_promises.writeFile)((0, import_path4.join)(resolved, PROFILES_FILE), JSON.stringify(profiles, null, 2));
+  getLogger().debug({ configPath, count: profiles.length }, "profiles: saved");
+}
+
+// src/providers/codex-cli.ts
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_fs4 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_path5 = require("path");
+var import_readline2 = require("readline");
+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 (0, import_fast_glob.default)(["**/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 (0, import_promises2.stat)(filePath);
+          if (s.size > 0) results.push({ filePath, account: "codex" });
+        } catch (err) {
+          log.warn({ filePath, err }, "codex discovery: stat failed");
+        }
+      }
+    }
+    return results;
+  }
+  // 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;
         }
@@ -606,7 +1032,7 @@ function reduceCodexEntry(acc, entry, tier) {
 }
 function finalizeCodexMeta(acc, filePath, account, tier) {
   if (acc.messageCount === 0) return null;
-  const sessionId = acc.sessionId || (0, import_path3.basename)(filePath, ".jsonl");
+  const sessionId = acc.sessionId || (0, import_path5.basename)(filePath, ".jsonl");
   const projectPath = acc.cwd;
   const kind = acc.lastAssistant === null && acc.toolNames.length > 0 ? "task" : "conversation";
   return {
@@ -618,7 +1044,7 @@ function finalizeCodexMeta(acc, filePath, account, tier) {
     sessionId,
     sessionName: "",
     projectPath,
-    projectName: getShortProjectName(projectPath),
+    projectName: getShortProjectName3(projectPath),
     account,
     timestamp: acc.latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
     messageCount: acc.messageCount,
@@ -637,7 +1063,7 @@ function finalizeCodexMeta(acc, filePath, account, tier) {
     lastPrompt: acc.lastUser?.text || void 0
   };
 }
-function getShortProjectName(fullPath) {
+function getShortProjectName3(fullPath) {
   return fullPath.split("/").filter(Boolean).slice(-3).join("/");
 }
 async function parseCodexConversation(filePath, account) {
@@ -648,7 +1074,7 @@ async function parseCodexConversation(filePath, account) {
   let cwd = "";
   let latestTimestamp = "";
   let lastUserText = "";
-  const rl = (0, import_readline.createInterface)({ input: (0, import_fs3.createReadStream)(filePath), crlfDelay: Infinity });
+  const rl = (0, import_readline2.createInterface)({ input: (0, import_fs4.createReadStream)(filePath), crlfDelay: Infinity });
   try {
     for await (const line of rl) {
       if (!line.trim()) continue;
@@ -685,8 +1111,8 @@ async function parseCodexConversation(filePath, account) {
     id: filePath,
     filePath,
     projectPath: cwd,
-    projectName: getShortProjectName(cwd),
-    sessionId: sessionId || (0, import_path3.basename)(filePath, ".jsonl"),
+    projectName: getShortProjectName3(cwd),
+    sessionId: sessionId || (0, import_path5.basename)(filePath, ".jsonl"),
     sessionName: "",
     messages,
     fullText: textParts.join(" "),
@@ -763,525 +1189,315 @@ async function discoverJsonlFiles(dirs, onProgress) {
   return results;
 }
 
-// src/persistent/metadata-reducer.ts
-var import_path5 = require("path");
+// 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/parser.ts
-var import_fs4 = require("fs");
-var import_path4 = require("path");
-var import_readline2 = require("readline");
+// src/scanner.ts
+var import_events = require("events");
+var import_fs11 = require("fs");
+var import_os2 = require("os");
+var import_path9 = require("path");
 
-// 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;
+// src/cache.ts
+var LRUCache = class {
+  map = /* @__PURE__ */ new Map();
+  capacity;
+  constructor(capacity) {
+    this.capacity = capacity;
   }
-  const type = entry.type;
-  if (type === "last-prompt") {
-    if (entry.lastPrompt && !state.lastPrompt) state.lastPrompt = entry.lastPrompt;
-    return null;
+  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;
   }
-  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;
+  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);
+    }
   }
-  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;
+  has(key) {
+    return this.map.has(key);
   }
-  if (entry.teamName) {
-    metadata.teamName = entry.teamName;
-    if (!state.teamInfo[metadata.teamName] && content) {
-      const info = parseTeammateMessageTag(content);
-      if (info) state.teamInfo[metadata.teamName] = info;
-    }
+  delete(key) {
+    return this.map.delete(key);
   }
-  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];
+  clear() {
+    this.map.clear();
   }
-}
+  get size() {
+    return this.map.size;
+  }
+};
 
-// src/parser.ts
-async function parseMeta(filePath, account, tier) {
-  const log = getLogger();
-  log.trace({ filePath, account, tier: tier.name }, "parseMeta: start");
-  const state = initialReducerState();
-  const fileStream = (0, import_fs4.createReadStream)(filePath);
-  const rl = (0, import_readline2.createInterface)({ input: fileStream, crlfDelay: Infinity });
-  try {
-    for await (const line of rl) {
-      if (!line.trim()) continue;
-      let entry;
-      try {
-        entry = JSON.parse(line);
-      } catch {
-        state.badJsonLines++;
-        continue;
+// src/persistent/conversation-stream.ts
+var import_path6 = require("path");
+
+// src/persistent/paged-reader.ts
+var import_fs6 = require("fs");
+var import_promises5 = require("timers/promises");
+
+// src/persistent/jsonl-tail-reader.ts
+var import_fs5 = require("fs");
+var import_promises4 = require("timers/promises");
+var YIELD_EVERY_LINES = 500;
+async function tailReduce(filePath, startOffset, startLine, state, tier) {
+  const stream = (0, import_fs5.createReadStream)(filePath, { start: startOffset, encoding: "utf8" });
+  let buffer = "";
+  let offset = startOffset;
+  let line = startLine;
+  let parsedLines = 0;
+  let sinceYield = 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++;
+      if (++sinceYield >= YIELD_EVERY_LINES) {
+        sinceYield = 0;
+        await (0, import_promises4.setImmediate)();
       }
-      reduceLine(state, entry, tier);
     }
-  } catch (err) {
-    log.warn({ filePath, err }, "parseMeta: read failed");
-    return null;
-  }
-  if (state.badJsonLines > 0) {
-    log.warn(
-      { filePath, badJsonLines: state.badJsonLines },
-      "parseMeta: skipped malformed JSON lines"
-    );
   }
-  const meta = finalizeMeta(state, filePath, account, tier);
-  if (!meta) log.trace({ filePath }, "parseMeta: no messages");
-  return meta;
+  return { newOffset: offset, newLine: line, parsedLines, badJsonLines: state.badJsonLines };
 }
-async function parseConversation(filePath, account) {
-  const log = getLogger();
-  log.trace({ filePath, account }, "parseConversation: start");
-  const messages = [];
-  let badJsonLines = 0;
-  const textParts = [];
-  const turnDurations = [];
-  const state = initialConvState();
-  const fileStream = (0, import_fs4.createReadStream)(filePath);
-  const rl = (0, import_readline2.createInterface)({ input: fileStream, crlfDelay: Infinity });
-  try {
-    for await (const line of rl) {
-      if (!line.trim()) continue;
+
+// src/persistent/paged-reader.ts
+var CHECKPOINT_INTERVAL = 500;
+async function streamMessages(filePath, startOffset, startLine, state, onMessage, onEntry) {
+  const stream = (0, import_fs6.createReadStream)(filePath, { start: startOffset, encoding: "utf8" });
+  let buffer = "";
+  let offset = startOffset;
+  let line = startLine;
+  let sinceYield = 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);
+      offset += Buffer.byteLength(lineWithNewline, "utf8");
+      line += 1;
+      if (++sinceYield >= YIELD_EVERY_LINES) {
+        sinceYield = 0;
+        await (0, import_promises5.setImmediate)();
+      }
+      if (text.length === 0) continue;
       let entry;
       try {
-        entry = JSON.parse(line);
+        entry = JSON.parse(text);
       } catch {
-        badJsonLines++;
-        continue;
-      }
-      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 (onEntry?.(entry)) continue;
       const message = reduceConvLine(state, entry);
-      if (message) {
-        messages.push(message);
-        if (message.text) textParts.push(message.text);
+      if (message && onMessage(message, offset, line)) {
+        stream.destroy();
+        return { offset, line };
       }
     }
-  } catch (err) {
-    log.warn({ filePath, err }, "parseConversation: read failed");
-    return null;
-  }
-  if (badJsonLines > 0) {
-    log.warn({ filePath, badJsonLines }, "parseConversation: skipped malformed JSON lines");
-  }
-  if (messages.length === 0) {
-    log.trace({ filePath }, "parseConversation: no messages");
-    return null;
-  }
-  log.debug({ filePath, messageCount: messages.length }, "parseConversation: complete");
-  applyTeamInfo(messages, state);
-  return {
-    id: filePath,
-    filePath,
-    projectPath: state.cwd,
-    projectName: getShortProjectName2(state.cwd),
-    sessionId: state.sessionId || (0, import_path4.basename)(filePath, ".jsonl"),
-    sessionName: state.sessionName,
-    messages,
-    fullText: textParts.join(" "),
-    timestamp: state.latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
-    messageCount: messages.length,
-    account,
-    turnDurations: turnDurations.length > 0 ? turnDurations : void 0,
-    lastPrompt: state.lastPrompt || void 0
-  };
-}
-function extractTextContent(content) {
-  if (!content) return "";
-  if (typeof content === "string") return cleanSystemTags(content);
-  if (Array.isArray(content)) {
-    return content.map((item) => {
-      if (typeof item === "string") return item;
-      if (item?.type === "text" && item?.text) return item.text;
-      if (item?.type === "tool_result" && typeof item?.content === "string") return item.content;
-      return "";
-    }).filter(Boolean).map(cleanSystemTags).join(" ");
   }
-  return "";
-}
-function extractToolUseNames(content) {
-  if (!Array.isArray(content)) return [];
-  return content.filter((item) => item?.type === "tool_use" && item?.name).map((item) => item.name);
-}
-function extractToolUseBlocks(content) {
-  if (!Array.isArray(content)) return [];
-  return content.filter((item) => item?.type === "tool_use" && item?.name && item?.id).map((item) => ({
-    id: item.id,
-    name: item.name,
-    input: item.input || {}
-  }));
-}
-var TOOL_NAME_TO_TYPE = {
-  Edit: "edit",
-  Write: "write",
-  Read: "read",
-  Bash: "bash",
-  Grep: "grep",
-  Glob: "glob",
-  Agent: "taskAgent",
-  TaskCreate: "taskCreate",
-  TaskUpdate: "taskUpdate"
-};
-function extractToolResultBlocks(content, pendingToolUses) {
-  if (!Array.isArray(content)) return [];
-  return content.filter((item) => item?.type === "tool_result" && item?.tool_use_id).map((item) => {
-    const toolName = pendingToolUses.get(item.tool_use_id)?.name ?? "";
-    return {
-      toolUseId: item.tool_use_id,
-      type: TOOL_NAME_TO_TYPE[toolName] ?? "generic",
-      content: typeof item.content === "string" ? { text: item.content } : item.content ?? {},
-      isError: typeof item.is_error === "boolean" ? item.is_error : void 0
-    };
-  });
+  return { offset, line };
 }
-function collectToolNames(content, toolSet) {
-  if (!Array.isArray(content)) return;
-  for (const item of content) {
-    if (item?.type === "tool_use" && item?.name) {
-      toolSet.add(item.name);
+async function buildCheckpoints(filePath, interval = CHECKPOINT_INTERVAL, from = null) {
+  const checkpoints = [];
+  const state = from ? from.state : initialConvState();
+  let index = from ? from.messageIndex : 0;
+  await streamMessages(
+    filePath,
+    from?.byteOffset ?? 0,
+    from?.lineNumber ?? 0,
+    state,
+    (_msg, nextOffset, nextLine) => {
+      index += 1;
+      if (index % interval === 0) {
+        checkpoints.push({
+          messageIndex: index,
+          byteOffset: nextOffset,
+          lineNumber: nextLine,
+          state: structuredClone(state)
+        });
+      }
+      return false;
     }
-  }
-}
-function isOnlyToolResultContent(content) {
-  if (!Array.isArray(content)) return false;
-  return content.length > 0 && content.every((item) => item?.type === "tool_result");
-}
-function isTeammateContent(content) {
-  const raw = typeof content === "string" ? content : Array.isArray(content) ? content.map(
-    (item) => typeof item === "string" ? item : item?.type === "text" ? item.text ?? "" : ""
-  ).join("") : "";
-  return raw.includes("<teammate-message");
-}
-function extractThinking(content) {
-  if (!Array.isArray(content)) return { content: "", signature: "" };
-  const blocks = content.filter((item) => item?.type === "thinking");
-  return {
-    content: blocks.map((b) => b.thinking).filter(Boolean).join("\n\n"),
-    signature: blocks.map((b) => b.signature).filter(Boolean).join("")
-  };
-}
-function hasImageBlocks(content) {
-  if (!Array.isArray(content)) return false;
-  return content.some(
-    (item) => item?.type === "image" && (item?.source?.type === "base64" || item?.file?.base64 !== void 0)
   );
+  return checkpoints;
 }
-function parseTeammateMessageTag(content) {
-  const match = content.match(/<teammate-message\s+([^>]*)>/);
-  if (!match) return null;
-  const attrs = match[1];
-  const id = attrs.match(/teammate_id="([^"]*)"/)?.[1];
-  if (!id) return null;
-  const summary = attrs.match(/summary="([^"]*)"/)?.[1];
-  const color = attrs.match(/color="([^"]*)"/)?.[1];
-  return { teammateId: id, summary, color };
-}
-function getShortProjectName2(fullPath) {
-  const parts = fullPath.split("/").filter(Boolean);
-  return parts.slice(-3).join("/");
+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/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;
+// src/persistent/conversation-stream.ts
+async function foldTail(filePath, resume) {
+  const messages = [];
+  const textParts = [];
+  const turnDurations = [];
+  const end = await streamMessages(
+    filePath,
+    resume.offset,
+    resume.line,
+    resume.state,
+    (message) => {
+      messages.push(message);
+      if (message.text) textParts.push(message.text);
+      return false;
+    },
+    (entry) => {
+      if (entry.type === "system" && entry.subtype === "turn_duration" && typeof entry.durationMs === "number") {
+        turnDurations.push({
+          durationMs: entry.durationMs,
+          messageCount: entry.messageCount || 0,
+          uuid: entry.uuid
+        });
+        return true;
       }
+      return false;
     }
-  }
+  );
+  return { messages, textParts, turnDurations, end };
 }
-function finalizeMeta(state, filePath, account, tier) {
-  if (state.messageCount === 0) return null;
-  const isSubagent = filePath.includes("/subagents/");
-  let parentSessionId = null;
-  if (isSubagent) {
-    const uuidDir = (0, import_path5.dirname)((0, import_path5.dirname)(filePath));
-    parentSessionId = (0, import_path5.join)((0, import_path5.dirname)(uuidDir), `${(0, import_path5.basename)(uuidDir)}.jsonl`);
-  }
-  const projectPath = state.cwd;
+function assemble(filePath, account, messages, fullText, turnDurations, state) {
   return {
     id: filePath,
     filePath,
-    provider: CLAUDE_CODE_PROVIDER,
-    sessionId: state.sessionId || (0, import_path5.basename)(filePath, ".jsonl"),
-    sessionName: state.sessionName,
-    projectPath,
-    projectName: getShortProjectName3(projectPath),
-    account,
+    projectPath: state.cwd,
+    projectName: getShortProjectName2(state.cwd),
+    sessionId: state.sessionId || (0, import_path6.basename)(filePath, ".jsonl"),
+    sessionName: state.sessionName,
+    messages,
+    fullText,
     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,
+    messageCount: messages.length,
+    account,
+    turnDurations: turnDurations.length > 0 ? turnDurations : void 0,
     lastPrompt: state.lastPrompt || void 0
   };
 }
-function getShortProjectName3(fullPath) {
-  const parts = fullPath.split("/").filter(Boolean);
-  return parts.slice(-3).join("/");
+async function parseConversationResumable(filePath, account) {
+  const resume = { state: initialConvState(), offset: 0, line: 0 };
+  const { messages, textParts, turnDurations, end } = await foldTail(filePath, resume);
+  if (messages.length === 0) return null;
+  applyTeamInfo(messages, resume.state);
+  const conversation = assemble(
+    filePath,
+    account,
+    messages,
+    textParts.join(" "),
+    turnDurations,
+    resume.state
+  );
+  return { conversation, resume: { state: resume.state, offset: end.offset, line: end.line } };
+}
+async function extendConversation(previous, resume, filePath, account) {
+  const { messages: fresh, textParts, turnDurations, end } = await foldTail(filePath, resume);
+  const messages = fresh.length > 0 ? previous.messages.concat(fresh) : previous.messages;
+  applyTeamInfo(messages, resume.state);
+  const fullText = textParts.length === 0 ? previous.fullText : previous.fullText ? `${previous.fullText} ${textParts.join(" ")}` : textParts.join(" ");
+  const allTurnDurations = (previous.turnDurations ?? []).concat(turnDurations);
+  const conversation = assemble(
+    filePath,
+    account,
+    messages,
+    fullText,
+    allTurnDurations,
+    resume.state
+  );
+  return { conversation, resume: { state: resume.state, offset: end.offset, line: end.line } };
 }
 
-// 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
-var import_events = require("events");
-var import_fs10 = require("fs");
-var import_os2 = require("os");
-var import_path8 = require("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
 var import_crypto = require("crypto");
-var import_fs5 = require("fs");
+var import_fs7 = require("fs");
 var FP_BYTES = 4096;
 function fingerprint(filePath, size) {
   const hash = (0, import_crypto.createHash)("sha1");
   hash.update(String(size));
-  const fd = (0, import_fs5.openSync)(filePath, "r");
+  const fd = (0, import_fs7.openSync)(filePath, "r");
   try {
     const head = Buffer.alloc(Math.min(FP_BYTES, size));
     if (head.length > 0) {
-      (0, import_fs5.readSync)(fd, head, 0, head.length, 0);
+      (0, import_fs7.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);
-      (0, import_fs5.readSync)(fd, tail, 0, tailLen, size - tailLen);
+      (0, import_fs7.readSync)(fd, tail, 0, tailLen, size - tailLen);
       hash.update(tail);
     }
   } finally {
-    (0, import_fs5.closeSync)(fd);
+    (0, import_fs7.closeSync)(fd);
   }
   return hash.digest("hex");
 }
 function classify(filePath, existing) {
   let stat4;
   try {
-    const s = (0, import_fs5.statSync)(filePath);
+    const s = (0, import_fs7.statSync)(filePath);
     stat4 = { size: s.size, mtimeMs: s.mtimeMs };
   } catch {
     return { change: "vanished" };
@@ -1308,14 +1524,17 @@ function classify(filePath, existing) {
   return { change: "reindex", stat: stat4 };
 }
 
+// src/persistent/index-engine.ts
+var import_fs10 = require("fs");
+
 // src/providers/parse.ts
-var import_fs6 = require("fs");
+var import_fs8 = require("fs");
 var import_readline3 = require("readline");
 async function parseMetaWithProvider(provider, filePath, account, tier) {
   const log = getLogger();
   const acc = provider.createEmptyAccumulator();
   const rl = (0, import_readline3.createInterface)({
-    input: (0, import_fs6.createReadStream)(filePath),
+    input: (0, import_fs8.createReadStream)(filePath),
     crlfDelay: Infinity
   });
   try {
@@ -1357,8 +1576,8 @@ function resolveTier(tierName, customTiers) {
 
 // src/persistent/db.ts
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
-var import_fs7 = require("fs");
-var import_path6 = require("path");
+var import_fs9 = require("fs");
+var import_path7 = require("path");
 
 // src/persistent/schema.ts
 var SCHEMA_VERSION = 4;
@@ -1551,7 +1770,7 @@ function hasColumn(db, table, column) {
 // src/persistent/db.ts
 function openDatabase(dbPath) {
   if (dbPath !== ":memory:") {
-    (0, import_fs7.mkdirSync)((0, import_path6.dirname)(dbPath), { recursive: true });
+    (0, import_fs9.mkdirSync)((0, import_path7.dirname)(dbPath), { recursive: true });
   }
   const db = new import_better_sqlite3.default(dbPath);
   db.pragma("journal_mode = WAL");
@@ -1564,7 +1783,7 @@ function openDatabase(dbPath) {
 }
 
 // src/persistent/dir-watermark.ts
-var import_promises4 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 var FULL_RECONCILE_EVERY_N_SCANS = 20;
 async function discoverJsonlFilesGated(dirs, files, scannedDirs, options = {}) {
   const log = getLogger();
@@ -1580,7 +1799,7 @@ async function discoverJsonlFilesGated(dirs, files, scannedDirs, options = {}) {
     for (const projectDir of resolved.entries) {
       let dirStat;
       try {
-        dirStat = await (0, import_promises4.stat)(projectDir);
+        dirStat = await (0, import_promises6.stat)(projectDir);
       } catch {
         scannedDirs.remove(projectDir);
         continue;
@@ -1618,7 +1837,7 @@ async function discoverJsonlFilesGated(dirs, files, scannedDirs, options = {}) {
 async function resolveProjectDirs(projectsDir, scannedDirs) {
   let rootStat;
   try {
-    rootStat = await (0, import_promises4.stat)(projectsDir);
+    rootStat = await (0, import_promises6.stat)(projectsDir);
   } catch {
     return null;
   }
@@ -1628,7 +1847,7 @@ async function resolveProjectDirs(projectsDir, scannedDirs) {
   }
   let entries;
   try {
-    entries = (await (0, import_promises4.readdir)(projectsDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => joinPath(projectsDir, e.name));
+    entries = (await (0, import_promises6.readdir)(projectsDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => joinPath(projectsDir, e.name));
   } catch {
     return null;
   }
@@ -1642,104 +1861,6 @@ function joinPath(dir, name) {
   return dir.endsWith("/") ? `${dir}${name}` : `${dir}/${name}`;
 }
 
-// src/persistent/jsonl-tail-reader.ts
-var import_fs8 = require("fs");
-async function tailReduce(filePath, startOffset, startLine, state, tier) {
-  const stream = (0, import_fs8.createReadStream)(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
-var import_fs9 = require("fs");
-var CHECKPOINT_INTERVAL = 500;
-async function streamMessages(filePath, startOffset, startLine, state, onMessage) {
-  const stream = (0, import_fs9.createReadStream)(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) {
@@ -1760,6 +1881,22 @@ var CheckpointsRepo = class {
     });
     tx();
   }
+  // Insert checkpoints without touching existing rows. Appends never invalidate
+  // the chain covering the immutable prefix (Kafka sparse-index style); rows are
+  // only ever removed on truncation/replace or deletion.
+  append(sourcePath, checkpoints) {
+    const tx = this.db.transaction(() => {
+      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) {
@@ -1771,6 +1908,17 @@ var CheckpointsRepo = class {
     ).get(sourcePath, messageIndex);
     return row ? toCheckpoint(row) : null;
   }
+  // The highest-index checkpoint for a file, or null if none. The resume point
+  // for extending the chain after an append.
+  last(sourcePath) {
+    const row = this.db.prepare(
+      `SELECT message_index, byte_offset, line_number, parser_state
+         FROM message_checkpoints
+         WHERE source_path = ?
+         ORDER BY message_index DESC LIMIT 1`
+    ).get(sourcePath);
+    return row ? toCheckpoint(row) : null;
+  }
   count(sourcePath) {
     return this.db.prepare("SELECT COUNT(*) AS n FROM message_checkpoints WHERE source_path = ?").get(sourcePath).n;
   }
@@ -1788,7 +1936,7 @@ function toCheckpoint(row) {
 }
 
 // src/persistent/repositories/conversation-files.repo.ts
-var import_path7 = require("path");
+var import_path8 = require("path");
 var ConversationFilesRepo = class {
   constructor(db) {
     this.db = db;
@@ -1805,7 +1953,7 @@ var ConversationFilesRepo = class {
     const info = this.db.prepare(
       `INSERT INTO conversation_files (absolute_path, parent_dir, file_name, account)
          VALUES (?, ?, ?, ?)`
-    ).run(absolutePath, (0, import_path7.dirname)(absolutePath), (0, import_path7.basename)(absolutePath), account);
+    ).run(absolutePath, (0, import_path8.dirname)(absolutePath), (0, import_path8.basename)(absolutePath), account);
     return Number(info.lastInsertRowid);
   }
   // Advance the cursor + persisted reducer state after a successful index pass.
@@ -2164,6 +2312,9 @@ var PersistentEngine = class {
   // restart just means the first few post-restart scans don't force an early
   // backstop pass, which is harmless (watermarks themselves persist in the DB).
   scanCount = 0;
+  // In-flight checkpoint build/extension per file, so concurrent getPage
+  // callers share one stream instead of each walking the file.
+  checkpointBuilds = /* @__PURE__ */ new Map();
   constructor(dbPath, options = {}) {
     this.db = openDatabase(dbPath);
     this.files = new ConversationFilesRepo(this.db);
@@ -2216,7 +2367,7 @@ var PersistentEngine = class {
       const batch = discovered.slice(i, i + BATCH_SIZE);
       const results = await Promise.all(
         batch.map(async ({ filePath, account, provider }) => {
-          const meta = await this.indexFile(
+          const { meta } = await this.indexFile(
             filePath,
             account,
             tier.name,
@@ -2251,7 +2402,9 @@ var PersistentEngine = class {
   // 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.
+  // half-written row or an over-advanced cursor. Returns the classification
+  // alongside the meta so callers (refreshFile) can keep, extend, or evict
+  // their own per-file caches without re-stat'ing the file (racy) themselves.
   async indexFile(filePath, account, tierName, customTiers, resolveGitBranch, force = false, provider) {
     const log = getLogger();
     const tier = resolveTier(tierName, customTiers);
@@ -2259,13 +2412,21 @@ var PersistentEngine = class {
     const { change, stat: stat4 } = classify(filePath, existing);
     if (change === "vanished" || !stat4) {
       this.markDeleted(filePath);
-      return null;
+      return { meta: null, change: "vanished" };
     }
     if (change === "unchanged" && !force) {
-      return this.conversations.getBySourcePath(filePath);
+      return { meta: this.conversations.getBySourcePath(filePath), change };
     }
     if (provider && provider.name !== CLAUDE_CODE_PROVIDER) {
-      return this.indexFileWithProvider(provider, filePath, account, tier, stat4, resolveGitBranch);
+      const meta2 = await this.indexFileWithProvider(
+        provider,
+        filePath,
+        account,
+        tier,
+        stat4,
+        resolveGitBranch
+      );
+      return { meta: meta2, change };
     }
     const resume = change === "appended" && !force && existing?.reducer_state;
     const state = resume ? JSON.parse(existing.reducer_state) : initialReducerState();
@@ -2276,12 +2437,12 @@ var PersistentEngine = class {
       result = await tailReduce(filePath, startOffset, startLine, state, tier);
     } catch (err) {
       log.warn({ filePath, err }, "persistent: tail read failed");
-      return null;
+      return { meta: null, change };
     }
     const meta = finalizeMeta(state, filePath, account, tier);
     if (!meta) {
       this.markDeleted(filePath);
-      return null;
+      return { meta: null, change };
     }
     meta.gitBranch = resolveGitBranch(meta.projectPath);
     const fp = stat4.size > 0 ? fingerprint(filePath, stat4.size) : null;
@@ -2289,7 +2450,7 @@ var PersistentEngine = class {
     const upsert = this.db.transaction(() => {
       this.conversations.upsert(fileId, meta, state.pageMessageCount);
       this.fts.upsert(meta);
-      this.checkpoints.remove(filePath);
+      if (!resume) this.checkpoints.remove(filePath);
       this.files.updateCursor(fileId, {
         sizeBytes: stat4.size,
         mtimeMs: stat4.mtimeMs,
@@ -2322,7 +2483,7 @@ var PersistentEngine = class {
       { filePath, change, bytesRead: result.newOffset - startOffset, msgs: meta.messageCount },
       "persistent: indexed file"
     );
-    return meta;
+    return { meta, change };
   }
   // 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
@@ -2422,15 +2583,40 @@ var PersistentEngine = class {
       return { messages: messages.slice(fromIndex2, beforeIndex2), total: total2, fromIndex: fromIndex2 };
     }
     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);
-    }
+    await this.ensureCheckpoints(filePath, total);
     const beforeIndex = options.beforeIndex ?? total;
     const fromIndex = Math.max(0, beforeIndex - options.limit);
-    const floor = this.checkpoints.floor(filePath, fromIndex);
+    let floor = this.checkpoints.floor(filePath, fromIndex);
+    if (floor) {
+      try {
+        if (floor.byteOffset > (0, import_fs10.statSync)(filePath).size) floor = null;
+      } catch {
+      }
+    }
     return readPage(filePath, total, options, floor);
   }
+  // Build or extend the checkpoint chain so it covers `total` messages. Cold
+  // file → full build; a file that grew → extend from the last persisted
+  // checkpoint (reads only past its offset, never the prefix). Single-flighted
+  // per path: concurrent getPage callers await the same build instead of
+  // streaming the file in parallel.
+  ensureCheckpoints(filePath, total) {
+    if (total <= CHECKPOINT_INTERVAL) return Promise.resolve();
+    const inFlight = this.checkpointBuilds.get(filePath);
+    if (inFlight) return inFlight;
+    const build = (async () => {
+      const last = this.checkpoints.last(filePath);
+      if (last && total < last.messageIndex + CHECKPOINT_INTERVAL) return;
+      const fresh = await buildCheckpoints(filePath, CHECKPOINT_INTERVAL, last);
+      if (fresh.length === 0) return;
+      if (last) this.checkpoints.append(filePath, fresh);
+      else this.checkpoints.replaceAll(filePath, fresh);
+    })().finally(() => {
+      if (this.checkpointBuilds.get(filePath) === build) this.checkpointBuilds.delete(filePath);
+    });
+    this.checkpointBuilds.set(filePath, build);
+    return build;
+  }
 };
 
 // src/watcher/file-watcher.ts
@@ -2532,10 +2718,12 @@ var IndexQueue = class {
 var BATCH_SIZE2 = 12;
 var DEFAULT_CONFIG_PATH = "~/.config/threadbase-scanner";
 function defaultDbPath() {
-  return process.env.TB_SCANNER_DB ?? (0, import_path8.join)((0, import_os2.homedir)(), ".config", "threadbase-scanner", "index.db");
+  return process.env.TB_SCANNER_DB ?? (0, import_path9.join)((0, import_os2.homedir)(), ".config", "threadbase-scanner", "index.db");
 }
 var ConversationScanner = class {
   metadataCache = /* @__PURE__ */ new Map();
+  // Parsed conversations plus (persistent claude-code entries only) the resume
+  // point that lets refreshFile extend them in place when the file grows.
   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
@@ -2567,7 +2755,9 @@ var ConversationScanner = class {
   // can't hit a closed DB (the watch-mode half of Bug #4).
   inFlightReconcile = null;
   constructor(options) {
-    this.conversationLRU = new LRUCache(options?.conversationCacheSize ?? 5);
+    this.conversationLRU = new LRUCache(
+      options?.conversationCacheSize ?? 5
+    );
     if (options?.persistent === false) {
       this.dbPath = null;
       this.sidecarEnabled = false;
@@ -2699,7 +2889,7 @@ var ConversationScanner = class {
             const cached = statCache.get(filePath);
             if (cached) {
               try {
-                const s = (0, import_fs10.statSync)(filePath);
+                const s = (0, import_fs11.statSync)(filePath);
                 if (s.mtimeMs === cached.stat.mtimeMs && s.size === cached.stat.size) {
                   return cached.meta;
                 }
@@ -2824,7 +3014,7 @@ var ConversationScanner = class {
     const cached = this.conversationLRU.get(id);
     if (cached) {
       log.debug({ id }, "getConversation: cache hit");
-      return cached;
+      return cached.conversation;
     }
     const meta = this.persistent ? this.engine().getByIdOrSession(id) : this.metadataCache.get(id) ?? this.resolveSessionId(id);
     if (!meta) {
@@ -2833,9 +3023,14 @@ var ConversationScanner = class {
     }
     log.debug({ id, filePath: meta.filePath }, "getConversation: cache miss, parsing");
     try {
+      if (this.persistent && meta.provider !== CODEX_CLI_PROVIDER) {
+        const parsed = await parseConversationResumable(meta.filePath, meta.account);
+        if (parsed) this.conversationLRU.set(id, parsed);
+        return parsed?.conversation ?? null;
+      }
       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);
+        this.conversationLRU.set(id, { conversation });
       }
       return conversation;
     } catch (err) {
@@ -2907,20 +3102,30 @@ var ConversationScanner = class {
   // not seen before. Returns the fresh ConversationMeta, or null when the file
   // no longer parses (missing/empty) — in which case any prior entry for it is
   // dropped from all indexes.
-  async refreshFile(filePath, account) {
+  //
+  // Single-flighted per path: concurrent callers (stacked client retries, a
+  // watcher tick racing a caller) await the one in-flight refresh instead of
+  // each re-reading the file.
+  refreshesInFlight = /* @__PURE__ */ new Map();
+  refreshFile(filePath, account) {
+    const inFlight = this.refreshesInFlight.get(filePath);
+    if (inFlight) return inFlight;
+    const refresh = this.doRefreshFile(filePath, account).finally(() => {
+      if (this.refreshesInFlight.get(filePath) === refresh) {
+        this.refreshesInFlight.delete(filePath);
+      }
+    });
+    this.refreshesInFlight.set(filePath, refresh);
+    return refresh;
+  }
+  async doRefreshFile(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(
+      const { meta: meta2, change } = await engine.indexFile(
         filePath,
         resolvedAccount2,
         this.lastTier.name,
@@ -2929,8 +3134,19 @@ var ConversationScanner = class {
         false,
         provider
       );
-      evict2(meta2);
-      log.debug({ filePath, kept: !!meta2 }, "refreshFile: updated persistent index");
+      const cacheKeys = /* @__PURE__ */ new Set();
+      for (const m of [previous2, meta2]) {
+        if (m) {
+          cacheKeys.add(m.id);
+          cacheKeys.add(m.sessionId);
+        }
+      }
+      if (!meta2 || change === "reindex" || change === "vanished") {
+        for (const key of cacheKeys) this.conversationLRU.delete(key);
+      } else if (change === "appended") {
+        await this.extendCachedConversations(cacheKeys, filePath, meta2.account);
+      }
+      log.debug({ filePath, change, kept: !!meta2 }, "refreshFile: updated persistent index");
       return meta2;
     }
     const previous = this.metadataCache.get(filePath);
@@ -2974,6 +3190,39 @@ var ConversationScanner = class {
     );
     return meta;
   }
+  // Advance every cached parse of an appended file by folding only the new
+  // bytes through the conversation reducer — the in-memory analogue of the
+  // persisted metadata fold. Entries without resume state (Codex) and entries
+  // whose extension fails are evicted so the next read re-parses from scratch.
+  async extendCachedConversations(cacheKeys, filePath, account) {
+    const wrappers = /* @__PURE__ */ new Map();
+    for (const key of cacheKeys) {
+      const wrapper = this.conversationLRU.get(key);
+      if (!wrapper) continue;
+      const keys = wrappers.get(wrapper) ?? [];
+      keys.push(key);
+      wrappers.set(wrapper, keys);
+    }
+    for (const [wrapper, keys] of wrappers) {
+      if (!wrapper.resume) {
+        for (const key of keys) this.conversationLRU.delete(key);
+        continue;
+      }
+      try {
+        const extended = await extendConversation(
+          wrapper.conversation,
+          wrapper.resume,
+          filePath,
+          account
+        );
+        wrapper.conversation = extended.conversation;
+        wrapper.resume = extended.resume;
+      } catch (err) {
+        getLogger().warn({ filePath, err }, "refreshFile: cache extension failed, evicting");
+        for (const key of keys) this.conversationLRU.delete(key);
+      }
+    }
+  }
   getMetadataCache() {
     if (this.persistent) {
       const map = /* @__PURE__ */ new Map();
@@ -3138,13 +3387,13 @@ var ConversationScanner = class {
     if (previous?.provider) return void 0;
     let sample = "";
     try {
-      const fd = (0, import_fs10.openSync)(filePath, "r");
+      const fd = (0, import_fs11.openSync)(filePath, "r");
       try {
         const buf = Buffer.alloc(8192);
-        const n = (0, import_fs10.readSync)(fd, buf, 0, buf.length, 0);
+        const n = (0, import_fs11.readSync)(fd, buf, 0, buf.length, 0);
         sample = buf.subarray(0, n).toString("utf8");
       } finally {
-        (0, import_fs10.closeSync)(fd);
+        (0, import_fs11.closeSync)(fd);
       }
     } catch {
       return void 0;
@@ -3271,12 +3520,14 @@ async function getConversation(id, options, scanner) {
   applySinceFilter,
   applySort,
   cleanSystemTags,
+  createJsonlParseState,
   createLogger,
   detectDefaultProfile,
   getConversation,
   getLogger,
   getProjectsDir,
   loadProfiles,
+  parseJsonlLine,
   readGitBranch,
   readSidecar,
   resetDefaultScanner,