@threadbase-sh/scanner 0.9.4 → 0.10.1

package/dist/index.js

@@ -289,94 +289,137 @@ 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) {
+// src/parser.ts
+import { createReadStream } from "fs";
+import { basename as basename2 } from "path";
+import { createInterface } from "readline";
+
+// src/persistent/metadata-reducer.ts
+import { basename, dirname as dirname2, join as join2 } from "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 {
-    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(readFileSync2(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
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { join as join2 } from "path";
-var PROFILES_FILE = "profiles.json";
-function resolveConfigDir(configDir) {
-  return configDir.replace(/^~/, homedir());
-}
-function getProjectsDir(profile) {
-  return join2(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 = dirname2(dirname2(filePath));
+    parentSessionId = join2(dirname2(uuidDir), `${basename(uuidDir)}.jsonl`);
+  }
+  const projectPath = state.cwd;
   return {
-    id: "default",
-    label: "Default",
-    configDir: join2(homedir(), ".claude"),
-    enabled: true,
-    emoji: "\u{1F916}"
+    id: filePath,
+    filePath,
+    provider: CLAUDE_CODE_PROVIDER,
+    sessionId: state.sessionId || 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 readFile(join2(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 mkdir(resolved, { recursive: true });
-  await writeFile(join2(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
-import fg from "fast-glob";
-import { createReadStream } from "fs";
-import { stat } from "fs/promises";
-import { basename } from "path";
-import { createInterface } from "readline";
-
 // src/tags.ts
 var SYSTEM_TAGS = [
   "system-reminder",
@@ -405,186 +448,49 @@ 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;
-  }
-  // Codex rollout lines carry distinctive top-level types.
-  canParse(_filePath, sample) {
-    for (const line of sample.split("\n")) {
+// 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 = createReadStream(filePath);
+  const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
       if (!line.trim()) continue;
+      let entry;
       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;
+        entry = JSON.parse(line);
       } catch {
+        state.badJsonLines++;
+        continue;
       }
+      reduceLine(state, entry, tier);
     }
-    return false;
+  } catch (err) {
+    log.warn({ filePath, err }, "parseMeta: read failed");
+    return null;
   }
-  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;
-  }
-  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;
-  }
-  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;
-  }
-  if (acc.previewLength < tier.previewMax) {
-    acc.previewParts.push(text);
-    acc.previewLength += text.length;
-  }
-  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;
+  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;
 }
-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) {
+async function parseConversation(filePath, account) {
   const log = getLogger();
+  log.trace({ filePath, account }, "parseConversation: start");
   const messages = [];
+  let badJsonLines = 0;
   const textParts = [];
-  let sessionId = "";
-  let cwd = "";
-  let latestTimestamp = "";
-  let lastUserText = "";
-  const rl = createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
+  const turnDurations = [];
+  const state = initialConvState();
+  const fileStream = createReadStream(filePath);
+  const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
       if (!line.trim()) continue;
@@ -592,120 +498,146 @@ async function parseCodexConversation(filePath, account) {
       try {
         entry = JSON.parse(line);
       } catch {
+        badJsonLines++;
         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);
+      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 (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;
+      const message = reduceConvLine(state, entry);
+      if (message) {
+        messages.push(message);
+        if (message.text) textParts.push(message.text);
+      }
     }
   } catch (err) {
-    log.warn({ filePath, err }, "parseCodexConversation: read failed");
+    log.warn({ filePath, err }, "parseConversation: read failed");
     return null;
   }
-  if (messages.length === 0) 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: 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,
-    lastPrompt: lastUserText || void 0
+    turnDurations: turnDurations.length > 0 ? turnDurations : void 0,
+    lastPrompt: state.lastPrompt || void 0
   };
 }
-
-// src/discovery.ts
-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) {
-  const log = getLogger();
-  const results = [];
-  for (const { projectsDir, account } of dirs) {
-    let filePaths;
-    try {
-      filePaths = await fg2("**/*.jsonl", {
-        cwd: projectsDir,
-        absolute: true,
-        dot: false
-      });
-    } catch (err) {
-      log.warn({ projectsDir, account, err }, "discovery: glob failed");
-      continue;
-    }
-    const filtered = filePaths.filter((fp) => !EXCLUDED_SEGMENTS.some((seg) => fp.includes(seg)));
-    let kept = 0;
-    let skippedEmpty = 0;
-    let skippedInaccessible = 0;
-    for (let i = 0; i < filtered.length; i += STAT_CONCURRENCY) {
-      const chunk = filtered.slice(i, i + STAT_CONCURRENCY);
-      const statted = await Promise.all(
-        chunk.map(async (filePath) => {
-          try {
-            const s = await stat2(filePath);
-            return { filePath, size: s.size };
-          } catch (err) {
-            log.warn({ filePath, err }, "discovery: stat failed");
-            return { filePath, size: -1 };
-          }
-        })
-      );
-      for (const { filePath, size } of statted) {
-        if (size < 0) {
-          skippedInaccessible++;
-        } else if (size > 0) {
-          results.push({ filePath, account });
-          kept++;
-        } else {
-          skippedEmpty++;
-        }
-      }
-    }
-    log.debug(
-      {
-        projectsDir,
-        account,
-        globMatches: filePaths.length,
-        afterExclusions: filtered.length,
-        kept,
-        skippedEmpty,
-        skippedInaccessible
-      },
-      "discovery: directory scanned"
-    );
-    onProgress?.(results.length);
+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(" ");
   }
-  log.debug({ totalFiles: results.length, dirs: dirs.length }, "discovery: complete");
-  return results;
+  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/metadata-reducer.ts
-import { basename as basename3, dirname as dirname2, join as join3 } from "path";
-
-// src/parser.ts
-import { createReadStream as createReadStream2 } from "fs";
-import { basename as basename2 } from "path";
-import { createInterface as createInterface2 } from "readline";
 
 // src/persistent/conversation-reducer.ts
 function initialConvState() {
@@ -762,7 +694,10 @@ function reduceConvLine(state, entry) {
   if (isToolResultOnly) {
     const pending = new Map(Object.entries(state.pendingToolUses));
     const toolResultBlocks = extractToolResultBlocks(msg?.content, pending);
-    if (toolResultBlocks.length > 0) metadata.toolResults = toolResultBlocks;
+    if (toolResultBlocks.length > 0) {
+      metadata.toolResults = toolResultBlocks;
+      for (const block of toolResultBlocks) delete state.pendingToolUses[block.toolUseId];
+    }
   }
   if (entry.teamName) {
     metadata.teamName = entry.teamName;
@@ -793,6 +728,17 @@ function reduceConvLine(state, entry) {
     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) {
@@ -801,394 +747,662 @@ function applyTeamInfo(messages, state) {
   }
 }
 
-// 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 = createReadStream2(filePath);
-  const rl = createInterface2({ input: fileStream, crlfDelay: Infinity });
+// 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 {
-    for await (const line of rl) {
-      if (!line.trim()) continue;
-      let entry;
-      try {
-        entry = JSON.parse(line);
-      } catch {
-        state.badJsonLines++;
-        continue;
-      }
-      reduceLine(state, entry, tier);
-    }
+    writeFileSync(sidecarPath(jsonlPath), JSON.stringify(sidecar, null, 2));
   } catch (err) {
-    log.warn({ filePath, err }, "parseMeta: read failed");
-    return null;
+    getLogger().warn({ jsonlPath, err }, "sidecar: write failed");
   }
-  if (state.badJsonLines > 0) {
-    log.warn(
-      { filePath, badJsonLines: state.badJsonLines },
-      "parseMeta: skipped malformed JSON lines"
-    );
+}
+function readSidecar(jsonlPath) {
+  try {
+    return JSON.parse(readFileSync2(sidecarPath(jsonlPath), "utf-8"));
+  } catch {
+    return null;
   }
-  const meta = finalizeMeta(state, filePath, account, tier);
-  if (!meta) log.trace({ filePath }, "parseMeta: no messages");
-  return meta;
 }
-async function parseConversation(filePath, account) {
+
+// src/profiles.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join as join3 } from "path";
+var PROFILES_FILE = "profiles.json";
+function resolveConfigDir(configDir) {
+  return configDir.replace(/^~/, homedir());
+}
+function getProjectsDir(profile) {
+  return join3(resolveConfigDir(profile.configDir), "projects");
+}
+async function detectDefaultProfile() {
+  return {
+    id: "default",
+    label: "Default",
+    configDir: join3(homedir(), ".claude"),
+    enabled: true,
+    emoji: "\u{1F916}"
+  };
+}
+async function loadProfiles(configPath) {
   const log = getLogger();
-  log.trace({ filePath, account }, "parseConversation: start");
-  const messages = [];
-  let badJsonLines = 0;
-  const textParts = [];
-  const turnDurations = [];
-  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;
-      let entry;
+    const resolved = resolveConfigDir(configPath);
+    const data = await readFile(join3(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 mkdir(resolved, { recursive: true });
+  await writeFile(join3(resolved, PROFILES_FILE), JSON.stringify(profiles, null, 2));
+  getLogger().debug({ configPath, count: profiles.length }, "profiles: saved");
+}
+
+// src/providers/codex-cli.ts
+import fg from "fast-glob";
+import { createReadStream as createReadStream2 } from "fs";
+import { stat } from "fs/promises";
+import { basename as basename3 } from "path";
+import { createInterface as createInterface2 } from "readline";
+var CodexCliProvider = class {
+  name = CODEX_CLI_PROVIDER;
+  async discover(roots) {
+    const log = getLogger();
+    const results = [];
+    for (const root of roots) {
+      let paths;
       try {
-        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
+        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;
       }
-      const message = reduceConvLine(state, entry);
-      if (message) {
-        messages.push(message);
-        if (message.text) textParts.push(message.text);
+      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");
+        }
       }
     }
-  } catch (err) {
-    log.warn({ filePath, err }, "parseConversation: read failed");
-    return null;
+    return results;
   }
-  if (badJsonLines > 0) {
-    log.warn({ filePath, badJsonLines }, "parseConversation: skipped malformed JSON lines");
+  // 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;
   }
-  if (messages.length === 0) {
-    log.trace({ filePath }, "parseConversation: no messages");
-    return null;
+  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
+    };
   }
-  log.debug({ filePath, messageCount: messages.length }, "parseConversation: complete");
-  applyTeamInfo(messages, state);
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  if (acc.previewLength < tier.previewMax) {
+    acc.previewParts.push(text);
+    acc.previewLength += text.length;
+  }
+  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 || basename3(filePath, ".jsonl");
+  const projectPath = acc.cwd;
+  const kind = acc.lastAssistant === null && acc.toolNames.length > 0 ? "task" : "conversation";
   return {
     id: filePath,
     filePath,
-    projectPath: state.cwd,
-    projectName: getShortProjectName2(state.cwd),
-    sessionId: state.sessionId || basename2(filePath, ".jsonl"),
-    sessionName: state.sessionName,
-    messages,
-    fullText: textParts.join(" "),
-    timestamp: state.latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
-    messageCount: messages.length,
+    provider: CODEX_CLI_PROVIDER,
+    kind,
+    externalSessionId: acc.sessionId || void 0,
+    sessionId,
+    sessionName: "",
+    projectPath,
+    projectName: getShortProjectName3(projectPath),
     account,
-    turnDurations: turnDurations.length > 0 ? turnDurations : void 0,
-    lastPrompt: state.lastPrompt || void 0
+    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 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 getShortProjectName3(fullPath) {
+  return fullPath.split("/").filter(Boolean).slice(-3).join("/");
 }
-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 parseCodexConversation(filePath, account) {
+  const log = getLogger();
+  const messages = [];
+  const textParts = [];
+  let sessionId = "";
+  let cwd = "";
+  let latestTimestamp = "";
+  let lastUserText = "";
+  const rl = createInterface2({ input: createReadStream2(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;
   }
-}
-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");
+  if (messages.length === 0) return null;
   return {
-    content: blocks.map((b) => b.thinking).filter(Boolean).join("\n\n"),
-    signature: blocks.map((b) => b.signature).filter(Boolean).join("")
+    id: filePath,
+    filePath,
+    projectPath: cwd,
+    projectName: getShortProjectName3(cwd),
+    sessionId: sessionId || basename3(filePath, ".jsonl"),
+    sessionName: "",
+    messages,
+    fullText: textParts.join(" "),
+    timestamp: latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    messageCount: messages.length,
+    account,
+    lastPrompt: lastUserText || void 0
   };
 }
-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/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
-  };
+// src/discovery.ts
+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) {
+  const log = getLogger();
+  const results = [];
+  for (const { projectsDir, account } of dirs) {
+    let filePaths;
+    try {
+      filePaths = await fg2("**/*.jsonl", {
+        cwd: projectsDir,
+        absolute: true,
+        dot: false
+      });
+    } catch (err) {
+      log.warn({ projectsDir, account, err }, "discovery: glob failed");
+      continue;
+    }
+    const filtered = filePaths.filter((fp) => !EXCLUDED_SEGMENTS.some((seg) => fp.includes(seg)));
+    let kept = 0;
+    let skippedEmpty = 0;
+    let skippedInaccessible = 0;
+    for (let i = 0; i < filtered.length; i += STAT_CONCURRENCY) {
+      const chunk = filtered.slice(i, i + STAT_CONCURRENCY);
+      const statted = await Promise.all(
+        chunk.map(async (filePath) => {
+          try {
+            const s = await stat2(filePath);
+            return { filePath, size: s.size };
+          } catch (err) {
+            log.warn({ filePath, err }, "discovery: stat failed");
+            return { filePath, size: -1 };
+          }
+        })
+      );
+      for (const { filePath, size } of statted) {
+        if (size < 0) {
+          skippedInaccessible++;
+        } else if (size > 0) {
+          results.push({ filePath, account });
+          kept++;
+        } else {
+          skippedEmpty++;
+        }
+      }
+    }
+    log.debug(
+      {
+        projectsDir,
+        account,
+        globMatches: filePaths.length,
+        afterExclusions: filtered.length,
+        kept,
+        skippedEmpty,
+        skippedInaccessible
+      },
+      "discovery: directory scanned"
+    );
+    onProgress?.(results.length);
+  }
+  log.debug({ totalFiles: results.length, dirs: dirs.length }, "discovery: complete");
+  return results;
 }
-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;
+
+// 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);
   }
-  const type = entry.type;
-  if (type === "last-prompt") {
-    if (entry.lastPrompt && !state.lastPrompt) state.lastPrompt = entry.lastPrompt;
-    return;
+  // 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;
   }
-  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;
+  createEmptyAccumulator() {
+    return initialReducerState();
   }
-  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++;
+  reduceEntry(acc, entry, tier) {
+    reduceLine(acc, entry, tier);
   }
-  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;
+  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 statSync3 } 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/conversation-stream.ts
+import { basename as basename4 } from "path";
+
+// src/persistent/paged-reader.ts
+import { createReadStream as createReadStream4 } from "fs";
+import { setImmediate as yieldToEventLoop2 } from "timers/promises";
+
+// src/persistent/jsonl-tail-reader.ts
+import { createReadStream as createReadStream3 } from "fs";
+import { setImmediate as yieldToEventLoop } from "timers/promises";
+var YIELD_EVERY_LINES = 500;
+async function tailReduce(filePath, startOffset, startLine, state, tier) {
+  const stream = createReadStream3(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++;
       }
-      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;
+      offset += Buffer.byteLength(lineWithNewline, "utf8");
+      line++;
+      if (++sinceYield >= YIELD_EVERY_LINES) {
+        sinceYield = 0;
+        await yieldToEventLoop();
       }
     }
   }
+  return { newOffset: offset, newLine: line, parsedLines, badJsonLines: state.badJsonLines };
 }
-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`);
+
+// src/persistent/paged-reader.ts
+var CHECKPOINT_INTERVAL = 500;
+async function streamMessages(filePath, startOffset, startLine, state, onMessage, onEntry) {
+  const stream = createReadStream4(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 yieldToEventLoop2();
+      }
+      if (text.length === 0) continue;
+      let entry;
+      try {
+        entry = JSON.parse(text);
+      } catch {
+        continue;
+      }
+      if (onEntry?.(entry)) continue;
+      const message = reduceConvLine(state, entry);
+      if (message && onMessage(message, offset, line)) {
+        stream.destroy();
+        return { offset, line };
+      }
+    }
   }
-  const projectPath = state.cwd;
+  return { offset, line };
+}
+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;
+    }
+  );
+  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/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 assemble(filePath, account, messages, fullText, turnDurations, state) {
   return {
     id: filePath,
     filePath,
-    provider: CLAUDE_CODE_PROVIDER,
-    sessionId: state.sessionId || basename3(filePath, ".jsonl"),
+    projectPath: state.cwd,
+    projectName: getShortProjectName2(state.cwd),
+    sessionId: state.sessionId || basename4(filePath, ".jsonl"),
     sessionName: state.sessionName,
-    projectPath,
-    projectName: getShortProjectName3(projectPath),
-    account,
+    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
-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";
@@ -1244,14 +1458,17 @@ function classify(filePath, existing) {
   return { change: "reindex", stat: stat4 };
 }
 
+// src/persistent/index-engine.ts
+import { statSync as statSync2 } from "fs";
+
 // src/providers/parse.ts
-import { createReadStream as createReadStream3 } from "fs";
+import { createReadStream as createReadStream5 } 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),
+    input: createReadStream5(filePath),
     crlfDelay: Infinity
   });
   try {
@@ -1578,104 +1795,6 @@ function joinPath(dir, name) {
   return dir.endsWith("/") ? `${dir}${name}` : `${dir}/${name}`;
 }
 
-// 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) {
@@ -1696,6 +1815,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) {
@@ -1707,6 +1842,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;
   }
@@ -1724,7 +1870,7 @@ function toCheckpoint(row) {
 }
 
 // src/persistent/repositories/conversation-files.repo.ts
-import { basename as basename4, dirname as dirname4 } from "path";
+import { basename as basename5, dirname as dirname4 } from "path";
 var ConversationFilesRepo = class {
   constructor(db) {
     this.db = db;
@@ -1741,7 +1887,7 @@ var ConversationFilesRepo = class {
     const info = this.db.prepare(
       `INSERT INTO conversation_files (absolute_path, parent_dir, file_name, account)
          VALUES (?, ?, ?, ?)`
-    ).run(absolutePath, dirname4(absolutePath), basename4(absolutePath), account);
+    ).run(absolutePath, dirname4(absolutePath), basename5(absolutePath), account);
     return Number(info.lastInsertRowid);
   }
   // Advance the cursor + persisted reducer state after a successful index pass.
@@ -2100,6 +2246,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);
@@ -2152,7 +2301,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,
@@ -2187,7 +2336,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);
@@ -2195,13 +2346,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();
@@ -2212,12 +2371,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;
@@ -2225,7 +2384,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,
@@ -2258,7 +2417,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
@@ -2358,15 +2517,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 > statSync2(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
@@ -2472,6 +2656,8 @@ function defaultDbPath() {
 }
 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
@@ -2503,7 +2689,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;
@@ -2635,7 +2823,7 @@ var ConversationScanner = class {
             const cached = statCache.get(filePath);
             if (cached) {
               try {
-                const s = statSync2(filePath);
+                const s = statSync3(filePath);
                 if (s.mtimeMs === cached.stat.mtimeMs && s.size === cached.stat.size) {
                   return cached.meta;
                 }
@@ -2760,7 +2948,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) {
@@ -2769,9 +2957,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) {
@@ -2843,20 +3036,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,
@@ -2865,8 +3068,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);
@@ -2910,6 +3124,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();
@@ -3206,12 +3453,14 @@ export {
   applySinceFilter,
   applySort,
   cleanSystemTags,
+  initialConvState as createJsonlParseState,
   createLogger,
   detectDefaultProfile,
   getConversation,
   getLogger,
   getProjectsDir,
   loadProfiles,
+  parseJsonlLine,
   readGitBranch,
   readSidecar,
   resetDefaultScanner,