crispy-recall 0.2.0 → 0.2.1

package/dist/recall.js

@@ -2378,11 +2378,11 @@ var require_extract_zip = __commonJS({
     var { createWriteStream: createWriteStream3, promises: fs5 } = require("fs");
     var getStream = require_get_stream();
     var path4 = require("path");
-    var { promisify: promisify3 } = require("util");
+    var { promisify: promisify4 } = require("util");
     var stream2 = require("stream");
     var yauzl = require_yauzl();
-    var openZip = promisify3(yauzl.open);
-    var pipeline = promisify3(stream2.pipeline);
+    var openZip = promisify4(yauzl.open);
+    var pipeline = promisify4(stream2.pipeline);
     var Extractor = class {
       constructor(zipPath, opts) {
         this.zipPath = zipPath;
@@ -2466,7 +2466,7 @@ var require_extract_zip = __commonJS({
         if (isDir)
           return;
         debug("opening read stream", dest);
-        const readStream = await promisify3(this.zipfile.openReadStream.bind(this.zipfile))(entry);
+        const readStream = await promisify4(this.zipfile.openReadStream.bind(this.zipfile))(entry);
         if (symlink) {
           const link = await getStream(readStream);
           debug("creating symlink", link, dest);
@@ -2584,16 +2584,55 @@ var init_paths = __esm({
   }
 });
 
+// src/installer/stable-node.ts
+function stableNodePath(opts = {}) {
+  const execPath = opts.execPath ?? process.execPath;
+  const platform2 = opts.platform ?? process.platform;
+  if (platform2 !== "darwin")
+    return execPath;
+  const candidates = opts.candidates ?? DEFAULT_CANDIDATES;
+  let realExec;
+  try {
+    realExec = (0, import_node_fs2.realpathSync)(execPath);
+  } catch {
+    return execPath;
+  }
+  for (const candidate of candidates) {
+    try {
+      if ((0, import_node_fs2.existsSync)(candidate) && (0, import_node_fs2.realpathSync)(candidate) === realExec) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return execPath;
+}
+var import_node_fs2, DEFAULT_CANDIDATES;
+var init_stable_node = __esm({
+  "src/installer/stable-node.ts"() {
+    "use strict";
+    import_node_fs2 = require("node:fs");
+    DEFAULT_CANDIDATES = [
+      "/opt/homebrew/bin/node",
+      // Apple Silicon Homebrew
+      "/opt/homebrew/opt/node/bin/node",
+      "/usr/local/bin/node",
+      // Intel Homebrew
+      "/usr/local/opt/node/bin/node"
+    ];
+  }
+});
+
 // src/installer/settings-merge.ts
 function writeFileAtomic(path4, contents) {
   const tmp = `${path4}.tmp.${process.pid}`;
   try {
-    (0, import_node_fs2.writeFileSync)(tmp, contents);
-    (0, import_node_fs2.renameSync)(tmp, path4);
+    (0, import_node_fs3.writeFileSync)(tmp, contents);
+    (0, import_node_fs3.renameSync)(tmp, path4);
   } catch (err) {
     try {
-      if ((0, import_node_fs2.existsSync)(tmp))
-        (0, import_node_fs2.unlinkSync)(tmp);
+      if ((0, import_node_fs3.existsSync)(tmp))
+        (0, import_node_fs3.unlinkSync)(tmp);
     } catch {
     }
     throw err;
@@ -2604,7 +2643,7 @@ function backupStamp() {
 }
 function backupFile(path4) {
   const dest = `${path4}.bak.${backupStamp()}`;
-  (0, import_node_fs2.copyFileSync)(path4, dest);
+  (0, import_node_fs3.copyFileSync)(path4, dest);
   return dest;
 }
 function detectLineEnding(raw2) {
@@ -2653,9 +2692,9 @@ function makeEntry(command) {
   return { matcher: "", hooks: [{ type: "command", command }] };
 }
 function mergeStopHook(filePath, hookScriptPath) {
-  const desiredCommand = `"${process.execPath}" "${hookScriptPath}"`;
-  const exists = (0, import_node_fs2.existsSync)(filePath);
-  const raw2 = exists ? (0, import_node_fs2.readFileSync)(filePath, "utf-8") : null;
+  const desiredCommand = `"${stableNodePath()}" "${hookScriptPath}"`;
+  const exists = (0, import_node_fs3.existsSync)(filePath);
+  const raw2 = exists ? (0, import_node_fs3.readFileSync)(filePath, "utf-8") : null;
   const obj = raw2 && raw2.trim().length > 0 ? parseTolerant(raw2) : {};
   if (!obj.hooks || typeof obj.hooks !== "object")
     obj.hooks = {};
@@ -2681,9 +2720,9 @@ function mergeStopHook(filePath, hookScriptPath) {
   return backup ? { changed: true, backup } : { changed: true };
 }
 function removeStopHook(filePath) {
-  if (!(0, import_node_fs2.existsSync)(filePath))
+  if (!(0, import_node_fs3.existsSync)(filePath))
     return { changed: false };
-  const raw2 = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+  const raw2 = (0, import_node_fs3.readFileSync)(filePath, "utf-8");
   if (raw2.trim().length === 0)
     return { changed: false };
   const obj = parseTolerant(raw2);
@@ -2713,11 +2752,12 @@ function removeStopHook(filePath) {
   writeFileAtomic(filePath, serialize(obj, raw2));
   return { changed: true, backup };
 }
-var import_node_fs2, HOOK_ARRAYS;
+var import_node_fs3, HOOK_ARRAYS;
 var init_settings_merge = __esm({
   "src/installer/settings-merge.ts"() {
     "use strict";
-    import_node_fs2 = require("node:fs");
+    import_node_fs3 = require("node:fs");
+    init_stable_node();
     HOOK_ARRAYS = ["Stop", "SubagentStop"];
   }
 });
@@ -2728,10 +2768,10 @@ function configPath() {
 }
 function readConfig() {
   const p = configPath();
-  if (!(0, import_node_fs3.existsSync)(p))
+  if (!(0, import_node_fs4.existsSync)(p))
     return null;
   try {
-    return JSON.parse((0, import_node_fs3.readFileSync)(p, "utf-8"));
+    return JSON.parse((0, import_node_fs4.readFileSync)(p, "utf-8"));
   } catch (err) {
     log({
       source: "installer/config",
@@ -2743,7 +2783,7 @@ function readConfig() {
 }
 function writeEmbedderConfig(embedder) {
   const p = configPath();
-  (0, import_node_fs3.mkdirSync)((0, import_node_path2.dirname)(p), { recursive: true });
+  (0, import_node_fs4.mkdirSync)((0, import_node_path2.dirname)(p), { recursive: true });
   const existing = readConfig() ?? {};
   const merged = { ...existing, embedder };
   writeFileAtomic(p, JSON.stringify(merged, null, 2) + "\n");
@@ -2760,11 +2800,11 @@ function readEmbedderConfig() {
     return cfg.embedder;
   return { mode: "cpu", ngl: 0, libDir: null, detectedAt: "" };
 }
-var import_node_fs3, import_node_path2;
+var import_node_fs4, import_node_path2;
 var init_config = __esm({
   "src/installer/config.ts"() {
     "use strict";
-    import_node_fs3 = require("node:fs");
+    import_node_fs4 = require("node:fs");
     import_node_path2 = require("node:path");
     init_paths();
     init_log();
@@ -2775,15 +2815,21 @@ var init_config = __esm({
 // src/recall/embedder.ts
 var embedder_exports = {};
 __export(embedder_exports, {
+  LLAMA_RELEASE_TAG: () => LLAMA_RELEASE_TAG,
+  MACOS_MIN_VERSION: () => MACOS_MIN_VERSION,
+  buildUnzipInvocations: () => buildUnzipInvocations,
   disposeEmbedder: () => disposeEmbedder,
   embed: () => embed,
   embedBatch: () => embedBatch,
   ensureBinary: () => ensureBinary,
   ensureModel: () => ensureModel,
+  extractArchive: () => extractArchive,
   getBinaryPath: () => getBinaryPath,
   getModelPath: () => getModelPath,
   hasNvidiaGpu: () => hasNvidiaGpu,
-  initEmbedder: () => initEmbedder
+  initEmbedder: () => initEmbedder,
+  installExtractedBinaries: () => installExtractedBinaries,
+  withTimeout: () => withTimeout
 });
 function gpuRuntime() {
   if (_gpuRuntime === void 0) {
@@ -2860,8 +2906,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_fs5.existsSync)(binPath);
+  const serverNeeded = SERVER_SUPPORTED && !(0, import_node_fs5.existsSync)(serverBinPath);
   if (embeddingExists && !serverNeeded) {
     binaryPath = binPath;
     return binPath;
@@ -2904,11 +2950,11 @@ async function validateBinary(binPath) {
   }
 }
 async function clearBinDir() {
-  if (!(0, import_node_fs4.existsSync)(binDir()))
+  if (!(0, import_node_fs5.existsSync)(binDir()))
     return;
   for (const file of await (0, import_promises.readdir)(binDir())) {
     try {
-      (0, import_node_fs4.unlinkSync)((0, import_node_path3.join)(binDir(), file));
+      (0, import_node_fs5.unlinkSync)((0, import_node_path3.join)(binDir(), file));
     } catch {
     }
   }
@@ -2957,10 +3003,86 @@ async function performBinaryDownload(binPath) {
   }
   throw new Error("No suitable llama-embedding binary found");
 }
+function withTimeout(promise, ms, label) {
+  let timer;
+  const timeout = new Promise((_3, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`${label} timed out after ${Math.round(ms / 1e3)}s`)),
+      ms
+    );
+  });
+  promise.catch(() => {
+  });
+  return Promise.race([promise, timeout]).finally(() => {
+    if (timer)
+      clearTimeout(timer);
+  });
+}
+function psQuote(p) {
+  return p.replace(/'/g, "''");
+}
+function buildUnzipInvocations(plat, archivePath, dir) {
+  if (plat === "win32") {
+    return [{
+      cmd: "powershell",
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Expand-Archive -LiteralPath '${psQuote(archivePath)}' -DestinationPath '${psQuote(dir)}' -Force`
+      ]
+    }];
+  }
+  const unzip = { cmd: "unzip", args: ["-o", "-q", archivePath, "-d", dir] };
+  return plat === "darwin" ? [unzip, { cmd: "ditto", args: ["-x", "-k", archivePath, dir] }] : [unzip];
+}
+async function osUnzip(archivePath, dir) {
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
+  const invocations = buildUnzipInvocations((0, import_node_os2.platform)(), archivePath, dir);
+  let lastErr;
+  for (const { cmd, args } of invocations) {
+    try {
+      await execFileAsync(cmd, args, { timeout: EXTRACT_TIMEOUT_MS, windowsHide: true });
+      return;
+    } catch (err) {
+      lastErr = err;
+    }
+  }
+  throw lastErr instanceof Error ? lastErr : new Error(`Native unzip failed for ${archivePath}`);
+}
+async function extractArchive(archivePath, baseDir, assetName, timeoutMs = EXTRACT_TIMEOUT_MS) {
+  try {
+    await withTimeout((0, import_extract_zip.default)(archivePath, { dir: baseDir }), timeoutMs, `Extracting ${assetName}`);
+    return baseDir;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log({
+      source: "recall-catchup",
+      level: "warn",
+      summary: `Bundled unzip failed for ${assetName} (${msg}); falling back to system unzip`
+    });
+    const fallbackDir = (0, import_node_path3.join)(baseDir, "__os_unzip__");
+    await osUnzip(archivePath, fallbackDir);
+    return fallbackDir;
+  }
+}
+async function installExtractedBinaries(extractedDir, destDir = binDir()) {
+  const buildBinDir = (0, import_node_path3.join)(extractedDir, "build", "bin");
+  const sourceDir = (0, import_node_fs5.existsSync)(buildBinDir) ? buildBinDir : extractedDir;
+  (0, import_node_fs5.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_path3.join)(sourceDir, file), (0, import_node_path3.join)(destDir, file), { force: true });
+    copiedCount++;
+  }
+  return copiedCount;
+}
 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 });
+  (0, import_node_fs5.mkdirSync)(binDir(), { recursive: true });
   const archivePath = (0, import_node_path3.join)(binDir(), assetName);
   const tmpPath = archivePath + ".tmp";
   log({
@@ -2970,56 +3092,46 @@ 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_fs5.existsSync)(tmpPath))
+      (0, import_node_fs5.unlinkSync)(tmpPath);
     await downloadFile(url, tmpPath);
-    (0, import_node_fs4.renameSync)(tmpPath, archivePath);
+    (0, import_node_fs5.renameSync)(tmpPath, archivePath);
     const tmpExtractDir = (0, import_node_path3.join)((0, import_node_os2.tmpdir)(), `llama-extract-${Date.now()}`);
-    (0, import_node_fs4.mkdirSync)(tmpExtractDir, { recursive: true });
+    (0, import_node_fs5.mkdirSync)(tmpExtractDir, { recursive: true });
     try {
-      await (0, import_extract_zip.default)(archivePath, { dir: tmpExtractDir });
-      const buildBinDir = (0, import_node_path3.join)(tmpExtractDir, "build", "bin");
-      const sourceDir = (0, import_node_fs4.existsSync)(buildBinDir) ? buildBinDir : tmpExtractDir;
-      let copiedCount = 0;
-      for (const file of await (0, import_promises.readdir)(sourceDir)) {
-        if (!isWantedFile(file))
-          continue;
-        const src = (0, import_node_path3.join)(sourceDir, file);
-        const dest = (0, import_node_path3.join)(binDir(), file);
-        await (0, import_promises.cp)(src, dest, { force: true });
-        copiedCount++;
-      }
+      const extractedDir = await extractArchive(archivePath, tmpExtractDir, assetName);
+      const copiedCount = await installExtractedBinaries(extractedDir);
       if (copiedCount === 0) {
         throw new Error(`No binaries found in archive ${assetName}`);
       }
     } finally {
       try {
-        (0, import_node_fs4.rmSync)(tmpExtractDir, { recursive: true, force: true });
+        (0, import_node_fs5.rmSync)(tmpExtractDir, { recursive: true, force: true });
       } catch {
       }
     }
-    if ((0, import_node_fs4.existsSync)(archivePath)) {
+    if ((0, import_node_fs5.existsSync)(archivePath)) {
       try {
-        (0, import_node_fs4.unlinkSync)(archivePath);
+        (0, import_node_fs5.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_fs5.existsSync)(binPath))
+        (0, import_node_fs5.chmodSync)(binPath, 493);
       const serverBin = getServerBinaryPath();
-      if ((0, import_node_fs4.existsSync)(serverBin)) {
-        (0, import_node_fs4.chmodSync)(serverBin, 493);
+      if ((0, import_node_fs5.existsSync)(serverBin)) {
+        (0, import_node_fs5.chmodSync)(serverBin, 493);
       }
     }
-    if (!(0, import_node_fs4.existsSync)(binPath)) {
+    if (!(0, import_node_fs5.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_fs5.existsSync)(p)) {
         try {
-          (0, import_node_fs4.unlinkSync)(p);
+          (0, import_node_fs5.unlinkSync)(p);
         } catch {
         }
       }
@@ -3032,8 +3144,8 @@ function getModelPath() {
 }
 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_fs5.existsSync)(modelPath)) {
+    const stat = (0, import_node_fs5.statSync)(modelPath);
     if (stat.size > 1e8)
       return modelPath;
   }
@@ -3049,9 +3161,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_fs5.mkdirSync)(modelsDir(), { recursive: true });
+    if ((0, import_node_fs5.existsSync)(tmpPath)) {
+      (0, import_node_fs5.unlinkSync)(tmpPath);
     }
     log({
       source: "recall-catchup",
@@ -3060,7 +3172,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_fs5.renameSync)(tmpPath, modelPath);
     log({
       source: "recall-catchup",
       level: "info",
@@ -3068,9 +3180,9 @@ async function performModelDownload(modelPath) {
     });
     return modelPath;
   } catch (err) {
-    if ((0, import_node_fs4.existsSync)(tmpPath)) {
+    if ((0, import_node_fs5.existsSync)(tmpPath)) {
       try {
-        (0, import_node_fs4.unlinkSync)(tmpPath);
+        (0, import_node_fs5.unlinkSync)(tmpPath);
       } catch {
       }
     }
@@ -3088,7 +3200,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_fs5.createWriteStream)(destPath);
       const pipeResponse = (response) => {
         if (response.statusCode !== 200) {
           cleanup();
@@ -3158,7 +3270,7 @@ function getPidFilePath() {
   return (0, import_node_path3.join)(runDir(), `llama-embed-${process.pid}.pid`);
 }
 function writePidFile(pid, socketPath) {
-  (0, import_node_fs4.writeFileSync)(getPidFilePath(), JSON.stringify({
+  (0, import_node_fs5.writeFileSync)(getPidFilePath(), JSON.stringify({
     pid,
     socketPath,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3168,20 +3280,20 @@ function writePidFile(pid, socketPath) {
 function cleanupPidAndSocket() {
   for (const f3 of [getPidFilePath(), getSocketPath()]) {
     try {
-      (0, import_node_fs4.unlinkSync)(f3);
+      (0, import_node_fs5.unlinkSync)(f3);
     } catch {
     }
   }
 }
 function cleanupStalePidFiles() {
-  if (!(0, import_node_fs4.existsSync)(runDir()))
+  if (!(0, import_node_fs5.existsSync)(runDir()))
     return;
   try {
-    const files = (0, import_node_fs4.readdirSync)(runDir()).filter((f3) => f3.startsWith("llama-embed-") && f3.endsWith(".pid"));
+    const files = (0, import_node_fs5.readdirSync)(runDir()).filter((f3) => f3.startsWith("llama-embed-") && f3.endsWith(".pid"));
     for (const f3 of files) {
       const pidFile = (0, import_node_path3.join)(runDir(), f3);
       try {
-        const data = JSON.parse((0, import_node_fs4.readFileSync)(pidFile, "utf-8"));
+        const data = JSON.parse((0, import_node_fs5.readFileSync)(pidFile, "utf-8"));
         const ownerPid = data.ownerPid ?? data.pid;
         if (!isProcessAlive(ownerPid)) {
           if (data.pid && isProcessAlive(data.pid)) {
@@ -3191,19 +3303,19 @@ function cleanupStalePidFiles() {
             }
           }
           try {
-            (0, import_node_fs4.unlinkSync)(pidFile);
+            (0, import_node_fs5.unlinkSync)(pidFile);
           } catch {
           }
           if (data.socketPath) {
             try {
-              (0, import_node_fs4.unlinkSync)(data.socketPath);
+              (0, import_node_fs5.unlinkSync)(data.socketPath);
             } catch {
             }
           }
         }
       } catch {
         try {
-          (0, import_node_fs4.unlinkSync)(pidFile);
+          (0, import_node_fs5.unlinkSync)(pidFile);
         } catch {
         }
       }
@@ -3242,14 +3354,14 @@ 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_fs5.existsSync)(serverBin)) {
     throw new Error("llama-server binary not available");
   }
-  (0, import_node_fs4.mkdirSync)(runDir(), { recursive: true });
+  (0, import_node_fs5.mkdirSync)(runDir(), { recursive: true });
   const socket = getSocketPath();
-  if ((0, import_node_fs4.existsSync)(socket)) {
+  if ((0, import_node_fs5.existsSync)(socket)) {
     try {
-      (0, import_node_fs4.unlinkSync)(socket);
+      (0, import_node_fs5.unlinkSync)(socket);
     } catch {
     }
   }
@@ -3612,12 +3724,12 @@ async function embedBatchInner(texts) {
 async function disposeEmbedder() {
   await killServer();
 }
-var import_node_child_process, import_node_fs4, import_promises, import_node_http, import_node_path3, 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, 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, embedQueue, embedRunning, binaryPath, downloadPromise, binaryDownloadPromise, serverProcess, activeSocketPath, idleTimer, serverStartPromise, serverCooldownUntil, serverRetryPromise, activeServerRequests, WANTED_FILES, WANTED_LIB_PATTERNS;
+var import_node_child_process, import_node_fs5, import_promises, import_node_http, import_node_path3, 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 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_fs5 = require("node:fs");
     import_promises = require("node:fs/promises");
     import_node_http = require("node:http");
     import_node_path3 = require("node:path");
@@ -3634,6 +3746,7 @@ var init_embedder = __esm({
     BATCH_SEPARATOR = "<#sep#>";
     MAX_ARG_BYTES = (0, import_node_os2.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";
@@ -3644,6 +3757,7 @@ var init_embedder = __esm({
     HTTP_REQUEST_TIMEOUT_MS = 12e4;
     SERVER_KILL_TIMEOUT_MS = 5e3;
     SERVER_COOLDOWN_MS = 6e4;
+    EXTRACT_TIMEOUT_MS = 12e4;
     embedQueue = [];
     embedRunning = false;
     binaryPath = null;
@@ -4127,9 +4241,9 @@ var require_backup = __commonJS({
     "use strict";
     var fs5 = require("fs");
     var path4 = require("path");
-    var { promisify: promisify3 } = require("util");
+    var { promisify: promisify4 } = require("util");
     var { cppdb } = require_util();
-    var fsAccess = promisify3(fs5.access);
+    var fsAccess = promisify4(fs5.access);
     module2.exports = async function backup(filename, options) {
       if (options == null)
         options = {};
@@ -4591,7 +4705,7 @@ function getDb(dbPath2) {
   if (db) {
     closeDb();
   }
-  (0, import_node_fs5.mkdirSync)((0, import_node_path4.dirname)(dbPath2), { recursive: true });
+  (0, import_node_fs6.mkdirSync)((0, import_node_path4.dirname)(dbPath2), { recursive: true });
   cleanupWasmArtifacts(dbPath2);
   const raw2 = openDatabase(dbPath2);
   try {
@@ -4628,13 +4742,13 @@ function openDatabase(dbPath2) {
 }
 function resolveNativeBinding() {
   const sibling = (0, import_node_path4.join)(__dirname, "better_sqlite3.node");
-  if ((0, import_node_fs5.existsSync)(sibling))
+  if ((0, import_node_fs6.existsSync)(sibling))
     return sibling;
   const resolved = resolveInstalledBinding();
   if (resolved)
     return resolved;
   const staged = (0, import_node_path4.join)(binDir(), "better_sqlite3.node");
-  if ((0, import_node_fs5.existsSync)(staged))
+  if ((0, import_node_fs6.existsSync)(staged))
     return staged;
   return null;
 }
@@ -4652,7 +4766,7 @@ function findNativeBinding(baseDir) {
     (0, import_node_path4.join)(baseDir, "build", "Debug", "better_sqlite3.node")
   ]) {
     try {
-      if ((0, import_node_fs5.statSync)(c).isFile())
+      if ((0, import_node_fs6.statSync)(c).isFile())
         return c;
     } catch {
     }
@@ -4662,7 +4776,7 @@ function findNativeBinding(baseDir) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -4710,12 +4824,12 @@ function configurePragmas(raw2, dbPath2) {
 }
 function cleanupWasmArtifacts(dbPath2) {
   try {
-    (0, import_node_fs5.rmSync)(`${dbPath2}.lock`, { recursive: true, force: true });
+    (0, import_node_fs6.rmSync)(`${dbPath2}.lock`, { recursive: true, force: true });
   } catch {
   }
   try {
-    if ((0, import_node_fs5.existsSync)(`${dbPath2}.owner`))
-      (0, import_node_fs5.unlinkSync)(`${dbPath2}.owner`);
+    if ((0, import_node_fs6.existsSync)(`${dbPath2}.owner`))
+      (0, import_node_fs6.unlinkSync)(`${dbPath2}.owner`);
   } catch {
   }
 }
@@ -4803,11 +4917,11 @@ function ensureSchema(db4) {
     CREATE INDEX IF NOT EXISTS idx_watermark_vendor ON ingest_watermark(vendor);
   `);
 }
-var import_node_fs5, import_node_path4, import_node_module, import_better_sqlite3, BindingLoadError, db, currentDbPath;
+var import_node_fs6, import_node_path4, import_node_module, import_better_sqlite3, BindingLoadError, db, currentDbPath;
 var init_db = __esm({
   "src/db.ts"() {
     "use strict";
-    import_node_fs5 = require("node:fs");
+    import_node_fs6 = require("node:fs");
     import_node_path4 = require("node:path");
     import_node_module = require("node:module");
     init_log();
@@ -4817,7 +4931,10 @@ var init_db = __esm({
       constructor(dbPath2, cause) {
         super(
           `recall: failed to load the better-sqlite3 native binding while opening ${dbPath2}: ${cause.message}
-The binding is ABI-locked to the Node it was built for \u2014 run \`recall doctor\` (usually fixed by re-running \`recall install\`).`
+The native SQLite binding is ABI-locked to the Node it was built for. This is usually one of:
+  \u2022 recall is running under a different Node than the one npm installed it with (e.g. Homebrew node vs nvm) \u2014 reinstall with \`npm install -g crispy-recall\` using the node on your PATH, then \`recall install\`.
+  \u2022 no prebuilt binary matched your Node version and it could not compile \u2014 use Node 22 LTS or 24+ (Node 23 has no prebuilt SQLite binding), and on macOS make sure Xcode Command Line Tools are installed (\`xcode-select --install\`).
+Run \`recall doctor\` for details.`
         );
         this.dbPath = dbPath2;
         this.cause = cause;
@@ -9465,7 +9582,7 @@ var init_esm3 = __esm({
 });
 
 // node_modules/path-scurry/dist/esm/index.js
-var import_node_path5, import_node_url, import_fs, actualFS, import_promises2, realpathSync, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
+var import_node_path5, import_node_url, import_fs, actualFS, import_promises2, realpathSync2, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
 var init_esm4 = __esm({
   "node_modules/path-scurry/dist/esm/index.js"() {
     init_esm2();
@@ -9475,13 +9592,13 @@ var init_esm4 = __esm({
     actualFS = __toESM(require("node:fs"), 1);
     import_promises2 = require("node:fs/promises");
     init_esm3();
-    realpathSync = import_fs.realpathSync.native;
+    realpathSync2 = import_fs.realpathSync.native;
     defaultFS = {
       lstatSync: import_fs.lstatSync,
       readdir: import_fs.readdir,
       readdirSync: import_fs.readdirSync,
       readlinkSync: import_fs.readlinkSync,
-      realpathSync,
+      realpathSync: realpathSync2,
       promises: {
         lstat: import_promises2.lstat,
         readdir: import_promises2.readdir,
@@ -13319,7 +13436,7 @@ async function mtimeScan(opts) {
       result.scanned++;
       let stat;
       try {
-        stat = (0, import_node_fs6.statSync)(file);
+        stat = (0, import_node_fs7.statSync)(file);
       } catch {
         continue;
       }
@@ -13363,12 +13480,12 @@ function sessionIdFromPath(file, vendor) {
   const m2 = base.match(/^rollout-.+-([0-9a-f-]{36})$/i);
   return m2 ? m2[1] : base;
 }
-var import_node_fs6, import_node_os3, import_node_path6;
+var import_node_fs7, import_node_os3, import_node_path6;
 var init_mtime_scan = __esm({
   "src/recall/mtime-scan.ts"() {
     "use strict";
     init_esm5();
-    import_node_fs6 = require("node:fs");
+    import_node_fs7 = require("node:fs");
     import_node_os3 = require("node:os");
     import_node_path6 = require("node:path");
     init_db();
@@ -14155,21 +14272,21 @@ function isAlive(pid) {
 function tryAcquireEmbedLock() {
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      (0, import_node_fs7.writeFileSync)(LOCK_PATH, String(process.pid), { flag: "wx" });
+      (0, import_node_fs8.writeFileSync)(LOCK_PATH, String(process.pid), { flag: "wx" });
       return true;
     } catch {
       let heldPid;
       let ageMs;
       try {
-        heldPid = parseInt((0, import_node_fs7.readFileSync)(LOCK_PATH, "utf8"), 10);
-        ageMs = Date.now() - (0, import_node_fs7.statSync)(LOCK_PATH).mtimeMs;
+        heldPid = parseInt((0, import_node_fs8.readFileSync)(LOCK_PATH, "utf8"), 10);
+        ageMs = Date.now() - (0, import_node_fs8.statSync)(LOCK_PATH).mtimeMs;
       } catch {
         continue;
       }
       if (isAlive(heldPid) && ageMs < STALE_MS)
         return false;
       try {
-        (0, import_node_fs7.unlinkSync)(LOCK_PATH);
+        (0, import_node_fs8.unlinkSync)(LOCK_PATH);
       } catch {
       }
     }
@@ -14178,17 +14295,17 @@ function tryAcquireEmbedLock() {
 }
 function releaseEmbedLock() {
   try {
-    const held = parseInt((0, import_node_fs7.readFileSync)(LOCK_PATH, "utf8"), 10);
+    const held = parseInt((0, import_node_fs8.readFileSync)(LOCK_PATH, "utf8"), 10);
     if (held === process.pid)
-      (0, import_node_fs7.unlinkSync)(LOCK_PATH);
+      (0, import_node_fs8.unlinkSync)(LOCK_PATH);
   } catch {
   }
 }
-var import_node_fs7, import_node_path8, LOCK_PATH, STALE_MS;
+var import_node_fs8, import_node_path8, LOCK_PATH, STALE_MS;
 var init_embed_lock = __esm({
   "src/recall/embed-lock.ts"() {
     "use strict";
-    import_node_fs7 = require("node:fs");
+    import_node_fs8 = require("node:fs");
     import_node_path8 = require("node:path");
     init_paths();
     LOCK_PATH = (0, import_node_path8.join)(runDir(), "embed.lock");
@@ -14244,7 +14361,7 @@ function clearCancelFlag() {
 function startLockHeartbeat(lockPath) {
   const t = setInterval(() => {
     try {
-      (0, import_node_fs8.utimesSync)(lockPath, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+      (0, import_node_fs9.utimesSync)(lockPath, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
     } catch {
     }
   }, 5 * 60 * 1e3);
@@ -14264,7 +14381,7 @@ async function runFts5Catchup(opts) {
       continue;
     if (alreadyIndexed.has(s.sessionId))
       continue;
-    if (!(0, import_node_fs8.existsSync)(s.path))
+    if (!(0, import_node_fs9.existsSync)(s.path))
       continue;
     try {
       const result = await ingestSessionMessages(s.sessionId, s.path, s.vendor);
@@ -14457,11 +14574,11 @@ async function startRecallCatchup(opts = {}) {
     running = false;
   }
 }
-var import_node_fs8, import_node_os5, SILENT_EMBED_THRESHOLD, FREE_MEM_FLOOR_MB, SECONDS_PER_MESSAGE, CATCHUP_BATCH_SIZE, MAX_CONSECUTIVE_FAILURES, status, cancelRequested, running;
+var import_node_fs9, import_node_os5, SILENT_EMBED_THRESHOLD, FREE_MEM_FLOOR_MB, SECONDS_PER_MESSAGE, CATCHUP_BATCH_SIZE, MAX_CONSECUTIVE_FAILURES, status, cancelRequested, running;
 var init_catchup = __esm({
   "src/recall/catchup.ts"() {
     "use strict";
-    import_node_fs8 = require("node:fs");
+    import_node_fs9 = require("node:fs");
     import_node_os5 = require("node:os");
     init_dist2();
     init_session_manager_shim();
@@ -14495,7 +14612,7 @@ function cudaAssetUrl() {
   let version = "";
   try {
     const pkgPath = (0, import_node_path9.join)(__dirname, "..", "package.json");
-    const pkg = JSON.parse((0, import_node_fs9.readFileSync)(pkgPath, "utf8"));
+    const pkg = JSON.parse((0, import_node_fs10.readFileSync)(pkgPath, "utf8"));
     version = typeof pkg.version === "string" ? pkg.version : "";
     const repoUrl = typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url;
     const m2 = repoUrl?.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
@@ -14541,7 +14658,7 @@ async function detectGpu(opts = {}) {
   if (p === "win32" && a3 === "x64") {
     return { ...base, cudaAvailable: "prebuilt", plannedMode: "gpu" };
   }
-  if (p === "linux" && a3 === "x64" && (0, import_node_fs9.existsSync)(cudaBackendLib())) {
+  if (p === "linux" && a3 === "x64" && (0, import_node_fs10.existsSync)(cudaBackendLib())) {
     return { ...base, cudaAvailable: "reuse-existing", plannedMode: "gpu" };
   }
   if (p === "linux" && a3 === "x64") {
@@ -14676,16 +14793,16 @@ async function runGpuPhase(opts = {}) {
 async function defaultStage(args) {
   const target = binDir();
   const libPath = cudaBackendLib();
-  if ((0, import_node_fs9.existsSync)(libPath))
+  if ((0, import_node_fs10.existsSync)(libPath))
     return target;
   if (args.offline)
     return null;
   try {
-    (0, import_node_fs9.mkdirSync)(target, { recursive: true });
+    (0, import_node_fs10.mkdirSync)(target, { recursive: true });
     const zipPath = (0, import_node_path9.join)((0, import_node_os6.tmpdir)(), CUDA_ASSET_NAME);
     await downloadFile2(CUDA_ASSET_URL, zipPath);
     await (0, import_extract_zip2.default)(zipPath, { dir: target });
-    return (0, import_node_fs9.existsSync)(libPath) ? target : null;
+    return (0, import_node_fs10.existsSync)(libPath) ? target : null;
   } catch (err) {
     log({ source: "installer/gpu", level: "info", summary: `prebuilt CUDA staging failed: ${err.message}` });
     return null;
@@ -14708,7 +14825,7 @@ function downloadFile2(url, destPath) {
         done(new Error(`HTTP ${status2}`));
         return;
       }
-      const file = (0, import_node_fs9.createWriteStream)(destPath);
+      const file = (0, import_node_fs10.createWriteStream)(destPath);
       res.pipe(file);
       file.on("finish", () => file.close(() => done()));
       file.on("error", done);
@@ -14716,12 +14833,12 @@ function downloadFile2(url, destPath) {
     (0, import_node_https.get)(url, { headers: { "User-Agent": "recall" } }, pipeTo).on("error", done);
   });
 }
-var import_node_child_process3, import_node_fs9, import_node_path9, import_node_util2, import_node_os6, import_node_https, import_extract_zip2, execFileAsync2, EXPECTED_DIMS2, OFFLOAD_TIMEOUT_MS, DEFAULT_NGL, CUDA_ASSET_NAME, CUDA_ASSET_URL, STAGE_DOWNLOAD_TIMEOUT_MS;
+var import_node_child_process3, import_node_fs10, import_node_path9, import_node_util2, import_node_os6, import_node_https, import_extract_zip2, execFileAsync2, EXPECTED_DIMS2, OFFLOAD_TIMEOUT_MS, DEFAULT_NGL, CUDA_ASSET_NAME, CUDA_ASSET_URL, STAGE_DOWNLOAD_TIMEOUT_MS;
 var init_gpu = __esm({
   "src/installer/gpu.ts"() {
     "use strict";
     import_node_child_process3 = require("node:child_process");
-    import_node_fs9 = require("node:fs");
+    import_node_fs10 = require("node:fs");
     import_node_path9 = require("node:path");
     import_node_util2 = require("node:util");
     import_node_os6 = require("node:os");
@@ -14776,7 +14893,7 @@ function installLockPath() {
 }
 function readLockBody() {
   try {
-    return JSON.parse((0, import_node_fs10.readFileSync)(installLockPath(), "utf-8"));
+    return JSON.parse((0, import_node_fs11.readFileSync)(installLockPath(), "utf-8"));
   } catch {
     return null;
   }
@@ -14790,17 +14907,17 @@ function pidAlive(pid) {
   }
 }
 function acquireInstallLock() {
-  (0, import_node_fs10.mkdirSync)(runDir(), { recursive: true });
+  (0, import_node_fs11.mkdirSync)(runDir(), { recursive: true });
   const body = JSON.stringify({ pid: process.pid, ts: Date.now() });
   try {
-    (0, import_node_fs10.writeFileSync)(installLockPath(), body, { flag: "wx" });
+    (0, import_node_fs11.writeFileSync)(installLockPath(), body, { flag: "wx" });
     return { ok: true, tookOver: false };
   } catch {
     const existing = readLockBody();
     if (existing && pidAlive(existing.pid) && Date.now() - existing.ts < STALE_LOCK_MS) {
       return { ok: false, tookOver: false, existingPid: existing.pid };
     }
-    (0, import_node_fs10.writeFileSync)(installLockPath(), body);
+    (0, import_node_fs11.writeFileSync)(installLockPath(), body);
     return { ok: true, tookOver: true, ...existing ? { existingPid: existing.pid } : {} };
   }
 }
@@ -14808,7 +14925,7 @@ function releaseInstallLock() {
   try {
     const existing = readLockBody();
     if (existing && existing.pid === process.pid) {
-      (0, import_node_fs10.unlinkSync)(installLockPath());
+      (0, import_node_fs11.unlinkSync)(installLockPath());
     }
   } catch {
   }
@@ -14817,14 +14934,14 @@ function detectWsl() {
   if (process.env["WSL_DISTRO_NAME"])
     return true;
   try {
-    return /microsoft/i.test((0, import_node_fs10.readFileSync)("/proc/version", "utf-8"));
+    return /microsoft/i.test((0, import_node_fs11.readFileSync)("/proc/version", "utf-8"));
   } catch {
     return false;
   }
 }
 function canWrite(path4) {
   try {
-    (0, import_node_fs10.accessSync)(path4, import_node_fs10.constants.W_OK);
+    (0, import_node_fs11.accessSync)(path4, import_node_fs11.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -14844,7 +14961,7 @@ function checkPlatform(report, opts) {
       remediation: "recall supports Linux x64/arm64, macOS x64/arm64, Windows x64."
     });
   }
-  if (isWsl && (0, import_node_fs10.existsSync)((0, import_node_path10.join)((0, import_node_os7.homedir)(), ".claude")) && process.env["CLAUDE_CONFIG_DIR"] === void 0) {
+  if (isWsl && (0, import_node_fs11.existsSync)((0, import_node_path10.join)((0, import_node_os7.homedir)(), ".claude")) && process.env["CLAUDE_CONFIG_DIR"] === void 0) {
     report.warnings.push({
       check: "platform.wsl",
       severity: "WARN",
@@ -14852,6 +14969,51 @@ function checkPlatform(report, opts) {
     });
   }
 }
+async function readMacosProductVersion() {
+  try {
+    const { stdout } = await execFileAsync3("sw_vers", ["-productVersion"], { timeout: 5e3, windowsHide: true });
+    const v2 = stdout.trim();
+    return v2.length > 0 ? v2 : null;
+  } catch {
+    return null;
+  }
+}
+function compareMajorMinor(a3, b3) {
+  const pa = a3.split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b3.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 2; i++) {
+    const da = pa[i] ?? 0;
+    const db4 = pb[i] ?? 0;
+    if (da !== db4)
+      return da - db4;
+  }
+  return 0;
+}
+async function checkMacosFloor(report, opts) {
+  const os3 = opts.platform ?? (0, import_node_os7.platform)();
+  if (os3 !== "darwin")
+    return;
+  const a3 = opts.arch ?? (0, import_node_os7.arch)();
+  const { MACOS_MIN_VERSION: MACOS_MIN_VERSION2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
+  const floor = a3 === "arm64" ? MACOS_MIN_VERSION2.arm64 : MACOS_MIN_VERSION2.x64;
+  const version = opts.macosProductVersion ? await opts.macosProductVersion() : await readMacosProductVersion();
+  if (!version) {
+    report.warnings.push({
+      check: "platform.macos-version",
+      severity: "WARN",
+      message: "Could not determine the macOS version (sw_vers unavailable) \u2014 skipping the minimum-OS check for the bundled llama.cpp binaries."
+    });
+    return;
+  }
+  if (compareMajorMinor(version, floor) < 0) {
+    report.failures.push({
+      check: "platform.macos-version",
+      severity: "FAIL",
+      message: `macOS ${version} is below the minimum for recall's bundled llama.cpp binaries (needs ${MACOS_MIN_VERSION2.arm64}+ on Apple Silicon, ${MACOS_MIN_VERSION2.x64}+ on Intel). Semantic embedding cannot run.`,
+      remediation: `Upgrade macOS to ${floor} or newer to install recall.`
+    });
+  }
+}
 function checkClaude(report) {
   const dir = claudeDir();
   const settings = claudeSettingsPath();
@@ -14861,7 +15023,7 @@ function checkClaude(report) {
   let ok = true;
   let status2 = "ready";
   let existingHooks = 0;
-  if (!(0, import_node_fs10.existsSync)(dir)) {
+  if (!(0, import_node_fs11.existsSync)(dir)) {
     ok = false;
     status2 = "missing";
     report.failures.push({
@@ -14870,12 +15032,12 @@ function checkClaude(report) {
       message: `~/.claude not found at ${dir}`,
       remediation: "Install Claude Code first, or set CLAUDE_CONFIG_DIR."
     });
-    report.claude = { ok, status: status2, paths, existingHooks, existingInstall: (0, import_node_fs10.existsSync)(recallRoot()) };
+    report.claude = { ok, status: status2, paths, existingHooks, existingInstall: (0, import_node_fs11.existsSync)(recallRoot()) };
     return;
   }
-  if ((0, import_node_fs10.existsSync)(settings)) {
+  if ((0, import_node_fs11.existsSync)(settings)) {
     try {
-      const parsed = JSON.parse((0, import_node_fs10.readFileSync)(settings, "utf-8"));
+      const parsed = JSON.parse((0, import_node_fs11.readFileSync)(settings, "utf-8"));
       const stop = parsed?.hooks?.Stop;
       const subStop = parsed?.hooks?.SubagentStop;
       existingHooks = (Array.isArray(stop) ? stop.length : 0) + (Array.isArray(subStop) ? subStop.length : 0);
@@ -14889,17 +15051,17 @@ function checkClaude(report) {
     status2 = "fresh";
     report.warnings.push({ check: "claude.settings", severity: "WARN", message: "No settings.json \u2014 will create one." });
   }
-  if (!(0, import_node_fs10.existsSync)(skills)) {
+  if (!(0, import_node_fs11.existsSync)(skills)) {
     report.warnings.push({ check: "claude.skills", severity: "WARN", message: "skills/ absent \u2014 will create it." });
   }
-  if ((0, import_node_fs10.existsSync)(skillFile)) {
+  if ((0, import_node_fs11.existsSync)(skillFile)) {
     report.warnings.push({ check: "claude.recall-skill", severity: "WARN", message: "recall skill present \u2014 will back up + overwrite." });
   }
-  report.claude = { ok, status: status2, paths, existingHooks, existingInstall: (0, import_node_fs10.existsSync)(recallRoot()) };
+  report.claude = { ok, status: status2, paths, existingHooks, existingInstall: (0, import_node_fs11.existsSync)(recallRoot()) };
 }
 function checkCodex(report) {
   const dir = codexDir();
-  if (!(0, import_node_fs10.existsSync)(dir)) {
+  if (!(0, import_node_fs11.existsSync)(dir)) {
     report.codex = null;
     return;
   }
@@ -14910,8 +15072,8 @@ function checkCodex(report) {
 }
 function checkDisk() {
   try {
-    const base = (0, import_node_fs10.existsSync)(recallRoot()) ? recallRoot() : (0, import_node_os7.homedir)();
-    const st = (0, import_node_fs10.statfsSync)(base);
+    const base = (0, import_node_fs11.existsSync)(recallRoot()) ? recallRoot() : (0, import_node_os7.homedir)();
+    const st = (0, import_node_fs11.statfsSync)(base);
     const freeBytes = Number(st.bavail) * Number(st.bsize);
     const freeMb = Math.floor(freeBytes / (1024 * 1024));
     const disk = `${freeMb} MB free`;
@@ -14955,8 +15117,8 @@ function httpReachable(url, timeoutMs) {
 async function checkNetwork(offline) {
   if (offline) {
     const { getBinaryPath: getBinaryPath2, getModelPath: getModelPath2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
-    const haveBin = (0, import_node_fs10.existsSync)(getBinaryPath2());
-    const haveModel = (0, import_node_fs10.existsSync)(getModelPath2());
+    const haveBin = (0, import_node_fs11.existsSync)(getBinaryPath2());
+    const haveModel = (0, import_node_fs11.existsSync)(getModelPath2());
     if (haveBin && haveModel)
       return { network: "offline (pre-staged binary + model present)" };
     if (haveBin || haveModel)
@@ -14981,6 +15143,7 @@ async function runPreflight(opts = {}) {
     failures: []
   };
   checkPlatform(report, opts);
+  await checkMacosFloor(report, opts);
   checkClaude(report);
   checkCodex(report);
   const node = checkNode();
@@ -15012,16 +15175,19 @@ async function runPreflight(opts = {}) {
 function preflightPassed(report) {
   return report.failures.length === 0;
 }
-var import_node_fs10, import_node_os7, import_node_path10, import_node_https2, STALE_LOCK_MS;
+var import_node_fs11, import_node_os7, import_node_path10, import_node_https2, import_node_child_process4, import_node_util3, execFileAsync3, STALE_LOCK_MS;
 var init_preflight = __esm({
   "src/installer/preflight.ts"() {
     "use strict";
-    import_node_fs10 = require("node:fs");
+    import_node_fs11 = require("node:fs");
     import_node_os7 = require("node:os");
     import_node_path10 = require("node:path");
     import_node_https2 = require("node:https");
+    import_node_child_process4 = require("node:child_process");
+    import_node_util3 = require("node:util");
     init_paths();
     init_gpu();
+    execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
     STALE_LOCK_MS = 60 * 60 * 1e3;
   }
 });
@@ -15130,7 +15296,7 @@ var init_manifest = __esm({
 function openReadonly(dbFile) {
   const staged = (0, import_node_path11.join)(binDir(), "better_sqlite3.node");
   try {
-    return (0, import_node_fs11.existsSync)(staged) ? new import_better_sqlite32.default(dbFile, { readonly: true, fileMustExist: true, nativeBinding: staged }) : new import_better_sqlite32.default(dbFile, { readonly: true, fileMustExist: true });
+    return (0, import_node_fs12.existsSync)(staged) ? new import_better_sqlite32.default(dbFile, { readonly: true, fileMustExist: true, nativeBinding: staged }) : new import_better_sqlite32.default(dbFile, { readonly: true, fileMustExist: true });
   } catch {
     try {
       return new import_better_sqlite32.default(dbFile, { readonly: true, fileMustExist: true });
@@ -15141,10 +15307,10 @@ function openReadonly(dbFile) {
 }
 function classifyUpgrade() {
   const dbFile = dbPath();
-  if (!(0, import_node_fs11.existsSync)(dbFile)) {
+  if (!(0, import_node_fs12.existsSync)(dbFile)) {
     return { state: "fresh", journalMode: null, markerPresent: false, coverage: 1 };
   }
-  const markerPresent = (0, import_node_fs11.existsSync)((0, import_node_path11.join)(binDir(), ".binding-info.json"));
+  const markerPresent = (0, import_node_fs12.existsSync)((0, import_node_path11.join)(binDir(), ".binding-info.json"));
   let journalMode = null;
   let coverage = 1;
   const raw2 = openReadonly(dbFile);
@@ -15176,14 +15342,14 @@ function classifyUpgrade() {
 }
 function snapshotDb() {
   const dbFile = dbPath();
-  if (!(0, import_node_fs11.existsSync)(dbFile))
+  if (!(0, import_node_fs12.existsSync)(dbFile))
     return null;
   const dest = `${dbFile}.pre-upgrade-${backupStamp()}`;
   try {
-    (0, import_node_fs11.copyFileSync)(dbFile, dest);
+    (0, import_node_fs12.copyFileSync)(dbFile, dest);
     const journal = `${dbFile}-journal`;
-    if ((0, import_node_fs11.existsSync)(journal))
-      (0, import_node_fs11.copyFileSync)(journal, `${dest}-journal`);
+    if ((0, import_node_fs12.existsSync)(journal))
+      (0, import_node_fs12.copyFileSync)(journal, `${dest}-journal`);
     return dest;
   } catch (e2) {
     log({ source: "installer/upgrade", level: "warn", summary: `pre-upgrade snapshot failed: ${e2.message}` });
@@ -15223,10 +15389,10 @@ function handleIntegrity() {
 }
 function backfillAlreadyRunning() {
   const pidFile = (0, import_node_path11.join)(runDir(), "backfill.pid");
-  if (!(0, import_node_fs11.existsSync)(pidFile))
+  if (!(0, import_node_fs12.existsSync)(pidFile))
     return false;
   try {
-    const pid = parseInt((0, import_node_fs11.readFileSync)(pidFile, "utf-8").trim(), 10);
+    const pid = parseInt((0, import_node_fs12.readFileSync)(pidFile, "utf-8").trim(), 10);
     if (Number.isNaN(pid))
       return false;
     process.kill(pid, 0);
@@ -15241,11 +15407,11 @@ function migrationReportLine(coverage) {
   const pct = Math.round(coverage * 100);
   return `Embed migration: re-embedding in background (${pct}% at v${EMBED_VERSION}) \u2014 semantic search stays available`;
 }
-var import_node_fs11, import_node_path11, import_better_sqlite32;
+var import_node_fs12, import_node_path11, import_better_sqlite32;
 var init_upgrade_migrate = __esm({
   "src/installer/upgrade-migrate.ts"() {
     "use strict";
-    import_node_fs11 = require("node:fs");
+    import_node_fs12 = require("node:fs");
     import_node_path11 = require("node:path");
     import_better_sqlite32 = __toESM(require_lib());
     init_db();
@@ -15258,8 +15424,8 @@ var init_upgrade_migrate = __esm({
 
 // src/installer/claudemd-nudge.ts
 function applyNudge(filePath) {
-  const exists = (0, import_node_fs12.existsSync)(filePath);
-  const raw2 = exists ? (0, import_node_fs12.readFileSync)(filePath, "utf-8") : "";
+  const exists = (0, import_node_fs13.existsSync)(filePath);
+  const raw2 = exists ? (0, import_node_fs13.readFileSync)(filePath, "utf-8") : "";
   if (RECALL_HEADING.test(raw2))
     return { changed: false };
   const ending = raw2.includes("\r\n") ? "\r\n" : "\n";
@@ -15273,9 +15439,9 @@ function applyNudge(filePath) {
   return backup ? { changed: true, backup } : { changed: true };
 }
 function removeNudge(filePath) {
-  if (!(0, import_node_fs12.existsSync)(filePath))
+  if (!(0, import_node_fs13.existsSync)(filePath))
     return { changed: false };
-  const raw2 = (0, import_node_fs12.readFileSync)(filePath, "utf-8");
+  const raw2 = (0, import_node_fs13.readFileSync)(filePath, "utf-8");
   if (!RECALL_HEADING.test(raw2))
     return { changed: false };
   const ending = raw2.includes("\r\n") ? "\r\n" : "\n";
@@ -15303,11 +15469,11 @@ function removeNudge(filePath) {
   writeFileAtomic(filePath, next);
   return { changed: true, backup };
 }
-var import_node_fs12, RECALL_BLOCK, RECALL_HEADING;
+var import_node_fs13, RECALL_BLOCK, RECALL_HEADING;
 var init_claudemd_nudge = __esm({
   "src/installer/claudemd-nudge.ts"() {
     "use strict";
-    import_node_fs12 = require("node:fs");
+    import_node_fs13 = require("node:fs");
     init_settings_merge();
     RECALL_BLOCK = [
       "",
@@ -15325,13 +15491,14 @@ var init_claudemd_nudge = __esm({
 var install_exports = {};
 __export(install_exports, {
   defaultDistDir: () => defaultDistDir,
+  probeStagedBinding: () => probeStagedBinding,
   runInstall: () => runInstall
 });
 function defaultDistDir() {
   const argv1 = process.argv[1];
   if (argv1) {
     try {
-      return (0, import_node_path12.dirname)((0, import_node_fs13.realpathSync)(argv1));
+      return (0, import_node_path12.dirname)((0, import_node_fs14.realpathSync)(argv1));
     } catch {
       return (0, import_node_path12.dirname)(argv1);
     }
@@ -15339,7 +15506,7 @@ function defaultDistDir() {
   return __dirname;
 }
 function resolveTemplatePath(explicit) {
-  if (explicit && (0, import_node_fs13.existsSync)(explicit))
+  if (explicit && (0, import_node_fs14.existsSync)(explicit))
     return explicit;
   const here = __dirname;
   const candidates = [
@@ -15351,44 +15518,44 @@ function resolveTemplatePath(explicit) {
     // source: src/installer/
   ];
   for (const c of candidates)
-    if ((0, import_node_fs13.existsSync)(c))
+    if ((0, import_node_fs14.existsSync)(c))
       return c;
   return candidates[candidates.length - 1];
 }
 function recallBinCommand() {
-  return `"${process.execPath}" "${(0, import_node_path12.join)(binDir(), "recall.js")}"`;
+  return `"${stableNodePath()}" "${(0, import_node_path12.join)(binDir(), "recall.js")}"`;
 }
 function writeSkill(targetPath, templatePath, runnable) {
-  const template = (0, import_node_fs13.readFileSync)(templatePath, "utf-8");
+  const template = (0, import_node_fs14.readFileSync)(templatePath, "utf-8");
   const body = template.replaceAll("$RECALL_BIN", runnable);
-  (0, import_node_fs13.mkdirSync)((0, import_node_path12.dirname)(targetPath), { recursive: true });
-  if ((0, import_node_fs13.existsSync)(targetPath)) {
-    if ((0, import_node_fs13.readFileSync)(targetPath, "utf-8") === body)
+  (0, import_node_fs14.mkdirSync)((0, import_node_path12.dirname)(targetPath), { recursive: true });
+  if ((0, import_node_fs14.existsSync)(targetPath)) {
+    if ((0, import_node_fs14.readFileSync)(targetPath, "utf-8") === body)
       return false;
     backupFile(targetPath);
   }
-  (0, import_node_fs13.writeFileSync)(targetPath, body);
+  (0, import_node_fs14.writeFileSync)(targetPath, body);
   return true;
 }
 function stageBundles(distDir, written) {
-  (0, import_node_fs13.mkdirSync)(binDir(), { recursive: true });
+  (0, import_node_fs14.mkdirSync)(binDir(), { recursive: true });
   for (const name of STAGED_BUNDLES) {
     const src = (0, import_node_path12.join)(distDir, name);
-    if (!(0, import_node_fs13.existsSync)(src)) {
+    if (!(0, import_node_fs14.existsSync)(src)) {
       log({ source: "installer/install", level: "warn", summary: `bundle ${name} not found in ${distDir} \u2014 skipping stage` });
       continue;
     }
     const dest = (0, import_node_path12.join)(binDir(), name);
-    (0, import_node_fs13.copyFileSync)(src, dest);
+    (0, import_node_fs14.copyFileSync)(src, dest);
     written.push(dest);
   }
-  stageNativeBinding(written);
+  return stageNativeBinding(written);
 }
 function stageNativeBinding(written) {
   const staleWasm = (0, import_node_path12.join)(binDir(), "node-sqlite3-wasm.wasm");
-  if ((0, import_node_fs13.existsSync)(staleWasm)) {
+  if ((0, import_node_fs14.existsSync)(staleWasm)) {
     try {
-      (0, import_node_fs13.unlinkSync)(staleWasm);
+      (0, import_node_fs14.unlinkSync)(staleWasm);
     } catch {
     }
   }
@@ -15399,26 +15566,45 @@ function stageNativeBinding(written) {
       level: "warn",
       summary: "better_sqlite3.node not found in node_modules \u2014 the CLI/hooks will fail to load SQLite until reinstalled"
     });
-    return;
+    return { ok: true };
   }
   const dest = (0, import_node_path12.join)(binDir(), "better_sqlite3.node");
-  (0, import_node_fs13.copyFileSync)(binding, dest);
+  (0, import_node_fs14.copyFileSync)(binding, dest);
   written.push(dest);
+  const probe = probeStagedBinding(dest);
+  if (!probe.ok) {
+    const remediation = isBindingLoadError({ message: probe.message }) ? `The SQLite binding npm installed was built for a different Node than the one running recall (${process.execPath}, ${process.version}). This usually means \`npm install -g\` ran under a different Node (e.g. Homebrew vs nvm). Re-run \`npm install -g crispy-recall\` using the same node that is on your PATH, then \`recall install\`. (${probe.message})` : `The staged SQLite binding could not be loaded (${probe.message}). Re-run \`npm install -g crispy-recall\` with the node that is on your PATH, then \`recall install\`.`;
+    return { ok: false, remediation };
+  }
   const markerPath = (0, import_node_path12.join)(binDir(), ".binding-info.json");
-  (0, import_node_fs13.writeFileSync)(
+  (0, import_node_fs14.writeFileSync)(
     markerPath,
     JSON.stringify(
       {
         platform: process.platform,
         arch: process.arch,
         nodeModuleVersion: process.versions.modules,
-        nodePath: process.execPath
+        // Upgrade-stable public path, not the Cellar path brew upgrade deletes;
+        // doctor's pinnedNodeOk checks existsSync(nodePath), which this satisfies.
+        nodePath: stableNodePath()
       },
       null,
       2
     )
   );
   written.push(markerPath);
+  return { ok: true };
+}
+function probeStagedBinding(dest) {
+  const res = (0, import_node_child_process5.spawnSync)(process.execPath, ["-e", "require(process.argv[1])", dest], {
+    encoding: "utf-8",
+    timeout: 2e4,
+    windowsHide: true
+  });
+  if (res.status === 0)
+    return { ok: true };
+  const message = (res.stderr || res.stdout || "").trim() || (res.error ? res.error.message : `binding probe exited with code ${res.status}`);
+  return { ok: false, message };
 }
 function resolveInstalledBinding2() {
   try {
@@ -15434,7 +15620,7 @@ function findDotNode(baseDir) {
     (0, import_node_path12.join)(baseDir, "build", "Debug", "better_sqlite3.node")
   ]) {
     try {
-      if ((0, import_node_fs13.statSync)(c).isFile())
+      if ((0, import_node_fs14.statSync)(c).isFile())
         return c;
     } catch {
     }
@@ -15444,7 +15630,7 @@ function findDotNode(baseDir) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -15530,12 +15716,27 @@ ${wmsg}` });
       say("upgrade: quiesced stale Stop hook before migration");
     }
     for (const d3 of [binDir(), modelsDir(), runDir(), logsDir()])
-      (0, import_node_fs13.mkdirSync)(d3, { recursive: true });
-    stageBundles(opts.distDir ?? defaultDistDir(), filesWritten);
+      (0, import_node_fs14.mkdirSync)(d3, { recursive: true });
+    const staged = stageBundles(opts.distDir ?? defaultDistDir(), filesWritten);
+    if (!staged.ok) {
+      if (interactive)
+        le(staged.remediation, "Install aborted");
+      else
+        log({ source: "installer/install", level: "error", summary: `install aborted: ${staged.remediation}` });
+      return {
+        aborted: true,
+        abortReason: staged.remediation,
+        report,
+        selected: [...selected],
+        gpu,
+        filesWritten,
+        migration: { state: migration.state, coverage: migration.coverage, drainLaunched: false }
+      };
+    }
     say(`scaffolded ${recallRoot()}`);
     if (opts.offline) {
-      const haveBin = (0, import_node_fs13.existsSync)(getBinaryPath());
-      const haveModel = (0, import_node_fs13.existsSync)(getModelPath());
+      const haveBin = (0, import_node_fs14.existsSync)(getBinaryPath());
+      const haveModel = (0, import_node_fs14.existsSync)(getModelPath());
       if (!haveBin || !haveModel) {
         const msg = `--offline but runtime not pre-staged (binary=${haveBin}, model=${haveModel}). Pre-stage ~/.recall/bin + model (or drop --offline), then re-run \`recall install\`` + (migration.state === "needs-migration" ? " (which restores the recall Stop hook)." : ".");
         log({ source: "installer/install", level: "error", summary: msg });
@@ -15716,29 +15917,29 @@ ${wmsg}` });
   };
 }
 function spawnDetachedBackfill() {
-  (0, import_node_fs13.mkdirSync)(runDir(), { recursive: true });
-  (0, import_node_fs13.mkdirSync)(logsDir(), { recursive: true });
+  (0, import_node_fs14.mkdirSync)(runDir(), { recursive: true });
+  (0, import_node_fs14.mkdirSync)(logsDir(), { recursive: true });
   const recallBundle = (0, import_node_path12.join)(binDir(), "recall.js");
-  const logFd = (0, import_node_fs13.openSync)((0, import_node_path12.join)(logsDir(), "backfill.log"), "a");
-  const child = (0, import_node_child_process4.spawn)(process.execPath, [recallBundle, "backfill", "--auto-embed"], {
+  const logFd = (0, import_node_fs14.openSync)((0, import_node_path12.join)(logsDir(), "backfill.log"), "a");
+  const child = (0, import_node_child_process5.spawn)(process.execPath, [recallBundle, "backfill", "--auto-embed"], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     windowsHide: true,
     env: { ...process.env }
   });
   if (child.pid !== void 0) {
-    (0, import_node_fs13.writeFileSync)((0, import_node_path12.join)(runDir(), "backfill.pid"), String(child.pid));
+    (0, import_node_fs14.writeFileSync)((0, import_node_path12.join)(runDir(), "backfill.pid"), String(child.pid));
   }
   child.unref();
   return child.pid;
 }
-var import_node_fs13, import_node_child_process4, import_node_module2, import_node_path12, STAGED_BUNDLES;
+var import_node_fs14, import_node_child_process5, import_node_module2, import_node_path12, STAGED_BUNDLES;
 var init_install = __esm({
   "src/installer/install.ts"() {
     "use strict";
     init_dist2();
-    import_node_fs13 = require("node:fs");
-    import_node_child_process4 = require("node:child_process");
+    import_node_fs14 = require("node:fs");
+    import_node_child_process5 = require("node:child_process");
     import_node_module2 = require("node:module");
     import_node_path12 = require("node:path");
     init_paths();
@@ -15748,6 +15949,7 @@ var init_install = __esm({
     init_manifest();
     init_gpu();
     init_settings_merge();
+    init_stable_node();
     init_upgrade_migrate();
     init_claudemd_nudge();
     init_embedder();
@@ -15765,8 +15967,8 @@ function runUninstall(opts = {}) {
   const removed = [];
   for (const skillFile of [claudeRecallSkillPath(), codexRecallSkillPath()]) {
     const dir = (0, import_node_path13.dirname)(skillFile);
-    if ((0, import_node_fs14.existsSync)(dir)) {
-      (0, import_node_fs14.rmSync)(dir, { recursive: true, force: true });
+    if ((0, import_node_fs15.existsSync)(dir)) {
+      (0, import_node_fs15.rmSync)(dir, { recursive: true, force: true });
       removed.push(dir);
     }
   }
@@ -15781,8 +15983,8 @@ function runUninstall(opts = {}) {
   let purged = false;
   if (opts.purge) {
     closeDb();
-    if ((0, import_node_fs14.existsSync)(recallRoot())) {
-      (0, import_node_fs14.rmSync)(recallRoot(), { recursive: true, force: true });
+    if ((0, import_node_fs15.existsSync)(recallRoot())) {
+      (0, import_node_fs15.rmSync)(recallRoot(), { recursive: true, force: true });
       removed.push(recallRoot());
     }
     purged = true;
@@ -15790,11 +15992,11 @@ function runUninstall(opts = {}) {
   log({ source: "installer/uninstall", level: "info", summary: `uninstall removed ${removed.length} targets (purge=${purged})` });
   return { removed, purged };
 }
-var import_node_fs14, import_node_path13;
+var import_node_fs15, import_node_path13;
 var init_uninstall = __esm({
   "src/installer/uninstall.ts"() {
     "use strict";
-    import_node_fs14 = require("node:fs");
+    import_node_fs15 = require("node:fs");
     import_node_path13 = require("node:path");
     init_settings_merge();
     init_claudemd_nudge();
@@ -15816,14 +16018,14 @@ function getStatus() {
   const messageCount = d3.get("SELECT COUNT(*) AS c FROM messages").c;
   const lastRow = d3.get("SELECT MAX(created_at) AS m FROM messages");
   const lastIngest = lastRow.m ? new Date(lastRow.m).toISOString() : null;
-  const dbSizeBytes = (0, import_node_fs15.existsSync)(dbPath()) ? (0, import_node_fs15.statSync)(dbPath()).size : 0;
+  const dbSizeBytes = (0, import_node_fs16.existsSync)(dbPath()) ? (0, import_node_fs16.statSync)(dbPath()).size : 0;
   const embeddingGap = getEmbeddingGapStats();
   const embedVersions = getEmbedVersionStats();
   let backfillPid = null;
   let backfillRunning = false;
   const pidFile = (0, import_node_path14.join)(runDir(), "backfill.pid");
-  if ((0, import_node_fs15.existsSync)(pidFile)) {
-    const pid = parseInt((0, import_node_fs15.readFileSync)(pidFile, "utf-8").trim(), 10);
+  if ((0, import_node_fs16.existsSync)(pidFile)) {
+    const pid = parseInt((0, import_node_fs16.readFileSync)(pidFile, "utf-8").trim(), 10);
     if (!Number.isNaN(pid)) {
       backfillPid = pid;
       try {
@@ -15866,11 +16068,11 @@ function printStatus(json) {
   console.log(`Embedder:      ${s.embedder.toUpperCase()}`);
   console.log(`Backfill:      ${s.backfillPid === null ? "none recorded" : `PID ${s.backfillPid} (${s.backfillRunning ? "running" : "finished"})`}`);
 }
-var import_node_fs15, import_node_path14;
+var import_node_fs16, import_node_path14;
 var init_status = __esm({
   "src/installer/status.ts"() {
     "use strict";
-    import_node_fs15 = require("node:fs");
+    import_node_fs16 = require("node:fs");
     import_node_path14 = require("node:path");
     init_db();
     init_paths();
@@ -15983,7 +16185,7 @@ function stagedBindingPath() {
 }
 function checkBindingHealth() {
   const problems = [];
-  const installed = (0, import_node_fs16.existsSync)((0, import_node_path15.join)(binDir(), "recall.js"));
+  const installed = (0, import_node_fs17.existsSync)((0, import_node_path15.join)(binDir(), "recall.js"));
   if (!installed) {
     return {
       installed: false,
@@ -15997,21 +16199,21 @@ function checkBindingHealth() {
     };
   }
   const markerPath = (0, import_node_path15.join)(binDir(), ".binding-info.json");
-  const markerPresent = (0, import_node_fs16.existsSync)(markerPath);
+  const markerPresent = (0, import_node_fs17.existsSync)(markerPath);
   let abiOk = null;
   let pinnedNodeOk = null;
   if (!markerPresent) {
     problems.push("no .binding-info.json marker \u2014 pre-migration (wasm-era) install; run `recall install`");
   } else {
     try {
-      const marker = JSON.parse((0, import_node_fs16.readFileSync)(markerPath, "utf-8"));
+      const marker = JSON.parse((0, import_node_fs17.readFileSync)(markerPath, "utf-8"));
       abiOk = String(marker.nodeModuleVersion) === String(process.versions.modules);
       if (!abiOk) {
         problems.push(
           `binding ABI mismatch (staged for NODE_MODULE_VERSION ${marker.nodeModuleVersion}, current ${process.versions.modules}) \u2014 run \`recall install\``
         );
       }
-      pinnedNodeOk = !!marker.nodePath && (0, import_node_fs16.existsSync)(marker.nodePath);
+      pinnedNodeOk = !!marker.nodePath && (0, import_node_fs17.existsSync)(marker.nodePath);
       if (!pinnedNodeOk) {
         problems.push(`pinned Node path missing (${marker.nodePath ?? "unset"}) \u2014 run \`recall install\``);
       }
@@ -16024,9 +16226,9 @@ function checkBindingHealth() {
   let embedCoverage = null;
   const localBinding = stagedBindingPath();
   const dbFile = dbPath();
-  if ((0, import_node_fs16.existsSync)(dbFile)) {
+  if ((0, import_node_fs17.existsSync)(dbFile)) {
     try {
-      const raw2 = (0, import_node_fs16.existsSync)(localBinding) ? new import_better_sqlite33.default(dbFile, { readonly: true, fileMustExist: true, nativeBinding: localBinding }) : new import_better_sqlite33.default(dbFile, { readonly: true, fileMustExist: true });
+      const raw2 = (0, import_node_fs17.existsSync)(localBinding) ? new import_better_sqlite33.default(dbFile, { readonly: true, fileMustExist: true, nativeBinding: localBinding }) : new import_better_sqlite33.default(dbFile, { readonly: true, fileMustExist: true });
       bindingLoads = true;
       journalMode = String(raw2.pragma("journal_mode", { simple: true }));
       try {
@@ -16056,7 +16258,7 @@ function checkBindingHealth() {
     }
   } else {
     try {
-      const raw2 = (0, import_node_fs16.existsSync)(localBinding) ? new import_better_sqlite33.default(":memory:", { nativeBinding: localBinding }) : new import_better_sqlite33.default(":memory:");
+      const raw2 = (0, import_node_fs17.existsSync)(localBinding) ? new import_better_sqlite33.default(":memory:", { nativeBinding: localBinding }) : new import_better_sqlite33.default(":memory:");
       bindingLoads = true;
       raw2.close();
     } catch (e2) {
@@ -16130,11 +16332,11 @@ function printTable(report, embedderMode, fallbackReason) {
   if (!report.warnings.length && !report.failures.length)
     console.log("\nAll checks passed.");
 }
-var import_node_fs16, import_node_path15, import_better_sqlite33;
+var import_node_fs17, import_node_path15, import_better_sqlite33;
 var init_doctor = __esm({
   "src/installer/doctor.ts"() {
     "use strict";
-    import_node_fs16 = require("node:fs");
+    import_node_fs17 = require("node:fs");
     import_node_path15 = require("node:path");
     import_better_sqlite33 = __toESM(require_lib());
     init_preflight();
@@ -16738,8 +16940,8 @@ function gitSafe(repoRoot, args) {
 }
 
 // src/cli/recall.ts
-var import_node_fs17 = require("node:fs");
-var import_node_child_process5 = require("node:child_process");
+var import_node_fs18 = require("node:fs");
+var import_node_child_process6 = require("node:child_process");
 var import_node_path16 = require("node:path");
 var UUID_PREFIX = /^[0-9a-f]{8}/i;
 var argv = process.argv.slice(2);
@@ -16830,7 +17032,7 @@ for (let i = 0; i < argv.length; i++) {
 function getVersion() {
   try {
     const pkg = JSON.parse(
-      (0, import_node_fs17.readFileSync)((0, import_node_path16.join)(__dirname, "..", "package.json"), "utf8")
+      (0, import_node_fs18.readFileSync)((0, import_node_path16.join)(__dirname, "..", "package.json"), "utf8")
     );
     return pkg.version ?? "unknown";
   } catch {
@@ -17406,22 +17608,22 @@ async function runBackfill() {
   clearCancelFlag();
   const detach = hasFlag("--detach");
   if (detach) {
-    (0, import_node_fs17.mkdirSync)(logsDir(), { recursive: true });
-    (0, import_node_fs17.mkdirSync)(runDir(), { recursive: true });
+    (0, import_node_fs18.mkdirSync)(logsDir(), { recursive: true });
+    (0, import_node_fs18.mkdirSync)(runDir(), { recursive: true });
     const logPath = (0, import_node_path16.join)(logsDir(), "backfill.log");
-    const logFd = (0, import_node_fs17.openSync)(logPath, "a");
+    const logFd = (0, import_node_fs18.openSync)(logPath, "a");
     const args = [process.argv[1], "backfill", "--auto-embed"];
     const vendors2 = parseVendors();
     if (vendors2) {
       args.push("--vendor", vendors2[0]);
     }
-    const child = (0, import_node_child_process5.spawn)(process.execPath, args, {
+    const child = (0, import_node_child_process6.spawn)(process.execPath, args, {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       windowsHide: true
     });
     if (child.pid !== void 0) {
-      (0, import_node_fs17.writeFileSync)((0, import_node_path16.join)(runDir(), "backfill.pid"), String(child.pid));
+      (0, import_node_fs18.writeFileSync)((0, import_node_path16.join)(runDir(), "backfill.pid"), String(child.pid));
     }
     child.unref();
     process.stderr.write(`[recall] backfill detached (pid=${child.pid}, log=${logPath})