@threadbase-sh/streamer 1.24.3 → 1.24.5

package/dist/cli.cjs

@@ -101524,7 +101524,7 @@ var require_async2 = __commonJS({
         readdirWithFileTypes(directory, settings, callback);
         return;
       }
-      readdir6(directory, settings, callback);
+      readdir7(directory, settings, callback);
     }
     exports2.read = read;
     function readdirWithFileTypes(directory, settings, callback) {
@@ -101573,7 +101573,7 @@ var require_async2 = __commonJS({
         });
       };
     }
-    function readdir6(directory, settings, callback) {
+    function readdir7(directory, settings, callback) {
       settings.fs.readdir(directory, (readdirError, names) => {
         if (readdirError !== null) {
           callFailureCallback(callback, readdirError);
@@ -101608,7 +101608,7 @@ var require_async2 = __commonJS({
         });
       });
     }
-    exports2.readdir = readdir6;
+    exports2.readdir = readdir7;
     function callFailureCallback(callback, error51) {
       callback(error51);
     }
@@ -101632,7 +101632,7 @@ var require_sync2 = __commonJS({
       if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
         return readdirWithFileTypes(directory, settings);
       }
-      return readdir6(directory, settings);
+      return readdir7(directory, settings);
     }
     exports2.read = read;
     function readdirWithFileTypes(directory, settings) {
@@ -101657,7 +101657,7 @@ var require_sync2 = __commonJS({
       });
     }
     exports2.readdirWithFileTypes = readdirWithFileTypes;
-    function readdir6(directory, settings) {
+    function readdir7(directory, settings) {
       const names = settings.fs.readdirSync(directory);
       return names.map((name) => {
         const entryPath = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
@@ -101673,7 +101673,7 @@ var require_sync2 = __commonJS({
         return entry;
       });
     }
-    exports2.readdir = readdir6;
+    exports2.readdir = readdir7;
   }
 });
 
@@ -124915,14 +124915,14 @@ var prompt_exports = {};
 __export(prompt_exports, {
   interactivePrompt: () => interactivePrompt
 });
-var import_node_process2, import_promises17, interactivePrompt;
+var import_node_process2, import_promises18, interactivePrompt;
 var init_prompt = __esm({
   "src/lifecycle/prompt.ts"() {
     "use strict";
     import_node_process2 = require("process");
-    import_promises17 = require("readline/promises");
+    import_promises18 = require("readline/promises");
     interactivePrompt = async ({ prodPort, suggestedAltPort }) => {
-      const rl = (0, import_promises17.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
+      const rl = (0, import_promises18.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
       try {
         import_node_process2.stdout.write(
           `
@@ -129481,6 +129481,7 @@ var import_readline3 = require("readline");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
 var import_fs11 = require("fs");
 var import_path8 = require("path");
+var import_promises7 = require("fs/promises");
 var import_fs12 = require("fs");
 var import_fs13 = require("fs");
 var import_path9 = require("path");
@@ -132302,30 +132303,33 @@ function fingerprint(filePath, size) {
   return hash2.digest("hex");
 }
 function classify(filePath, existing) {
-  let stat32;
+  let stat42;
   try {
     const s3 = (0, import_fs9.statSync)(filePath);
-    stat32 = { size: s3.size, mtimeMs: s3.mtimeMs };
+    stat42 = { size: s3.size, mtimeMs: s3.mtimeMs };
   } catch {
     return { change: "vanished" };
   }
   if (!existing || existing.status !== "active" || existing.last_indexed_offset === 0) {
-    return { change: "reindex", stat: stat32 };
+    return { change: "reindex", stat: stat42 };
   }
-  if (stat32.size < existing.last_indexed_offset) {
-    return { change: "reindex", stat: stat32 };
+  if (stat42.size < existing.last_indexed_offset) {
+    return { change: "reindex", stat: stat42 };
   }
-  if (stat32.size === existing.size_bytes && stat32.mtimeMs === existing.mtime_ms) {
-    return { change: "unchanged", stat: stat32 };
+  if (stat42.size === existing.size_bytes && stat42.mtimeMs === existing.mtime_ms) {
+    return { change: "unchanged", stat: stat42 };
   }
-  if (stat32.size === existing.last_indexed_offset) {
-    const fp = fingerprint(filePath, stat32.size);
+  if (stat42.size === existing.last_indexed_offset) {
+    const fp = fingerprint(filePath, stat42.size);
     if (existing.content_fingerprint && fp !== existing.content_fingerprint) {
-      return { change: "reindex", stat: stat32 };
+      return { change: "reindex", stat: stat42 };
     }
-    return { change: "unchanged", stat: stat32 };
+    return { change: "unchanged", stat: stat42 };
+  }
+  if (existing.content_fingerprint && existing.size_bytes === existing.last_indexed_offset && fingerprint(filePath, existing.last_indexed_offset) === existing.content_fingerprint) {
+    return { change: "appended", stat: stat42 };
   }
-  return { change: "appended", stat: stat32 };
+  return { change: "reindex", stat: stat42 };
 }
 async function parseMetaWithProvider(provider, filePath, account, tier) {
   const log8 = getLogger2();
@@ -132368,7 +132372,7 @@ function resolveTier(tierName, customTiers) {
   }
   return tier;
 }
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 4;
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS conversation_files (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -132502,6 +132506,24 @@ CREATE TABLE IF NOT EXISTS message_checkpoints (
 
 CREATE INDEX IF NOT EXISTS idx_message_checkpoints_lookup
   ON message_checkpoints(source_path, message_index);
+
+-- Per-directory mtime watermark for the discovery dir-mtime gate (skips the
+-- glob for a directory whose file/subdir SET hasn't changed; never skips
+-- per-file classify()). One row for a profile's projectsDir itself (parent_root
+-- IS NULL) and one row per immediate project subdirectory discovered under it
+-- (parent_root = the projectsDir path). has_nested marks a project dir known to
+-- contain files below its own top level (e.g. subagents/) \u2014 those always
+-- re-glob regardless of mtime, since a project-dir-level watermark can't see a
+-- change two levels down.
+CREATE TABLE IF NOT EXISTS scanned_dirs (
+  path TEXT PRIMARY KEY,
+  parent_root TEXT,
+  mtime_ms INTEGER NOT NULL,
+  has_nested INTEGER NOT NULL DEFAULT 0,
+  updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_scanned_dirs_parent_root ON scanned_dirs(parent_root);
 `;
 function runMigrations(db) {
   const current = db.pragma("user_version", { simple: true });
@@ -132547,6 +132569,82 @@ function openDatabase(dbPath) {
   getLogger2().debug({ dbPath }, "db: opened");
   return db;
 }
+var FULL_RECONCILE_EVERY_N_SCANS = 20;
+async function discoverJsonlFilesGated(dirs, files, scannedDirs, options = {}) {
+  const log8 = getLogger2();
+  if (options.fullRescan) {
+    return discoverJsonlFiles(dirs);
+  }
+  const results = [];
+  for (const rawDir of dirs) {
+    const { account } = rawDir;
+    const projectsDir = rawDir.projectsDir.replace(/\\/g, "/");
+    const resolved = await resolveProjectDirs(projectsDir, scannedDirs);
+    if (resolved === null) continue;
+    for (const projectDir of resolved.entries) {
+      let dirStat;
+      try {
+        dirStat = await (0, import_promises7.stat)(projectDir);
+      } catch {
+        scannedDirs.remove(projectDir);
+        continue;
+      }
+      const watermark = scannedDirs.get(projectDir);
+      const canReuse = watermark !== void 0 && watermark.mtime_ms === dirStat.mtimeMs && watermark.has_nested === 0;
+      if (canReuse) {
+        const known = files.activePathsByParentDir(projectDir);
+        if (known.length > 0) {
+          for (const row of known) {
+            results.push({ filePath: row.absolute_path, account: row.account });
+          }
+          continue;
+        }
+      }
+      const found = await discoverJsonlFiles([{ projectsDir: projectDir, account }]);
+      const hasNested = found.some((f2) => dirnameOf(f2.filePath) !== projectDir);
+      scannedDirs.upsert(projectDir, projectsDir, dirStat.mtimeMs, hasNested);
+      results.push(...found);
+    }
+    if (resolved.commitRoot) {
+      scannedDirs.upsert(projectsDir, null, resolved.commitRoot.mtimeMs, false);
+      const seen = new Set(resolved.entries);
+      for (const known of scannedDirs.childrenOf(projectsDir)) {
+        if (!seen.has(known.path)) scannedDirs.remove(known.path);
+      }
+    }
+  }
+  log8.debug(
+    { totalFiles: results.length, dirs: dirs.length },
+    "dir-watermark: gated discovery complete"
+  );
+  return results;
+}
+async function resolveProjectDirs(projectsDir, scannedDirs) {
+  let rootStat;
+  try {
+    rootStat = await (0, import_promises7.stat)(projectsDir);
+  } catch {
+    return null;
+  }
+  const rootWatermark = scannedDirs.get(projectsDir);
+  if (rootWatermark !== void 0 && rootWatermark.mtime_ms === rootStat.mtimeMs) {
+    return { entries: scannedDirs.childrenOf(projectsDir).map((row) => row.path) };
+  }
+  let entries;
+  try {
+    entries = (await (0, import_promises7.readdir)(projectsDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => joinPath(projectsDir, e.name));
+  } catch {
+    return null;
+  }
+  return { entries, commitRoot: { mtimeMs: rootStat.mtimeMs } };
+}
+function dirnameOf(filePath) {
+  const idx = filePath.lastIndexOf("/");
+  return idx === -1 ? filePath : filePath.slice(0, idx);
+}
+function joinPath(dir, name) {
+  return dir.endsWith("/") ? `${dir}${name}` : `${dir}/${name}`;
+}
 async function tailReduce(filePath, startOffset, startLine, state, tier) {
   const stream = (0, import_fs12.createReadStream)(filePath, { start: startOffset, encoding: "utf8" });
   let buffer = "";
@@ -132743,6 +132841,27 @@ var ConversationFilesRepo = class {
     const rows = this.db.prepare("SELECT absolute_path FROM conversation_files WHERE status != 'deleted'").all();
     return rows.map((r) => r.absolute_path);
   }
+  // Active file paths belonging to any of the given accounts. Backs the
+  // deletion-reconcile so a scan that covered only some accounts can't mark
+  // another account's files deleted (they live in the same shared index.db but
+  // a different profile owns them). Returns [] for an empty account list.
+  activePathsByAccounts(accounts) {
+    if (accounts.length === 0) return [];
+    const placeholders = accounts.map(() => "?").join(", ");
+    const rows = this.db.prepare(
+      `SELECT absolute_path FROM conversation_files
+         WHERE status != 'deleted' AND account IN (${placeholders})`
+    ).all(...accounts);
+    return rows.map((r) => r.absolute_path);
+  }
+  // Active files whose immediate parent is exactly parentDir (no nested
+  // subdirectories). Backs the dir-mtime gate's reuse path: a project dir with
+  // an unchanged mtime and no nested files can skip the glob entirely.
+  activePathsByParentDir(parentDir) {
+    return this.db.prepare(
+      "SELECT absolute_path, account FROM conversation_files WHERE parent_dir = ? AND status != 'deleted'"
+    ).all(parentDir);
+  }
 };
 function rowToMeta(row) {
   return {
@@ -132986,6 +133105,34 @@ function toMatchQuery(query) {
   if (terms.length === 0) return "";
   return terms.map((t2) => `"${t2}"*`).join(" AND ");
 }
+var ScannedDirsRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  get(path2) {
+    return this.db.prepare("SELECT * FROM scanned_dirs WHERE path = ?").get(path2);
+  }
+  // Known project subdirectories under a root, path ascending (stable order).
+  childrenOf(parentRoot) {
+    return this.db.prepare("SELECT * FROM scanned_dirs WHERE parent_root = ? ORDER BY path ASC").all(parentRoot);
+  }
+  upsert(path2, parentRoot, mtimeMs, hasNested) {
+    this.db.prepare(
+      `INSERT INTO scanned_dirs (path, parent_root, mtime_ms, has_nested, updated_at)
+         VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+         ON CONFLICT(path) DO UPDATE SET
+           parent_root = excluded.parent_root,
+           mtime_ms = excluded.mtime_ms,
+           has_nested = excluded.has_nested,
+           updated_at = CURRENT_TIMESTAMP`
+    ).run(path2, parentRoot, mtimeMs, hasNested ? 1 : 0);
+  }
+  // Drop a project subdirectory's watermark row (it vanished from disk).
+  remove(path2) {
+    this.db.prepare("DELETE FROM scanned_dirs WHERE path = ?").run(path2);
+  }
+};
 var BATCH_SIZE = 12;
 var PersistentEngine = class {
   db;
@@ -132993,15 +133140,22 @@ var PersistentEngine = class {
   conversations;
   fts;
   checkpoints;
+  scannedDirs;
   // When true, write a portable <file>.idx.json sidecar next to each indexed
   // JSONL. Off by default.
   sidecar;
+  // Counts indexAll() passes so the dir-mtime gate's full-reconcile backstop
+  // (FULL_RECONCILE_EVERY_N_SCANS) can fire periodically. In-memory only: a
+  // 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;
   constructor(dbPath, options = {}) {
     this.db = openDatabase(dbPath);
     this.files = new ConversationFilesRepo(this.db);
     this.conversations = new ConversationsRepo(this.db);
     this.fts = new FtsRepo(this.db);
     this.checkpoints = new CheckpointsRepo(this.db);
+    this.scannedDirs = new ScannedDirsRepo(this.db);
     this.sidecar = options.sidecar ?? false;
   }
   close() {
@@ -133020,7 +133174,12 @@ var PersistentEngine = class {
         projectsDir: getProjectsDir(p2),
         account: p2.id
       }));
-      for (const f2 of await discoverJsonlFiles(configDirs)) discovered.push(f2);
+      this.scanCount++;
+      const forceFullGlob = options.fullRescan === true || this.scanCount % FULL_RECONCILE_EVERY_N_SCANS === 0;
+      const gated = await discoverJsonlFilesGated(configDirs, this.files, this.scannedDirs, {
+        fullRescan: forceFullGlob
+      });
+      for (const f2 of gated) discovered.push(f2);
     }
     const codex = new CodexCliProvider();
     if (enabled.includes(CODEX_CLI_PROVIDER) && (options.codexRoots?.length ?? 0) > 0) {
@@ -133059,8 +133218,15 @@ var PersistentEngine = class {
       scanned += batch.length;
       options.onProgress?.(scanned, discovered.length);
     }
+    const coveredAccounts = /* @__PURE__ */ new Set();
+    if (enabled.includes(CLAUDE_CODE_PROVIDER)) {
+      for (const p2 of activeProfiles) coveredAccounts.add(p2.id);
+    }
+    if (enabled.includes(CODEX_CLI_PROVIDER) && (options.codexRoots?.length ?? 0) > 0) {
+      coveredAccounts.add("codex");
+    }
     const seen = new Set(discovered.map((d) => d.filePath));
-    for (const path2 of this.files.allActivePaths()) {
+    for (const path2 of this.files.activePathsByAccounts([...coveredAccounts])) {
       if (!seen.has(path2)) this.markDeleted(path2);
     }
     log8.info({ scanned, indexed: this.conversations.count() }, "persistent: indexAll complete");
@@ -133075,8 +133241,8 @@ var PersistentEngine = class {
     const log8 = getLogger2();
     const tier = resolveTier(tierName, customTiers);
     const existing = this.files.getByPath(filePath);
-    const { change, stat: stat32 } = classify(filePath, existing);
-    if (change === "vanished" || !stat32) {
+    const { change, stat: stat42 } = classify(filePath, existing);
+    if (change === "vanished" || !stat42) {
       this.markDeleted(filePath);
       return null;
     }
@@ -133084,7 +133250,7 @@ var PersistentEngine = class {
       return this.conversations.getBySourcePath(filePath);
     }
     if (provider && provider.name !== CLAUDE_CODE_PROVIDER) {
-      return this.indexFileWithProvider(provider, filePath, account, tier, stat32, resolveGitBranch);
+      return this.indexFileWithProvider(provider, filePath, account, tier, stat42, resolveGitBranch);
     }
     const resume = change === "appended" && !force && existing?.reducer_state;
     const state = resume ? JSON.parse(existing.reducer_state) : initialReducerState();
@@ -133103,15 +133269,15 @@ var PersistentEngine = class {
       return null;
     }
     meta3.gitBranch = resolveGitBranch(meta3.projectPath);
-    const fp = stat32.size > 0 ? fingerprint(filePath, stat32.size) : null;
+    const fp = stat42.size > 0 ? fingerprint(filePath, stat42.size) : null;
     const fileId = this.files.ensure(filePath, account);
     const upsert = this.db.transaction(() => {
       this.conversations.upsert(fileId, meta3, state.pageMessageCount);
       this.fts.upsert(meta3);
       this.checkpoints.remove(filePath);
       this.files.updateCursor(fileId, {
-        sizeBytes: stat32.size,
-        mtimeMs: stat32.mtimeMs,
+        sizeBytes: stat42.size,
+        mtimeMs: stat42.mtimeMs,
         // Advance only to the last fully-parsed line; a trailing partial line
         // is left for the next pass.
         offset: result.newOffset,
@@ -133128,8 +133294,8 @@ var PersistentEngine = class {
         buildSidecar(
           meta3,
           {
-            sizeBytes: stat32.size,
-            mtimeMs: stat32.mtimeMs,
+            sizeBytes: stat42.size,
+            mtimeMs: stat42.mtimeMs,
             offset: result.newOffset,
             line: result.newLine
           },
@@ -133148,7 +133314,7 @@ var PersistentEngine = class {
   // the Threadbase path uses. The cursor records size/mtime (and offset = size)
   // so the next pass classifies an unchanged file as "unchanged" and skips it;
   // any change reparses from 0 again. No reducer_state is persisted.
-  async indexFileWithProvider(provider, filePath, account, tier, stat32, resolveGitBranch) {
+  async indexFileWithProvider(provider, filePath, account, tier, stat42, resolveGitBranch) {
     const log8 = getLogger2();
     const meta3 = await parseMetaWithProvider(provider, filePath, account, tier);
     if (!meta3) {
@@ -133158,18 +133324,18 @@ var PersistentEngine = class {
     if (meta3.gitBranch === null && meta3.projectPath) {
       meta3.gitBranch = resolveGitBranch(meta3.projectPath);
     }
-    const fp = stat32.size > 0 ? fingerprint(filePath, stat32.size) : null;
+    const fp = stat42.size > 0 ? fingerprint(filePath, stat42.size) : null;
     const fileId = this.files.ensure(filePath, account);
     const upsert = this.db.transaction(() => {
       this.conversations.upsert(fileId, meta3, meta3.messageCount);
       this.fts.upsert(meta3);
       this.checkpoints.remove(filePath);
       this.files.updateCursor(fileId, {
-        sizeBytes: stat32.size,
-        mtimeMs: stat32.mtimeMs,
+        sizeBytes: stat42.size,
+        mtimeMs: stat42.mtimeMs,
         // offset = size marks the file fully consumed (non-zero so the next pass
         // can classify it "unchanged"); no resumable reducer state is kept.
-        offset: stat32.size,
+        offset: stat42.size,
         line: 0,
         reducerState: null,
         fingerprint: fp,
@@ -133363,10 +133529,21 @@ var ConversationScanner = class {
   dbPath;
   sidecarEnabled;
   engineInstance = null;
+  // The most recent scan()'s promise while it is still running, or null when
+  // idle. close() awaits it before closing the SQLite handle so a fire-and-
+  // forget scan can't have its DB shut mid-indexAll ("database connection is
+  // not open"). Tracks the latest scan only — concurrent scans on one instance
+  // aren't a supported pattern (a single writer DB), and the latest resolving
+  // implies earlier ones already settled in practice.
+  inFlightScan = null;
   emitter = new import_events2.EventEmitter();
   watcher = null;
   queue = null;
   periodicTimer = null;
+  // The in-flight periodicReconcile() job, if one is mid-run. unwatch() awaits
+  // it before dropping the queue/engine so its post-await engine.files access
+  // can't hit a closed DB (the watch-mode half of Bug #4).
+  inFlightReconcile = null;
   constructor(options) {
     this.conversationLRU = new LRUCache(options?.conversationCacheSize ?? 5);
     if (options?.persistent === false) {
@@ -133389,14 +133566,31 @@ var ConversationScanner = class {
     return this.engineInstance;
   }
   // Release the SQLite connection. No-op in legacy mode. Safe to call
-  // repeatedly. Stops the watcher first if one is running; call unwatch()
-  // explicitly beforehand if you need to await watcher teardown.
-  close() {
-    if (this.watcher || this.queue || this.periodicTimer) void this.unwatch();
+  // repeatedly. Awaits watcher teardown AND any in-flight scan before closing
+  // the DB handle, so a fire-and-forget scan() can never have its connection
+  // shut mid-indexAll() ("database connection is not open"). This is why close()
+  // is async — callers should await it during shutdown. (Scanner review Bug #4.)
+  async close() {
+    if (this.watcher || this.queue || this.periodicTimer) await this.unwatch();
+    if (this.inFlightScan) {
+      try {
+        await this.inFlightScan;
+      } catch {
+      }
+    }
     this.engineInstance?.close();
     this.engineInstance = null;
   }
   async scan(options = {}) {
+    const promise2 = this.runScan(options);
+    this.inFlightScan = promise2;
+    try {
+      return await promise2;
+    } finally {
+      if (this.inFlightScan === promise2) this.inFlightScan = null;
+    }
+  }
+  async runScan(options) {
     const profiles = await this.resolveProfiles(options.profiles);
     const activeProfiles = profiles.filter((p2) => p2.enabled && p2.scanHistory !== false);
     this.lastTier = resolveTier(options.tier ?? "standard", options.tiers);
@@ -133710,7 +133904,7 @@ var ConversationScanner = class {
         this.lastTier.name,
         void 0,
         readGitBranch,
-        true,
+        false,
         provider
       );
       evict2(meta22);
@@ -133832,7 +134026,10 @@ var ConversationScanner = class {
     const periodicMs = options.periodicMs ?? 6e4;
     if (periodicMs > 0) {
       this.periodicTimer = setInterval(() => {
-        void this.periodicReconcile(activeProfiles);
+        const job = this.periodicReconcile(activeProfiles).finally(() => {
+          if (this.inFlightReconcile === job) this.inFlightReconcile = null;
+        });
+        this.inFlightReconcile = job;
       }, periodicMs);
       this.periodicTimer.unref?.();
     }
@@ -133876,6 +134073,9 @@ var ConversationScanner = class {
       clearInterval(this.periodicTimer);
       this.periodicTimer = null;
     }
+    if (this.inFlightReconcile) {
+      await this.inFlightReconcile;
+    }
     if (this.watcher) {
       await this.watcher.stop();
       this.watcher = null;
@@ -134018,7 +134218,7 @@ async function search(query, options, scanner) {
 // src/server.ts
 var import_events3 = require("events");
 var import_fs24 = require("fs");
-var import_promises14 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 var import_http = require("http");
 var import_os10 = require("os");
 var import_path21 = require("path");
@@ -134110,7 +134310,7 @@ function readAgentConfig(env = process.env) {
 }
 
 // src/agent/conversation-writer.ts
-var import_promises7 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 var import_node_path6 = require("path");
 function createConversationWriter(opts) {
   const { baseDir } = opts;
@@ -134120,7 +134320,7 @@ function createConversationWriter(opts) {
         throw new Error("ConversationWriter: refusing to write empty assistant turn");
       }
       const file2 = (0, import_node_path6.join)(baseDir, `${args.sessionId}.jsonl`);
-      await (0, import_promises7.mkdir)((0, import_node_path6.dirname)(file2), { recursive: true });
+      await (0, import_promises8.mkdir)((0, import_node_path6.dirname)(file2), { recursive: true });
       const record2 = {
         role: "assistant",
         turnId: args.turnId,
@@ -134130,7 +134330,7 @@ function createConversationWriter(opts) {
       };
       const line = `${JSON.stringify(record2)}
 `;
-      await (0, import_promises7.appendFile)(file2, line, { encoding: "utf8" });
+      await (0, import_promises8.appendFile)(file2, line, { encoding: "utf8" });
     }
   };
 }
@@ -137048,7 +137248,7 @@ var createHonoApp = (deps, upgradeWebSocket) => {
 init_auth();
 
 // src/browse.ts
-var import_promises8 = require("fs/promises");
+var import_promises9 = require("fs/promises");
 var import_path10 = require("path");
 var BrowsePathNotFoundError = class extends Error {
   constructor(message) {
@@ -137070,7 +137270,7 @@ async function resolveBrowsePath(browseRoot, relativePath) {
     throw new Error("Path outside browse root");
   }
   try {
-    await (0, import_promises8.realpath)(target);
+    await (0, import_promises9.realpath)(target);
   } catch (err) {
     if (err?.code === "ENOENT") {
       throw new BrowsePathNotFoundError(`Path not found: ${target}`);
@@ -137080,7 +137280,7 @@ async function resolveBrowsePath(browseRoot, relativePath) {
   return target;
 }
 async function listDirectories(absolutePath) {
-  const entries = await (0, import_promises8.readdir)(absolutePath, { withFileTypes: true });
+  const entries = await (0, import_promises9.readdir)(absolutePath, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name })).sort((a, b2) => a.name.localeCompare(b2.name));
 }
 async function createDirectory(parentAbsolutePath, name) {
@@ -137089,12 +137289,12 @@ async function createDirectory(parentAbsolutePath, name) {
   }
   const target = (0, import_path10.join)(parentAbsolutePath, name);
   try {
-    const s3 = await (0, import_promises8.stat)(target);
+    const s3 = await (0, import_promises9.stat)(target);
     if (s3.isDirectory()) throw new Error("Directory already exists");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
-  await (0, import_promises8.mkdir)(target);
+  await (0, import_promises9.mkdir)(target);
   return target;
 }
 
@@ -137904,6 +138104,61 @@ var ConversationCache = class _ConversationCache {
     }
     return ghosts;
   }
+  /**
+   * Reconcile the cache against the authoritative set of conversation file
+   * paths a fresh scan surfaced: drop any cached row whose `file_path` is not
+   * in `livePaths` (removed from disk, or now filtered out — e.g. became an
+   * agent JSONL). This is the "removed conversations" half of a ?refresh=1
+   * reconcile; the additions/updates half is upsertFromScannerMeta.
+   *
+   * Skip semantics depend on whether the file still exists on disk:
+   *  - File GONE from disk → always removed, tail or not. This matches the old
+   *    invalidate()+rebuild behavior (a deleted conversation must disappear on
+   *    refresh) and keeps refresh=1 truthful about removals. NOTE: this is an
+   *    INTENTIONAL divergence from pruneGhostFiles(), which KEEPS tailed ghosts
+   *    so their cached history stays viewable on a background prune. refresh=1
+   *    has the opposite contract (mobile relies on removals being reflected), so
+   *    do not "unify" the two — they serve different purposes.
+   *  - File STILL on disk but absent from `livePaths` → the CRITICAL #2 race:
+   *    the scan snapshot predates a just-created (and now live-tailed) file.
+   *    A tailed row here is actively maintained from real content, so it is
+   *    kept — dropping it would flicker the active conversation out of
+   *    /api/conversations. An untailed on-disk row not in the snapshot is a
+   *    transient scan/discovery gap; it is left alone (not removed) and the
+   *    next reconcile picks it up, rather than risk removing a real file the
+   *    scan simply hasn't surfaced yet.
+   * Returns the removed IDs.
+   */
+  reconcileDeletions(livePaths, opts) {
+    const exists = opts?.exists ?? import_fs16.existsSync;
+    const rows = this.stmts.allFilePaths.all();
+    const removed = [];
+    const drop = this.db.transaction((ids) => {
+      for (const id of ids) {
+        this.stmts.deleteTailById.run(id);
+        this.stmts.deleteById.run(id);
+      }
+    });
+    for (const row of rows) {
+      if (livePaths.has(row.file_path)) continue;
+      if (exists(row.file_path)) continue;
+      removed.push(row.id);
+    }
+    if (removed.length > 0) {
+      drop(removed);
+      if (this.fileIndexLoaded) {
+        for (const id of removed) {
+          for (const [fp, cid] of this.fileIndex) {
+            if (cid === id) {
+              this.fileIndex.delete(fp);
+              break;
+            }
+          }
+        }
+      }
+    }
+    return removed;
+  }
 };
 
 // src/db/config.ts
@@ -139932,11 +140187,11 @@ function seal(plaintext, recipientPublicKeyBase64) {
 // node_modules/chokidar/index.js
 var import_node_events2 = require("events");
 var import_node_fs7 = require("fs");
-var import_promises11 = require("fs/promises");
+var import_promises12 = require("fs/promises");
 var sp2 = __toESM(require("path"), 1);
 
 // node_modules/readdirp/index.js
-var import_promises9 = require("fs/promises");
+var import_promises10 = require("fs/promises");
 var import_node_path9 = require("path");
 var import_node_stream2 = require("stream");
 var EntryTypes2 = {
@@ -140017,7 +140272,7 @@ var ReaddirpStream2 = class extends import_node_stream2.Readable {
     const { root, type } = opts;
     this._fileFilter = normalizeFilter2(opts.fileFilter);
     this._directoryFilter = normalizeFilter2(opts.directoryFilter);
-    const statMethod = opts.lstat ? import_promises9.lstat : import_promises9.stat;
+    const statMethod = opts.lstat ? import_promises10.lstat : import_promises10.stat;
     if (wantBigintFsStats2) {
       this._stat = (path2) => statMethod(path2, { bigint: true });
     } else {
@@ -140088,7 +140343,7 @@ var ReaddirpStream2 = class extends import_node_stream2.Readable {
   async _exploreDir(path2, depth) {
     let files;
     try {
-      files = await (0, import_promises9.readdir)(path2, this._rdOptions);
+      files = await (0, import_promises10.readdir)(path2, this._rdOptions);
     } catch (error51) {
       this._onError(error51);
     }
@@ -140126,8 +140381,8 @@ var ReaddirpStream2 = class extends import_node_stream2.Readable {
     if (stats && stats.isSymbolicLink()) {
       const full = entry.fullPath;
       try {
-        const entryRealPath = await (0, import_promises9.realpath)(full);
-        const entryRealPathStats = await (0, import_promises9.lstat)(entryRealPath);
+        const entryRealPath = await (0, import_promises10.realpath)(full);
+        const entryRealPathStats = await (0, import_promises10.lstat)(entryRealPath);
         if (entryRealPathStats.isFile()) {
           return "file";
         }
@@ -140170,7 +140425,7 @@ function readdirp2(root, options = {}) {
 
 // node_modules/chokidar/handler.js
 var import_node_fs6 = require("fs");
-var import_promises10 = require("fs/promises");
+var import_promises11 = require("fs/promises");
 var import_node_os3 = require("os");
 var sp = __toESM(require("path"), 1);
 var STR_DATA2 = "data";
@@ -140197,7 +140452,7 @@ var EVENTS2 = {
 };
 var EV2 = EVENTS2;
 var THROTTLE_MODE_WATCH2 = "watch";
-var statMethods2 = { lstat: import_promises10.lstat, stat: import_promises10.stat };
+var statMethods2 = { lstat: import_promises11.lstat, stat: import_promises11.stat };
 var KEY_LISTENERS2 = "listeners";
 var KEY_ERR2 = "errHandlers";
 var KEY_RAW2 = "rawEmitters";
@@ -140554,7 +140809,7 @@ var setFsWatchListener2 = (path2, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows3 && error51.code === "EPERM") {
         try {
-          const fd = await (0, import_promises10.open)(path2, "r");
+          const fd = await (0, import_promises11.open)(path2, "r");
           await fd.close();
           broadcastErr(error51);
         } catch (err) {
@@ -140685,7 +140940,7 @@ var NodeFsHandler2 = class {
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats2 = await (0, import_promises10.stat)(file2);
+          const newStats2 = await (0, import_promises11.stat)(file2);
           if (this.fsw.closed)
             return;
           const at2 = newStats2.atimeMs;
@@ -140740,7 +140995,7 @@ var NodeFsHandler2 = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises10.realpath)(path2);
+        linkPath = await (0, import_promises11.realpath)(path2);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -140889,7 +141144,7 @@ var NodeFsHandler2 = class {
       let closer;
       if (stats.isDirectory()) {
         const absPath = sp.resolve(path2);
-        const targetPath = follow ? await (0, import_promises10.realpath)(path2) : path2;
+        const targetPath = follow ? await (0, import_promises11.realpath)(path2) : path2;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -140899,7 +141154,7 @@ var NodeFsHandler2 = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises10.realpath)(path2) : path2;
+        const targetPath = follow ? await (0, import_promises11.realpath)(path2) : path2;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
@@ -141059,7 +141314,7 @@ var DirEntry2 = class {
       return;
     const dir = this.path;
     try {
-      await (0, import_promises11.readdir)(dir);
+      await (0, import_promises12.readdir)(dir);
     } catch (err) {
       if (this._removeWatcher) {
         this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
@@ -141409,7 +141664,7 @@ var FSWatcher2 = class extends import_node_events2.EventEmitter {
       const fullPath = opts.cwd ? sp2.join(opts.cwd, path2) : path2;
       let stats2;
       try {
-        stats2 = await (0, import_promises11.stat)(fullPath);
+        stats2 = await (0, import_promises12.stat)(fullPath);
       } catch (err) {
       }
       if (!stats2 || this.closed)
@@ -141663,7 +141918,7 @@ var chokidar_default = { watch: watch2, FSWatcher: FSWatcher2 };
 
 // src/services/conversations/conversationWatcher.ts
 var import_fs22 = require("fs");
-var import_promises12 = require("fs/promises");
+var import_promises13 = require("fs/promises");
 var ConversationWatcher = class {
   files = /* @__PURE__ */ new Map();
   directories = /* @__PURE__ */ new Map();
@@ -141710,6 +141965,19 @@ var ConversationWatcher = class {
     void entry.watcher.close();
     this.files.delete(filePath);
   }
+  /**
+   * Re-drive the tail read for a file that's already being tailed. A per-file
+   * chokidar handle can die silently (fs.watch stops firing after inode churn)
+   * while the coarser directory watcher keeps reporting changes — calling this
+   * from the directory-event path makes the tail self-healing. Reads are
+   * offset-based and coalesced, so a redundant poke after a normal change
+   * event is a cheap stat + no-op. Returns false for untailed paths.
+   */
+  poke(filePath) {
+    if (!this.files.has(filePath)) return false;
+    void this.readNewLines(filePath);
+    return true;
+  }
   /**
    * Watch a directory of conversation JSONL files. Fires
    * onConversationChanged for any add/change/unlink event so the caller
@@ -141754,12 +142022,12 @@ var ConversationWatcher = class {
     entry.reading = true;
     try {
       for (; ; ) {
-        const st2 = await (0, import_promises12.stat)(filePath);
+        const st2 = await (0, import_promises13.stat)(filePath);
         if (st2.size <= entry.offset) break;
         const readFrom = entry.offset;
         const bytesToRead = st2.size - readFrom;
         const buf = Buffer.alloc(bytesToRead);
-        const fh = await (0, import_promises12.open)(filePath, "r");
+        const fh = await (0, import_promises13.open)(filePath, "r");
         try {
           await fh.read(buf, 0, bytesToRead, readFrom);
         } finally {
@@ -142159,7 +142427,7 @@ function discoveredToResponse(d, conversationId) {
 
 // src/uploads.ts
 var import_crypto8 = require("crypto");
-var import_promises13 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 var import_heic_convert = __toESM(require_heic_convert(), 1);
 var import_path20 = require("path");
 var UPLOAD_DIR_NAME = ".threadbase-uploads";
@@ -142195,9 +142463,9 @@ async function saveUploadFile(input) {
   const id = `up_${(0, import_crypto8.randomBytes)(8).toString("hex")}`;
   const safeName = sanitizeFilename(originalName) || `file${MIME_TO_EXT[mimeType] ?? ""}`;
   const dir = (0, import_path20.join)(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
-  await (0, import_promises13.mkdir)(dir, { recursive: true });
+  await (0, import_promises14.mkdir)(dir, { recursive: true });
   const filePath = (0, import_path20.join)(dir, `${Date.now()}-${id}-${safeName}`);
-  await (0, import_promises13.writeFile)(filePath, buffer);
+  await (0, import_promises14.writeFile)(filePath, buffer);
   return {
     id,
     filePath,
@@ -142653,6 +142921,14 @@ var StreamerServer = class {
   // window so the self-healing kickstart-relaunch race doesn't spam warn.
   binding = false;
   cacheReady = false;
+  // Every fire-and-forget task that runs a scan and then writes to this.cache
+  // in an async continuation (startup warm-up, background count refresh, …).
+  // close() awaits all of them before closing this.cache, so a scan's post-scan
+  // cache writes (upsertFromScannerMeta / populateTailFromFile / pruneGhostFiles
+  // / reconcileDeletions) can never hit a cache.db that was already closed
+  // ("database connection is not open"), which would otherwise leave the cache
+  // empty. Register via trackCacheWrite(); each entry removes itself on settle.
+  inFlightCacheWrites = /* @__PURE__ */ new Set();
   apiKey;
   apiKeySource;
   localNoAuth;
@@ -142728,7 +143004,7 @@ var StreamerServer = class {
     this.agentEntrypoints = parseAgentEntrypointsEnv(process.env.THREADBASE_AGENT_ENTRYPOINTS);
     const rawRoot = process.env.THREADBASE_BROWSE_ROOT ?? loadBrowseRoot() ?? config2.browseRoot;
     if (rawRoot) {
-      (0, import_promises14.realpath)(rawRoot).then((resolved) => {
+      (0, import_promises15.realpath)(rawRoot).then((resolved) => {
         this.browseRoot = resolved;
         if (this.verbose) this.log.info(`Browse root: ${resolved}`, { browseRoot: resolved });
       }).catch(() => {
@@ -142784,6 +143060,7 @@ var StreamerServer = class {
         }
       },
       onConversationChanged: (filePath) => {
+        this.fileWatcher.poke(filePath);
         this.cache?.invalidateByFilePath(filePath, { skipIfTailed: true });
         this.markScannerStaleDebounced();
         this.log.debug?.(`Scanner invalidated by directory event: ${filePath}`, {
@@ -143220,6 +143497,7 @@ var StreamerServer = class {
         });
       }
     });
+    this.trackCacheWrite(warmUp);
     if (opts?.awaitReady) await warmUp;
   }
   // Bind the HTTP listener, retrying on a transient EADDRINUSE. See the call
@@ -143267,11 +143545,23 @@ var StreamerServer = class {
       }
     }
   }
+  // Register a fire-and-forget task that writes to this.cache after a scan, so
+  // close() can await it before closing cache.db. Removes itself on settle. The
+  // caller keeps its own error handling; this wrapper swallows rejections so a
+  // failed task never rejects close()'s Promise.all.
+  trackCacheWrite(task) {
+    const guarded = task.catch(() => void 0);
+    this.inFlightCacheWrites.add(guarded);
+    void guarded.finally(() => {
+      this.inFlightCacheWrites.delete(guarded);
+    });
+  }
   async close() {
     for (const timer of this.ptyGraceTimers.values()) clearTimeout(timer);
     this.ptyGraceTimers.clear();
     this.markScannerStaleDebounced.cancel();
-    for (const s3 of this.allScanners) s3.close();
+    await Promise.all([...this.inFlightCacheWrites]);
+    await Promise.all([...this.allScanners].map((s3) => s3.close()));
     this.allScanners.clear();
     this.scanner = null;
     this.cache?.close();
@@ -143411,12 +143701,23 @@ var StreamerServer = class {
     const project = url2.searchParams.get("project") ?? void 0;
     const providerFilter = url2.searchParams.get("provider") ?? void 0;
     const bustCache = url2.searchParams.get("refresh") === "1";
-    if (bustCache) {
-      this.cache?.invalidate();
-      this.scanner = null;
-      this.scannerReady = null;
+    if (bustCache && this.cache) {
+      const scanner2 = await this.rescanForRefresh();
+      const metas2 = [...scanner2.getMetadataCache().values()];
+      try {
+        this.cache.upsertFromScannerMeta(metas2);
+        const livePaths = new Set(
+          metas2.map((m2) => m2.filePath).filter((p2) => Boolean(p2))
+        );
+        this.cache.reconcileDeletions(livePaths);
+      } catch (err) {
+        this.log.warn(
+          `refresh reconcile failed: ${err instanceof Error ? err.message : String(err)}`,
+          { event: "conversations.reconcile_failed" }
+        );
+      }
     }
-    if (this.cache && !bustCache) {
+    if (this.cache) {
       const { conversations, total: total2 } = this.cache.listConversations({
         project,
         provider: providerFilter,
@@ -143481,12 +143782,6 @@ var StreamerServer = class {
       };
     });
     json2(res, 200, { conversations: adapted, hasMore: offset + limit < total, offset, total });
-    if (this.cache && bustCache) {
-      try {
-        this.cache.upsertFromScannerMeta([...scanner.getMetadataCache().values()]);
-      } catch {
-      }
-    }
   }
   async handleConversationsCount(url2, res) {
     const project = url2.searchParams.get("project") ?? void 0;
@@ -143515,19 +143810,21 @@ var StreamerServer = class {
   // later count reflects new/removed conversations. Never awaited by the request
   // path — refresh=1 returns the cached total synchronously and this catches up.
   refreshCountInBackground() {
-    void (async () => {
-      try {
-        const scanner = await this.getFreshScanner();
-        if (this.cache) {
-          this.cache.upsertFromScannerMeta([...scanner.getMetadataCache().values()]);
+    this.trackCacheWrite(
+      (async () => {
+        try {
+          const scanner = await this.getFreshScanner();
+          if (this.cache) {
+            this.cache.upsertFromScannerMeta([...scanner.getMetadataCache().values()]);
+          }
+        } catch (err) {
+          this.log.warn(
+            `Background count refresh failed: ${err instanceof Error ? err.message : String(err)}`,
+            { event: "count.refresh_failed" }
+          );
         }
-      } catch (err) {
-        this.log.warn(
-          `Background count refresh failed: ${err instanceof Error ? err.message : String(err)}`,
-          { event: "count.refresh_failed" }
-        );
-      }
-    })();
+      })()
+    );
   }
   handleSessionsCount(res) {
     json2(res, 200, { total: this.sessionStore.list(this.ptyAttachedIds()).length });
@@ -143640,6 +143937,30 @@ var StreamerServer = class {
     this.scannerReady = null;
     return this.getScanner();
   }
+  // refresh=1's scan: reuse the WARM persistent scanner (its index.db + cursors
+  // survive, so classify() still skips unchanged files) and re-run its scan
+  // with fullRescan:true — the escape hatch that bypasses the scanner's
+  // dir-mtime discovery gate, since an explicit user pull-to-refresh is exactly
+  // the "don't trust the gate, check disk for real" signal. Unlike
+  // getFreshScanner() this does NOT discard the warm scanner. scannerReady is
+  // only ever reassigned to a live scan promise (never nulled mid-scan), so the
+  // getScanner() anti-infinite-loop guard is preserved.
+  async rescanForRefresh() {
+    if (this.scannerReady) await this.scannerReady;
+    this.scannerStale = false;
+    if (!this.scanner) {
+      this.scanner = new ConversationScanner();
+      this.allScanners.add(this.scanner);
+    }
+    const scanner = this.scanner;
+    this.scannerReady = scanner.scan({
+      ...this.scanProfiles ? { profiles: this.scanProfiles } : {},
+      ...this.codexScanOpts(),
+      fullRescan: true
+    });
+    await this.scannerReady;
+    return scanner;
+  }
   findJsonlPath(uuid3) {
     const projectsDir = (0, import_path21.join)((0, import_os10.homedir)(), ".claude", "projects");
     if (!(0, import_fs24.existsSync)(projectsDir)) return null;
@@ -145052,7 +145373,7 @@ function isBrewInstall(scriptPath = process.argv[1] ?? "") {
 var import_node_crypto4 = require("crypto");
 var import_node_fs8 = require("fs");
 var import_node_path10 = require("path");
-var import_promises15 = require("stream/promises");
+var import_promises16 = require("stream/promises");
 
 // src/updater/manifest.ts
 init_zod();
@@ -145127,7 +145448,7 @@ async function downloadAndVerify(opts) {
     }
   });
   try {
-    await (0, import_promises15.pipeline)(res.body.pipeThrough(measured), out);
+    await (0, import_promises16.pipeline)(res.body.pipeThrough(measured), out);
   } catch (err) {
     (0, import_node_fs8.rmSync)(targetPath, { force: true });
     throw err;
@@ -145341,7 +145662,7 @@ var import_fs28 = __toESM(require("fs"), 1);
 var import_node_fs14 = __toESM(require("fs"), 1);
 var import_node_path19 = __toESM(require("path"), 1);
 var import_node_fs15 = __toESM(require("fs"), 1);
-var import_promises16 = __toESM(require("fs/promises"), 1);
+var import_promises17 = __toESM(require("fs/promises"), 1);
 var import_node_path20 = __toESM(require("path"), 1);
 var import_node_path21 = require("path");
 var import_node_fs16 = __toESM(require("fs"), 1);
@@ -147573,7 +147894,7 @@ var gr = (s3, t2, e) => {
     E2 ? e(E2) : x2 && a ? Es(x2, o, h, (Le) => S2(Le)) : n ? import_node_fs15.default.chmod(s3, r, e) : e();
   };
   if (s3 === d) return no(s3, S2);
-  if (l) return import_promises16.default.mkdir(s3, { mode: r, recursive: true }).then((E2) => S2(null, E2 ?? void 0), S2);
+  if (l) return import_promises17.default.mkdir(s3, { mode: r, recursive: true }).then((E2) => S2(null, E2 ?? void 0), S2);
   let D2 = f(import_node_path20.default.relative(d, s3)).split("/");
   Ss(d, D2, r, c, d, void 0, S2);
 };