crispy-recall 0.2.0 → 0.3.0

package/dist/stop-hook.js

@@ -153,21 +153,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 path2 = rest.substring(firstSlash + 1);
+      var path = rest.substring(firstSlash + 1);
       if ("localhost" == host)
         host = "";
       if (host) {
         host = sep + sep + host;
       }
-      path2 = path2.replace(/^(.+)\|/, "$1:");
+      path = path.replace(/^(.+)\|/, "$1:");
       if (sep == "\\") {
-        path2 = path2.replace(/\//g, "\\");
+        path = path.replace(/\//g, "\\");
       }
-      if (/^.+\:/.test(path2)) {
+      if (/^.+\:/.test(path)) {
       } else {
-        path2 = sep + path2;
+        path = sep + path;
       }
-      return host + path2;
+      return host + path;
     }
   }
 });
@@ -176,18 +176,18 @@ var require_file_uri_to_path = __commonJS({
 var require_bindings = __commonJS({
   "node_modules/bindings/bindings.js"(exports2, module2) {
     var fs3 = require("fs");
-    var path2 = require("path");
+    var path = require("path");
     var fileURLToPath = require_file_uri_to_path();
-    var join5 = path2.join;
-    var dirname2 = path2.dirname;
-    var exists = fs3.accessSync && function(path3) {
+    var join4 = path.join;
+    var dirname2 = path.dirname;
+    var exists = fs3.accessSync && function(path2) {
       try {
-        fs3.accessSync(path3);
+        fs3.accessSync(path2);
       } catch (e) {
         return false;
       }
       return true;
-    } || fs3.existsSync || path2.existsSync;
+    } || fs3.existsSync || path.existsSync;
     var defaults = {
       arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
       compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
@@ -233,13 +233,13 @@ var require_bindings = __commonJS({
       if (!opts.module_root) {
         opts.module_root = exports2.getRoot(exports2.getFileName());
       }
-      if (path2.extname(opts.bindings) != ".node") {
+      if (path.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 = join5.apply(
+        n = join4.apply(
           null,
           opts.try[i].map(function(p) {
             return opts[p] || p;
@@ -300,7 +300,7 @@ var require_bindings = __commonJS({
         if (dir === ".") {
           dir = process.cwd();
         }
-        if (exists(join5(dir, "package.json")) || exists(join5(dir, "node_modules"))) {
+        if (exists(join4(dir, "package.json")) || exists(join4(dir, "node_modules"))) {
           return dir;
         }
         if (prev === dir) {
@@ -309,7 +309,7 @@ var require_bindings = __commonJS({
           );
         }
         prev = dir;
-        dir = join5(dir, "..");
+        dir = join4(dir, "..");
       }
     };
   }
@@ -477,7 +477,7 @@ var require_backup = __commonJS({
   "node_modules/better-sqlite3/lib/methods/backup.js"(exports2, module2) {
     "use strict";
     var fs3 = require("fs");
-    var path2 = require("path");
+    var path = require("path");
     var { promisify } = require("util");
     var { cppdb } = require_util();
     var fsAccess = promisify(fs3.access);
@@ -501,7 +501,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(path2.dirname(filename)).catch(() => {
+      await fsAccess(path.dirname(filename)).catch(() => {
         throw new TypeError("Cannot save backup because the directory does not exist");
       });
       const isNewFile = await fsAccess(filename).then(() => false, () => true);
@@ -832,7 +832,7 @@ var require_database = __commonJS({
   "node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
     "use strict";
     var fs3 = require("fs");
-    var path2 = require("path");
+    var path = require("path");
     var util = require_util();
     var SqliteError = require_sqlite_error();
     var DEFAULT_ADDON;
@@ -879,7 +879,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(path2.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+        addon = requireFunc(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
       } else {
         addon = nativeBinding;
       }
@@ -887,7 +887,7 @@ var require_database = __commonJS({
         addon.setErrorConstructor(SqliteError);
         addon.isInitialized = true;
       }
-      if (!anonymous && !filename.startsWith("file:") && !fs3.existsSync(path2.dirname(filename))) {
+      if (!anonymous && !filename.startsWith("file:") && !fs3.existsSync(path.dirname(filename))) {
         throw new TypeError("Cannot open database because the directory does not exist");
       }
       Object.defineProperties(this, {
@@ -933,6 +933,7 @@ var init_quantize = __esm({
 // src/hooks/stop-hook.ts
 var stop_hook_exports = {};
 __export(stop_hook_exports, {
+  resolveIngestTarget: () => resolveIngestTarget,
   vendorForTranscript: () => vendorForTranscript
 });
 module.exports = __toCommonJS(stop_hook_exports);
@@ -976,13 +977,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;
@@ -997,7 +1010,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) {
@@ -1012,12 +1025,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();
@@ -1128,16 +1174,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)
     );
 
@@ -1149,68 +1197,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
@@ -1233,7 +1347,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();
@@ -1249,8 +1363,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([
@@ -1260,9 +1374,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");
@@ -1270,6 +1430,260 @@ function insertMessages(messages, opts) {
   }
 }
 
+// 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();
 
@@ -1288,13 +1702,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) {
@@ -1483,37 +1897,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();
@@ -2148,6 +2531,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") {
@@ -2155,18 +2568,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;
@@ -2183,31 +2603,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
   };
 }
 
@@ -2216,9 +2649,35 @@ init_paths();
 var import_fs = require("fs");
 var import_child_process = require("child_process");
 var import_path = require("path");
-function vendorForTranscript(transcriptPath) {
+function vendorForTranscript(transcriptPath, codexHome = process.env["CODEX_HOME"]) {
   const p = transcriptPath.replace(/\\/g, "/");
-  return p.includes("/.codex/") ? "codex" : "claude";
+  const root = codexHome?.replace(/\\/g, "/").replace(/\/$/, "");
+  const underCodexHome = root ? p === root || p.startsWith(`${root}/`) : false;
+  return p.includes("/.codex/") || underCodexHome ? "codex" : "claude";
+}
+function resolveIngestTarget(payload) {
+  if (payload.agent_transcript_path) {
+    const transcriptPath = payload.agent_transcript_path;
+    const base = transcriptPath.replace(/\\/g, "/").split("/").pop().replace(/\.jsonl$/i, "");
+    if (!base)
+      return null;
+    return {
+      sessionId: base,
+      transcriptPath,
+      hook: {
+        ...payload.session_id ? { payloadSessionId: payload.session_id } : {},
+        ...payload.agent_id ? { agentId: payload.agent_id } : {},
+        isSubagent: true
+      }
+    };
+  }
+  if (!payload.session_id || !payload.transcript_path)
+    return null;
+  return {
+    sessionId: payload.session_id,
+    transcriptPath: payload.transcript_path,
+    hook: { payloadSessionId: payload.session_id, isSubagent: false }
+  };
 }
 function logStopHook(line) {
   try {
@@ -2237,40 +2696,47 @@ async function runStopHook() {
   } catch {
     process.exit(0);
   }
-  if (!payload?.session_id || !payload?.transcript_path)
-    process.exit(0);
   if (payload.stop_hook_active)
     process.exit(0);
+  const target = resolveIngestTarget(payload);
+  if (!target)
+    process.exit(0);
+  let ingestedClass;
+  let canonicalId = target.sessionId;
   try {
     getDb(dbPath()).exec("PRAGMA busy_timeout = 5000;");
-    const vendor = vendorForTranscript(payload.transcript_path);
+    const vendor = vendorForTranscript(target.transcriptPath);
     const result = await ingestSessionMessages(
-      payload.session_id,
-      payload.transcript_path,
+      target.sessionId,
+      target.transcriptPath,
       vendor,
-      { projectId: payload.cwd ?? void 0 }
+      { projectId: payload.cwd ?? void 0, hook: target.hook }
     );
+    ingestedClass = result?.retrievalClass;
+    canonicalId = result?.sessionId ?? target.sessionId;
     if (result?.error) {
       logStopHook(
-        `${(/* @__PURE__ */ new Date()).toISOString()} ingest-failed sid=${payload.session_id} err=${result.error}
+        `${(/* @__PURE__ */ new Date()).toISOString()} ingest-failed sid=${target.sessionId} err=${result.error}
 `
       );
     }
   } catch (e) {
     logStopHook(
-      `${(/* @__PURE__ */ new Date()).toISOString()} ingest-failed sid=${payload.session_id} err=${e.message}
+      `${(/* @__PURE__ */ new Date()).toISOString()} ingest-failed sid=${target.sessionId} err=${e.message}
 `
     );
   }
-  (0, import_child_process.spawn)(
-    process.execPath,
-    [(0, import_path.join)(binDir(), "embed-pending.js"), payload.session_id],
-    {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true
-    }
-  ).unref();
+  if (!target.hook.isSubagent && ingestedClass !== "agent") {
+    (0, import_child_process.spawn)(
+      process.execPath,
+      [(0, import_path.join)(binDir(), "embed-pending.js"), canonicalId],
+      {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      }
+    ).unref();
+  }
   process.exit(0);
 }
 if (typeof require !== "undefined" && typeof module !== "undefined" && require.main === module) {
@@ -2278,5 +2744,6 @@ if (typeof require !== "undefined" && typeof module !== "undefined" && require.m
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  resolveIngestTarget,
   vendorForTranscript
 });