@threadbase-sh/scanner 0.9.4 → 0.10.1

package/dist/cli.js

@@ -5,7 +5,7 @@ import { Command } from "commander";
 import pino2 from "pino";
 
 // package.json
-var version = "0.9.4";
+var version = "0.10.1";
 
 // src/logger.ts
 import pino from "pino";
@@ -60,7 +60,7 @@ async function saveProfiles(profiles, configPath) {
 
 // src/scanner.ts
 import { EventEmitter } from "events";
-import { closeSync as closeSync2, openSync as openSync2, readSync as readSync2, statSync as statSync2 } from "fs";
+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";
 
@@ -499,7 +499,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;
@@ -883,6 +886,208 @@ function getShortProjectName2(fullPath) {
   return parts.slice(-3).join("/");
 }
 
+// src/persistent/conversation-stream.ts
+import { basename as basename3 } from "path";
+
+// src/persistent/paged-reader.ts
+import { createReadStream as createReadStream3 } from "fs";
+import { setImmediate as yieldToEventLoop2 } from "timers/promises";
+
+// src/persistent/jsonl-tail-reader.ts
+import { createReadStream as createReadStream2 } from "fs";
+import { setImmediate as yieldToEventLoop } from "timers/promises";
+var YIELD_EVERY_LINES = 500;
+async function tailReduce(filePath, startOffset, startLine, state, tier) {
+  const stream = createReadStream2(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 yieldToEventLoop();
+      }
+    }
+  }
+  return { newOffset: offset, newLine: line, parsedLines, badJsonLines: state.badJsonLines };
+}
+
+// src/persistent/paged-reader.ts
+var CHECKPOINT_INTERVAL = 500;
+async function streamMessages(filePath, startOffset, startLine, state, onMessage, onEntry) {
+  const stream = createReadStream3(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 };
+      }
+    }
+  }
+  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,
+    projectPath: state.cwd,
+    projectName: getShortProjectName2(state.cwd),
+    sessionId: state.sessionId || basename3(filePath, ".jsonl"),
+    sessionName: state.sessionName,
+    messages,
+    fullText,
+    timestamp: state.latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    messageCount: messages.length,
+    account,
+    turnDurations: turnDurations.length > 0 ? turnDurations : void 0,
+    lastPrompt: state.lastPrompt || void 0
+  };
+}
+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/persistent/cursor.ts
 import { createHash } from "crypto";
 import { closeSync, openSync, readSync, statSync } from "fs";
@@ -938,11 +1143,14 @@ function classify(filePath, existing) {
   return { change: "reindex", stat: stat4 };
 }
 
+// src/persistent/index-engine.ts
+import { statSync as statSync2 } from "fs";
+
 // src/providers/codex-cli.ts
 import fg2 from "fast-glob";
-import { createReadStream as createReadStream2 } from "fs";
+import { createReadStream as createReadStream4 } from "fs";
 import { stat as stat2 } from "fs/promises";
-import { basename as basename3 } from "path";
+import { basename as basename4 } from "path";
 import { createInterface as createInterface2 } from "readline";
 var CodexCliProvider = class {
   name = CODEX_CLI_PROVIDER;
@@ -1076,7 +1284,7 @@ function reduceCodexEntry(acc, entry, tier) {
 }
 function finalizeCodexMeta(acc, filePath, account, tier) {
   if (acc.messageCount === 0) return null;
-  const sessionId = acc.sessionId || basename3(filePath, ".jsonl");
+  const sessionId = acc.sessionId || basename4(filePath, ".jsonl");
   const projectPath = acc.cwd;
   const kind = acc.lastAssistant === null && acc.toolNames.length > 0 ? "task" : "conversation";
   return {
@@ -1118,7 +1326,7 @@ async function parseCodexConversation(filePath, account) {
   let cwd = "";
   let latestTimestamp = "";
   let lastUserText = "";
-  const rl = createInterface2({ input: createReadStream2(filePath), crlfDelay: Infinity });
+  const rl = createInterface2({ input: createReadStream4(filePath), crlfDelay: Infinity });
   try {
     for await (const line of rl) {
       if (!line.trim()) continue;
@@ -1156,7 +1364,7 @@ async function parseCodexConversation(filePath, account) {
     filePath,
     projectPath: cwd,
     projectName: getShortProjectName3(cwd),
-    sessionId: sessionId || basename3(filePath, ".jsonl"),
+    sessionId: sessionId || basename4(filePath, ".jsonl"),
     sessionName: "",
     messages,
     fullText: textParts.join(" "),
@@ -1168,13 +1376,13 @@ async function parseCodexConversation(filePath, account) {
 }
 
 // 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 {
@@ -1501,104 +1709,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) {
@@ -1619,6 +1729,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) {
@@ -1630,6 +1756,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;
   }
@@ -1647,7 +1784,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;
@@ -1664,7 +1801,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.
@@ -2056,6 +2193,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);
@@ -2108,7 +2248,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,
@@ -2143,7 +2283,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);
@@ -2151,13 +2293,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();
@@ -2168,12 +2318,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;
@@ -2181,7 +2331,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,
@@ -2214,7 +2364,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
@@ -2314,15 +2464,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/providers/threadbase.ts
@@ -2464,6 +2639,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
@@ -2495,7 +2672,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;
@@ -2627,7 +2806,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;
                 }
@@ -2752,7 +2931,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) {
@@ -2761,9 +2940,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) {
@@ -2835,20 +3019,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,
@@ -2857,8 +3051,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);
@@ -2902,6 +3107,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();