crispy-recall 0.3.0 → 0.4.0

package/dist/embed-pending.js

@@ -42,6 +42,12 @@ function recallRoot() {
     return envRoot;
   return (0, import_node_path.join)((0, import_node_os.homedir)(), ".recall");
 }
+function remoteRoot() {
+  const env = process.env["RECALL_REMOTE_ROOT"];
+  if (env && env.length > 0)
+    return env;
+  return (0, import_node_path.join)(recallRoot(), "remote");
+}
 function dbPath() {
   return (0, import_node_path.join)(recallRoot(), "recall.db");
 }
@@ -54,6 +60,9 @@ function binDir() {
 function runDir() {
   return (0, import_node_path.join)(recallRoot(), "run");
 }
+function logsDir() {
+  return (0, import_node_path.join)(recallRoot(), "logs");
+}
 function ensureDir() {
   (0, import_node_fs.mkdirSync)(recallRoot(), { recursive: true });
 }
@@ -149,7 +158,7 @@ var require_sqlite_error = __commonJS({
 // node_modules/file-uri-to-path/index.js
 var require_file_uri_to_path = __commonJS({
   "node_modules/file-uri-to-path/index.js"(exports2, module2) {
-    var sep2 = require("path").sep || "/";
+    var sep3 = require("path").sep || "/";
     module2.exports = fileUriToPath;
     function fileUriToPath(uri) {
       if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
@@ -162,15 +171,15 @@ var require_file_uri_to_path = __commonJS({
       if ("localhost" == host)
         host = "";
       if (host) {
-        host = sep2 + sep2 + host;
+        host = sep3 + sep3 + host;
       }
       path2 = path2.replace(/^(.+)\|/, "$1:");
-      if (sep2 == "\\") {
+      if (sep3 == "\\") {
         path2 = path2.replace(/\//g, "\\");
       }
       if (/^.+\:/.test(path2)) {
       } else {
-        path2 = sep2 + path2;
+        path2 = sep3 + path2;
       }
       return host + path2;
     }
@@ -183,8 +192,8 @@ var require_bindings = __commonJS({
     var fs3 = require("fs");
     var path2 = require("path");
     var fileURLToPath3 = require_file_uri_to_path();
-    var join7 = path2.join;
-    var dirname3 = path2.dirname;
+    var join9 = path2.join;
+    var dirname4 = path2.dirname;
     var exists = fs3.accessSync && function(path3) {
       try {
         fs3.accessSync(path3);
@@ -244,7 +253,7 @@ var require_bindings = __commonJS({
       var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
       var tries = [], i = 0, l = opts.try.length, n, b, err;
       for (; i < l; i++) {
-        n = join7.apply(
+        n = join9.apply(
           null,
           opts.try[i].map(function(p) {
             return opts[p] || p;
@@ -300,12 +309,12 @@ var require_bindings = __commonJS({
       return fileName;
     };
     exports2.getRoot = function getRoot(file) {
-      var dir = dirname3(file), prev;
+      var dir = dirname4(file), prev;
       while (true) {
         if (dir === ".") {
           dir = process.cwd();
         }
-        if (exists(join7(dir, "package.json")) || exists(join7(dir, "node_modules"))) {
+        if (exists(join9(dir, "package.json")) || exists(join9(dir, "node_modules"))) {
           return dir;
         }
         if (prev === dir) {
@@ -314,7 +323,7 @@ var require_bindings = __commonJS({
           );
         }
         prev = dir;
-        dir = join7(dir, "..");
+        dir = join9(dir, "..");
       }
     };
   }
@@ -515,13 +524,13 @@ var require_backup = __commonJS({
     var runBackup = (backup, handler) => {
       let rate = 0;
       let useDefault = true;
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve3, reject) => {
         setImmediate(function step() {
           try {
             const progress = backup.transfer(rate);
             if (!progress.remainingPages) {
               backup.close();
-              resolve(progress);
+              resolve3(progress);
               return;
             }
             if (useDefault) {
@@ -1292,10 +1301,10 @@ var require_browser = __commonJS({
     exports2.useColors = useColors;
     exports2.storage = localstorage();
     exports2.destroy = /* @__PURE__ */ (() => {
-      let warned2 = false;
+      let warned3 = false;
       return () => {
-        if (!warned2) {
-          warned2 = true;
+        if (!warned3) {
+          warned3 = true;
           console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
         }
       };
@@ -1966,7 +1975,7 @@ var require_get_stream = __commonJS({
       };
       const { maxBuffer } = options;
       let stream2;
-      await new Promise((resolve, reject) => {
+      await new Promise((resolve3, reject) => {
         const rejectPromise = (error) => {
           if (error && stream2.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
             error.bufferedData = stream2.getBufferedValue();
@@ -1978,7 +1987,7 @@ var require_get_stream = __commonJS({
             rejectPromise(error);
             return;
           }
-          resolve();
+          resolve3();
         });
         stream2.on("data", () => {
           if (stream2.getBufferedLength() > maxBuffer) {
@@ -3349,7 +3358,7 @@ var require_extract_zip = __commonJS({
         debug("opening", this.zipPath, "with opts", this.opts);
         this.zipfile = await openZip(this.zipPath, { lazyEntries: true });
         this.canceled = false;
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve3, reject) => {
           this.zipfile.on("error", (err) => {
             this.canceled = true;
             reject(err);
@@ -3358,7 +3367,7 @@ var require_extract_zip = __commonJS({
           this.zipfile.on("close", () => {
             if (!this.canceled) {
               debug("zip extraction complete");
-              resolve();
+              resolve3();
             }
           });
           this.zipfile.on("entry", async (entry) => {
@@ -3485,14 +3494,14 @@ var init_settings_merge = __esm({
 
 // src/installer/config.ts
 function configPath() {
-  return (0, import_node_path3.join)(recallRoot(), "config.json");
+  return (0, import_node_path7.join)(recallRoot(), "config.json");
 }
 function readConfig() {
   const p = configPath();
-  if (!(0, import_node_fs3.existsSync)(p))
+  if (!(0, import_node_fs7.existsSync)(p))
     return null;
   try {
-    return JSON.parse((0, import_node_fs3.readFileSync)(p, "utf-8"));
+    return JSON.parse((0, import_node_fs7.readFileSync)(p, "utf-8"));
   } catch (err) {
     log({
       source: "installer/config",
@@ -3508,12 +3517,12 @@ function readEmbedderConfig() {
     return cfg.embedder;
   return { mode: "cpu", ngl: 0, libDir: null, detectedAt: "" };
 }
-var import_node_fs3, import_node_path3;
+var import_node_fs7, import_node_path7;
 var init_config = __esm({
   "src/installer/config.ts"() {
     "use strict";
-    import_node_fs3 = require("node:fs");
-    import_node_path3 = require("node:path");
+    import_node_fs7 = require("node:fs");
+    import_node_path7 = require("node:path");
     init_paths();
     init_log();
     init_settings_merge();
@@ -3547,13 +3556,13 @@ function gpuRuntime() {
   }
   return _gpuRuntime;
 }
-function withGpuLibDir(libDir, sep2) {
+function withGpuLibDir(libDir, sep3) {
   const gpu = gpuRuntime();
-  return gpu?.libDir ? `${gpu.libDir}${sep2}${libDir}` : libDir;
+  return gpu?.libDir ? `${gpu.libDir}${sep3}${libDir}` : libDir;
 }
 async function withEmbedMutex(fn) {
-  return new Promise((resolve, reject) => {
-    embedQueue.push({ resolve, reject, fn });
+  return new Promise((resolve3, reject) => {
+    embedQueue.push({ resolve: resolve3, reject, fn });
     drainEmbedQueue();
   });
 }
@@ -3576,10 +3585,10 @@ function initEmbedder(binPath) {
   binaryPath = binPath;
 }
 function getBinaryPath() {
-  return (0, import_node_path4.join)(binDir(), BIN_NAME);
+  return (0, import_node_path8.join)(binDir(), BIN_NAME);
 }
 function getServerBinaryPath() {
-  return (0, import_node_path4.join)(binDir(), SERVER_BIN_NAME);
+  return (0, import_node_path8.join)(binDir(), SERVER_BIN_NAME);
 }
 async function hasNvidiaGpu() {
   try {
@@ -3590,8 +3599,8 @@ async function hasNvidiaGpu() {
   }
 }
 async function getBinaryAssetCandidates() {
-  const p = (0, import_node_os2.platform)();
-  const a = (0, import_node_os2.arch)();
+  const p = (0, import_node_os4.platform)();
+  const a = (0, import_node_os4.arch)();
   const tag = LLAMA_RELEASE_TAG;
   if (p === "linux" && a === "x64")
     return [`llama-${tag}-bin-ubuntu-x64.zip`];
@@ -3615,8 +3624,8 @@ async function getBinaryAssetCandidates() {
 async function ensureBinary() {
   const binPath = getBinaryPath();
   const serverBinPath = getServerBinaryPath();
-  const embeddingExists = (0, import_node_fs4.existsSync)(binPath);
-  const serverNeeded = SERVER_SUPPORTED && !(0, import_node_fs4.existsSync)(serverBinPath);
+  const embeddingExists = (0, import_node_fs8.existsSync)(binPath);
+  const serverNeeded = SERVER_SUPPORTED && !(0, import_node_fs8.existsSync)(serverBinPath);
   if (embeddingExists && !serverNeeded) {
     binaryPath = binPath;
     return binPath;
@@ -3639,11 +3648,11 @@ function isWantedFile(name) {
 }
 async function validateBinary(binPath) {
   try {
-    const libDir = (0, import_node_path4.join)(binPath, "..");
+    const libDir = (0, import_node_path8.join)(binPath, "..");
     const env = { ...process.env };
-    if ((0, import_node_os2.platform)() === "win32") {
+    if ((0, import_node_os4.platform)() === "win32") {
       env.PATH = `${libDir};${process.env.PATH || ""}`;
-    } else if ((0, import_node_os2.platform)() === "darwin") {
+    } else if ((0, import_node_os4.platform)() === "darwin") {
       env.DYLD_LIBRARY_PATH = libDir;
     } else {
       env.LD_LIBRARY_PATH = libDir;
@@ -3659,11 +3668,11 @@ async function validateBinary(binPath) {
   }
 }
 async function clearBinDir() {
-  if (!(0, import_node_fs4.existsSync)(binDir()))
+  if (!(0, import_node_fs8.existsSync)(binDir()))
     return;
   for (const file of await (0, import_promises.readdir)(binDir())) {
     try {
-      (0, import_node_fs4.unlinkSync)((0, import_node_path4.join)(binDir(), file));
+      (0, import_node_fs8.unlinkSync)((0, import_node_path8.join)(binDir(), file));
     } catch {
     }
   }
@@ -3746,8 +3755,8 @@ function buildUnzipInvocations(plat, archivePath, dir) {
   return plat === "darwin" ? [unzip, { cmd: "ditto", args: ["-x", "-k", archivePath, dir] }] : [unzip];
 }
 async function osUnzip(archivePath, dir) {
-  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
-  const invocations = buildUnzipInvocations((0, import_node_os2.platform)(), archivePath, dir);
+  (0, import_node_fs8.mkdirSync)(dir, { recursive: true });
+  const invocations = buildUnzipInvocations((0, import_node_os4.platform)(), archivePath, dir);
   let lastErr;
   for (const { cmd, args } of invocations) {
     try {
@@ -3770,20 +3779,20 @@ async function extractArchive(archivePath, baseDir, assetName, timeoutMs = EXTRA
       level: "warn",
       summary: `Bundled unzip failed for ${assetName} (${msg}); falling back to system unzip`
     });
-    const fallbackDir = (0, import_node_path4.join)(baseDir, "__os_unzip__");
+    const fallbackDir = (0, import_node_path8.join)(baseDir, "__os_unzip__");
     await osUnzip(archivePath, fallbackDir);
     return fallbackDir;
   }
 }
 async function installExtractedBinaries(extractedDir, destDir = binDir()) {
-  const buildBinDir = (0, import_node_path4.join)(extractedDir, "build", "bin");
-  const sourceDir = (0, import_node_fs4.existsSync)(buildBinDir) ? buildBinDir : extractedDir;
-  (0, import_node_fs4.mkdirSync)(destDir, { recursive: true });
+  const buildBinDir = (0, import_node_path8.join)(extractedDir, "build", "bin");
+  const sourceDir = (0, import_node_fs8.existsSync)(buildBinDir) ? buildBinDir : extractedDir;
+  (0, import_node_fs8.mkdirSync)(destDir, { recursive: true });
   let copiedCount = 0;
   for (const file of await (0, import_promises.readdir)(sourceDir)) {
     if (!isWantedFile(file))
       continue;
-    await (0, import_promises.cp)((0, import_node_path4.join)(sourceDir, file), (0, import_node_path4.join)(destDir, file), { force: true });
+    await (0, import_promises.cp)((0, import_node_path8.join)(sourceDir, file), (0, import_node_path8.join)(destDir, file), { force: true });
     copiedCount++;
   }
   return copiedCount;
@@ -3791,8 +3800,8 @@ async function installExtractedBinaries(extractedDir, destDir = binDir()) {
 async function downloadAndExtract(assetName, binPath) {
   const url = `https://github.com/ggml-org/llama.cpp/releases/download/${LLAMA_RELEASE_TAG}/${assetName}`;
   const isGpu = assetName.includes("cuda") || assetName.includes("vulkan");
-  (0, import_node_fs4.mkdirSync)(binDir(), { recursive: true });
-  const archivePath = (0, import_node_path4.join)(binDir(), assetName);
+  (0, import_node_fs8.mkdirSync)(binDir(), { recursive: true });
+  const archivePath = (0, import_node_path8.join)(binDir(), assetName);
   const tmpPath = archivePath + ".tmp";
   log({
     source: "recall-catchup",
@@ -3801,12 +3810,12 @@ async function downloadAndExtract(assetName, binPath) {
     data: { url, dest: binPath }
   });
   try {
-    if ((0, import_node_fs4.existsSync)(tmpPath))
-      (0, import_node_fs4.unlinkSync)(tmpPath);
+    if ((0, import_node_fs8.existsSync)(tmpPath))
+      (0, import_node_fs8.unlinkSync)(tmpPath);
     await downloadFile(url, tmpPath);
-    (0, import_node_fs4.renameSync)(tmpPath, archivePath);
-    const tmpExtractDir = (0, import_node_path4.join)((0, import_node_os2.tmpdir)(), `llama-extract-${Date.now()}`);
-    (0, import_node_fs4.mkdirSync)(tmpExtractDir, { recursive: true });
+    (0, import_node_fs8.renameSync)(tmpPath, archivePath);
+    const tmpExtractDir = (0, import_node_path8.join)((0, import_node_os4.tmpdir)(), `llama-extract-${Date.now()}`);
+    (0, import_node_fs8.mkdirSync)(tmpExtractDir, { recursive: true });
     try {
       const extractedDir = await extractArchive(archivePath, tmpExtractDir, assetName);
       const copiedCount = await installExtractedBinaries(extractedDir);
@@ -3815,32 +3824,32 @@ async function downloadAndExtract(assetName, binPath) {
       }
     } finally {
       try {
-        (0, import_node_fs4.rmSync)(tmpExtractDir, { recursive: true, force: true });
+        (0, import_node_fs8.rmSync)(tmpExtractDir, { recursive: true, force: true });
       } catch {
       }
     }
-    if ((0, import_node_fs4.existsSync)(archivePath)) {
+    if ((0, import_node_fs8.existsSync)(archivePath)) {
       try {
-        (0, import_node_fs4.unlinkSync)(archivePath);
+        (0, import_node_fs8.unlinkSync)(archivePath);
       } catch {
       }
     }
-    if ((0, import_node_os2.platform)() !== "win32") {
-      if ((0, import_node_fs4.existsSync)(binPath))
-        (0, import_node_fs4.chmodSync)(binPath, 493);
+    if ((0, import_node_os4.platform)() !== "win32") {
+      if ((0, import_node_fs8.existsSync)(binPath))
+        (0, import_node_fs8.chmodSync)(binPath, 493);
       const serverBin = getServerBinaryPath();
-      if ((0, import_node_fs4.existsSync)(serverBin)) {
-        (0, import_node_fs4.chmodSync)(serverBin, 493);
+      if ((0, import_node_fs8.existsSync)(serverBin)) {
+        (0, import_node_fs8.chmodSync)(serverBin, 493);
       }
     }
-    if (!(0, import_node_fs4.existsSync)(binPath)) {
+    if (!(0, import_node_fs8.existsSync)(binPath)) {
       throw new Error(`${BIN_NAME} not found after extracting ${assetName}`);
     }
   } catch (err) {
     for (const p of [tmpPath, archivePath]) {
-      if ((0, import_node_fs4.existsSync)(p)) {
+      if ((0, import_node_fs8.existsSync)(p)) {
         try {
-          (0, import_node_fs4.unlinkSync)(p);
+          (0, import_node_fs8.unlinkSync)(p);
         } catch {
         }
       }
@@ -3849,12 +3858,12 @@ async function downloadAndExtract(assetName, binPath) {
   }
 }
 function getModelPath() {
-  return (0, import_node_path4.join)(modelsDir(), MODEL_FILENAME);
+  return (0, import_node_path8.join)(modelsDir(), MODEL_FILENAME);
 }
 async function ensureModel() {
   const modelPath = getModelPath();
-  if ((0, import_node_fs4.existsSync)(modelPath)) {
-    const stat = (0, import_node_fs4.statSync)(modelPath);
+  if ((0, import_node_fs8.existsSync)(modelPath)) {
+    const stat = (0, import_node_fs8.statSync)(modelPath);
     if (stat.size > 1e8)
       return modelPath;
   }
@@ -3870,9 +3879,9 @@ async function ensureModel() {
 async function performModelDownload(modelPath) {
   const tmpPath = modelPath + ".tmp";
   try {
-    (0, import_node_fs4.mkdirSync)(modelsDir(), { recursive: true });
-    if ((0, import_node_fs4.existsSync)(tmpPath)) {
-      (0, import_node_fs4.unlinkSync)(tmpPath);
+    (0, import_node_fs8.mkdirSync)(modelsDir(), { recursive: true });
+    if ((0, import_node_fs8.existsSync)(tmpPath)) {
+      (0, import_node_fs8.unlinkSync)(tmpPath);
     }
     log({
       source: "recall-catchup",
@@ -3881,7 +3890,7 @@ async function performModelDownload(modelPath) {
       data: { url: MODEL_URL, dest: modelPath }
     });
     await downloadFile(MODEL_URL, tmpPath);
-    (0, import_node_fs4.renameSync)(tmpPath, modelPath);
+    (0, import_node_fs8.renameSync)(tmpPath, modelPath);
     log({
       source: "recall-catchup",
       level: "info",
@@ -3889,9 +3898,9 @@ async function performModelDownload(modelPath) {
     });
     return modelPath;
   } catch (err) {
-    if ((0, import_node_fs4.existsSync)(tmpPath)) {
+    if ((0, import_node_fs8.existsSync)(tmpPath)) {
       try {
-        (0, import_node_fs4.unlinkSync)(tmpPath);
+        (0, import_node_fs8.unlinkSync)(tmpPath);
       } catch {
       }
     }
@@ -3900,7 +3909,7 @@ async function performModelDownload(modelPath) {
 }
 async function downloadFile(url, destPath) {
   const DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     let timeoutHandle = null;
     const cleanup = () => {
       if (timeoutHandle) {
@@ -3909,7 +3918,7 @@ async function downloadFile(url, destPath) {
       }
     };
     import("node:https").then(({ default: https }) => {
-      const file = (0, import_node_fs4.createWriteStream)(destPath);
+      const file = (0, import_node_fs8.createWriteStream)(destPath);
       const pipeResponse = (response) => {
         if (response.statusCode !== 200) {
           cleanup();
@@ -3929,7 +3938,7 @@ async function downloadFile(url, destPath) {
         file.on("finish", () => {
           cleanup();
           file.close();
-          resolve();
+          resolve3();
         });
         file.on("error", (err) => {
           cleanup();
@@ -3973,13 +3982,13 @@ function isProcessAlive(pid) {
   }
 }
 function getSocketPath() {
-  return (0, import_node_path4.join)(runDir(), `llama-embed-${process.pid}.sock`);
+  return (0, import_node_path8.join)(runDir(), `llama-embed-${process.pid}.sock`);
 }
 function getPidFilePath() {
-  return (0, import_node_path4.join)(runDir(), `llama-embed-${process.pid}.pid`);
+  return (0, import_node_path8.join)(runDir(), `llama-embed-${process.pid}.pid`);
 }
 function writePidFile(pid, socketPath) {
-  (0, import_node_fs4.writeFileSync)(getPidFilePath(), JSON.stringify({
+  (0, import_node_fs8.writeFileSync)(getPidFilePath(), JSON.stringify({
     pid,
     socketPath,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3989,20 +3998,20 @@ function writePidFile(pid, socketPath) {
 function cleanupPidAndSocket() {
   for (const f of [getPidFilePath(), getSocketPath()]) {
     try {
-      (0, import_node_fs4.unlinkSync)(f);
+      (0, import_node_fs8.unlinkSync)(f);
     } catch {
     }
   }
 }
 function cleanupStalePidFiles() {
-  if (!(0, import_node_fs4.existsSync)(runDir()))
+  if (!(0, import_node_fs8.existsSync)(runDir()))
     return;
   try {
-    const files = (0, import_node_fs4.readdirSync)(runDir()).filter((f) => f.startsWith("llama-embed-") && f.endsWith(".pid"));
+    const files = (0, import_node_fs8.readdirSync)(runDir()).filter((f) => f.startsWith("llama-embed-") && f.endsWith(".pid"));
     for (const f of files) {
-      const pidFile = (0, import_node_path4.join)(runDir(), f);
+      const pidFile = (0, import_node_path8.join)(runDir(), f);
       try {
-        const data = JSON.parse((0, import_node_fs4.readFileSync)(pidFile, "utf-8"));
+        const data = JSON.parse((0, import_node_fs8.readFileSync)(pidFile, "utf-8"));
         const ownerPid = data.ownerPid ?? data.pid;
         if (!isProcessAlive(ownerPid)) {
           if (data.pid && isProcessAlive(data.pid)) {
@@ -4012,19 +4021,19 @@ function cleanupStalePidFiles() {
             }
           }
           try {
-            (0, import_node_fs4.unlinkSync)(pidFile);
+            (0, import_node_fs8.unlinkSync)(pidFile);
           } catch {
           }
           if (data.socketPath) {
             try {
-              (0, import_node_fs4.unlinkSync)(data.socketPath);
+              (0, import_node_fs8.unlinkSync)(data.socketPath);
             } catch {
             }
           }
         }
       } catch {
         try {
-          (0, import_node_fs4.unlinkSync)(pidFile);
+          (0, import_node_fs8.unlinkSync)(pidFile);
         } catch {
         }
       }
@@ -4033,17 +4042,17 @@ function cleanupStalePidFiles() {
   }
 }
 function healthCheck(socketPath) {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const req = (0, import_node_http.request)(
       { socketPath, path: "/health", method: "GET", timeout: 2e3 },
       (res) => {
-        resolve(res.statusCode === 200);
+        resolve3(res.statusCode === 200);
       }
     );
-    req.on("error", () => resolve(false));
+    req.on("error", () => resolve3(false));
     req.on("timeout", () => {
       req.destroy();
-      resolve(false);
+      resolve3(false);
     });
     req.end();
   });
@@ -4063,22 +4072,22 @@ async function waitForHealth(socketPath, child) {
 async function startServer() {
   const modelPath = await ensureModel();
   const serverBin = getServerBinaryPath();
-  if (!(0, import_node_fs4.existsSync)(serverBin)) {
+  if (!(0, import_node_fs8.existsSync)(serverBin)) {
     throw new Error("llama-server binary not available");
   }
-  (0, import_node_fs4.mkdirSync)(runDir(), { recursive: true });
+  (0, import_node_fs8.mkdirSync)(runDir(), { recursive: true });
   const socket = getSocketPath();
-  if ((0, import_node_fs4.existsSync)(socket)) {
+  if ((0, import_node_fs8.existsSync)(socket)) {
     try {
-      (0, import_node_fs4.unlinkSync)(socket);
+      (0, import_node_fs8.unlinkSync)(socket);
     } catch {
     }
   }
-  const libDir = (0, import_node_path4.join)(serverBin, "..");
-  const envKey = (0, import_node_os2.platform)() === "darwin" ? "DYLD_LIBRARY_PATH" : "LD_LIBRARY_PATH";
+  const libDir = (0, import_node_path8.join)(serverBin, "..");
+  const envKey = (0, import_node_os4.platform)() === "darwin" ? "DYLD_LIBRARY_PATH" : "LD_LIBRARY_PATH";
   const gpu = gpuRuntime();
   const nglArgs = gpu ? ["-ngl", String(gpu.ngl)] : [];
-  const child = (0, import_node_child_process.spawn)(serverBin, [
+  const child = (0, import_node_child_process2.spawn)(serverBin, [
     "-m",
     modelPath,
     "--embeddings",
@@ -4159,20 +4168,20 @@ async function killServer() {
     cleanupPidAndSocket();
     return;
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const forceKillTimer = setTimeout(() => {
       try {
         child.kill("SIGKILL");
       } catch {
       }
       cleanupPidAndSocket();
-      resolve();
+      resolve3();
     }, SERVER_KILL_TIMEOUT_MS);
     forceKillTimer.unref();
     child.once("exit", () => {
       clearTimeout(forceKillTimer);
       cleanupPidAndSocket();
-      resolve();
+      resolve3();
     });
     try {
       child.kill("SIGTERM");
@@ -4231,7 +4240,7 @@ async function retryServer() {
   }
 }
 function httpPost(socketPath, path2, body, timeoutMs) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const data = JSON.stringify(body);
     const req = (0, import_node_http.request)(
       {
@@ -4248,7 +4257,7 @@ function httpPost(socketPath, path2, body, timeoutMs) {
         const chunks = [];
         res.on("data", (chunk) => chunks.push(chunk));
         res.on("end", () => {
-          resolve({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString() });
+          resolve3({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString() });
         });
         res.on("error", reject);
       }
@@ -4322,16 +4331,16 @@ async function embedViaProcess(texts, modelPath, opts) {
       args.push("-ngl", String(gpu.ngl));
     args.push("--embd-separator", BATCH_SEPARATOR);
     if (useFile) {
-      tmpFile = (0, import_node_path4.join)((0, import_node_os2.tmpdir)(), `recall-embed-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
+      tmpFile = (0, import_node_path8.join)((0, import_node_os4.tmpdir)(), `recall-embed-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
       await (0, import_promises.writeFile)(tmpFile, joined, "utf-8");
       args.push("-f", tmpFile);
     } else {
       args.push("-p", joined);
     }
-    const libDir = (0, import_node_path4.join)(binaryPath, "..");
-    const envKey = (0, import_node_os2.platform)() === "darwin" ? "DYLD_LIBRARY_PATH" : (0, import_node_os2.platform)() === "win32" ? "PATH" : "LD_LIBRARY_PATH";
+    const libDir = (0, import_node_path8.join)(binaryPath, "..");
+    const envKey = (0, import_node_os4.platform)() === "darwin" ? "DYLD_LIBRARY_PATH" : (0, import_node_os4.platform)() === "win32" ? "PATH" : "LD_LIBRARY_PATH";
     const env = { ...process.env };
-    if ((0, import_node_os2.platform)() === "win32") {
+    if ((0, import_node_os4.platform)() === "win32") {
       env.PATH = withGpuLibDir(`${libDir};${process.env.PATH || ""}`, ";");
     } else {
       env[envKey] = withGpuLibDir(libDir, ":");
@@ -4339,6 +4348,13 @@ async function embedViaProcess(texts, modelPath, opts) {
     const { stdout, stderr } = await execFileAsync(binaryPath, args, {
       maxBuffer: 2 * 1024 * 1024,
       env,
+      // llama-embedding.exe is a console program. The Stop hook spawns
+      // embed-pending detached (DETACHED_PROCESS), so that parent holds no
+      // console for this child to inherit — without CREATE_NO_WINDOW, Windows
+      // allocates a fresh console and a terminal window flashes on screen once
+      // per batch, at the end of every turn. Server mode is off on Windows, so
+      // this one-shot path runs for every embed there.
+      windowsHide: true,
       ...opts?.timeoutMs ? { timeout: opts.timeoutMs, killSignal: "SIGKILL" } : {}
     });
     if (stderr) {
@@ -4447,32 +4463,32 @@ async function embedBatchInner(texts) {
 async function disposeEmbedder() {
   await killServer();
 }
-var import_node_child_process, import_node_fs4, import_promises, import_node_http, import_node_path4, import_node_os2, import_node_util, import_extract_zip, execFileAsync, _gpuRuntime, MODEL_FILENAME, MODEL_URL, EXPECTED_DIMS, BATCH_SEPARATOR, MAX_ARG_BYTES, LLAMA_RELEASE_TAG, MACOS_MIN_VERSION, BIN_NAME, SERVER_BIN_NAME, SERVER_SUPPORTED, SERVER_THRESHOLD, IDLE_TIMEOUT_MS, HEALTH_POLL_INTERVAL_MS, HEALTH_POLL_TIMEOUT_MS, HTTP_REQUEST_TIMEOUT_MS, SERVER_KILL_TIMEOUT_MS, SERVER_COOLDOWN_MS, EXTRACT_TIMEOUT_MS, embedQueue, embedRunning, binaryPath, downloadPromise, binaryDownloadPromise, serverProcess, activeSocketPath, idleTimer, serverStartPromise, serverCooldownUntil, serverRetryPromise, activeServerRequests, WANTED_FILES, WANTED_LIB_PATTERNS;
+var import_node_child_process2, import_node_fs8, import_promises, import_node_http, import_node_path8, import_node_os4, import_node_util, import_extract_zip, execFileAsync, _gpuRuntime, MODEL_FILENAME, MODEL_URL, EXPECTED_DIMS, BATCH_SEPARATOR, MAX_ARG_BYTES, LLAMA_RELEASE_TAG, MACOS_MIN_VERSION, BIN_NAME, SERVER_BIN_NAME, SERVER_SUPPORTED, SERVER_THRESHOLD, IDLE_TIMEOUT_MS, HEALTH_POLL_INTERVAL_MS, HEALTH_POLL_TIMEOUT_MS, HTTP_REQUEST_TIMEOUT_MS, SERVER_KILL_TIMEOUT_MS, SERVER_COOLDOWN_MS, EXTRACT_TIMEOUT_MS, embedQueue, embedRunning, binaryPath, downloadPromise, binaryDownloadPromise, serverProcess, activeSocketPath, idleTimer, serverStartPromise, serverCooldownUntil, serverRetryPromise, activeServerRequests, WANTED_FILES, WANTED_LIB_PATTERNS;
 var init_embedder = __esm({
   "src/recall/embedder.ts"() {
     "use strict";
-    import_node_child_process = require("node:child_process");
-    import_node_fs4 = require("node:fs");
+    import_node_child_process2 = require("node:child_process");
+    import_node_fs8 = require("node:fs");
     import_promises = require("node:fs/promises");
     import_node_http = require("node:http");
-    import_node_path4 = require("node:path");
-    import_node_os2 = require("node:os");
+    import_node_path8 = require("node:path");
+    import_node_os4 = require("node:os");
     import_node_util = require("node:util");
     import_extract_zip = __toESM(require_extract_zip());
     init_log();
     init_paths();
     init_config();
-    execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+    execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
     MODEL_FILENAME = "nomic-embed-text-v1.5.Q8_0.gguf";
     MODEL_URL = "https://huggingface.co/nomic-ai/nomic-embed-text-v1.5-GGUF/resolve/main/nomic-embed-text-v1.5.Q8_0.gguf";
     EXPECTED_DIMS = 768;
     BATCH_SEPARATOR = "<#sep#>";
-    MAX_ARG_BYTES = (0, import_node_os2.platform)() === "win32" ? 0 : 1e5;
+    MAX_ARG_BYTES = (0, import_node_os4.platform)() === "win32" ? 0 : 1e5;
     LLAMA_RELEASE_TAG = "b5300";
     MACOS_MIN_VERSION = { arm64: "14.0", x64: "13.7" };
-    BIN_NAME = (0, import_node_os2.platform)() === "win32" ? "llama-embedding.exe" : "llama-embedding";
-    SERVER_BIN_NAME = (0, import_node_os2.platform)() === "win32" ? "llama-server.exe" : "llama-server";
-    SERVER_SUPPORTED = (0, import_node_os2.platform)() !== "win32";
+    BIN_NAME = (0, import_node_os4.platform)() === "win32" ? "llama-embedding.exe" : "llama-embedding";
+    SERVER_BIN_NAME = (0, import_node_os4.platform)() === "win32" ? "llama-server.exe" : "llama-server";
+    SERVER_SUPPORTED = (0, import_node_os4.platform)() !== "win32";
     SERVER_THRESHOLD = 5;
     IDLE_TIMEOUT_MS = 3e4;
     HEALTH_POLL_INTERVAL_MS = 200;
@@ -4738,10 +4754,127 @@ var require_brace_expansion = __commonJS({
 });
 
 // src/cli/embed-pending.ts
-var import_node_fs7 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 init_paths();
 
+// src/recall/embed-failures.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+init_paths();
+var attempts = /* @__PURE__ */ new Map();
+var MAX_MESSAGE_ATTEMPTS = 3;
+function exhaustedEmbedMessageIds() {
+  const durable = Object.entries(readEmbedFailure()?.retryAfter ?? {}).filter(([, until]) => until > Date.now()).map(([id]) => id);
+  return [.../* @__PURE__ */ new Set([...durable, ...[...attempts].filter(([, n]) => n >= MAX_MESSAGE_ATTEMPTS).map(([id]) => id)])];
+}
+function readEmbedFailure() {
+  try {
+    const value = JSON.parse((0, import_node_fs2.readFileSync)((0, import_node_path2.join)(logsDir(), "embed-failure.json"), "utf8"));
+    if (!value || typeof value !== "object" || typeof value.updatedAt !== "string" || typeof value.reason !== "string" || typeof value.attempts !== "number" || !Array.isArray(value.failedMessageIds) || !value.failedMessageIds.every((id) => typeof id === "string"))
+      return null;
+    if (value.retryAfter && (typeof value.retryAfter !== "object" || Array.isArray(value.retryAfter) || !Object.values(value.retryAfter).every((n) => typeof n === "number" && Number.isFinite(n))))
+      return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function recordEmbedFailure(messageId, reason) {
+  attempts.set(messageId, (attempts.get(messageId) ?? 0) + 1);
+  try {
+    (0, import_node_fs2.mkdirSync)(logsDir(), { recursive: true });
+    const previous = readEmbedFailure();
+    const retryAfter = previous?.retryAfter ?? {};
+    if (attempts.get(messageId) >= MAX_MESSAGE_ATTEMPTS)
+      retryAfter[messageId] = Date.now() + 15 * 6e4;
+    (0, import_node_fs2.writeFileSync)((0, import_node_path2.join)(logsDir(), "embed-failure.json"), JSON.stringify({
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attempts: attempts.get(messageId),
+      reason,
+      failedMessageIds: [.../* @__PURE__ */ new Set([...previous?.failedMessageIds ?? [], messageId])],
+      retryAfter
+    }));
+  } catch {
+  }
+}
+function recordEmbedSuccess(messageId) {
+  attempts.delete(messageId);
+  try {
+    const previous = readEmbedFailure();
+    if (!previous)
+      return;
+    if (!previous.failedMessageIds.includes(messageId) && !(previous.retryAfter && messageId in previous.retryAfter))
+      return;
+    previous.failedMessageIds = previous.failedMessageIds.filter((id) => id !== messageId);
+    if (previous.retryAfter)
+      delete previous.retryAfter[messageId];
+    if (previous.failedMessageIds.length)
+      (0, import_node_fs2.writeFileSync)((0, import_node_path2.join)(logsDir(), "embed-failure.json"), JSON.stringify(previous));
+    else
+      (0, import_node_fs2.rmSync)((0, import_node_path2.join)(logsDir(), "embed-failure.json"), { force: true });
+  } catch {
+  }
+}
+
+// src/adapters/system-context.ts
+function firstTextContent(message) {
+  if (!message)
+    return void 0;
+  const content = message.content;
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    const firstText = content.find(
+      (b) => typeof b === "object" && b !== null && b.type === "text"
+    );
+    if (firstText && "text" in firstText) {
+      return firstText.text;
+    }
+  }
+  return void 0;
+}
+function isSystemContextContent(message) {
+  if (!message || message.role !== "user")
+    return false;
+  const text = firstTextContent(message);
+  if (!text)
+    return false;
+  if (text.startsWith("<system-reminder>"))
+    return true;
+  if (text.startsWith("<environment_context>"))
+    return true;
+  if (text.startsWith("<INSTRUCTIONS>"))
+    return true;
+  if (text.startsWith("# AGENTS.md instructions for"))
+    return true;
+  if (text.startsWith("<context>"))
+    return true;
+  if (text.startsWith("<task-notification>"))
+    return true;
+  if (text.startsWith("<command-name>"))
+    return true;
+  if (text.startsWith("<local-command-stdout>"))
+    return true;
+  if (text.startsWith("<local-command-caveat>"))
+    return true;
+  return false;
+}
+
 // src/recall/transcript-utils.ts
+var META_KEEP_PREFIXES = [
+  "<task-notification>",
+  "[SYSTEM NOTIFICATION",
+  "Another Claude session sent a message"
+];
+function shouldDropAsMeta(entry) {
+  if (entry.isMeta !== true)
+    return false;
+  const text = firstTextContent(entry.message);
+  if (text && META_KEEP_PREFIXES.some((prefix) => text.startsWith(prefix))) {
+    return false;
+  }
+  return true;
+}
 function stripToolContent(entries) {
   const out = [];
   for (const entry of entries) {
@@ -4770,8 +4903,8 @@ function stripToolContent(entries) {
 }
 
 // src/db.ts
-var import_node_fs2 = require("node:fs");
-var import_node_path2 = require("node:path");
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
 var import_node_module = require("node:module");
 init_log();
 init_paths();
@@ -4791,11 +4924,12 @@ Run \`recall doctor\` for details.`
   }
 };
 var MigrationPendingError = class extends Error {
-  constructor(dbPath2) {
+  constructor(dbPath2, kind = "retrieval-class") {
     super(
-      "recall: this database needs a one-time schema migration \u2014 run `recall install` to finish it. (Normal commands refuse to rewrite the index unattended.)"
+      kind === "codex-rekey" ? "recall: this database needs a one-time Codex message-id migration \u2014 run `recall install` (or `recall repair --rekey-codex`) to finish it. (Normal commands refuse to rewrite the index unattended.)" : "recall: this database needs a one-time schema migration \u2014 run `recall install` to finish it. (Normal commands refuse to rewrite the index unattended.)"
     );
     this.dbPath = dbPath2;
+    this.kind = kind;
     this.name = "MigrationPendingError";
   }
 };
@@ -4819,7 +4953,7 @@ function getDb(dbPath2, opts) {
   if (db) {
     closeDb();
   }
-  (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(dbPath2), { recursive: true });
+  (0, import_node_fs3.mkdirSync)((0, import_node_path3.dirname)(dbPath2), { recursive: true });
   cleanupWasmArtifacts(dbPath2);
   const raw = openDatabase(dbPath2);
   try {
@@ -4836,16 +4970,43 @@ function getDb(dbPath2, opts) {
     }
     db = adapter;
     currentDbPath = dbPath2;
+    ensureStemScratch(db);
     log({ source: "db", level: "info", summary: `DB: opened pending-migration DB at ${dbPath2} (installer mode)` });
     return db;
   }
+  if (isCodexRekeyPending(adapter) && !opts?.allowPendingMigration) {
+    raw.close();
+    throw new MigrationPendingError(dbPath2, "codex-rekey");
+  }
   db = adapter;
   currentDbPath = dbPath2;
-  ensureSchema(db);
+  try {
+    ensureSchema(db);
+    ensureStemScratch(db);
+  } catch (error) {
+    closeDb();
+    throw error;
+  }
   log({ source: "db", level: "info", summary: `DB: initialized at ${dbPath2}` });
   return db;
 }
+function ensureStemScratch(db3) {
+  db3.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS temp._stem USING fts5(
+      t, tokenize='porter unicode61'
+    );
+    CREATE VIRTUAL TABLE IF NOT EXISTS temp._stem_vocab
+      USING fts5vocab(temp, _stem, 'row');
+  `);
+}
 var RETRIEVAL_MIGRATION_KEY = "retrieval_class_migration";
+function rethrowIfBusy(err) {
+  const code = err?.code;
+  const message = err?.message;
+  if (typeof code === "string" && code.startsWith("SQLITE_BUSY") || typeof message === "string" && /database is locked|SQLITE_BUSY/i.test(message))
+    throw err;
+}
+var PROJECT_KEY_BACKFILL_KEY = "project_key_backfill";
 function isRetrievalMigrationPending(d) {
   try {
     const hasMessages = d.get(
@@ -4863,13 +5024,40 @@ function isRetrievalMigrationPending(d) {
       [RETRIEVAL_MIGRATION_KEY]
     );
     return row?.value !== "complete";
-  } catch {
+  } catch (err) {
+    rethrowIfBusy(err);
+    return true;
+  }
+}
+var CODEX_REKEY_MIGRATION_KEY = "codex_message_id_v2";
+function isCodexRekeyPending(d) {
+  try {
+    const hasMessages = d.get(
+      `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'messages'`
+    );
+    if (!hasMessages)
+      return false;
+    const hasMeta = d.get(
+      `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'schema_meta'`
+    );
+    if (!hasMeta)
+      return true;
+    const row = d.get(
+      `SELECT value FROM schema_meta WHERE key = ?`,
+      [CODEX_REKEY_MIGRATION_KEY]
+    );
+    return row?.value !== "complete";
+  } catch (err) {
+    rethrowIfBusy(err);
     return true;
   }
 }
 function closeDb() {
-  if (db) {
+  if (!db)
+    return;
+  try {
     db.close();
+  } finally {
     db = null;
     currentDbPath = null;
   }
@@ -4885,32 +5073,32 @@ function openDatabase(dbPath2) {
   }
 }
 function resolveNativeBinding() {
-  const sibling = (0, import_node_path2.join)(__dirname, "better_sqlite3.node");
-  if ((0, import_node_fs2.existsSync)(sibling))
+  const sibling = (0, import_node_path3.join)(__dirname, "better_sqlite3.node");
+  if ((0, import_node_fs3.existsSync)(sibling))
     return sibling;
   const resolved = resolveInstalledBinding();
   if (resolved)
     return resolved;
-  const staged = (0, import_node_path2.join)(binDir(), "better_sqlite3.node");
-  if ((0, import_node_fs2.existsSync)(staged))
+  const staged = (0, import_node_path3.join)(binDir(), "better_sqlite3.node");
+  if ((0, import_node_fs3.existsSync)(staged))
     return staged;
   return null;
 }
 function resolveInstalledBinding() {
   try {
     const pkgJson = (0, import_node_module.createRequire)(__filename).resolve("better-sqlite3/package.json");
-    return findNativeBinding((0, import_node_path2.dirname)(pkgJson));
+    return findNativeBinding((0, import_node_path3.dirname)(pkgJson));
   } catch {
     return null;
   }
 }
 function findNativeBinding(baseDir) {
   for (const c of [
-    (0, import_node_path2.join)(baseDir, "build", "Release", "better_sqlite3.node"),
-    (0, import_node_path2.join)(baseDir, "build", "Debug", "better_sqlite3.node")
+    (0, import_node_path3.join)(baseDir, "build", "Release", "better_sqlite3.node"),
+    (0, import_node_path3.join)(baseDir, "build", "Debug", "better_sqlite3.node")
   ]) {
     try {
-      if ((0, import_node_fs2.statSync)(c).isFile())
+      if ((0, import_node_fs3.statSync)(c).isFile())
         return c;
     } catch {
     }
@@ -4920,12 +5108,12 @@ function findNativeBinding(baseDir) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
-      const p = (0, import_node_path2.join)(dir, e.name);
+      const p = (0, import_node_path3.join)(dir, e.name);
       if (e.isDirectory())
         stack.push(p);
       else if (e.name.endsWith(".node"))
@@ -4968,12 +5156,12 @@ function configurePragmas(raw, dbPath2) {
 }
 function cleanupWasmArtifacts(dbPath2) {
   try {
-    (0, import_node_fs2.rmSync)(`${dbPath2}.lock`, { recursive: true, force: true });
+    (0, import_node_fs3.rmSync)(`${dbPath2}.lock`, { recursive: true, force: true });
   } catch {
   }
   try {
-    if ((0, import_node_fs2.existsSync)(`${dbPath2}.owner`))
-      (0, import_node_fs2.unlinkSync)(`${dbPath2}.owner`);
+    if ((0, import_node_fs3.existsSync)(`${dbPath2}.owner`))
+      (0, import_node_fs3.unlinkSync)(`${dbPath2}.owner`);
   } catch {
   }
 }
@@ -4989,6 +5177,7 @@ var RETRIEVAL_SCHEMA_DDL = {
       created_at      INTEGER NOT NULL,
       message_role    TEXT,
       retrieval_class TEXT NOT NULL DEFAULT 'hot',
+      project_key     TEXT,
       UNIQUE(session_id, message_id)
     );
 
@@ -5078,15 +5267,18 @@ var RETRIEVAL_SCHEMA_DDL = {
   `
 };
 function ensureSchema(db3) {
+  const fresh = !db3.get(
+    `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'messages'`
+  );
   db3.exec("BEGIN IMMEDIATE");
   try {
     db3.exec(RETRIEVAL_SCHEMA_DDL.tables);
     db3.exec(RETRIEVAL_SCHEMA_DDL.fts);
     db3.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS _stem USING fts5(
+      CREATE VIRTUAL TABLE IF NOT EXISTS main._stem USING fts5(
         t, tokenize='porter unicode61'
       );
-      CREATE VIRTUAL TABLE IF NOT EXISTS _stem_vocab
+      CREATE VIRTUAL TABLE IF NOT EXISTS main._stem_vocab
         USING fts5vocab(_stem, 'row');
     `);
     db3.exec(`
@@ -5107,6 +5299,16 @@ function ensureSchema(db3) {
           throw e;
       }
     }
+    const hasProjectKey = () => db3.all(`PRAGMA table_info(messages)`).some((c) => c.name === "project_key");
+    if (!hasProjectKey()) {
+      try {
+        db3.exec(`ALTER TABLE messages ADD COLUMN project_key TEXT`);
+      } catch (e) {
+        if (!hasProjectKey())
+          throw e;
+      }
+    }
+    db3.exec(`CREATE INDEX IF NOT EXISTS idx_messages_project_key ON messages(project_key)`);
     db3.exec(`
       CREATE TABLE IF NOT EXISTS ingest_watermark (
         transcript_path TEXT PRIMARY KEY,
@@ -5120,6 +5322,18 @@ function ensureSchema(db3) {
       INSERT OR IGNORE INTO schema_meta(key, value)
       VALUES ('${RETRIEVAL_MIGRATION_KEY}', 'complete');
     `);
+    if (fresh) {
+      db3.exec(`
+        INSERT OR IGNORE INTO schema_meta(key, value)
+        VALUES ('${CODEX_REKEY_MIGRATION_KEY}', 'complete');
+      `);
+    }
+    if (fresh) {
+      db3.exec(`
+        INSERT OR IGNORE INTO schema_meta(key, value)
+        VALUES ('${PROJECT_KEY_BACKFILL_KEY}', 'complete');
+      `);
+    }
     db3.exec("COMMIT");
   } catch (e) {
     try {
@@ -5147,6 +5361,8 @@ var ENRICH_MAX_CHARS = 200;
 var ENRICH_PREV_CHARS = 512;
 var ENRICH_SEP = "\n";
 function buildEmbedText(messageText, prevText) {
+  messageText = messageText.replaceAll("\0", "");
+  prevText = prevText?.replaceAll("\0", "") ?? null;
   if (messageText.length >= ENRICH_MAX_CHARS || !prevText)
     return messageText;
   return prevText.slice(-ENRICH_PREV_CHARS) + ENRICH_SEP + messageText;
@@ -5165,10 +5381,11 @@ function ensureDir2() {
 }
 function insertMessages(messages, opts) {
   if (messages.length === 0 && !opts?.replaceSessionId && !opts?.provenance)
-    return;
+    return 0;
   ensureDir2();
   const d = db2();
   d.exec("BEGIN IMMEDIATE");
+  let inserted = 0;
   try {
     if (opts?.replaceSessionId) {
       d.run(
@@ -5180,20 +5397,65 @@ function insertMessages(messages, opts) {
     }
     const stmt = d.prepare(
       `INSERT OR IGNORE INTO messages
-       (message_id, session_id, message_seq, message_text, project_id, created_at, message_role, retrieval_class)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+       (message_id, session_id, message_seq, message_text, project_id, created_at, message_role, retrieval_class, project_key)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
     );
+    const invalidatedSessions = /* @__PURE__ */ new Set();
+    const sourceIds = /* @__PURE__ */ new Map();
     for (const m of messages) {
-      stmt.run([
-        m.message_id,
+      const ids = sourceIds.get(m.session_id) ?? /* @__PURE__ */ new Set();
+      ids.add(m.message_id);
+      ids.add(`session:${m.session_id}:${m.message_id}`);
+      sourceIds.set(m.session_id, ids);
+    }
+    if (opts?.provenance && opts.sourceMessageIds) {
+      const sid = opts.provenance.sessionId;
+      const ids = sourceIds.get(sid);
+      for (const id of opts.sourceMessageIds) {
+        ids?.add(id);
+        ids?.add(`session:${sid}:${id}`);
+      }
+    }
+    const partialSessions = /* @__PURE__ */ new Map();
+    const maxStoredSeq = /* @__PURE__ */ new Map();
+    for (const [sid, ids] of sourceIds) {
+      const stored = d.all("SELECT message_id, message_seq FROM messages WHERE session_id = ?", [sid]);
+      const max = stored.reduce((acc, r) => Math.max(acc, r.message_seq), -1);
+      maxStoredSeq.set(sid, max);
+      if (stored.some((r) => !ids.has(r.message_id)))
+        partialSessions.set(sid, max);
+    }
+    for (const m of messages) {
+      const scopedId = `session:${m.session_id}:${m.message_id}`;
+      const scoped = d.get("SELECT message_id FROM messages WHERE message_id = ? AND session_id = ?", [scopedId, m.session_id]);
+      const owner = d.get("SELECT session_id FROM messages WHERE message_id = ?", [m.message_id]);
+      const id = scoped || owner && owner.session_id !== m.session_id ? scopedId : m.message_id;
+      const existing = d.get("SELECT message_seq FROM messages WHERE message_id = ? AND session_id = ?", [id, m.session_id]);
+      let sequence = m.message_seq;
+      if (partialSessions.has(m.session_id)) {
+        sequence = existing?.message_seq ?? partialSessions.get(m.session_id) + 1;
+        partialSessions.set(m.session_id, Math.max(partialSessions.get(m.session_id), sequence));
+      }
+      const insertsPredecessor = !existing && sequence <= (maxStoredSeq.get(m.session_id) ?? -1);
+      if (existing && existing.message_seq !== sequence || insertsPredecessor) {
+        if (!invalidatedSessions.has(m.session_id)) {
+          d.run("DELETE FROM message_vectors WHERE message_id IN (SELECT message_id FROM messages WHERE session_id = ?)", [m.session_id]);
+          invalidatedSessions.add(m.session_id);
+        }
+        d.run("UPDATE messages SET message_seq = ? WHERE message_id = ? AND session_id = ?", [sequence, id, m.session_id]);
+      }
+      maxStoredSeq.set(m.session_id, Math.max(maxStoredSeq.get(m.session_id) ?? -1, sequence));
+      inserted += stmt.run([
+        id,
         m.session_id,
-        m.message_seq,
+        sequence,
         m.message_text,
         m.project_id,
         m.created_at,
         m.message_role,
-        m.retrieval_class ?? "hot"
-      ]);
+        m.retrieval_class ?? "hot",
+        m.project_key ?? null
+      ]).changes;
     }
     if (opts?.provenance) {
       const p = opts.provenance;
@@ -5233,6 +5495,15 @@ function insertMessages(messages, opts) {
         );
       }
     }
+    if (opts?.adopt) {
+      const { sessionId, projectKey, projectId } = opts.adopt;
+      if (projectKey !== null) {
+        d.run("UPDATE messages SET project_key = ? WHERE session_id = ? AND project_key IS NULL", [projectKey, sessionId]);
+      }
+      if (projectId !== null && projectId !== "") {
+        d.run("UPDATE messages SET project_id = ? WHERE session_id = ? AND (project_id IS NULL OR project_id = '')", [projectId, sessionId]);
+      }
+    }
     for (const a of opts?.aliases ?? []) {
       d.run(
         `INSERT OR REPLACE INTO session_aliases (alias_id, session_id, source, created_at)
@@ -5241,11 +5512,23 @@ function insertMessages(messages, opts) {
       );
     }
     d.exec("COMMIT");
+    return inserted;
   } catch (e) {
     d.exec("ROLLBACK");
     throw e;
   }
 }
+function hasSessionMessages(sessionId) {
+  try {
+    const row = db2().get(
+      "SELECT 1 FROM messages WHERE session_id = ? LIMIT 1",
+      [sessionId]
+    );
+    return row != null;
+  } catch {
+    return false;
+  }
+}
 function insertMessageVectors(records) {
   if (records.length === 0)
     return;
@@ -5285,13 +5568,14 @@ function getUnembeddedMessages(limit) {
            ORDER BY p.message_seq DESC LIMIT 1) AS prev_text
        FROM messages m
        WHERE m.message_text != ''
+         AND m.message_id NOT IN (SELECT value FROM json_each(?))
          AND m.retrieval_class = 'hot'
-         AND (LENGTH(m.message_text) >= ${MIN_EMBED_CHARS}
+         AND (LENGTH(m.message_text) >= ${MIN_EMBED_CHARS} OR INSTR(m.message_text, char(0)) > 0
               OR EXISTS (SELECT 1 FROM messages p2 WHERE p2.session_id = m.session_id AND p2.message_seq < m.message_seq AND p2.retrieval_class = 'hot'))
          AND NOT EXISTS (SELECT 1 FROM message_vectors mv WHERE mv.message_id = m.message_id AND mv.embed_version = ?)
        ORDER BY m.created_at DESC
        LIMIT ?`,
-      [EMBED_VERSION, limit]
+      [JSON.stringify(exhaustedEmbedMessageIds()), EMBED_VERSION, limit]
     );
     return rows.map((r) => {
       const message_text = r.message_text;
@@ -5315,6 +5599,89 @@ init_log();
 // src/adapters/codex/codex-jsonl-reader.ts
 var fs = __toESM(require("fs"));
 init_log();
+
+// src/recall/transcript-roots.ts
+var import_node_os2 = require("node:os");
+var import_node_path5 = require("node:path");
+
+// src/hub/runtime.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path4 = require("node:path");
+init_paths();
+var STALE_RECORD_MS = 60 * 60 * 1e3;
+var REFUSED_RECENT_MAX = 5;
+function hubHostsPath() {
+  return (0, import_node_path4.join)(runDir(), "hub-hosts.json");
+}
+function readHostRecords() {
+  try {
+    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(hubHostsPath(), "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return {};
+    const out = {};
+    for (const [host, rec] of Object.entries(parsed)) {
+      if (!rec || typeof rec !== "object")
+        continue;
+      const r = rec;
+      out[host] = {
+        ...typeof r["lastPushAt"] === "string" ? { lastPushAt: r["lastPushAt"] } : {},
+        ...typeof r["lastQueryAt"] === "string" ? { lastQueryAt: r["lastQueryAt"] } : {},
+        ...typeof r["lastFullManifestAt"] === "string" ? { lastFullManifestAt: r["lastFullManifestAt"] } : {},
+        refusedCollisions: typeof r["refusedCollisions"] === "number" ? r["refusedCollisions"] : 0,
+        refusedRecent: Array.isArray(r["refusedRecent"]) ? r["refusedRecent"].filter((v) => typeof v === "string").slice(0, REFUSED_RECENT_MAX) : []
+      };
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+// src/recall/transcript-roots.ts
+init_log();
+var DRVFS = /^\/mnt\/[a-zA-Z]\//;
+var warned = /* @__PURE__ */ new Set();
+function defaultClaudeRoot() {
+  return (0, import_node_path5.join)((0, import_node_os2.homedir)(), ".claude");
+}
+function defaultCodexRoot() {
+  return (0, import_node_path5.join)((0, import_node_os2.homedir)(), ".codex");
+}
+function guardedHosts(override) {
+  if (process.platform !== "linux")
+    return [];
+  const abs = (0, import_node_path5.resolve)(override).replace(/\\/g, "/");
+  if (!DRVFS.test(abs.endsWith("/") ? abs : `${abs}/`))
+    return [];
+  return Object.keys(readHostRecords());
+}
+function resolveRoot(envVar, fallback) {
+  const override = process.env[envVar];
+  if (!override || override.length === 0)
+    return fallback;
+  const hosts = guardedHosts(override);
+  if (hosts.length === 0)
+    return override;
+  if (!warned.has(envVar)) {
+    warned.add(envVar);
+    log({
+      level: "warn",
+      source: "transcript-roots",
+      summary: `ignoring ${envVar}=${override}: this hub serves satellite ${hosts.join(", ")} and that tree is pushed by a satellite; set the variable elsewhere or unset it`
+    });
+  }
+  return fallback;
+}
+function claudeRoot() {
+  return resolveRoot("CLAUDE_CONFIG_DIR", defaultClaudeRoot());
+}
+function codexRoot() {
+  return resolveRoot("CODEX_HOME", defaultCodexRoot());
+}
+
+// src/adapters/codex/codex-jsonl-reader.ts
+var META_READ_LIMIT = 256 * 1024;
+var META_CHUNK_SIZE = 8192;
 function parseCodexJsonlFile(filepath) {
   try {
     const content = fs.readFileSync(filepath, "utf-8");
@@ -5334,20 +5701,39 @@ function parseCodexJsonlFile(filepath) {
     return records;
   } catch (error) {
     log({ level: "error", source: "codex-jsonl-reader", summary: `Failed to read ${filepath}: ${error instanceof Error ? error.message : String(error)}`, data: { filepath, error: String(error) } });
-    return [];
+    throw error;
   }
 }
 function extractCodexSessionMeta(filepath) {
   let fd = null;
   try {
     fd = fs.openSync(filepath, "r");
-    const buffer = Buffer.alloc(8192);
-    const bytesRead = fs.readSync(fd, buffer, 0, 8192, 0);
-    if (bytesRead === 0)
+    const chunks = [];
+    let position = 0;
+    let newlineIdx = -1;
+    let atEof = false;
+    while (position < META_READ_LIMIT) {
+      const chunk = Buffer.alloc(Math.min(META_CHUNK_SIZE, META_READ_LIMIT - position));
+      const bytesRead = fs.readSync(fd, chunk, 0, chunk.length, position);
+      if (bytesRead === 0) {
+        atEof = true;
+        break;
+      }
+      const slice = chunk.subarray(0, bytesRead);
+      const idx = slice.indexOf(10);
+      chunks.push(slice);
+      if (idx >= 0) {
+        newlineIdx = position + idx;
+        break;
+      }
+      position += bytesRead;
+    }
+    if (chunks.length === 0)
       return null;
-    const content = buffer.toString("utf-8", 0, bytesRead);
-    const newlineIdx = content.indexOf("\n");
-    const firstLine = newlineIdx >= 0 ? content.slice(0, newlineIdx) : content;
+    if (newlineIdx < 0 && !atEof)
+      return null;
+    const joined = Buffer.concat(chunks);
+    const firstLine = (newlineIdx >= 0 ? joined.subarray(0, newlineIdx) : joined).toString("utf-8");
     const record = JSON.parse(firstLine.trim());
     if (record.type !== "session_meta")
       return null;
@@ -5539,7 +5925,10 @@ function parseSubagentSource(source, _transcriptPath) {
   const looksSubagent = subRaw !== void 0 || typeTag === "subagent";
   if (!looksSubagent)
     return none;
-  if (subRaw !== void 0 && (typeof subRaw !== "object" || subRaw === null)) {
+  if (typeof subRaw === "string" && ["review", "compact", "memory_consolidation"].includes(subRaw)) {
+    return { ...none, isSubagent: true, meta: { type: subRaw } };
+  }
+  if (subRaw !== void 0 && (typeof subRaw !== "object" || subRaw === null || Array.isArray(subRaw))) {
     return { ...none, malformed: true };
   }
   const sub = subRaw ?? {};
@@ -5548,7 +5937,7 @@ function parseSubagentSource(source, _transcriptPath) {
   const parentThreadId = typeof spawn2.parent_thread_id === "string" && spawn2.parent_thread_id ? spawn2.parent_thread_id : null;
   const depth = typeof spawn2.depth === "number" && Number.isFinite(spawn2.depth) ? spawn2.depth : null;
   const meta = {};
-  for (const k of ["agent_path", "agent_type", "agent_name", "path", "type", "name"]) {
+  for (const k of ["agent_path", "agent_type", "agent_name", "agent_nickname", "agent_role", "path", "type", "name"]) {
     const v = spawn2[k] ?? sub[k];
     if (typeof v === "string" || typeof v === "number")
       meta[k] = v;
@@ -5576,6 +5965,255 @@ function normalizePath(p) {
   return normalized;
 }
 
+// src/recall/project-key.ts
+var import_node_fs5 = require("node:fs");
+var import_node_os3 = require("node:os");
+var import_node_child_process = require("node:child_process");
+var cache = /* @__PURE__ */ new Map();
+var GIT_TIMEOUT_MS = 3e3;
+function runGit(cwd, args, timeout) {
+  return (0, import_node_child_process.spawnSync)("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    ...timeout === void 0 ? {} : { timeout },
+    windowsHide: true
+  });
+}
+function isTransient(r) {
+  const code = r.error?.code;
+  if (code !== void 0 && code !== "ENOENT")
+    return true;
+  return r.signal != null;
+}
+function foldKeyPath(p, platform2 = process.platform) {
+  if (/^[A-Za-z]:\//.test(p))
+    return p.toLowerCase();
+  if (/^\/(?!\/)/.test(p))
+    return p;
+  return platform2 === "win32" ? p.toLowerCase() : p;
+}
+function wslUncToPosix(p) {
+  let s = p.trim();
+  if (/^[\\/]{2}\?[\\/]UNC[\\/]/i.test(s))
+    s = "//" + s.slice(8);
+  else if (/^[\\/]{2}\?[\\/]/.test(s))
+    s = s.slice(4);
+  const m = /^[\\/]{2}(?:wsl\$|wsl\.localhost)[\\/]+([^\\/]+)(?:[\\/]+(.*))?$/i.exec(s);
+  if (!m)
+    return void 0;
+  const rest = (m[2] ?? "").replace(/[\\/]+/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
+  return { distro: m[1], posix: "/" + rest };
+}
+var MAX_RESOLVE_DEPTH = 64;
+function resolveCaseInsensitive(p) {
+  if ((0, import_node_fs5.existsSync)(p))
+    return p;
+  const home = (0, import_node_os3.homedir)();
+  if (!home || home === "/")
+    return void 0;
+  const prefix = home.replace(/\/+$/, "") + "/";
+  if (!p.toLowerCase().startsWith(prefix.toLowerCase()))
+    return void 0;
+  let current = prefix.slice(0, -1);
+  if (!(0, import_node_fs5.existsSync)(current))
+    return void 0;
+  const segments = p.slice(prefix.length).split("/").filter((seg) => seg.length > 0);
+  if (segments.length > MAX_RESOLVE_DEPTH)
+    return void 0;
+  for (const seg of segments) {
+    const exact = current + "/" + seg;
+    if ((0, import_node_fs5.existsSync)(exact)) {
+      current = exact;
+      continue;
+    }
+    let entries;
+    try {
+      entries = (0, import_node_fs5.readdirSync)(current);
+    } catch {
+      return void 0;
+    }
+    const lower = seg.toLowerCase();
+    const hits = entries.filter((e) => e.toLowerCase() === lower);
+    if (hits.length !== 1)
+      return void 0;
+    current = current + "/" + hits[0];
+  }
+  return (0, import_node_fs5.existsSync)(current) ? current : void 0;
+}
+function pathKey(p) {
+  const unc = wslUncToPosix(p);
+  if (unc)
+    return "path:" + unc.posix;
+  return "path:" + foldKeyPath(normalizePath(p));
+}
+var upgradeCache = /* @__PURE__ */ new Map();
+function upgradeLocalPathKey(key) {
+  if (!key.startsWith("path:"))
+    return key;
+  const hit = upgradeCache.get(key);
+  if (hit !== void 0)
+    return hit;
+  const answer = (() => {
+    const raw = key.slice("path:".length);
+    const unc = wslUncToPosix(raw);
+    const p = unc ? unc.posix : raw;
+    if (!/^\/(?!\/)/.test(p))
+      return key;
+    const dir = resolveCaseInsensitive(p);
+    if (dir === void 0)
+      return key;
+    const r = deriveProjectKey(dir);
+    if (r.key && (r.kind === "git" || r.kind === "origin"))
+      return r.key;
+    return key;
+  })();
+  upgradeCache.set(key, answer);
+  return answer;
+}
+function normalizeOrigin(url) {
+  let s = url.trim();
+  if (!s)
+    return void 0;
+  if (/^file:\/\//i.test(s))
+    return void 0;
+  if (/^[A-Za-z]:/.test(s))
+    return void 0;
+  const scheme = /^([A-Za-z][A-Za-z0-9+.-]*:)?\/\//.exec(s);
+  if (scheme) {
+    s = s.slice(scheme[0].length);
+  } else if (s.includes("://")) {
+    return void 0;
+  }
+  const firstSlash = s.indexOf("/");
+  const authEnd = firstSlash < 0 ? s.length : firstSlash;
+  const at = s.lastIndexOf("@", authEnd - 1);
+  if (at >= 0)
+    s = s.slice(at + 1);
+  if (!scheme) {
+    if (s.startsWith("/") || s.startsWith("."))
+      return void 0;
+    const colon = s.indexOf(":");
+    if (colon < 0)
+      return void 0;
+    s = s.slice(0, colon) + "/" + s.slice(colon + 1).replace(/^\/+/, "");
+  }
+  const slash = s.indexOf("/");
+  let host = slash < 0 ? s : s.slice(0, slash);
+  const rest = slash < 0 ? "" : s.slice(slash);
+  const port = /^(.*):(\d+)$/.exec(host);
+  if (port)
+    host = port[1];
+  if (!host)
+    return void 0;
+  s = host + rest;
+  s = s.replace(/\/+$/, "");
+  s = s.replace(/\.git$/i, "");
+  s = s.replace(/\/+$/, "");
+  if (!s.includes("/"))
+    return void 0;
+  return s.toLowerCase();
+}
+function transient() {
+  return { key: void 0, kind: "transient", transientFailure: true };
+}
+function deriveProjectKey(cwd) {
+  const cacheKey = normalizePath(cwd);
+  const hit = cache.get(cacheKey);
+  if (hit)
+    return hit;
+  const result = derive(cwd);
+  if (!result.transientFailure)
+    cache.set(cacheKey, result);
+  return result;
+}
+function derive(cwd) {
+  if (!(0, import_node_fs5.existsSync)(cwd))
+    return { kind: "path", key: pathKey(cwd) };
+  let rev = runGit(cwd, ["rev-parse", "--is-shallow-repository", "--show-toplevel"], GIT_TIMEOUT_MS);
+  if (rev.error?.code === "ENOENT") {
+    return { kind: "path", key: pathKey(cwd), gitMissing: true };
+  }
+  if (isTransient(rev)) {
+    rev = runGit(cwd, ["rev-parse", "--is-shallow-repository", "--show-toplevel"]);
+    if (rev.error?.code === "ENOENT") {
+      return { kind: "path", key: pathKey(cwd), gitMissing: true };
+    }
+    if (isTransient(rev))
+      return transient();
+  }
+  if (rev.status === 128)
+    return { kind: "path", key: pathKey(cwd) };
+  if (rev.status !== 0)
+    return { kind: "path", key: pathKey(cwd) };
+  const lines = (rev.stdout ?? "").split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  const shallow = lines[0] === "true";
+  const toplevel = lines[1];
+  if (!shallow) {
+    const args = ["--no-replace-objects", "rev-list", "--max-parents=0", "--format=%ct %H", "HEAD"];
+    let roots = runGit(cwd, args, GIT_TIMEOUT_MS);
+    if (isTransient(roots)) {
+      roots = runGit(cwd, args);
+      if (isTransient(roots))
+        return transient();
+    }
+    if (roots.status === 0) {
+      const parsed = [];
+      for (const line of (roots.stdout ?? "").split("\n")) {
+        const t = line.trim();
+        if (!t || t.startsWith("commit "))
+          continue;
+        const m = /^(\d+)\s+([0-9a-f]{40})$/.exec(t);
+        if (m)
+          parsed.push({ ct: Number(m[1]), hash: m[2] });
+      }
+      parsed.sort((a, b) => a.ct - b.ct || (a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0));
+      const first = parsed[0];
+      if (first) {
+        return { kind: "git", key: "git:" + first.hash, ...toplevel ? { toplevel } : {} };
+      }
+    }
+  }
+  let origin = runGit(cwd, ["config", "--get", "remote.origin.url"], GIT_TIMEOUT_MS);
+  if (isTransient(origin)) {
+    origin = runGit(cwd, ["config", "--get", "remote.origin.url"]);
+    if (isTransient(origin))
+      return transient();
+  }
+  if (origin.status === 0) {
+    const value = normalizeOrigin(origin.stdout ?? "");
+    if (value)
+      return { kind: "origin", key: "origin:" + value, ...toplevel ? { toplevel } : {} };
+  }
+  return { kind: "path", key: pathKey(toplevel ?? cwd), ...toplevel ? { toplevel } : {} };
+}
+
+// src/recall/mirror-meta.ts
+var import_node_fs6 = require("node:fs");
+var import_node_path6 = require("node:path");
+init_paths();
+function isUnderRemoteRoot(p) {
+  return (0, import_node_path6.resolve)(p).startsWith((0, import_node_path6.resolve)(remoteRoot()) + import_node_path6.sep);
+}
+function readMirrorMeta(transcriptPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs6.readFileSync)(`${transcriptPath}.meta.json`, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object")
+    return null;
+  const m = parsed;
+  if (m["v"] !== 1)
+    return null;
+  if (m["key"] !== void 0 && typeof m["key"] !== "string")
+    return null;
+  if (m["cwd"] !== void 0 && typeof m["cwd"] !== "string")
+    return null;
+  return parsed;
+}
+
 // src/recall/message-ingest.ts
 init_log();
 
@@ -5605,48 +6243,11 @@ function parseJsonlFile(filepath) {
     return entries;
   } catch (error) {
     log({ level: "error", source: "jsonl-reader", summary: `Failed to read JSONL file ${filepath}: ${error instanceof Error ? error.message : String(error)}`, data: { filepath, error: String(error) } });
-    return [];
+    throw error;
   }
 }
 
 // src/adapters/claude/claude-entry-adapter.ts
-function isSystemContextContent(message) {
-  if (!message || message.role !== "user")
-    return false;
-  const content = message.content;
-  let text;
-  if (typeof content === "string") {
-    text = content;
-  } else if (Array.isArray(content)) {
-    const firstText = content.find(
-      (b) => typeof b === "object" && b !== null && b.type === "text"
-    );
-    if (firstText && "text" in firstText) {
-      text = firstText.text;
-    }
-  }
-  if (!text)
-    return false;
-  if (text.startsWith("<system-reminder>"))
-    return true;
-  if (text.startsWith("<environment_context>"))
-    return true;
-  if (text.startsWith("<INSTRUCTIONS>"))
-    return true;
-  if (text.startsWith("# AGENTS.md instructions for"))
-    return true;
-  if (text.startsWith("<context>"))
-    return true;
-  if (text.startsWith("<task-notification>"))
-    return true;
-  if (text.startsWith("<command-name>"))
-    return true;
-  if (text.startsWith("<local-command-stdout>"))
-    return true;
-  if (text.startsWith("<local-command-caveat>"))
-    return true;
-  return false;
-}
 function sanitizeContentBlocks(content) {
   if (typeof content === "string")
     return content;
@@ -5866,15 +6467,17 @@ function emitMessage(payload, base, model, counter) {
   if (role === "developer")
     return [];
   if (role === "user") {
+    const message = {
+      role: "user",
+      content: adaptContentItems(contentItems)
+    };
     return [
       {
         type: "user",
         uuid: generateId(base.sessionId, counter),
         ...base,
-        message: {
-          role: "user",
-          content: adaptContentItems(contentItems)
-        }
+        message,
+        ...isSystemContextContent(message) && { isMeta: true }
       }
     ];
   }
@@ -6351,6 +6954,11 @@ function parseCodexPatch(input) {
       currentKind = "update";
       continue;
     }
+    const moveMatch = line.match(/^\*\*\* Move to:\s*(.+)$/);
+    if (moveMatch && currentKind === "update") {
+      currentPath = moveMatch[1].trim();
+      continue;
+    }
     const addMatch = line.match(/^\*\*\* Add File:\s*(.+)$/);
     if (addMatch) {
       flushCurrent();
@@ -6386,7 +6994,7 @@ function parseCodexPatch(input) {
   return changes;
 }
 function generateId(sessionId, counter) {
-  return `codex-jsonl-${sessionId.slice(0, 8)}-${counter}`;
+  return `codex-jsonl-${sessionId}-${counter}`;
 }
 
 // src/recall/message-ingest.ts
@@ -6395,12 +7003,19 @@ function extractEntryText(entry) {
   if (!msg)
     return "";
   if (typeof msg.content === "string")
-    return msg.content.trim();
+    return msg.content.replaceAll("\0", "").trim();
   if (Array.isArray(msg.content)) {
-    return msg.content.filter((b) => b.type === "text").map((b) => b.text?.trim()).filter(Boolean).join("\n\n");
+    return msg.content.filter((b) => b.type === "text").map((b) => b.text?.replaceAll("\0", "").trim()).filter(Boolean).join("\n\n");
   }
   return "";
 }
+function loadTranscriptEntries(transcriptPath, vendor, canonicalSessionId) {
+  if (vendor === "claude") {
+    const raw = parseJsonlFile(transcriptPath);
+    return adaptClaudeEntries(raw);
+  }
+  return adaptCodexJsonlRecords(parseCodexJsonlFile(transcriptPath), canonicalSessionId);
+}
 function entriesCwd(entries) {
   for (const e of entries) {
     if (e.cwd)
@@ -6441,13 +7056,7 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
   }));
   let rawEntries;
   try {
-    if (vendor === "claude") {
-      const raw = parseJsonlFile(transcriptPath);
-      rawEntries = adaptClaudeEntries(raw);
-    } else {
-      const envelopes = parseCodexJsonlFile(transcriptPath);
-      rawEntries = adaptCodexJsonlRecords(envelopes, canonicalId);
-    }
+    rawEntries = loadTranscriptEntries(transcriptPath, vendor, canonicalId);
   } catch (err) {
     return {
       sessionId: canonicalId,
@@ -6468,11 +7077,22 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
   }
   const rawProjectId = options?.projectId ?? entriesCwd(rawEntries);
   const projectId = rawProjectId ? normalizePath(rawProjectId) : null;
+  const localKey = () => {
+    const k = deriveProjectKey(rawProjectId).key ?? null;
+    return k !== null && wslUncToPosix(rawProjectId) ? upgradeLocalPathKey(k) : k;
+  };
+  const sidecarKey = () => {
+    const k = readMirrorMeta(transcriptPath)?.key;
+    return k === void 0 ? null : upgradeLocalPathKey(k);
+  };
+  const projectKey = rawProjectId ? options?.projectKey !== void 0 ? options.projectKey : isUnderRemoteRoot(transcriptPath) ? sidecarKey() : localKey() : null;
   const filtered = stripToolContent(rawEntries);
   const topLevel = filtered.filter((e) => !e.parentToolUseID);
   const records = [];
   for (let i = 0; i < topLevel.length; i++) {
     const entry = topLevel[i];
+    if (shouldDropAsMeta(entry))
+      continue;
     if (!entry.uuid)
       continue;
     const text = extractEntryText(entry);
@@ -6487,7 +7107,8 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
       project_id: projectId,
       created_at: createdAt,
       message_role: entry.message?.role ?? entry.type ?? null,
-      retrieval_class: retrievalClass
+      retrieval_class: retrievalClass,
+      project_key: projectKey
     });
   }
   if (records.length === 0) {
@@ -6499,11 +7120,19 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
     }
     return { sessionId: canonicalId, chunksCreated: 0, skipped: true, retrievalClass };
   }
+  let inserted = 0;
+  const previouslyIndexed = hasSessionMessages(canonicalId);
   try {
-    insertMessages(records, {
+    inserted = insertMessages(records, {
+      sourceMessageIds: topLevel.flatMap((e) => e.uuid ? [e.uuid] : []),
       ...options?.force ? { replaceSessionId: canonicalId } : {},
       provenance,
-      aliases
+      aliases,
+      // Same identity this chunk's own rows get; back-fills the session's
+      // NULL-identity rows atomically with the insert (M2). Runs on every
+      // ingest path — push, sweep, backfill — so a sweep of a mirror whose
+      // sidecar now carries the key repairs rows without a new push.
+      adopt: { sessionId: canonicalId, projectKey, projectId }
     });
   } catch (err) {
     return {
@@ -6514,9 +7143,13 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
       retrievalClass
     };
   }
+  if (!previouslyIndexed && inserted < records.length) {
+    log({ source: "recall:ingest", level: "warn", summary: `Session ${canonicalId}: ${records.length} records offered, ${inserted} inserted (duplicate message IDs)` });
+  }
   return {
     sessionId: canonicalId,
-    chunksCreated: records.length,
+    chunksCreated: inserted,
+    recordsOffered: records.length,
     skipped: false,
     retrievalClass
   };
@@ -6527,9 +7160,10 @@ var SAFE_EMBED_CHARS = 6e3;
 async function embedRowsResilient(rows) {
   const { embedBatch: embedBatch2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
   const { quantizeToQ8: quantizeToQ82, computeNorm: computeNorm2 } = await Promise.resolve().then(() => (init_quantize(), quantize_exports));
-  rows = rows.map((r) => ({ messageId: r.messageId, text: DOC_PREFIX + r.text }));
+  rows = rows.map((r) => ({ messageId: r.messageId, text: DOC_PREFIX + r.text.replaceAll("\0", "") }));
   const toRecord = (messageId, f32) => {
     const { q8, scale } = quantizeToQ82(f32);
+    recordEmbedSuccess(messageId);
     return { messageId, embeddingQ8: q8, norm: computeNorm2(f32), quantScale: scale };
   };
   try {
@@ -6546,6 +7180,7 @@ async function embedRowsResilient(rows) {
           const [v] = await embedBatch2([r.text.slice(0, SAFE_EMBED_CHARS)]);
           records.push(toRecord(r.messageId, v));
         } catch (err) {
+          recordEmbedFailure(r.messageId, String(err));
           log({
             source: "recall:embed",
             level: "warn",
@@ -6574,8 +7209,11 @@ async function embedSessionMessages(sessionId, force) {
          ORDER BY m.message_seq ASC`,
     force ? [sessionId] : [sessionId, EMBED_VERSION]
   );
+  const exhausted = new Set(force ? [] : exhaustedEmbedMessageIds());
   const validRows = [];
   for (const r of rows) {
+    if (exhausted.has(r.message_id))
+      continue;
     const messageText = r.message_text.trim();
     if (!messageText)
       continue;
@@ -6608,8 +7246,11 @@ async function embedMessageBatch(messages) {
       text: text.length > MAX_EMBED_CHARS ? text.slice(0, MAX_EMBED_CHARS) : text
     });
   }
-  if (truncated.length === 0)
+  if (truncated.length === 0) {
+    for (const m of messages)
+      recordEmbedFailure(m.message_id, "No non-whitespace embedding input");
     return 0;
+  }
   const records = await embedRowsResilient(truncated);
   insertMessageVectors(records);
   return records.length;
@@ -6619,11 +7260,11 @@ async function embedMessageBatch(messages) {
 init_embedder();
 
 // src/recall/embed-lock.ts
-var import_node_fs5 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_fs9 = require("node:fs");
+var import_node_path9 = require("node:path");
 init_paths();
 function embedLockPath() {
-  return (0, import_node_path5.join)(runDir(), "embed.lock");
+  return (0, import_node_path9.join)(runDir(), "embed.lock");
 }
 var STALE_MS = 30 * 60 * 1e3;
 function isAlive(pid) {
@@ -6635,23 +7276,27 @@ function isAlive(pid) {
   }
 }
 function tryAcquireEmbedLock() {
+  try {
+    (0, import_node_fs9.mkdirSync)(runDir(), { recursive: true });
+  } catch {
+  }
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      (0, import_node_fs5.writeFileSync)(embedLockPath(), String(process.pid), { flag: "wx" });
+      (0, import_node_fs9.writeFileSync)(embedLockPath(), String(process.pid), { flag: "wx" });
       return true;
     } catch {
       let heldPid;
       let ageMs;
       try {
-        heldPid = parseInt((0, import_node_fs5.readFileSync)(embedLockPath(), "utf8"), 10);
-        ageMs = Date.now() - (0, import_node_fs5.statSync)(embedLockPath()).mtimeMs;
+        heldPid = parseInt((0, import_node_fs9.readFileSync)(embedLockPath(), "utf8"), 10);
+        ageMs = Date.now() - (0, import_node_fs9.statSync)(embedLockPath()).mtimeMs;
       } catch {
         continue;
       }
       if (isAlive(heldPid) && ageMs < STALE_MS)
         return false;
       try {
-        (0, import_node_fs5.unlinkSync)(embedLockPath());
+        (0, import_node_fs9.unlinkSync)(embedLockPath());
       } catch {
       }
     }
@@ -6660,9 +7305,9 @@ function tryAcquireEmbedLock() {
 }
 function releaseEmbedLock() {
   try {
-    const held = parseInt((0, import_node_fs5.readFileSync)(embedLockPath(), "utf8"), 10);
+    const held = parseInt((0, import_node_fs9.readFileSync)(embedLockPath(), "utf8"), 10);
     if (held === process.pid)
-      (0, import_node_fs5.unlinkSync)(embedLockPath());
+      (0, import_node_fs9.unlinkSync)(embedLockPath());
   } catch {
   }
 }
@@ -7476,8 +8121,8 @@ var path = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
-minimatch.sep = sep;
+var sep2 = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
+minimatch.sep = sep2;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
 var qmark2 = "[^/]";
@@ -8206,7 +8851,7 @@ var import_node_url2 = require("node:url");
 
 // node_modules/lru-cache/dist/esm/index.js
 var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
-var warned = /* @__PURE__ */ new Set();
+var warned2 = /* @__PURE__ */ new Set();
 var PROCESS = typeof process === "object" && !!process ? process : {};
 var emitWarning = (msg, type, code, fn) => {
   typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
@@ -8247,7 +8892,7 @@ if (typeof AC === "undefined") {
     emitWarning("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", warnACPolyfill);
   };
 }
-var shouldWarn = (code) => !warned.has(code);
+var shouldWarn = (code) => !warned2.has(code);
 var TYPE = Symbol("type");
 var isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
 var getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
@@ -8541,7 +9186,7 @@ var LRUCache = class _LRUCache {
     if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
       const code = "LRU_CACHE_UNBOUNDED";
       if (shouldWarn(code)) {
-        warned.add(code);
+        warned2.add(code);
         const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";
         emitWarning(msg, "UnboundedCacheWarning", code, _LRUCache);
       }
@@ -9574,7 +10219,7 @@ var LRUCache = class _LRUCache {
 };
 
 // node_modules/path-scurry/dist/esm/index.js
-var import_node_path6 = require("node:path");
+var import_node_path10 = require("node:path");
 var import_node_url = require("node:url");
 var import_fs = require("fs");
 var actualFS = __toESM(require("node:fs"), 1);
@@ -10309,10 +10954,10 @@ var Minipass = class extends import_node_events.EventEmitter {
    * Return a void Promise that resolves once the stream ends.
    */
   async promise() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       this.on(DESTROYED, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve());
+      this.on("end", () => resolve3());
     });
   }
   /**
@@ -10336,7 +10981,7 @@ var Minipass = class extends import_node_events.EventEmitter {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF])
         return stop();
-      let resolve;
+      let resolve3;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -10350,19 +10995,19 @@ var Minipass = class extends import_node_events.EventEmitter {
         this.off("end", onend);
         this.off(DESTROYED, ondestroy);
         this.pause();
-        resolve({ value, done: !!this[EOF] });
+        resolve3({ value, done: !!this[EOF] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED, ondestroy);
         stop();
-        resolve({ done: true, value: void 0 });
+        resolve3({ done: true, value: void 0 });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve = res2;
+        resolve3 = res2;
         this.once(DESTROYED, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -11334,9 +11979,9 @@ var PathBase = class {
     if (this.#asyncReaddirInFlight) {
       await this.#asyncReaddirInFlight;
     } else {
-      let resolve = () => {
+      let resolve3 = () => {
       };
-      this.#asyncReaddirInFlight = new Promise((res) => resolve = res);
+      this.#asyncReaddirInFlight = new Promise((res) => resolve3 = res);
       try {
         for (const e of await this.#fs.promises.readdir(fullpath, {
           withFileTypes: true
@@ -11349,7 +11994,7 @@ var PathBase = class {
         children.provisional = 0;
       }
       this.#asyncReaddirInFlight = void 0;
-      resolve();
+      resolve3();
     }
     return children.slice(0, children.provisional);
   }
@@ -11483,7 +12128,7 @@ var PathWin32 = class _PathWin32 extends PathBase {
    * @internal
    */
   getRootString(path2) {
-    return import_node_path6.win32.parse(path2).root;
+    return import_node_path10.win32.parse(path2).root;
   }
   /**
    * @internal
@@ -11579,7 +12224,7 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs3 = defaultFS } = {}) {
+  constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs: fs3 = defaultFS } = {}) {
     this.#fs = fsFromOption(fs3);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = (0, import_node_url.fileURLToPath)(cwd);
@@ -11590,7 +12235,7 @@ var PathScurryBase = class {
     this.#resolveCache = new ResolveCache();
     this.#resolvePosixCache = new ResolveCache();
     this.#children = new ChildrenCache(childrenCacheSize);
-    const split = cwdPath.substring(this.rootPath.length).split(sep2);
+    const split = cwdPath.substring(this.rootPath.length).split(sep3);
     if (split.length === 1 && !split[0]) {
       split.pop();
     }
@@ -12123,7 +12768,7 @@ var PathScurryWin32 = class extends PathScurryBase {
   sep = "\\";
   constructor(cwd = process.cwd(), opts = {}) {
     const { nocase = true } = opts;
-    super(cwd, import_node_path6.win32, "\\", { ...opts, nocase });
+    super(cwd, import_node_path10.win32, "\\", { ...opts, nocase });
     this.nocase = nocase;
     for (let p = this.cwd; p; p = p.parent) {
       p.nocase = this.nocase;
@@ -12133,7 +12778,7 @@ var PathScurryWin32 = class extends PathScurryBase {
    * @internal
    */
   parseRootPath(dir) {
-    return import_node_path6.win32.parse(dir).root.toUpperCase();
+    return import_node_path10.win32.parse(dir).root.toUpperCase();
   }
   /**
    * @internal
@@ -12155,7 +12800,7 @@ var PathScurryPosix = class extends PathScurryBase {
   sep = "/";
   constructor(cwd = process.cwd(), opts = {}) {
     const { nocase = false } = opts;
-    super(cwd, import_node_path6.posix, "/", { ...opts, nocase });
+    super(cwd, import_node_path10.posix, "/", { ...opts, nocase });
     this.nocase = nocase;
   }
   /**
@@ -13247,34 +13892,36 @@ var glob = Object.assign(glob_, {
 glob.glob = glob;
 
 // src/recall/mtime-scan.ts
-var import_node_fs6 = require("node:fs");
-var import_node_os3 = require("node:os");
-var import_node_path7 = require("node:path");
+var import_node_fs10 = require("node:fs");
 init_paths();
 init_log();
 async function mtimeScan(opts) {
-  const vendors = opts?.vendors ?? ["claude", "codex"];
-  const claudeRoot = process.env["CLAUDE_CONFIG_DIR"] ?? (0, import_node_path7.join)((0, import_node_os3.homedir)(), ".claude");
-  const codexRoot = process.env["CODEX_HOME"] ?? (0, import_node_path7.join)((0, import_node_os3.homedir)(), ".codex");
   const patterns = [];
-  if (vendors.includes("claude"))
-    patterns.push([transcriptGlob(claudeRoot, "projects", "**", "*.jsonl"), "claude"]);
-  if (vendors.includes("codex"))
-    patterns.push([transcriptGlob(codexRoot, "sessions", "**", "*.jsonl"), "codex"]);
+  if (opts?.roots) {
+    for (const r of opts.roots) {
+      patterns.push([transcriptGlob(r.root, r.vendor === "claude" ? "projects" : "sessions", "**", "*.jsonl"), r.vendor]);
+    }
+  } else {
+    const vendors = opts?.vendors ?? ["claude", "codex"];
+    if (vendors.includes("claude"))
+      patterns.push([transcriptGlob(claudeRoot(), "projects", "**", "*.jsonl"), "claude"]);
+    if (vendors.includes("codex"))
+      patterns.push([transcriptGlob(codexRoot(), "sessions", "**", "*.jsonl"), "codex"]);
+  }
   const db3 = getDb(dbPath());
   const watermarks = /* @__PURE__ */ new Map();
   const rows = db3.all("SELECT * FROM ingest_watermark");
   for (const row of rows) {
     watermarks.set(row.transcript_path, row);
   }
-  const result = { scanned: 0, unchanged: 0, ingested: 0, failed: 0 };
+  const result = { scanned: 0, unchanged: 0, ingested: 0, refused: 0, failed: 0 };
   for (const [pattern, vendor] of patterns) {
     const files = await glob(pattern, { nodir: true });
     for (const file of files) {
       result.scanned++;
       let stat;
       try {
-        stat = (0, import_node_fs6.statSync)(file);
+        stat = (0, import_node_fs10.statSync)(file);
       } catch {
         continue;
       }
@@ -13285,6 +13932,24 @@ async function mtimeScan(opts) {
         continue;
       }
       const sessionId = sessionIdFromPath(file, vendor);
+      if (opts?.guard) {
+        let refusal = null;
+        try {
+          refusal = opts.guard(file, vendor);
+        } catch (e) {
+          refusal = e.message;
+        }
+        if (refusal !== null) {
+          result.refused++;
+          log({
+            level: "debug",
+            source: "recall:mtime-scan",
+            summary: `Ingest refused, watermark not advanced: ${file}`,
+            data: { path: file, vendor, reason: refusal }
+          });
+          continue;
+        }
+      }
       try {
         const ingestResult = await ingestSessionMessages(sessionId, file, vendor);
         if (ingestResult.error) {
@@ -13324,7 +13989,7 @@ var CATCHUP_BATCH_SIZE = 80;
 var MAX_CONSECUTIVE_FAILURES = 3;
 var HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
 (async () => {
-  (0, import_node_fs7.mkdirSync)(runDir(), { recursive: true });
+  (0, import_node_fs11.mkdirSync)(runDir(), { recursive: true });
   const sessionId = process.argv[2];
   if (!tryAcquireEmbedLock())
     process.exit(0);
@@ -13341,7 +14006,7 @@ var HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
   process.on("SIGTERM", onSignal);
   const heartbeat = setInterval(() => {
     try {
-      (0, import_node_fs7.utimesSync)(embedLockPath(), /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+      (0, import_node_fs11.utimesSync)(embedLockPath(), /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
     } catch {
     }
   }, HEARTBEAT_INTERVAL_MS);
@@ -13352,13 +14017,14 @@ var HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
         await embedSessionMessages(sessionId);
       }
       let consecutiveFailures = 0;
-      while (consecutiveFailures < MAX_CONSECUTIVE_FAILURES) {
+      let rounds = 0;
+      while (consecutiveFailures < MAX_CONSECUTIVE_FAILURES && rounds++ < 1e4) {
         const batch = getUnembeddedMessages(CATCHUP_BATCH_SIZE);
         if (batch.length === 0)
           break;
         try {
-          await embedMessageBatch(batch);
-          consecutiveFailures = 0;
+          const embedded = await embedMessageBatch(batch);
+          consecutiveFailures = embedded === 0 ? consecutiveFailures + 1 : 0;
         } catch {
           consecutiveFailures++;
         }
@@ -13368,13 +14034,14 @@ var HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
     const scan = await mtimeScan();
     if (scan.ingested > 0) {
       let consecutiveFailures = 0;
-      while (consecutiveFailures < MAX_CONSECUTIVE_FAILURES) {
+      let rounds = 0;
+      while (consecutiveFailures < MAX_CONSECUTIVE_FAILURES && rounds++ < 1e4) {
         const batch = getUnembeddedMessages(CATCHUP_BATCH_SIZE);
         if (batch.length === 0)
           break;
         try {
-          await embedMessageBatch(batch);
-          consecutiveFailures = 0;
+          const embedded = await embedMessageBatch(batch);
+          consecutiveFailures = embedded === 0 ? consecutiveFailures + 1 : 0;
         } catch {
           consecutiveFailures++;
         }