crispy-recall 0.2.0 → 0.3.0

package/dist/embed-pending.js

@@ -158,21 +158,21 @@ var require_file_uri_to_path = __commonJS({
       var rest = decodeURI(uri.substring(7));
       var firstSlash = rest.indexOf("/");
       var host = rest.substring(0, firstSlash);
-      var path3 = rest.substring(firstSlash + 1);
+      var path2 = rest.substring(firstSlash + 1);
       if ("localhost" == host)
         host = "";
       if (host) {
         host = sep2 + sep2 + host;
       }
-      path3 = path3.replace(/^(.+)\|/, "$1:");
+      path2 = path2.replace(/^(.+)\|/, "$1:");
       if (sep2 == "\\") {
-        path3 = path3.replace(/\//g, "\\");
+        path2 = path2.replace(/\//g, "\\");
       }
-      if (/^.+\:/.test(path3)) {
+      if (/^.+\:/.test(path2)) {
       } else {
-        path3 = sep2 + path3;
+        path2 = sep2 + path2;
       }
-      return host + path3;
+      return host + path2;
     }
   }
 });
@@ -181,18 +181,18 @@ var require_file_uri_to_path = __commonJS({
 var require_bindings = __commonJS({
   "node_modules/bindings/bindings.js"(exports2, module2) {
     var fs3 = require("fs");
-    var path3 = require("path");
+    var path2 = require("path");
     var fileURLToPath3 = require_file_uri_to_path();
-    var join8 = path3.join;
-    var dirname3 = path3.dirname;
-    var exists = fs3.accessSync && function(path4) {
+    var join7 = path2.join;
+    var dirname3 = path2.dirname;
+    var exists = fs3.accessSync && function(path3) {
       try {
-        fs3.accessSync(path4);
+        fs3.accessSync(path3);
       } catch (e) {
         return false;
       }
       return true;
-    } || fs3.existsSync || path3.existsSync;
+    } || fs3.existsSync || path2.existsSync;
     var defaults2 = {
       arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
       compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
@@ -238,13 +238,13 @@ var require_bindings = __commonJS({
       if (!opts.module_root) {
         opts.module_root = exports2.getRoot(exports2.getFileName());
       }
-      if (path3.extname(opts.bindings) != ".node") {
+      if (path2.extname(opts.bindings) != ".node") {
         opts.bindings += ".node";
       }
       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 = join8.apply(
+        n = join7.apply(
           null,
           opts.try[i].map(function(p) {
             return opts[p] || p;
@@ -305,7 +305,7 @@ var require_bindings = __commonJS({
         if (dir === ".") {
           dir = process.cwd();
         }
-        if (exists(join8(dir, "package.json")) || exists(join8(dir, "node_modules"))) {
+        if (exists(join7(dir, "package.json")) || exists(join7(dir, "node_modules"))) {
           return dir;
         }
         if (prev === dir) {
@@ -314,7 +314,7 @@ var require_bindings = __commonJS({
           );
         }
         prev = dir;
-        dir = join8(dir, "..");
+        dir = join7(dir, "..");
       }
     };
   }
@@ -482,7 +482,7 @@ var require_backup = __commonJS({
   "node_modules/better-sqlite3/lib/methods/backup.js"(exports2, module2) {
     "use strict";
     var fs3 = require("fs");
-    var path3 = require("path");
+    var path2 = require("path");
     var { promisify: promisify2 } = require("util");
     var { cppdb } = require_util();
     var fsAccess = promisify2(fs3.access);
@@ -506,7 +506,7 @@ var require_backup = __commonJS({
         throw new TypeError('The "attached" option cannot be an empty string');
       if (handler != null && typeof handler !== "function")
         throw new TypeError('Expected the "progress" option to be a function');
-      await fsAccess(path3.dirname(filename)).catch(() => {
+      await fsAccess(path2.dirname(filename)).catch(() => {
         throw new TypeError("Cannot save backup because the directory does not exist");
       });
       const isNewFile = await fsAccess(filename).then(() => false, () => true);
@@ -837,7 +837,7 @@ var require_database = __commonJS({
   "node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
     "use strict";
     var fs3 = require("fs");
-    var path3 = require("path");
+    var path2 = require("path");
     var util = require_util();
     var SqliteError = require_sqlite_error();
     var DEFAULT_ADDON;
@@ -884,7 +884,7 @@ var require_database = __commonJS({
         addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
       } else if (typeof nativeBinding === "string") {
         const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : require;
-        addon = requireFunc(path3.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+        addon = requireFunc(path2.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
       } else {
         addon = nativeBinding;
       }
@@ -892,7 +892,7 @@ var require_database = __commonJS({
         addon.setErrorConstructor(SqliteError);
         addon.isInitialized = true;
       }
-      if (!anonymous && !filename.startsWith("file:") && !fs3.existsSync(path3.dirname(filename))) {
+      if (!anonymous && !filename.startsWith("file:") && !fs3.existsSync(path2.dirname(filename))) {
         throw new TypeError("Cannot open database because the directory does not exist");
       }
       Object.defineProperties(this, {
@@ -2648,7 +2648,7 @@ var require_yauzl = __commonJS({
     exports2.ZipFile = ZipFile;
     exports2.Entry = Entry;
     exports2.RandomAccessReader = RandomAccessReader;
-    function open(path3, options, callback) {
+    function open(path2, options, callback) {
       if (typeof options === "function") {
         callback = options;
         options = null;
@@ -2667,7 +2667,7 @@ var require_yauzl = __commonJS({
         options.strictFileNames = false;
       if (callback == null)
         callback = defaultCallback;
-      fs3.open(path3, "r", function(err, fd) {
+      fs3.open(path2, "r", function(err, fd) {
         if (err)
           return callback(err);
         fromFd(fd, options, function(err2, zipfile) {
@@ -3334,7 +3334,7 @@ var require_extract_zip = __commonJS({
     var debug = require_src()("extract-zip");
     var { createWriteStream: createWriteStream2, promises: fs3 } = require("fs");
     var getStream = require_get_stream();
-    var path3 = require("path");
+    var path2 = require("path");
     var { promisify: promisify2 } = require("util");
     var stream2 = require("stream");
     var yauzl = require_yauzl();
@@ -3371,12 +3371,12 @@ var require_extract_zip = __commonJS({
               this.zipfile.readEntry();
               return;
             }
-            const destDir = path3.dirname(path3.join(this.opts.dir, entry.fileName));
+            const destDir = path2.dirname(path2.join(this.opts.dir, entry.fileName));
             try {
               await fs3.mkdir(destDir, { recursive: true });
               const canonicalDestDir = await fs3.realpath(destDir);
-              const relativeDestDir = path3.relative(this.opts.dir, canonicalDestDir);
-              if (relativeDestDir.split(path3.sep).includes("..")) {
+              const relativeDestDir = path2.relative(this.opts.dir, canonicalDestDir);
+              if (relativeDestDir.split(path2.sep).includes("..")) {
                 throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
               }
               await this.extractEntry(entry);
@@ -3398,7 +3398,7 @@ var require_extract_zip = __commonJS({
         if (this.opts.onEntry) {
           this.opts.onEntry(entry, this.zipfile);
         }
-        const dest = path3.join(this.opts.dir, entry.fileName);
+        const dest = path2.join(this.opts.dir, entry.fileName);
         const mode = entry.externalFileAttributes >> 16 & 65535;
         const IFMT2 = 61440;
         const IFDIR2 = 16384;
@@ -3413,7 +3413,7 @@ var require_extract_zip = __commonJS({
           isDir = madeBy === 0 && entry.externalFileAttributes === 16;
         debug("extracting entry", { filename: entry.fileName, isDir, isSymlink: symlink });
         const procMode = this.getExtractedMode(mode, isDir) & 511;
-        const destDir = isDir ? dest : path3.dirname(dest);
+        const destDir = isDir ? dest : path2.dirname(dest);
         const mkdirOptions = { recursive: true };
         if (isDir) {
           mkdirOptions.mode = procMode;
@@ -3456,7 +3456,7 @@ var require_extract_zip = __commonJS({
     };
     module2.exports = async function(zipPath, opts) {
       debug("creating target directory", opts.dir);
-      if (!path3.isAbsolute(opts.dir)) {
+      if (!path2.isAbsolute(opts.dir)) {
         throw new Error("Target directory is expected to be absolute");
       }
       await fs3.mkdir(opts.dir, { recursive: true });
@@ -3466,10 +3466,20 @@ var require_extract_zip = __commonJS({
   }
 });
 
+// src/installer/stable-node.ts
+var init_stable_node = __esm({
+  "src/installer/stable-node.ts"() {
+    "use strict";
+  }
+});
+
 // src/installer/settings-merge.ts
 var init_settings_merge = __esm({
   "src/installer/settings-merge.ts"() {
     "use strict";
+    init_stable_node();
+    init_config();
+    init_paths();
   }
 });
 
@@ -3513,15 +3523,22 @@ 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,
+  embedBatchOneShot: () => embedBatchOneShot,
   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) {
@@ -3695,6 +3712,82 @@ async function performBinaryDownload(binPath) {
   }
   throw new Error("No suitable llama-embedding binary found");
 }
+function withTimeout(promise, ms, label) {
+  let timer;
+  const timeout = new Promise((_, 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_fs4.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_path4.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 });
+  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 });
+    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");
@@ -3715,18 +3808,8 @@ async function downloadAndExtract(assetName, binPath) {
     const tmpExtractDir = (0, import_node_path4.join)((0, import_node_os2.tmpdir)(), `llama-extract-${Date.now()}`);
     (0, import_node_fs4.mkdirSync)(tmpExtractDir, { recursive: true });
     try {
-      await (0, import_extract_zip.default)(archivePath, { dir: tmpExtractDir });
-      const buildBinDir = (0, import_node_path4.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_path4.join)(sourceDir, file);
-        const dest = (0, import_node_path4.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}`);
       }
@@ -4147,13 +4230,13 @@ async function retryServer() {
     serverRetryPromise = null;
   }
 }
-function httpPost(socketPath, path3, body, timeoutMs) {
+function httpPost(socketPath, path2, body, timeoutMs) {
   return new Promise((resolve, reject) => {
     const data = JSON.stringify(body);
     const req = (0, import_node_http.request)(
       {
         socketPath,
-        path: path3,
+        path: path2,
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -4206,7 +4289,7 @@ async function embedViaHttp(socketPath, texts) {
     return new Float32Array(item.embedding);
   });
 }
-async function embedViaProcess(texts, modelPath) {
+async function embedViaProcess(texts, modelPath, opts) {
   if (!binaryPath)
     throw new Error("llama-embedding binary not available");
   const sanitized = texts.map((t) => t.replaceAll(BATCH_SEPARATOR, " "));
@@ -4255,7 +4338,8 @@ async function embedViaProcess(texts, modelPath) {
     }
     const { stdout, stderr } = await execFileAsync(binaryPath, args, {
       maxBuffer: 2 * 1024 * 1024,
-      env
+      env,
+      ...opts?.timeoutMs ? { timeout: opts.timeoutMs, killSignal: "SIGKILL" } : {}
     });
     if (stderr) {
       log({
@@ -4297,6 +4381,19 @@ async function embedBatch(texts) {
     return [];
   return withEmbedMutex(() => embedBatchInner(texts));
 }
+async function embedBatchOneShot(texts, opts) {
+  if (texts.length === 0)
+    return [];
+  return withEmbedMutex(async () => {
+    if (!binaryPath) {
+      await ensureBinary();
+    }
+    if (!binaryPath)
+      throw new Error("llama-embedding binary not available");
+    const modelPath = await ensureModel();
+    return embedViaProcess(texts, modelPath, opts);
+  });
+}
 async function embedBatchInner(texts) {
   if (!binaryPath) {
     await ensureBinary();
@@ -4350,7 +4447,7 @@ 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, 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_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 init_embedder = __esm({
   "src/recall/embedder.ts"() {
     "use strict";
@@ -4372,6 +4469,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";
@@ -4382,6 +4480,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;
@@ -4681,13 +4780,25 @@ var BindingLoadError = class extends Error {
   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;
     this.name = "BindingLoadError";
   }
 };
+var MigrationPendingError = class extends Error {
+  constructor(dbPath2) {
+    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.)"
+    );
+    this.dbPath = dbPath2;
+    this.name = "MigrationPendingError";
+  }
+};
 function isBindingLoadError(e) {
   if (!e || typeof e !== "object")
     return false;
@@ -4702,7 +4813,7 @@ function isBindingLoadError(e) {
 }
 var db = null;
 var currentDbPath = null;
-function getDb(dbPath2) {
+function getDb(dbPath2, opts) {
   if (db && currentDbPath === dbPath2)
     return db;
   if (db) {
@@ -4717,12 +4828,45 @@ function getDb(dbPath2) {
     raw.close();
     throw e;
   }
-  db = createAdapter(raw);
+  const adapter = createAdapter(raw);
+  if (isRetrievalMigrationPending(adapter)) {
+    if (!opts?.allowPendingMigration) {
+      raw.close();
+      throw new MigrationPendingError(dbPath2);
+    }
+    db = adapter;
+    currentDbPath = dbPath2;
+    log({ source: "db", level: "info", summary: `DB: opened pending-migration DB at ${dbPath2} (installer mode)` });
+    return db;
+  }
+  db = adapter;
   currentDbPath = dbPath2;
   ensureSchema(db);
   log({ source: "db", level: "info", summary: `DB: initialized at ${dbPath2}` });
   return db;
 }
+var RETRIEVAL_MIGRATION_KEY = "retrieval_class_migration";
+function isRetrievalMigrationPending(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 = ?`,
+      [RETRIEVAL_MIGRATION_KEY]
+    );
+    return row?.value !== "complete";
+  } catch {
+    return true;
+  }
+}
 function closeDb() {
   if (db) {
     db.close();
@@ -4833,16 +4977,18 @@ function cleanupWasmArtifacts(dbPath2) {
   } catch {
   }
 }
-function ensureSchema(db3) {
-  db3.exec(`
+var RETRIEVAL_SCHEMA_DDL = {
+  /** messages + provenance tables + indexes (no FTS objects). */
+  tables: `
     CREATE TABLE IF NOT EXISTS messages (
-      message_id    TEXT PRIMARY KEY,
-      session_id    TEXT NOT NULL,
-      message_seq   INTEGER NOT NULL,
-      message_text  TEXT NOT NULL,
-      project_id    TEXT,
-      created_at    INTEGER NOT NULL,
-      message_role  TEXT,
+      message_id      TEXT PRIMARY KEY,
+      session_id      TEXT NOT NULL,
+      message_seq     INTEGER NOT NULL,
+      message_text    TEXT NOT NULL,
+      project_id      TEXT,
+      created_at      INTEGER NOT NULL,
+      message_role    TEXT,
+      retrieval_class TEXT NOT NULL DEFAULT 'hot',
       UNIQUE(session_id, message_id)
     );
 
@@ -4854,68 +5000,134 @@ function ensureSchema(db3) {
     -- embed drain and every Stop-hook catch-up. This index serves the ORDER BY so
     -- the planner walks it and early-terminates at LIMIT instead.
     CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at);
-  `);
-  db3.exec(`
+
+    -- session_provenance \u2014 durable per-session classification evidence:
+    -- canonical id, vendor, root-vs-agent kind, parent thread, hook/agent
+    -- metadata, and the transcript path \u2192 canonical id mapping that lets
+    -- later T1/mtime scans resolve a child to ONE identity.
+    CREATE TABLE IF NOT EXISTS session_provenance (
+      session_id        TEXT PRIMARY KEY,
+      vendor            TEXT NOT NULL,
+      kind              TEXT NOT NULL,
+      parent_session_id TEXT,
+      agent_depth       INTEGER,
+      agent_meta        TEXT,
+      transcript_path   TEXT,
+      updated_at        INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_provenance_path ON session_provenance(transcript_path);
+
+    -- session_aliases \u2014 alternate identifiers (e.g. a hook agent_id that
+    -- differs from the child rollout's session-meta UUID) \u2192 canonical id.
+    CREATE TABLE IF NOT EXISTS session_aliases (
+      alias_id   TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      source     TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS schema_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `,
+  /** Filtered external-content view + FTS + four-state triggers + vocab. */
+  fts: `
+    -- Filtered external-content source: FTS5 rebuild/integrity-check read
+    -- THIS view, so 'rebuild' repopulates only hot rows and the (rank-1)
+    -- integrity check compares against the filtered corpus.
+    CREATE VIEW IF NOT EXISTS searchable_messages AS
+      SELECT rowid, message_text FROM messages WHERE retrieval_class = 'hot';
+
     CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
       message_text,
-      content=messages,
+      content=searchable_messages,
       content_rowid=rowid,
       tokenize='porter unicode61'
     );
 
-    CREATE TRIGGER IF NOT EXISTS messages_fts_ai AFTER INSERT ON messages BEGIN
+    -- Four-state trigger behavior:
+    --   insert hot \u2192 add        | insert agent \u2192 no-op
+    --   delete hot \u2192 delete     | delete agent \u2192 no-op
+    --   update hot\u2192hot \u2192 delete old + add new
+    --   update hot\u2192agent \u2192 delete old only
+    --   update agent\u2192hot \u2192 add new only
+    --   update agent\u2192agent \u2192 no-op
+    CREATE TRIGGER IF NOT EXISTS messages_fts_ai AFTER INSERT ON messages
+      WHEN new.retrieval_class = 'hot'
+    BEGIN
       INSERT INTO messages_fts(rowid, message_text) VALUES (new.rowid, new.message_text);
     END;
 
-    CREATE TRIGGER IF NOT EXISTS messages_fts_ad AFTER DELETE ON messages BEGIN
+    CREATE TRIGGER IF NOT EXISTS messages_fts_ad AFTER DELETE ON messages
+      WHEN old.retrieval_class = 'hot'
+    BEGIN
       INSERT INTO messages_fts(messages_fts, rowid, message_text)
       VALUES ('delete', old.rowid, old.message_text);
     END;
 
     CREATE TRIGGER IF NOT EXISTS messages_fts_au AFTER UPDATE ON messages BEGIN
       INSERT INTO messages_fts(messages_fts, rowid, message_text)
-      VALUES ('delete', old.rowid, old.message_text);
-      INSERT INTO messages_fts(rowid, message_text) VALUES (new.rowid, new.message_text);
+        SELECT 'delete', old.rowid, old.message_text WHERE old.retrieval_class = 'hot';
+      INSERT INTO messages_fts(rowid, message_text)
+        SELECT new.rowid, new.message_text WHERE new.retrieval_class = 'hot';
     END;
-  `);
-  db3.exec(`
+
     CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts_vocab
       USING fts5vocab(messages_fts, 'row');
-  `);
-  db3.exec(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS _stem USING fts5(
-      t, tokenize='porter unicode61'
-    );
-    CREATE VIRTUAL TABLE IF NOT EXISTS _stem_vocab
-      USING fts5vocab(_stem, 'row');
-  `);
-  db3.exec(`
-    CREATE TABLE IF NOT EXISTS message_vectors (
-      message_id    TEXT PRIMARY KEY REFERENCES messages(message_id) ON DELETE CASCADE,
-      embedding_q8  BLOB NOT NULL,
-      norm          REAL NOT NULL,
-      quant_scale   REAL NOT NULL,
-      embed_version INTEGER NOT NULL DEFAULT 1
-    );
-  `);
-  const hasEmbedVersion = () => db3.all(`PRAGMA table_info(message_vectors)`).some((c) => c.name === "embed_version");
-  if (!hasEmbedVersion()) {
+  `
+};
+function ensureSchema(db3) {
+  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(
+        t, tokenize='porter unicode61'
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS _stem_vocab
+        USING fts5vocab(_stem, 'row');
+    `);
+    db3.exec(`
+      CREATE TABLE IF NOT EXISTS message_vectors (
+        message_id    TEXT PRIMARY KEY REFERENCES messages(message_id) ON DELETE CASCADE,
+        embedding_q8  BLOB NOT NULL,
+        norm          REAL NOT NULL,
+        quant_scale   REAL NOT NULL,
+        embed_version INTEGER NOT NULL DEFAULT 1
+      );
+    `);
+    const hasEmbedVersion = () => db3.all(`PRAGMA table_info(message_vectors)`).some((c) => c.name === "embed_version");
+    if (!hasEmbedVersion()) {
+      try {
+        db3.exec(`ALTER TABLE message_vectors ADD COLUMN embed_version INTEGER NOT NULL DEFAULT 1`);
+      } catch (e) {
+        if (!hasEmbedVersion())
+          throw e;
+      }
+    }
+    db3.exec(`
+      CREATE TABLE IF NOT EXISTS ingest_watermark (
+        transcript_path TEXT PRIMARY KEY,
+        last_mtime      INTEGER NOT NULL,
+        last_size       INTEGER NOT NULL,
+        vendor          TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_watermark_vendor ON ingest_watermark(vendor);
+    `);
+    db3.exec(`
+      INSERT OR IGNORE INTO schema_meta(key, value)
+      VALUES ('${RETRIEVAL_MIGRATION_KEY}', 'complete');
+    `);
+    db3.exec("COMMIT");
+  } catch (e) {
     try {
-      db3.exec(`ALTER TABLE message_vectors ADD COLUMN embed_version INTEGER NOT NULL DEFAULT 1`);
-    } catch (e) {
-      if (!hasEmbedVersion())
-        throw e;
+      db3.exec("ROLLBACK");
+    } catch {
     }
+    throw e;
   }
-  db3.exec(`
-    CREATE TABLE IF NOT EXISTS ingest_watermark (
-      transcript_path TEXT PRIMARY KEY,
-      last_mtime      INTEGER NOT NULL,
-      last_size       INTEGER NOT NULL,
-      vendor          TEXT NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS idx_watermark_vendor ON ingest_watermark(vendor);
-  `);
 }
 
 // src/recall/message-store.ts
@@ -4952,7 +5164,7 @@ function ensureDir2() {
   }
 }
 function insertMessages(messages, opts) {
-  if (messages.length === 0 && !opts?.replaceSessionId)
+  if (messages.length === 0 && !opts?.replaceSessionId && !opts?.provenance)
     return;
   ensureDir2();
   const d = db2();
@@ -4968,8 +5180,8 @@ 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)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`
+       (message_id, session_id, message_seq, message_text, project_id, created_at, message_role, retrieval_class)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
     );
     for (const m of messages) {
       stmt.run([
@@ -4979,9 +5191,55 @@ function insertMessages(messages, opts) {
         m.message_text,
         m.project_id,
         m.created_at,
-        m.message_role
+        m.message_role,
+        m.retrieval_class ?? "hot"
       ]);
     }
+    if (opts?.provenance) {
+      const p = opts.provenance;
+      d.run(
+        `INSERT INTO session_provenance
+           (session_id, vendor, kind, parent_session_id, agent_depth, agent_meta, transcript_path, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(session_id) DO UPDATE SET
+           vendor = excluded.vendor,
+           kind = excluded.kind,
+           parent_session_id = COALESCE(excluded.parent_session_id, session_provenance.parent_session_id),
+           agent_depth = COALESCE(excluded.agent_depth, session_provenance.agent_depth),
+           agent_meta = COALESCE(excluded.agent_meta, session_provenance.agent_meta),
+           transcript_path = COALESCE(excluded.transcript_path, session_provenance.transcript_path),
+           updated_at = excluded.updated_at`,
+        [
+          p.sessionId,
+          p.vendor,
+          p.kind,
+          p.parentSessionId,
+          p.agentDepth,
+          p.agentMeta ? JSON.stringify(p.agentMeta) : null,
+          p.transcriptPath,
+          Date.now()
+        ]
+      );
+      if (p.kind === "agent") {
+        d.run(
+          `UPDATE messages SET retrieval_class = 'agent'
+           WHERE session_id = ? AND retrieval_class != 'agent'`,
+          [p.sessionId]
+        );
+        d.run(
+          `DELETE FROM message_vectors WHERE message_id IN
+           (SELECT message_id FROM messages WHERE session_id = ?)`,
+          [p.sessionId]
+        );
+      }
+    }
+    for (const a of opts?.aliases ?? []) {
+      d.run(
+        `INSERT OR REPLACE INTO session_aliases (alias_id, session_id, source, created_at)
+         VALUES (?, ?, ?, ?)`,
+        [a.aliasId, a.sessionId, a.source, Date.now()]
+      );
+    }
     d.exec("COMMIT");
   } catch (e) {
     d.exec("ROLLBACK");
@@ -4998,15 +5256,17 @@ function insertMessageVectors(records) {
     const stmt = d.prepare(
       `INSERT OR REPLACE INTO message_vectors
        (message_id, embedding_q8, norm, quant_scale, embed_version)
-       VALUES (?, ?, ?, ?, ?)`
+       SELECT m.message_id, ?, ?, ?, ?
+       FROM messages m
+       WHERE m.message_id = ? AND m.retrieval_class = 'hot'`
     );
     for (const r of records) {
       stmt.run([
-        r.messageId,
         Buffer.from(r.embeddingQ8.buffer, r.embeddingQ8.byteOffset, r.embeddingQ8.byteLength),
         r.norm,
         r.quantScale,
-        EMBED_VERSION
+        EMBED_VERSION,
+        r.messageId
       ]);
     }
     d.exec("COMMIT");
@@ -5021,12 +5281,13 @@ function getUnembeddedMessages(limit) {
     const rows = db2().all(
       `SELECT m.message_id, m.session_id, m.message_text,
          (SELECT p.message_text FROM messages p
-           WHERE p.session_id = m.session_id AND p.message_seq < m.message_seq
+           WHERE p.session_id = m.session_id AND p.message_seq < m.message_seq AND p.retrieval_class = 'hot'
            ORDER BY p.message_seq DESC LIMIT 1) AS prev_text
        FROM messages m
        WHERE m.message_text != ''
+         AND m.retrieval_class = 'hot'
          AND (LENGTH(m.message_text) >= ${MIN_EMBED_CHARS}
-              OR EXISTS (SELECT 1 FROM messages p2 WHERE p2.session_id = m.session_id AND p2.message_seq < m.message_seq))
+              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 ?`,
@@ -5047,6 +5308,260 @@ function getUnembeddedMessages(limit) {
   }
 }
 
+// src/recall/session-classifier.ts
+init_paths();
+init_log();
+
+// src/adapters/codex/codex-jsonl-reader.ts
+var fs = __toESM(require("fs"));
+init_log();
+function parseCodexJsonlFile(filepath) {
+  try {
+    const content = fs.readFileSync(filepath, "utf-8");
+    const lines = content.split("\n");
+    const records = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      try {
+        const record = JSON.parse(trimmed);
+        records.push(record);
+      } catch (err) {
+        log({ level: "warn", source: "codex-jsonl-reader", summary: `Skipping unparseable line: ${err.message}` });
+      }
+    }
+    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 [];
+  }
+}
+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)
+      return null;
+    const content = buffer.toString("utf-8", 0, bytesRead);
+    const newlineIdx = content.indexOf("\n");
+    const firstLine = newlineIdx >= 0 ? content.slice(0, newlineIdx) : content;
+    const record = JSON.parse(firstLine.trim());
+    if (record.type !== "session_meta")
+      return null;
+    const payload = record.payload;
+    return {
+      id: payload.id,
+      cwd: payload.cwd,
+      cli_version: payload.cli_version,
+      git: payload.git,
+      ...payload.source && typeof payload.source === "object" ? { source: payload.source } : {}
+    };
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+var READ_BUFFER_SIZE = 64 * 1024;
+var TURN_CONTENT_CAP = 8 * 1024;
+
+// src/recall/session-classifier.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ROLLOUT_UUID_RE = /rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
+function normalize(p) {
+  return p.replace(/\\/g, "/");
+}
+function basenameNoExt(p) {
+  return normalize(p).split("/").pop().replace(/\.jsonl$/i, "");
+}
+function lookupStoredProvenance(transcriptPath) {
+  try {
+    const row = getDb(dbPath()).get(
+      `SELECT session_id, kind, parent_session_id FROM session_provenance
+       WHERE transcript_path = ? LIMIT 1`,
+      [normalize(transcriptPath)]
+    );
+    return row ?? null;
+  } catch {
+    return null;
+  }
+}
+function claudeSubagentParent(normPath) {
+  const segments = normPath.split("/");
+  const idx = segments.lastIndexOf("subagents");
+  if (idx <= 0)
+    return null;
+  const parent = segments[idx - 1];
+  return parent || null;
+}
+function classifySession(args) {
+  const { sessionId, transcriptPath, vendor, hook } = args;
+  const normPath = normalize(transcriptPath);
+  const base = basenameNoExt(transcriptPath);
+  const stored = lookupStoredProvenance(transcriptPath);
+  if (stored && !(stored.kind !== "agent" && hook?.isSubagent)) {
+    return {
+      kind: stored.kind === "agent" ? "agent" : "root",
+      canonicalSessionId: stored.session_id,
+      parentSessionId: stored.parent_session_id,
+      agentDepth: null,
+      agentMeta: null,
+      aliases: aliasCandidates(stored.session_id, sessionId, hook),
+      evidence: "stored"
+    };
+  }
+  if (vendor === "claude")
+    return classifyClaude(sessionId, normPath, base, hook);
+  return classifyCodex(sessionId, transcriptPath, base, hook);
+}
+function aliasCandidates(canonical, proposed, hook) {
+  const out = /* @__PURE__ */ new Set();
+  if (hook?.agentId && hook.agentId !== canonical)
+    out.add(hook.agentId);
+  if (proposed && proposed !== canonical)
+    out.add(proposed);
+  return [...out];
+}
+function classifyClaude(sessionId, normPath, base, hook) {
+  if (normPath.includes("/subagents/") && base.startsWith("agent-")) {
+    return {
+      kind: "agent",
+      canonicalSessionId: base,
+      parentSessionId: claudeSubagentParent(normPath) ?? hook?.payloadSessionId ?? null,
+      agentDepth: null,
+      agentMeta: hook?.agentId ? { hookAgentId: hook.agentId } : null,
+      aliases: aliasCandidates(base, sessionId, hook),
+      evidence: "claude-path"
+    };
+  }
+  if (base.startsWith("agent-") || sessionId.startsWith("agent-")) {
+    const canonical = base.startsWith("agent-") ? base : sessionId;
+    return {
+      kind: "agent",
+      canonicalSessionId: canonical,
+      parentSessionId: hook?.payloadSessionId ?? null,
+      agentDepth: null,
+      agentMeta: hook?.agentId ? { hookAgentId: hook.agentId } : null,
+      aliases: aliasCandidates(canonical, sessionId, hook),
+      evidence: "claude-name"
+    };
+  }
+  if (hook?.isSubagent) {
+    return {
+      kind: "agent",
+      canonicalSessionId: base || sessionId,
+      parentSessionId: hook.payloadSessionId ?? null,
+      agentDepth: null,
+      agentMeta: hook.agentId ? { hookAgentId: hook.agentId } : null,
+      aliases: aliasCandidates(base || sessionId, sessionId, hook),
+      evidence: "hook"
+    };
+  }
+  return {
+    kind: "root",
+    canonicalSessionId: sessionId,
+    parentSessionId: null,
+    agentDepth: null,
+    agentMeta: null,
+    aliases: [],
+    evidence: "default-root"
+  };
+}
+function classifyCodex(sessionId, transcriptPath, base, hook) {
+  const meta = extractCodexSessionMeta(transcriptPath);
+  const filenameUuid = ROLLOUT_UUID_RE.exec(normalize(transcriptPath))?.[1] ?? null;
+  const canonical = meta?.id && typeof meta.id === "string" && meta.id.length > 0 ? meta.id : filenameUuid ?? (UUID_RE.test(sessionId) ? sessionId : null);
+  const sub = parseSubagentSource(meta?.source, transcriptPath);
+  if (sub.malformed) {
+    log({
+      source: "recall:classify",
+      level: "warn",
+      summary: `codex session_meta.source looks subagent-like but is malformed \u2014 leaving session hot (conservative): ${transcriptPath}`
+    });
+  }
+  if (sub.isSubagent || hook?.isSubagent) {
+    if (!canonical) {
+      log({
+        source: "recall:classify",
+        level: "warn",
+        summary: `codex subagent transcript has no derivable canonical id \u2014 skipping ingest (conservative): ${transcriptPath}`
+      });
+      return {
+        kind: "agent",
+        canonicalSessionId: base || sessionId,
+        parentSessionId: sub.parentThreadId ?? hook?.payloadSessionId ?? null,
+        agentDepth: sub.depth,
+        agentMeta: sub.meta,
+        aliases: [],
+        evidence: sub.isSubagent ? "codex-meta" : "hook",
+        unresolvable: true
+      };
+    }
+    return {
+      kind: "agent",
+      canonicalSessionId: canonical,
+      parentSessionId: sub.parentThreadId ?? hook?.payloadSessionId ?? null,
+      agentDepth: sub.depth,
+      agentMeta: mergeMeta(sub.meta, hook?.agentId),
+      aliases: aliasCandidates(canonical, sessionId, hook),
+      evidence: sub.isSubagent ? "codex-meta" : "hook"
+    };
+  }
+  return {
+    kind: "root",
+    canonicalSessionId: canonical ?? sessionId,
+    parentSessionId: null,
+    agentDepth: null,
+    agentMeta: null,
+    aliases: canonical && canonical !== sessionId ? [sessionId] : [],
+    evidence: "default-root"
+  };
+}
+function mergeMeta(meta, hookAgentId) {
+  if (!hookAgentId)
+    return meta;
+  return { ...meta ?? {}, hookAgentId };
+}
+function parseSubagentSource(source, _transcriptPath) {
+  const none = { isSubagent: false, malformed: false, parentThreadId: null, depth: null, meta: null };
+  if (!source || typeof source !== "object")
+    return none;
+  const subRaw = source.subagent;
+  const typeTag = source.type;
+  const looksSubagent = subRaw !== void 0 || typeTag === "subagent";
+  if (!looksSubagent)
+    return none;
+  if (subRaw !== void 0 && (typeof subRaw !== "object" || subRaw === null)) {
+    return { ...none, malformed: true };
+  }
+  const sub = subRaw ?? {};
+  const spawnRaw = sub.thread_spawn ?? source.thread_spawn;
+  const spawn2 = spawnRaw && typeof spawnRaw === "object" ? spawnRaw : {};
+  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"]) {
+    const v = spawn2[k] ?? sub[k];
+    if (typeof v === "string" || typeof v === "number")
+      meta[k] = v;
+  }
+  return {
+    isSubagent: true,
+    malformed: false,
+    parentThreadId,
+    depth,
+    meta: Object.keys(meta).length > 0 ? meta : null
+  };
+}
+
 // src/recall/message-ingest.ts
 init_paths();
 
@@ -5065,13 +5580,13 @@ function normalizePath(p) {
 init_log();
 
 // src/adapters/claude/jsonl-reader.ts
-var fs = __toESM(require("fs"));
+var fs2 = __toESM(require("fs"));
 init_log();
-var READ_BUFFER_SIZE = 64 * 1024;
-var TURN_CONTENT_CAP = 8 * 1024;
+var READ_BUFFER_SIZE2 = 64 * 1024;
+var TURN_CONTENT_CAP2 = 8 * 1024;
 function parseJsonlFile(filepath) {
   try {
-    const content = fs.readFileSync(filepath, "utf-8");
+    const content = fs2.readFileSync(filepath, "utf-8");
     const lines = content.split("\n");
     const entries = [];
     for (const line of lines) {
@@ -5260,37 +5775,6 @@ function adaptClaudeEntries(rawEntries) {
   return rawEntries.map(adaptClaudeEntry).filter((entry) => entry !== null);
 }
 
-// src/adapters/codex/codex-jsonl-reader.ts
-var fs2 = __toESM(require("fs"));
-init_log();
-var path = __toESM(require("path"));
-var os = __toESM(require("os"));
-var CODEX_SESSIONS_DIR = path.join(os.homedir(), ".codex", "sessions");
-function parseCodexJsonlFile(filepath) {
-  try {
-    const content = fs2.readFileSync(filepath, "utf-8");
-    const lines = content.split("\n");
-    const records = [];
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed)
-        continue;
-      try {
-        const record = JSON.parse(trimmed);
-        records.push(record);
-      } catch (err) {
-        log({ level: "warn", source: "codex-jsonl-reader", summary: `Skipping unparseable line: ${err.message}` });
-      }
-    }
-    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 [];
-  }
-}
-var READ_BUFFER_SIZE2 = 64 * 1024;
-var TURN_CONTENT_CAP2 = 8 * 1024;
-
 // src/adapters/codex/codex-jsonl-adapter.ts
 function adaptCodexJsonlRecords(records, sessionId) {
   const outputIndex = /* @__PURE__ */ new Map();
@@ -5925,6 +6409,36 @@ function entriesCwd(entries) {
   return void 0;
 }
 async function ingestSessionMessages(sessionId, transcriptPath, vendor, options) {
+  const classification = classifySession({
+    sessionId,
+    transcriptPath,
+    vendor,
+    ...options?.hook ? { hook: options.hook } : {}
+  });
+  if (classification.unresolvable) {
+    return {
+      sessionId,
+      chunksCreated: 0,
+      skipped: true,
+      error: "subagent transcript has no derivable canonical identity \u2014 skipped (conservative)"
+    };
+  }
+  const canonicalId = classification.canonicalSessionId;
+  const retrievalClass = classification.kind === "agent" ? "agent" : "hot";
+  const provenance = {
+    sessionId: canonicalId,
+    vendor,
+    kind: classification.kind,
+    parentSessionId: classification.parentSessionId,
+    agentDepth: classification.agentDepth,
+    agentMeta: classification.agentMeta,
+    transcriptPath: transcriptPath.replace(/\\/g, "/")
+  };
+  const aliases = classification.aliases.map((aliasId) => ({
+    aliasId,
+    sessionId: canonicalId,
+    source: options?.hook?.agentId === aliasId ? "hook-agent-id" : "ingest-request-id"
+  }));
   let rawEntries;
   try {
     if (vendor === "claude") {
@@ -5932,18 +6446,25 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
       rawEntries = adaptClaudeEntries(raw);
     } else {
       const envelopes = parseCodexJsonlFile(transcriptPath);
-      rawEntries = adaptCodexJsonlRecords(envelopes, sessionId);
+      rawEntries = adaptCodexJsonlRecords(envelopes, canonicalId);
     }
   } catch (err) {
     return {
-      sessionId,
+      sessionId: canonicalId,
       chunksCreated: 0,
       skipped: false,
-      error: `Failed to load session: ${err instanceof Error ? err.message : String(err)}`
+      error: `Failed to load session: ${err instanceof Error ? err.message : String(err)}`,
+      retrievalClass
     };
   }
   if (rawEntries.length === 0) {
-    return { sessionId, chunksCreated: 0, skipped: true };
+    if (options?.force) {
+      try {
+        insertMessages([], { replaceSessionId: canonicalId, provenance, aliases });
+      } catch {
+      }
+    }
+    return { sessionId: canonicalId, chunksCreated: 0, skipped: true, retrievalClass };
   }
   const rawProjectId = options?.projectId ?? entriesCwd(rawEntries);
   const projectId = rawProjectId ? normalizePath(rawProjectId) : null;
@@ -5960,31 +6481,44 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
     const createdAt = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
     records.push({
       message_id: entry.uuid,
-      session_id: sessionId,
+      session_id: canonicalId,
       message_seq: i,
       message_text: text,
       project_id: projectId,
       created_at: createdAt,
-      message_role: entry.message?.role ?? entry.type ?? null
+      message_role: entry.message?.role ?? entry.type ?? null,
+      retrieval_class: retrievalClass
     });
   }
   if (records.length === 0) {
-    return { sessionId, chunksCreated: 0, skipped: true };
+    if (options?.force) {
+      try {
+        insertMessages([], { replaceSessionId: canonicalId, provenance, aliases });
+      } catch {
+      }
+    }
+    return { sessionId: canonicalId, chunksCreated: 0, skipped: true, retrievalClass };
   }
   try {
-    insertMessages(records, options?.force ? { replaceSessionId: sessionId } : void 0);
+    insertMessages(records, {
+      ...options?.force ? { replaceSessionId: canonicalId } : {},
+      provenance,
+      aliases
+    });
   } catch (err) {
     return {
-      sessionId,
+      sessionId: canonicalId,
       chunksCreated: 0,
       skipped: false,
-      error: `DB insert failed: ${err instanceof Error ? err.message : String(err)}`
+      error: `DB insert failed: ${err instanceof Error ? err.message : String(err)}`,
+      retrievalClass
     };
   }
   return {
-    sessionId,
+    sessionId: canonicalId,
     chunksCreated: records.length,
-    skipped: false
+    skipped: false,
+    retrievalClass
   };
 }
 var MAX_EMBED_CHARS = 14e3;
@@ -6028,14 +6562,14 @@ async function embedSessionMessages(sessionId, force) {
   const rows = d.all(
     force ? `SELECT m.message_id, m.message_text,
            (SELECT p.message_text FROM messages p
-             WHERE p.session_id = m.session_id AND p.message_seq < m.message_seq
+             WHERE p.session_id = m.session_id AND p.message_seq < m.message_seq AND p.retrieval_class = 'hot'
              ORDER BY p.message_seq DESC LIMIT 1) AS prev_text
-         FROM messages m WHERE m.session_id = ? ORDER BY m.message_seq ASC` : `SELECT m.message_id, m.message_text,
+         FROM messages m WHERE m.session_id = ? AND m.retrieval_class = 'hot' ORDER BY m.message_seq ASC` : `SELECT m.message_id, m.message_text,
            (SELECT p.message_text FROM messages p
-             WHERE p.session_id = m.session_id AND p.message_seq < m.message_seq
+             WHERE p.session_id = m.session_id AND p.message_seq < m.message_seq AND p.retrieval_class = 'hot'
              ORDER BY p.message_seq DESC LIMIT 1) AS prev_text
          FROM messages m
-         WHERE m.session_id = ?
+         WHERE m.session_id = ? AND m.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.message_seq ASC`,
     force ? [sessionId] : [sessionId, EMBED_VERSION]
@@ -6088,7 +6622,9 @@ init_embedder();
 var import_node_fs5 = require("node:fs");
 var import_node_path5 = require("node:path");
 init_paths();
-var LOCK_PATH = (0, import_node_path5.join)(runDir(), "embed.lock");
+function embedLockPath() {
+  return (0, import_node_path5.join)(runDir(), "embed.lock");
+}
 var STALE_MS = 30 * 60 * 1e3;
 function isAlive(pid) {
   try {
@@ -6101,21 +6637,21 @@ function isAlive(pid) {
 function tryAcquireEmbedLock() {
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      (0, import_node_fs5.writeFileSync)(LOCK_PATH, String(process.pid), { flag: "wx" });
+      (0, import_node_fs5.writeFileSync)(embedLockPath(), String(process.pid), { flag: "wx" });
       return true;
     } catch {
       let heldPid;
       let ageMs;
       try {
-        heldPid = parseInt((0, import_node_fs5.readFileSync)(LOCK_PATH, "utf8"), 10);
-        ageMs = Date.now() - (0, import_node_fs5.statSync)(LOCK_PATH).mtimeMs;
+        heldPid = parseInt((0, import_node_fs5.readFileSync)(embedLockPath(), "utf8"), 10);
+        ageMs = Date.now() - (0, import_node_fs5.statSync)(embedLockPath()).mtimeMs;
       } catch {
         continue;
       }
       if (isAlive(heldPid) && ageMs < STALE_MS)
         return false;
       try {
-        (0, import_node_fs5.unlinkSync)(LOCK_PATH);
+        (0, import_node_fs5.unlinkSync)(embedLockPath());
       } catch {
       }
     }
@@ -6124,9 +6660,9 @@ function tryAcquireEmbedLock() {
 }
 function releaseEmbedLock() {
   try {
-    const held = parseInt((0, import_node_fs5.readFileSync)(LOCK_PATH, "utf8"), 10);
+    const held = parseInt((0, import_node_fs5.readFileSync)(embedLockPath(), "utf8"), 10);
     if (held === process.pid)
-      (0, import_node_fs5.unlinkSync)(LOCK_PATH);
+      (0, import_node_fs5.unlinkSync)(embedLockPath());
   } catch {
   }
 }
@@ -6936,11 +7472,11 @@ var qmarksTestNoExtDot = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path2 = {
+var path = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep = defaultPlatform === "win32" ? path2.win32.sep : path2.posix.sep;
+var sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
 minimatch.sep = sep;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -9972,7 +10508,7 @@ var ENOCHILD = ENOTDIR | ENOENT | ENOREALPATH;
 var TYPEMASK = 1023;
 var entToType = (s) => s.isFile() ? IFREG : s.isDirectory() ? IFDIR : s.isSymbolicLink() ? IFLNK : s.isCharacterDevice() ? IFCHR : s.isBlockDevice() ? IFBLK : s.isSocket() ? IFSOCK : s.isFIFO() ? IFIFO : UNKNOWN;
 var normalizeCache = /* @__PURE__ */ new Map();
-var normalize = (s) => {
+var normalize2 = (s) => {
   const c = normalizeCache.get(s);
   if (c)
     return c;
@@ -9985,7 +10521,7 @@ var normalizeNocase = (s) => {
   const c = normalizeNocaseCache.get(s);
   if (c)
     return c;
-  const n = normalize(s.toLowerCase());
+  const n = normalize2(s.toLowerCase());
   normalizeNocaseCache.set(s, n);
   return n;
 };
@@ -10152,7 +10688,7 @@ var PathBase = class {
    */
   constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
     this.name = name;
-    this.#matchName = nocase ? normalizeNocase(name) : normalize(name);
+    this.#matchName = nocase ? normalizeNocase(name) : normalize2(name);
     this.#type = type & TYPEMASK;
     this.nocase = nocase;
     this.roots = roots;
@@ -10189,12 +10725,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path3) {
-    if (!path3) {
+  resolve(path2) {
+    if (!path2) {
       return this;
     }
-    const rootPath = this.getRootString(path3);
-    const dir = path3.substring(rootPath.length);
+    const rootPath = this.getRootString(path2);
+    const dir = path2.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -10245,7 +10781,7 @@ var PathBase = class {
       return this.parent || this;
     }
     const children = this.children();
-    const name = this.nocase ? normalizeNocase(pathPart) : normalize(pathPart);
+    const name = this.nocase ? normalizeNocase(pathPart) : normalize2(pathPart);
     for (const p of children) {
       if (p.#matchName === name) {
         return p;
@@ -10490,7 +11026,7 @@ var PathBase = class {
    * directly.
    */
   isNamed(n) {
-    return !this.nocase ? this.#matchName === normalize(n) : this.#matchName === normalizeNocase(n);
+    return !this.nocase ? this.#matchName === normalize2(n) : this.#matchName === normalizeNocase(n);
   }
   /**
    * Return the Path object corresponding to the target of a symbolic link.
@@ -10629,7 +11165,7 @@ var PathBase = class {
   #readdirMaybePromoteChild(e, c) {
     for (let p = c.provisional; p < c.length; p++) {
       const pchild = c[p];
-      const name = this.nocase ? normalizeNocase(e.name) : normalize(e.name);
+      const name = this.nocase ? normalizeNocase(e.name) : normalize2(e.name);
       if (name !== pchild.#matchName) {
         continue;
       }
@@ -10946,8 +11482,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path3) {
-    return import_node_path6.win32.parse(path3).root;
+  getRootString(path2) {
+    return import_node_path6.win32.parse(path2).root;
   }
   /**
    * @internal
@@ -10993,8 +11529,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path3) {
-    return path3.startsWith("/") ? "/" : "";
+  getRootString(path2) {
+    return path2.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -11083,11 +11619,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path3 = this.cwd) {
-    if (typeof path3 === "string") {
-      path3 = this.cwd.resolve(path3);
+  depth(path2 = this.cwd) {
+    if (typeof path2 === "string") {
+      path2 = this.cwd.resolve(path2);
     }
-    return path3.depth();
+    return path2.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -11574,9 +12110,9 @@ var PathScurryBase = class {
     process2();
     return results;
   }
-  chdir(path3 = this.cwd) {
+  chdir(path2 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path3 === "string" ? this.cwd.resolve(path3) : path3;
+    this.cwd = typeof path2 === "string" ? this.cwd.resolve(path2) : path2;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -11932,8 +12468,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path3, n]) => [
-      path3,
+    return [...this.store.entries()].map(([path2, n]) => [
+      path2,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -12138,9 +12674,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path3, opts) {
+  constructor(patterns, path2, opts) {
     this.patterns = patterns;
-    this.path = path3;
+    this.path = path2;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -12159,11 +12695,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path3) {
-    return this.seen.has(path3) || !!this.#ignore?.ignored?.(path3);
+  #ignored(path2) {
+    return this.seen.has(path2) || !!this.#ignore?.ignored?.(path2);
   }
-  #childrenIgnored(path3) {
-    return !!this.#ignore?.childrenIgnored?.(path3);
+  #childrenIgnored(path2) {
+    return !!this.#ignore?.childrenIgnored?.(path2);
   }
   // backpressure mechanism
   pause() {
@@ -12378,8 +12914,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path3, opts) {
-    super(patterns, path3, opts);
+  constructor(patterns, path2, opts) {
+    super(patterns, path2, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -12416,8 +12952,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path3, opts) {
-    super(patterns, path3, opts);
+  constructor(patterns, path2, opts) {
+    super(patterns, path2, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -12805,7 +13341,7 @@ var HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
   process.on("SIGTERM", onSignal);
   const heartbeat = setInterval(() => {
     try {
-      (0, import_node_fs7.utimesSync)(LOCK_PATH, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+      (0, import_node_fs7.utimesSync)(embedLockPath(), /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
     } catch {
     }
   }, HEARTBEAT_INTERVAL_MS);
@@ -12852,4 +13388,6 @@ var HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
     }
     releaseEmbedLock();
   }
-})();
+})().catch(() => {
+  process.exit(0);
+});