crispy-recall 0.3.0 → 0.4.0

package/dist/stop-hook.js

@@ -34,6 +34,47 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/paths.ts
+function recallRoot() {
+  if (rootOverride)
+    return rootOverride;
+  const envRoot = process.env["RECALL_HOME"];
+  if (envRoot && envRoot.length > 0)
+    return envRoot;
+  return (0, import_node_path.join)((0, import_node_os.homedir)(), ".recall");
+}
+function remoteRoot() {
+  const env = process.env["RECALL_REMOTE_ROOT"];
+  if (env && env.length > 0)
+    return env;
+  return (0, import_node_path.join)(recallRoot(), "remote");
+}
+function dbPath() {
+  return (0, import_node_path.join)(recallRoot(), "recall.db");
+}
+function binDir() {
+  return (0, import_node_path.join)(recallRoot(), "bin");
+}
+function runDir() {
+  return (0, import_node_path.join)(recallRoot(), "run");
+}
+function logsDir() {
+  return (0, import_node_path.join)(recallRoot(), "logs");
+}
+function ensureDir() {
+  (0, import_node_fs.mkdirSync)(recallRoot(), { recursive: true });
+}
+var import_node_fs, import_node_os, import_node_path, rootOverride;
+var init_paths = __esm({
+  "src/paths.ts"() {
+    "use strict";
+    import_node_fs = require("node:fs");
+    import_node_os = require("node:os");
+    import_node_path = require("node:path");
+    rootOverride = null;
+  }
+});
+
 // src/log.ts
 function log(entry) {
   if (LEVEL_ORDER[entry.level] < _threshold)
@@ -68,38 +109,6 @@ var init_log = __esm({
   }
 });
 
-// src/paths.ts
-function recallRoot() {
-  if (rootOverride)
-    return rootOverride;
-  const envRoot = process.env["RECALL_HOME"];
-  if (envRoot && envRoot.length > 0)
-    return envRoot;
-  return (0, import_node_path.join)((0, import_node_os.homedir)(), ".recall");
-}
-function dbPath() {
-  return (0, import_node_path.join)(recallRoot(), "recall.db");
-}
-function binDir() {
-  return (0, import_node_path.join)(recallRoot(), "bin");
-}
-function logsDir() {
-  return (0, import_node_path.join)(recallRoot(), "logs");
-}
-function ensureDir() {
-  (0, import_node_fs.mkdirSync)(recallRoot(), { recursive: true });
-}
-var import_node_fs, import_node_os, import_node_path, rootOverride;
-var init_paths = __esm({
-  "src/paths.ts"() {
-    "use strict";
-    import_node_fs = require("node:fs");
-    import_node_os = require("node:os");
-    import_node_path = require("node:path");
-    rootOverride = null;
-  }
-});
-
 // node_modules/better-sqlite3/lib/util.js
 var require_util = __commonJS({
   "node_modules/better-sqlite3/lib/util.js"(exports2) {
@@ -144,7 +153,7 @@ var require_sqlite_error = __commonJS({
 // node_modules/file-uri-to-path/index.js
 var require_file_uri_to_path = __commonJS({
   "node_modules/file-uri-to-path/index.js"(exports2, module2) {
-    var sep = require("path").sep || "/";
+    var sep2 = require("path").sep || "/";
     module2.exports = fileUriToPath;
     function fileUriToPath(uri) {
       if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
@@ -157,15 +166,15 @@ var require_file_uri_to_path = __commonJS({
       if ("localhost" == host)
         host = "";
       if (host) {
-        host = sep + sep + host;
+        host = sep2 + sep2 + host;
       }
       path = path.replace(/^(.+)\|/, "$1:");
-      if (sep == "\\") {
+      if (sep2 == "\\") {
         path = path.replace(/\//g, "\\");
       }
       if (/^.+\:/.test(path)) {
       } else {
-        path = sep + path;
+        path = sep2 + path;
       }
       return host + path;
     }
@@ -178,8 +187,8 @@ var require_bindings = __commonJS({
     var fs3 = require("fs");
     var path = require("path");
     var fileURLToPath = require_file_uri_to_path();
-    var join4 = path.join;
-    var dirname2 = path.dirname;
+    var join7 = path.join;
+    var dirname4 = path.dirname;
     var exists = fs3.accessSync && function(path2) {
       try {
         fs3.accessSync(path2);
@@ -239,7 +248,7 @@ var require_bindings = __commonJS({
       var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
       var tries = [], i = 0, l = opts.try.length, n, b, err;
       for (; i < l; i++) {
-        n = join4.apply(
+        n = join7.apply(
           null,
           opts.try[i].map(function(p) {
             return opts[p] || p;
@@ -295,12 +304,12 @@ var require_bindings = __commonJS({
       return fileName;
     };
     exports2.getRoot = function getRoot(file) {
-      var dir = dirname2(file), prev;
+      var dir = dirname4(file), prev;
       while (true) {
         if (dir === ".") {
           dir = process.cwd();
         }
-        if (exists(join4(dir, "package.json")) || exists(join4(dir, "node_modules"))) {
+        if (exists(join7(dir, "package.json")) || exists(join7(dir, "node_modules"))) {
           return dir;
         }
         if (prev === dir) {
@@ -309,7 +318,7 @@ var require_bindings = __commonJS({
           );
         }
         prev = dir;
-        dir = join4(dir, "..");
+        dir = join7(dir, "..");
       }
     };
   }
@@ -510,13 +519,13 @@ var require_backup = __commonJS({
     var runBackup = (backup, handler) => {
       let rate = 0;
       let useDefault = true;
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve3, reject) => {
         setImmediate(function step() {
           try {
             const progress = backup.transfer(rate);
             if (!progress.remainingPages) {
               backup.close();
-              resolve(progress);
+              resolve3(progress);
               return;
             }
             if (useDefault) {
@@ -930,15 +939,141 @@ var init_quantize = __esm({
   }
 });
 
+// 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();
+  }
+});
+
+// src/installer/config.ts
+function configPath() {
+  return (0, import_node_path6.join)(recallRoot(), "config.json");
+}
+function satelliteTokenPath() {
+  return (0, import_node_path6.join)(recallRoot(), "satellite-token");
+}
+function readConfig() {
+  const p = configPath();
+  if (!(0, import_node_fs6.existsSync)(p))
+    return null;
+  try {
+    return JSON.parse((0, import_node_fs6.readFileSync)(p, "utf-8"));
+  } catch (err) {
+    log({
+      source: "installer/config",
+      level: "warn",
+      summary: `config.json unparseable (${err.message}) \u2014 treating as absent`
+    });
+    return null;
+  }
+}
+function readSatelliteConfig() {
+  const sat = readConfig()?.satellite;
+  if (!sat || typeof sat.hubUrl !== "string" || sat.hubUrl.length === 0)
+    return null;
+  let token = null;
+  try {
+    const raw = (0, import_node_fs6.readFileSync)(satelliteTokenPath(), "utf-8").trim();
+    if (raw.length > 0)
+      token = raw;
+  } catch {
+  }
+  return { hubUrl: sat.hubUrl, host: typeof sat.host === "string" ? sat.host : "", token };
+}
+var import_node_fs6, import_node_path6;
+var init_config = __esm({
+  "src/installer/config.ts"() {
+    "use strict";
+    import_node_fs6 = require("node:fs");
+    import_node_path6 = require("node:path");
+    init_paths();
+    init_log();
+    init_settings_merge();
+  }
+});
+
 // src/hooks/stop-hook.ts
 var stop_hook_exports = {};
 __export(stop_hook_exports, {
   resolveIngestTarget: () => resolveIngestTarget,
+  retryBusyIngest: () => retryBusyIngest,
   vendorForTranscript: () => vendorForTranscript
 });
 module.exports = __toCommonJS(stop_hook_exports);
 
+// src/recall/embed-failures.ts
+init_paths();
+
+// src/adapters/system-context.ts
+function firstTextContent(message) {
+  if (!message)
+    return void 0;
+  const content = message.content;
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    const firstText = content.find(
+      (b) => typeof b === "object" && b !== null && b.type === "text"
+    );
+    if (firstText && "text" in firstText) {
+      return firstText.text;
+    }
+  }
+  return void 0;
+}
+function isSystemContextContent(message) {
+  if (!message || message.role !== "user")
+    return false;
+  const text = firstTextContent(message);
+  if (!text)
+    return false;
+  if (text.startsWith("<system-reminder>"))
+    return true;
+  if (text.startsWith("<environment_context>"))
+    return true;
+  if (text.startsWith("<INSTRUCTIONS>"))
+    return true;
+  if (text.startsWith("# AGENTS.md instructions for"))
+    return true;
+  if (text.startsWith("<context>"))
+    return true;
+  if (text.startsWith("<task-notification>"))
+    return true;
+  if (text.startsWith("<command-name>"))
+    return true;
+  if (text.startsWith("<local-command-stdout>"))
+    return true;
+  if (text.startsWith("<local-command-caveat>"))
+    return true;
+  return false;
+}
+
 // src/recall/transcript-utils.ts
+var META_KEEP_PREFIXES = [
+  "<task-notification>",
+  "[SYSTEM NOTIFICATION",
+  "Another Claude session sent a message"
+];
+function shouldDropAsMeta(entry) {
+  if (entry.isMeta !== true)
+    return false;
+  const text = firstTextContent(entry.message);
+  if (text && META_KEEP_PREFIXES.some((prefix) => text.startsWith(prefix))) {
+    return false;
+  }
+  return true;
+}
 function stripToolContent(entries) {
   const out = [];
   for (const entry of entries) {
@@ -988,11 +1123,12 @@ Run \`recall doctor\` for details.`
   }
 };
 var MigrationPendingError = class extends Error {
-  constructor(dbPath2) {
+  constructor(dbPath2, kind = "retrieval-class") {
     super(
-      "recall: this database needs a one-time schema migration \u2014 run `recall install` to finish it. (Normal commands refuse to rewrite the index unattended.)"
+      kind === "codex-rekey" ? "recall: this database needs a one-time Codex message-id migration \u2014 run `recall install` (or `recall repair --rekey-codex`) to finish it. (Normal commands refuse to rewrite the index unattended.)" : "recall: this database needs a one-time schema migration \u2014 run `recall install` to finish it. (Normal commands refuse to rewrite the index unattended.)"
     );
     this.dbPath = dbPath2;
+    this.kind = kind;
     this.name = "MigrationPendingError";
   }
 };
@@ -1033,16 +1169,43 @@ function getDb(dbPath2, opts) {
     }
     db = adapter;
     currentDbPath = dbPath2;
+    ensureStemScratch(db);
     log({ source: "db", level: "info", summary: `DB: opened pending-migration DB at ${dbPath2} (installer mode)` });
     return db;
   }
+  if (isCodexRekeyPending(adapter) && !opts?.allowPendingMigration) {
+    raw.close();
+    throw new MigrationPendingError(dbPath2, "codex-rekey");
+  }
   db = adapter;
   currentDbPath = dbPath2;
-  ensureSchema(db);
+  try {
+    ensureSchema(db);
+    ensureStemScratch(db);
+  } catch (error) {
+    closeDb();
+    throw error;
+  }
   log({ source: "db", level: "info", summary: `DB: initialized at ${dbPath2}` });
   return db;
 }
+function ensureStemScratch(db3) {
+  db3.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS temp._stem USING fts5(
+      t, tokenize='porter unicode61'
+    );
+    CREATE VIRTUAL TABLE IF NOT EXISTS temp._stem_vocab
+      USING fts5vocab(temp, _stem, 'row');
+  `);
+}
 var RETRIEVAL_MIGRATION_KEY = "retrieval_class_migration";
+function rethrowIfBusy(err) {
+  const code = err?.code;
+  const message = err?.message;
+  if (typeof code === "string" && code.startsWith("SQLITE_BUSY") || typeof message === "string" && /database is locked|SQLITE_BUSY/i.test(message))
+    throw err;
+}
+var PROJECT_KEY_BACKFILL_KEY = "project_key_backfill";
 function isRetrievalMigrationPending(d) {
   try {
     const hasMessages = d.get(
@@ -1060,13 +1223,40 @@ function isRetrievalMigrationPending(d) {
       [RETRIEVAL_MIGRATION_KEY]
     );
     return row?.value !== "complete";
-  } catch {
+  } catch (err) {
+    rethrowIfBusy(err);
+    return true;
+  }
+}
+var CODEX_REKEY_MIGRATION_KEY = "codex_message_id_v2";
+function isCodexRekeyPending(d) {
+  try {
+    const hasMessages = d.get(
+      `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'messages'`
+    );
+    if (!hasMessages)
+      return false;
+    const hasMeta = d.get(
+      `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'schema_meta'`
+    );
+    if (!hasMeta)
+      return true;
+    const row = d.get(
+      `SELECT value FROM schema_meta WHERE key = ?`,
+      [CODEX_REKEY_MIGRATION_KEY]
+    );
+    return row?.value !== "complete";
+  } catch (err) {
+    rethrowIfBusy(err);
     return true;
   }
 }
 function closeDb() {
-  if (db) {
+  if (!db)
+    return;
+  try {
     db.close();
+  } finally {
     db = null;
     currentDbPath = null;
   }
@@ -1186,6 +1376,7 @@ var RETRIEVAL_SCHEMA_DDL = {
       created_at      INTEGER NOT NULL,
       message_role    TEXT,
       retrieval_class TEXT NOT NULL DEFAULT 'hot',
+      project_key     TEXT,
       UNIQUE(session_id, message_id)
     );
 
@@ -1275,15 +1466,18 @@ var RETRIEVAL_SCHEMA_DDL = {
   `
 };
 function ensureSchema(db3) {
+  const fresh = !db3.get(
+    `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'messages'`
+  );
   db3.exec("BEGIN IMMEDIATE");
   try {
     db3.exec(RETRIEVAL_SCHEMA_DDL.tables);
     db3.exec(RETRIEVAL_SCHEMA_DDL.fts);
     db3.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS _stem USING fts5(
+      CREATE VIRTUAL TABLE IF NOT EXISTS main._stem USING fts5(
         t, tokenize='porter unicode61'
       );
-      CREATE VIRTUAL TABLE IF NOT EXISTS _stem_vocab
+      CREATE VIRTUAL TABLE IF NOT EXISTS main._stem_vocab
         USING fts5vocab(_stem, 'row');
     `);
     db3.exec(`
@@ -1304,6 +1498,16 @@ function ensureSchema(db3) {
           throw e;
       }
     }
+    const hasProjectKey = () => db3.all(`PRAGMA table_info(messages)`).some((c) => c.name === "project_key");
+    if (!hasProjectKey()) {
+      try {
+        db3.exec(`ALTER TABLE messages ADD COLUMN project_key TEXT`);
+      } catch (e) {
+        if (!hasProjectKey())
+          throw e;
+      }
+    }
+    db3.exec(`CREATE INDEX IF NOT EXISTS idx_messages_project_key ON messages(project_key)`);
     db3.exec(`
       CREATE TABLE IF NOT EXISTS ingest_watermark (
         transcript_path TEXT PRIMARY KEY,
@@ -1317,6 +1521,18 @@ function ensureSchema(db3) {
       INSERT OR IGNORE INTO schema_meta(key, value)
       VALUES ('${RETRIEVAL_MIGRATION_KEY}', 'complete');
     `);
+    if (fresh) {
+      db3.exec(`
+        INSERT OR IGNORE INTO schema_meta(key, value)
+        VALUES ('${CODEX_REKEY_MIGRATION_KEY}', 'complete');
+      `);
+    }
+    if (fresh) {
+      db3.exec(`
+        INSERT OR IGNORE INTO schema_meta(key, value)
+        VALUES ('${PROJECT_KEY_BACKFILL_KEY}', 'complete');
+      `);
+    }
     db3.exec("COMMIT");
   } catch (e) {
     try {
@@ -1348,10 +1564,11 @@ function ensureDir2() {
 }
 function insertMessages(messages, opts) {
   if (messages.length === 0 && !opts?.replaceSessionId && !opts?.provenance)
-    return;
+    return 0;
   ensureDir2();
   const d = db2();
   d.exec("BEGIN IMMEDIATE");
+  let inserted = 0;
   try {
     if (opts?.replaceSessionId) {
       d.run(
@@ -1363,20 +1580,65 @@ function insertMessages(messages, opts) {
     }
     const stmt = d.prepare(
       `INSERT OR IGNORE INTO messages
-       (message_id, session_id, message_seq, message_text, project_id, created_at, message_role, retrieval_class)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+       (message_id, session_id, message_seq, message_text, project_id, created_at, message_role, retrieval_class, project_key)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
     );
+    const invalidatedSessions = /* @__PURE__ */ new Set();
+    const sourceIds = /* @__PURE__ */ new Map();
     for (const m of messages) {
-      stmt.run([
-        m.message_id,
+      const ids = sourceIds.get(m.session_id) ?? /* @__PURE__ */ new Set();
+      ids.add(m.message_id);
+      ids.add(`session:${m.session_id}:${m.message_id}`);
+      sourceIds.set(m.session_id, ids);
+    }
+    if (opts?.provenance && opts.sourceMessageIds) {
+      const sid = opts.provenance.sessionId;
+      const ids = sourceIds.get(sid);
+      for (const id of opts.sourceMessageIds) {
+        ids?.add(id);
+        ids?.add(`session:${sid}:${id}`);
+      }
+    }
+    const partialSessions = /* @__PURE__ */ new Map();
+    const maxStoredSeq = /* @__PURE__ */ new Map();
+    for (const [sid, ids] of sourceIds) {
+      const stored = d.all("SELECT message_id, message_seq FROM messages WHERE session_id = ?", [sid]);
+      const max = stored.reduce((acc, r) => Math.max(acc, r.message_seq), -1);
+      maxStoredSeq.set(sid, max);
+      if (stored.some((r) => !ids.has(r.message_id)))
+        partialSessions.set(sid, max);
+    }
+    for (const m of messages) {
+      const scopedId = `session:${m.session_id}:${m.message_id}`;
+      const scoped = d.get("SELECT message_id FROM messages WHERE message_id = ? AND session_id = ?", [scopedId, m.session_id]);
+      const owner = d.get("SELECT session_id FROM messages WHERE message_id = ?", [m.message_id]);
+      const id = scoped || owner && owner.session_id !== m.session_id ? scopedId : m.message_id;
+      const existing = d.get("SELECT message_seq FROM messages WHERE message_id = ? AND session_id = ?", [id, m.session_id]);
+      let sequence = m.message_seq;
+      if (partialSessions.has(m.session_id)) {
+        sequence = existing?.message_seq ?? partialSessions.get(m.session_id) + 1;
+        partialSessions.set(m.session_id, Math.max(partialSessions.get(m.session_id), sequence));
+      }
+      const insertsPredecessor = !existing && sequence <= (maxStoredSeq.get(m.session_id) ?? -1);
+      if (existing && existing.message_seq !== sequence || insertsPredecessor) {
+        if (!invalidatedSessions.has(m.session_id)) {
+          d.run("DELETE FROM message_vectors WHERE message_id IN (SELECT message_id FROM messages WHERE session_id = ?)", [m.session_id]);
+          invalidatedSessions.add(m.session_id);
+        }
+        d.run("UPDATE messages SET message_seq = ? WHERE message_id = ? AND session_id = ?", [sequence, id, m.session_id]);
+      }
+      maxStoredSeq.set(m.session_id, Math.max(maxStoredSeq.get(m.session_id) ?? -1, sequence));
+      inserted += stmt.run([
+        id,
         m.session_id,
-        m.message_seq,
+        sequence,
         m.message_text,
         m.project_id,
         m.created_at,
         m.message_role,
-        m.retrieval_class ?? "hot"
-      ]);
+        m.retrieval_class ?? "hot",
+        m.project_key ?? null
+      ]).changes;
     }
     if (opts?.provenance) {
       const p = opts.provenance;
@@ -1416,6 +1678,15 @@ function insertMessages(messages, opts) {
         );
       }
     }
+    if (opts?.adopt) {
+      const { sessionId, projectKey, projectId } = opts.adopt;
+      if (projectKey !== null) {
+        d.run("UPDATE messages SET project_key = ? WHERE session_id = ? AND project_key IS NULL", [projectKey, sessionId]);
+      }
+      if (projectId !== null && projectId !== "") {
+        d.run("UPDATE messages SET project_id = ? WHERE session_id = ? AND (project_id IS NULL OR project_id = '')", [projectId, sessionId]);
+      }
+    }
     for (const a of opts?.aliases ?? []) {
       d.run(
         `INSERT OR REPLACE INTO session_aliases (alias_id, session_id, source, created_at)
@@ -1424,11 +1695,23 @@ function insertMessages(messages, opts) {
       );
     }
     d.exec("COMMIT");
+    return inserted;
   } catch (e) {
     d.exec("ROLLBACK");
     throw e;
   }
 }
+function hasSessionMessages(sessionId) {
+  try {
+    const row = db2().get(
+      "SELECT 1 FROM messages WHERE session_id = ? LIMIT 1",
+      [sessionId]
+    );
+    return row != null;
+  } catch {
+    return false;
+  }
+}
 
 // src/recall/session-classifier.ts
 init_paths();
@@ -1437,6 +1720,83 @@ init_log();
 // src/adapters/codex/codex-jsonl-reader.ts
 var fs = __toESM(require("fs"));
 init_log();
+
+// src/recall/transcript-roots.ts
+var import_node_os2 = require("node:os");
+var import_node_path4 = require("node:path");
+
+// src/hub/runtime.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
+init_paths();
+var STALE_RECORD_MS = 60 * 60 * 1e3;
+var REFUSED_RECENT_MAX = 5;
+function hubHostsPath() {
+  return (0, import_node_path3.join)(runDir(), "hub-hosts.json");
+}
+function readHostRecords() {
+  try {
+    const parsed = JSON.parse((0, import_node_fs3.readFileSync)(hubHostsPath(), "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return {};
+    const out = {};
+    for (const [host, rec] of Object.entries(parsed)) {
+      if (!rec || typeof rec !== "object")
+        continue;
+      const r = rec;
+      out[host] = {
+        ...typeof r["lastPushAt"] === "string" ? { lastPushAt: r["lastPushAt"] } : {},
+        ...typeof r["lastQueryAt"] === "string" ? { lastQueryAt: r["lastQueryAt"] } : {},
+        ...typeof r["lastFullManifestAt"] === "string" ? { lastFullManifestAt: r["lastFullManifestAt"] } : {},
+        refusedCollisions: typeof r["refusedCollisions"] === "number" ? r["refusedCollisions"] : 0,
+        refusedRecent: Array.isArray(r["refusedRecent"]) ? r["refusedRecent"].filter((v) => typeof v === "string").slice(0, REFUSED_RECENT_MAX) : []
+      };
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+// src/recall/transcript-roots.ts
+init_log();
+var DRVFS = /^\/mnt\/[a-zA-Z]\//;
+var warned = /* @__PURE__ */ new Set();
+function defaultCodexRoot() {
+  return (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".codex");
+}
+function guardedHosts(override) {
+  if (process.platform !== "linux")
+    return [];
+  const abs = (0, import_node_path4.resolve)(override).replace(/\\/g, "/");
+  if (!DRVFS.test(abs.endsWith("/") ? abs : `${abs}/`))
+    return [];
+  return Object.keys(readHostRecords());
+}
+function resolveRoot(envVar, fallback) {
+  const override = process.env[envVar];
+  if (!override || override.length === 0)
+    return fallback;
+  const hosts = guardedHosts(override);
+  if (hosts.length === 0)
+    return override;
+  if (!warned.has(envVar)) {
+    warned.add(envVar);
+    log({
+      level: "warn",
+      source: "transcript-roots",
+      summary: `ignoring ${envVar}=${override}: this hub serves satellite ${hosts.join(", ")} and that tree is pushed by a satellite; set the variable elsewhere or unset it`
+    });
+  }
+  return fallback;
+}
+function codexRoot() {
+  return resolveRoot("CODEX_HOME", defaultCodexRoot());
+}
+
+// src/adapters/codex/codex-jsonl-reader.ts
+var META_READ_LIMIT = 256 * 1024;
+var META_CHUNK_SIZE = 8192;
 function parseCodexJsonlFile(filepath) {
   try {
     const content = fs.readFileSync(filepath, "utf-8");
@@ -1456,20 +1816,39 @@ function parseCodexJsonlFile(filepath) {
     return records;
   } catch (error) {
     log({ level: "error", source: "codex-jsonl-reader", summary: `Failed to read ${filepath}: ${error instanceof Error ? error.message : String(error)}`, data: { filepath, error: String(error) } });
-    return [];
+    throw error;
   }
 }
 function extractCodexSessionMeta(filepath) {
   let fd = null;
   try {
     fd = fs.openSync(filepath, "r");
-    const buffer = Buffer.alloc(8192);
-    const bytesRead = fs.readSync(fd, buffer, 0, 8192, 0);
-    if (bytesRead === 0)
+    const chunks = [];
+    let position = 0;
+    let newlineIdx = -1;
+    let atEof = false;
+    while (position < META_READ_LIMIT) {
+      const chunk = Buffer.alloc(Math.min(META_CHUNK_SIZE, META_READ_LIMIT - position));
+      const bytesRead = fs.readSync(fd, chunk, 0, chunk.length, position);
+      if (bytesRead === 0) {
+        atEof = true;
+        break;
+      }
+      const slice = chunk.subarray(0, bytesRead);
+      const idx = slice.indexOf(10);
+      chunks.push(slice);
+      if (idx >= 0) {
+        newlineIdx = position + idx;
+        break;
+      }
+      position += bytesRead;
+    }
+    if (chunks.length === 0)
+      return null;
+    if (newlineIdx < 0 && !atEof)
       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 joined = Buffer.concat(chunks);
+    const firstLine = (newlineIdx >= 0 ? joined.subarray(0, newlineIdx) : joined).toString("utf-8");
     const record = JSON.parse(firstLine.trim());
     if (record.type !== "session_meta")
       return null;
@@ -1661,7 +2040,10 @@ function parseSubagentSource(source, _transcriptPath) {
   const looksSubagent = subRaw !== void 0 || typeTag === "subagent";
   if (!looksSubagent)
     return none;
-  if (subRaw !== void 0 && (typeof subRaw !== "object" || subRaw === null)) {
+  if (typeof subRaw === "string" && ["review", "compact", "memory_consolidation"].includes(subRaw)) {
+    return { ...none, isSubagent: true, meta: { type: subRaw } };
+  }
+  if (subRaw !== void 0 && (typeof subRaw !== "object" || subRaw === null || Array.isArray(subRaw))) {
     return { ...none, malformed: true };
   }
   const sub = subRaw ?? {};
@@ -1670,7 +2052,7 @@ function parseSubagentSource(source, _transcriptPath) {
   const parentThreadId = typeof spawn2.parent_thread_id === "string" && spawn2.parent_thread_id ? spawn2.parent_thread_id : null;
   const depth = typeof spawn2.depth === "number" && Number.isFinite(spawn2.depth) ? spawn2.depth : null;
   const meta = {};
-  for (const k of ["agent_path", "agent_type", "agent_name", "path", "type", "name"]) {
+  for (const k of ["agent_path", "agent_type", "agent_name", "agent_nickname", "agent_role", "path", "type", "name"]) {
     const v = spawn2[k] ?? sub[k];
     if (typeof v === "string" || typeof v === "number")
       meta[k] = v;
@@ -1698,6 +2080,255 @@ function normalizePath(p) {
   return normalized;
 }
 
+// src/recall/project-key.ts
+var import_node_fs4 = require("node:fs");
+var import_node_os3 = require("node:os");
+var import_node_child_process = require("node:child_process");
+var cache = /* @__PURE__ */ new Map();
+var GIT_TIMEOUT_MS = 3e3;
+function runGit(cwd, args, timeout) {
+  return (0, import_node_child_process.spawnSync)("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    ...timeout === void 0 ? {} : { timeout },
+    windowsHide: true
+  });
+}
+function isTransient(r) {
+  const code = r.error?.code;
+  if (code !== void 0 && code !== "ENOENT")
+    return true;
+  return r.signal != null;
+}
+function foldKeyPath(p, platform = process.platform) {
+  if (/^[A-Za-z]:\//.test(p))
+    return p.toLowerCase();
+  if (/^\/(?!\/)/.test(p))
+    return p;
+  return platform === "win32" ? p.toLowerCase() : p;
+}
+function wslUncToPosix(p) {
+  let s = p.trim();
+  if (/^[\\/]{2}\?[\\/]UNC[\\/]/i.test(s))
+    s = "//" + s.slice(8);
+  else if (/^[\\/]{2}\?[\\/]/.test(s))
+    s = s.slice(4);
+  const m = /^[\\/]{2}(?:wsl\$|wsl\.localhost)[\\/]+([^\\/]+)(?:[\\/]+(.*))?$/i.exec(s);
+  if (!m)
+    return void 0;
+  const rest = (m[2] ?? "").replace(/[\\/]+/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
+  return { distro: m[1], posix: "/" + rest };
+}
+var MAX_RESOLVE_DEPTH = 64;
+function resolveCaseInsensitive(p) {
+  if ((0, import_node_fs4.existsSync)(p))
+    return p;
+  const home = (0, import_node_os3.homedir)();
+  if (!home || home === "/")
+    return void 0;
+  const prefix = home.replace(/\/+$/, "") + "/";
+  if (!p.toLowerCase().startsWith(prefix.toLowerCase()))
+    return void 0;
+  let current = prefix.slice(0, -1);
+  if (!(0, import_node_fs4.existsSync)(current))
+    return void 0;
+  const segments = p.slice(prefix.length).split("/").filter((seg) => seg.length > 0);
+  if (segments.length > MAX_RESOLVE_DEPTH)
+    return void 0;
+  for (const seg of segments) {
+    const exact = current + "/" + seg;
+    if ((0, import_node_fs4.existsSync)(exact)) {
+      current = exact;
+      continue;
+    }
+    let entries;
+    try {
+      entries = (0, import_node_fs4.readdirSync)(current);
+    } catch {
+      return void 0;
+    }
+    const lower = seg.toLowerCase();
+    const hits = entries.filter((e) => e.toLowerCase() === lower);
+    if (hits.length !== 1)
+      return void 0;
+    current = current + "/" + hits[0];
+  }
+  return (0, import_node_fs4.existsSync)(current) ? current : void 0;
+}
+function pathKey(p) {
+  const unc = wslUncToPosix(p);
+  if (unc)
+    return "path:" + unc.posix;
+  return "path:" + foldKeyPath(normalizePath(p));
+}
+var upgradeCache = /* @__PURE__ */ new Map();
+function upgradeLocalPathKey(key) {
+  if (!key.startsWith("path:"))
+    return key;
+  const hit = upgradeCache.get(key);
+  if (hit !== void 0)
+    return hit;
+  const answer = (() => {
+    const raw = key.slice("path:".length);
+    const unc = wslUncToPosix(raw);
+    const p = unc ? unc.posix : raw;
+    if (!/^\/(?!\/)/.test(p))
+      return key;
+    const dir = resolveCaseInsensitive(p);
+    if (dir === void 0)
+      return key;
+    const r = deriveProjectKey(dir);
+    if (r.key && (r.kind === "git" || r.kind === "origin"))
+      return r.key;
+    return key;
+  })();
+  upgradeCache.set(key, answer);
+  return answer;
+}
+function normalizeOrigin(url) {
+  let s = url.trim();
+  if (!s)
+    return void 0;
+  if (/^file:\/\//i.test(s))
+    return void 0;
+  if (/^[A-Za-z]:/.test(s))
+    return void 0;
+  const scheme = /^([A-Za-z][A-Za-z0-9+.-]*:)?\/\//.exec(s);
+  if (scheme) {
+    s = s.slice(scheme[0].length);
+  } else if (s.includes("://")) {
+    return void 0;
+  }
+  const firstSlash = s.indexOf("/");
+  const authEnd = firstSlash < 0 ? s.length : firstSlash;
+  const at = s.lastIndexOf("@", authEnd - 1);
+  if (at >= 0)
+    s = s.slice(at + 1);
+  if (!scheme) {
+    if (s.startsWith("/") || s.startsWith("."))
+      return void 0;
+    const colon = s.indexOf(":");
+    if (colon < 0)
+      return void 0;
+    s = s.slice(0, colon) + "/" + s.slice(colon + 1).replace(/^\/+/, "");
+  }
+  const slash = s.indexOf("/");
+  let host = slash < 0 ? s : s.slice(0, slash);
+  const rest = slash < 0 ? "" : s.slice(slash);
+  const port = /^(.*):(\d+)$/.exec(host);
+  if (port)
+    host = port[1];
+  if (!host)
+    return void 0;
+  s = host + rest;
+  s = s.replace(/\/+$/, "");
+  s = s.replace(/\.git$/i, "");
+  s = s.replace(/\/+$/, "");
+  if (!s.includes("/"))
+    return void 0;
+  return s.toLowerCase();
+}
+function transient() {
+  return { key: void 0, kind: "transient", transientFailure: true };
+}
+function deriveProjectKey(cwd) {
+  const cacheKey = normalizePath(cwd);
+  const hit = cache.get(cacheKey);
+  if (hit)
+    return hit;
+  const result = derive(cwd);
+  if (!result.transientFailure)
+    cache.set(cacheKey, result);
+  return result;
+}
+function derive(cwd) {
+  if (!(0, import_node_fs4.existsSync)(cwd))
+    return { kind: "path", key: pathKey(cwd) };
+  let rev = runGit(cwd, ["rev-parse", "--is-shallow-repository", "--show-toplevel"], GIT_TIMEOUT_MS);
+  if (rev.error?.code === "ENOENT") {
+    return { kind: "path", key: pathKey(cwd), gitMissing: true };
+  }
+  if (isTransient(rev)) {
+    rev = runGit(cwd, ["rev-parse", "--is-shallow-repository", "--show-toplevel"]);
+    if (rev.error?.code === "ENOENT") {
+      return { kind: "path", key: pathKey(cwd), gitMissing: true };
+    }
+    if (isTransient(rev))
+      return transient();
+  }
+  if (rev.status === 128)
+    return { kind: "path", key: pathKey(cwd) };
+  if (rev.status !== 0)
+    return { kind: "path", key: pathKey(cwd) };
+  const lines = (rev.stdout ?? "").split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  const shallow = lines[0] === "true";
+  const toplevel = lines[1];
+  if (!shallow) {
+    const args = ["--no-replace-objects", "rev-list", "--max-parents=0", "--format=%ct %H", "HEAD"];
+    let roots = runGit(cwd, args, GIT_TIMEOUT_MS);
+    if (isTransient(roots)) {
+      roots = runGit(cwd, args);
+      if (isTransient(roots))
+        return transient();
+    }
+    if (roots.status === 0) {
+      const parsed = [];
+      for (const line of (roots.stdout ?? "").split("\n")) {
+        const t = line.trim();
+        if (!t || t.startsWith("commit "))
+          continue;
+        const m = /^(\d+)\s+([0-9a-f]{40})$/.exec(t);
+        if (m)
+          parsed.push({ ct: Number(m[1]), hash: m[2] });
+      }
+      parsed.sort((a, b) => a.ct - b.ct || (a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0));
+      const first = parsed[0];
+      if (first) {
+        return { kind: "git", key: "git:" + first.hash, ...toplevel ? { toplevel } : {} };
+      }
+    }
+  }
+  let origin = runGit(cwd, ["config", "--get", "remote.origin.url"], GIT_TIMEOUT_MS);
+  if (isTransient(origin)) {
+    origin = runGit(cwd, ["config", "--get", "remote.origin.url"]);
+    if (isTransient(origin))
+      return transient();
+  }
+  if (origin.status === 0) {
+    const value = normalizeOrigin(origin.stdout ?? "");
+    if (value)
+      return { kind: "origin", key: "origin:" + value, ...toplevel ? { toplevel } : {} };
+  }
+  return { kind: "path", key: pathKey(toplevel ?? cwd), ...toplevel ? { toplevel } : {} };
+}
+
+// src/recall/mirror-meta.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path5 = require("node:path");
+init_paths();
+function isUnderRemoteRoot(p) {
+  return (0, import_node_path5.resolve)(p).startsWith((0, import_node_path5.resolve)(remoteRoot()) + import_node_path5.sep);
+}
+function readMirrorMeta(transcriptPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs5.readFileSync)(`${transcriptPath}.meta.json`, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object")
+    return null;
+  const m = parsed;
+  if (m["v"] !== 1)
+    return null;
+  if (m["key"] !== void 0 && typeof m["key"] !== "string")
+    return null;
+  if (m["cwd"] !== void 0 && typeof m["cwd"] !== "string")
+    return null;
+  return parsed;
+}
+
 // src/recall/message-ingest.ts
 init_log();
 
@@ -1727,48 +2358,11 @@ function parseJsonlFile(filepath) {
     return entries;
   } catch (error) {
     log({ level: "error", source: "jsonl-reader", summary: `Failed to read JSONL file ${filepath}: ${error instanceof Error ? error.message : String(error)}`, data: { filepath, error: String(error) } });
-    return [];
+    throw error;
   }
 }
 
 // src/adapters/claude/claude-entry-adapter.ts
-function isSystemContextContent(message) {
-  if (!message || message.role !== "user")
-    return false;
-  const content = message.content;
-  let text;
-  if (typeof content === "string") {
-    text = content;
-  } else if (Array.isArray(content)) {
-    const firstText = content.find(
-      (b) => typeof b === "object" && b !== null && b.type === "text"
-    );
-    if (firstText && "text" in firstText) {
-      text = firstText.text;
-    }
-  }
-  if (!text)
-    return false;
-  if (text.startsWith("<system-reminder>"))
-    return true;
-  if (text.startsWith("<environment_context>"))
-    return true;
-  if (text.startsWith("<INSTRUCTIONS>"))
-    return true;
-  if (text.startsWith("# AGENTS.md instructions for"))
-    return true;
-  if (text.startsWith("<context>"))
-    return true;
-  if (text.startsWith("<task-notification>"))
-    return true;
-  if (text.startsWith("<command-name>"))
-    return true;
-  if (text.startsWith("<local-command-stdout>"))
-    return true;
-  if (text.startsWith("<local-command-caveat>"))
-    return true;
-  return false;
-}
 function sanitizeContentBlocks(content) {
   if (typeof content === "string")
     return content;
@@ -1988,15 +2582,17 @@ function emitMessage(payload, base, model, counter) {
   if (role === "developer")
     return [];
   if (role === "user") {
+    const message = {
+      role: "user",
+      content: adaptContentItems(contentItems)
+    };
     return [
       {
         type: "user",
         uuid: generateId(base.sessionId, counter),
         ...base,
-        message: {
-          role: "user",
-          content: adaptContentItems(contentItems)
-        }
+        message,
+        ...isSystemContextContent(message) && { isMeta: true }
       }
     ];
   }
@@ -2473,6 +3069,11 @@ function parseCodexPatch(input) {
       currentKind = "update";
       continue;
     }
+    const moveMatch = line.match(/^\*\*\* Move to:\s*(.+)$/);
+    if (moveMatch && currentKind === "update") {
+      currentPath = moveMatch[1].trim();
+      continue;
+    }
     const addMatch = line.match(/^\*\*\* Add File:\s*(.+)$/);
     if (addMatch) {
       flushCurrent();
@@ -2508,7 +3109,7 @@ function parseCodexPatch(input) {
   return changes;
 }
 function generateId(sessionId, counter) {
-  return `codex-jsonl-${sessionId.slice(0, 8)}-${counter}`;
+  return `codex-jsonl-${sessionId}-${counter}`;
 }
 
 // src/recall/message-ingest.ts
@@ -2517,12 +3118,19 @@ function extractEntryText(entry) {
   if (!msg)
     return "";
   if (typeof msg.content === "string")
-    return msg.content.trim();
+    return msg.content.replaceAll("\0", "").trim();
   if (Array.isArray(msg.content)) {
-    return msg.content.filter((b) => b.type === "text").map((b) => b.text?.trim()).filter(Boolean).join("\n\n");
+    return msg.content.filter((b) => b.type === "text").map((b) => b.text?.replaceAll("\0", "").trim()).filter(Boolean).join("\n\n");
   }
   return "";
 }
+function loadTranscriptEntries(transcriptPath, vendor, canonicalSessionId) {
+  if (vendor === "claude") {
+    const raw = parseJsonlFile(transcriptPath);
+    return adaptClaudeEntries(raw);
+  }
+  return adaptCodexJsonlRecords(parseCodexJsonlFile(transcriptPath), canonicalSessionId);
+}
 function entriesCwd(entries) {
   for (const e of entries) {
     if (e.cwd)
@@ -2563,13 +3171,7 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
   }));
   let rawEntries;
   try {
-    if (vendor === "claude") {
-      const raw = parseJsonlFile(transcriptPath);
-      rawEntries = adaptClaudeEntries(raw);
-    } else {
-      const envelopes = parseCodexJsonlFile(transcriptPath);
-      rawEntries = adaptCodexJsonlRecords(envelopes, canonicalId);
-    }
+    rawEntries = loadTranscriptEntries(transcriptPath, vendor, canonicalId);
   } catch (err) {
     return {
       sessionId: canonicalId,
@@ -2590,11 +3192,22 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
   }
   const rawProjectId = options?.projectId ?? entriesCwd(rawEntries);
   const projectId = rawProjectId ? normalizePath(rawProjectId) : null;
+  const localKey = () => {
+    const k = deriveProjectKey(rawProjectId).key ?? null;
+    return k !== null && wslUncToPosix(rawProjectId) ? upgradeLocalPathKey(k) : k;
+  };
+  const sidecarKey = () => {
+    const k = readMirrorMeta(transcriptPath)?.key;
+    return k === void 0 ? null : upgradeLocalPathKey(k);
+  };
+  const projectKey = rawProjectId ? options?.projectKey !== void 0 ? options.projectKey : isUnderRemoteRoot(transcriptPath) ? sidecarKey() : localKey() : null;
   const filtered = stripToolContent(rawEntries);
   const topLevel = filtered.filter((e) => !e.parentToolUseID);
   const records = [];
   for (let i = 0; i < topLevel.length; i++) {
     const entry = topLevel[i];
+    if (shouldDropAsMeta(entry))
+      continue;
     if (!entry.uuid)
       continue;
     const text = extractEntryText(entry);
@@ -2609,7 +3222,8 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
       project_id: projectId,
       created_at: createdAt,
       message_role: entry.message?.role ?? entry.type ?? null,
-      retrieval_class: retrievalClass
+      retrieval_class: retrievalClass,
+      project_key: projectKey
     });
   }
   if (records.length === 0) {
@@ -2621,11 +3235,19 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
     }
     return { sessionId: canonicalId, chunksCreated: 0, skipped: true, retrievalClass };
   }
+  let inserted = 0;
+  const previouslyIndexed = hasSessionMessages(canonicalId);
   try {
-    insertMessages(records, {
+    inserted = insertMessages(records, {
+      sourceMessageIds: topLevel.flatMap((e) => e.uuid ? [e.uuid] : []),
       ...options?.force ? { replaceSessionId: canonicalId } : {},
       provenance,
-      aliases
+      aliases,
+      // Same identity this chunk's own rows get; back-fills the session's
+      // NULL-identity rows atomically with the insert (M2). Runs on every
+      // ingest path — push, sweep, backfill — so a sweep of a mirror whose
+      // sidecar now carries the key repairs rows without a new push.
+      adopt: { sessionId: canonicalId, projectKey, projectId }
     });
   } catch (err) {
     return {
@@ -2636,26 +3258,58 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
       retrievalClass
     };
   }
+  if (!previouslyIndexed && inserted < records.length) {
+    log({ source: "recall:ingest", level: "warn", summary: `Session ${canonicalId}: ${records.length} records offered, ${inserted} inserted (duplicate message IDs)` });
+  }
   return {
     sessionId: canonicalId,
-    chunksCreated: records.length,
+    chunksCreated: inserted,
+    recordsOffered: records.length,
     skipped: false,
     retrievalClass
   };
 }
 
 // src/hooks/stop-hook.ts
+init_config();
 init_paths();
 var import_fs = require("fs");
 var import_child_process = require("child_process");
 var import_path = require("path");
-function vendorForTranscript(transcriptPath, codexHome = process.env["CODEX_HOME"]) {
+var import_promises = require("node:timers/promises");
+async function retryBusyIngest(operation) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      const result = await operation();
+      if (attempt < 2 && result.error && /database is locked|SQLITE_BUSY/i.test(result.error)) {
+        await (0, import_promises.setTimeout)(25 * (attempt + 1));
+        continue;
+      }
+      return result;
+    } catch (error) {
+      if (attempt >= 2 || !/database is locked|SQLITE_BUSY/i.test(String(error)))
+        throw error;
+      await (0, import_promises.setTimeout)(25 * (attempt + 1));
+    }
+  }
+}
+function vendorForTranscript(transcriptPath, codexHome = codexRoot()) {
   const p = transcriptPath.replace(/\\/g, "/");
   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 || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  if (payload.agent_transcript_path != null && typeof payload.agent_transcript_path !== "string")
+    return null;
+  if (payload.transcript_path != null && typeof payload.transcript_path !== "string")
+    return null;
+  if (payload.session_id != null && typeof payload.session_id !== "string")
+    return null;
+  if (payload.agent_id != null && typeof payload.agent_id !== "string")
+    return null;
   if (payload.agent_transcript_path) {
     const transcriptPath = payload.agent_transcript_path;
     const base = transcriptPath.replace(/\\/g, "/").split("/").pop().replace(/\.jsonl$/i, "");
@@ -2696,6 +3350,8 @@ async function runStopHook() {
   } catch {
     process.exit(0);
   }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    process.exit(0);
   if (payload.stop_hook_active)
     process.exit(0);
   const target = resolveIngestTarget(payload);
@@ -2703,15 +3359,45 @@ async function runStopHook() {
     process.exit(0);
   let ingestedClass;
   let canonicalId = target.sessionId;
+  let satellite = false;
   try {
-    getDb(dbPath()).exec("PRAGMA busy_timeout = 5000;");
+    const sat = readSatelliteConfig();
+    if (sat) {
+      satellite = true;
+      (0, import_child_process.spawn)(
+        process.execPath,
+        [
+          (0, import_path.join)(binDir(), "push-pending.js"),
+          "--named",
+          target.transcriptPath,
+          "--hook",
+          JSON.stringify(target.hook),
+          "--cwd",
+          payload.cwd ?? ""
+        ],
+        { detached: true, stdio: "ignore", windowsHide: true }
+      ).unref();
+      process.exit(0);
+    }
     const vendor = vendorForTranscript(target.transcriptPath);
-    const result = await ingestSessionMessages(
-      target.sessionId,
-      target.transcriptPath,
-      vendor,
-      { projectId: payload.cwd ?? void 0, hook: target.hook }
-    );
+    const projectKey = payload.cwd ? deriveProjectKey(payload.cwd).key ?? null : void 0;
+    const result = await retryBusyIngest(async () => {
+      getDb(dbPath()).exec("PRAGMA busy_timeout = 5000;");
+      return ingestSessionMessages(
+        target.sessionId,
+        target.transcriptPath,
+        vendor,
+        {
+          projectId: payload.cwd ?? void 0,
+          // Derive ONCE per turn (spec §4.2): two git spawns, ~4-7 ms. A throw
+          // is caught by the enclosing try, so the hook still exits 0. A
+          // transient failure becomes an explicit null — ingest must not repeat
+          // the derivation that just failed.
+          projectKey,
+          hook: target.hook
+        }
+      );
+    });
     ingestedClass = result?.retrievalClass;
     canonicalId = result?.sessionId ?? target.sessionId;
     if (result?.error) {
@@ -2726,7 +3412,7 @@ async function runStopHook() {
 `
     );
   }
-  if (!target.hook.isSubagent && ingestedClass !== "agent") {
+  if (!satellite && !target.hook.isSubagent && ingestedClass !== "agent") {
     (0, import_child_process.spawn)(
       process.execPath,
       [(0, import_path.join)(binDir(), "embed-pending.js"), canonicalId],
@@ -2740,10 +3426,15 @@ async function runStopHook() {
   process.exit(0);
 }
 if (typeof require !== "undefined" && typeof module !== "undefined" && require.main === module) {
-  void runStopHook();
+  void runStopHook().catch((error) => {
+    logStopHook(`${(/* @__PURE__ */ new Date()).toISOString()} hook-failed err=${String(error)}
+`);
+    process.exit(0);
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   resolveIngestTarget,
+  retryBusyIngest,
   vendorForTranscript
 });