codemem 0.43.1 → 0.44.0-alpha.1

package/dist/index.js

@@ -91,7 +91,7 @@ function emitJsonError(errorCode, message, exitCode = 1) {
 *   and empty) are treated as toggles, not paths, so the default is used.
 * - All I/O is best-effort: failures are swallowed.
 */
-var BOOLEAN_TOGGLE_VALUES = new Set([
+var BOOLEAN_TOGGLE_VALUES = /* @__PURE__ */ new Set([
 	"",
 	"0",
 	"false",
@@ -102,7 +102,7 @@ var BOOLEAN_TOGGLE_VALUES = new Set([
 	"on",
 	"no"
 ]);
-function expandHome$4(value) {
+function expandHome$3(value) {
 	const home = process.env.HOME?.trim() || homedir();
 	if (value === "~") return home;
 	if (value.startsWith("~/")) return join(home, value.slice(2));
@@ -111,8 +111,8 @@ function expandHome$4(value) {
 function pluginLogPath() {
 	const raw = process.env.CODEMEM_PLUGIN_LOG_PATH ?? process.env.CODEMEM_PLUGIN_LOG ?? "";
 	const normalized = raw.trim().toLowerCase();
-	if (BOOLEAN_TOGGLE_VALUES.has(normalized)) return expandHome$4("~/.codemem/plugin.log");
-	return expandHome$4(raw.trim());
+	if (BOOLEAN_TOGGLE_VALUES.has(normalized)) return expandHome$3("~/.codemem/plugin.log");
+	return expandHome$3(raw.trim());
 }
 /**
 * Append a single timestamped line to the plugin log. Best-effort: any
@@ -131,7 +131,7 @@ function logHookEvent(message) {
 var FILE_GATE_MIN_BYTES = 1500;
 var FETCH_LIMIT = 40;
 var DISPLAY_LIMIT = 15;
-var MTIME_FRESH_TOLERANCE_MS = 300 * 1e3;
+var MTIME_FRESH_TOLERANCE_MS = 3e5;
 var SMALL_FILE_BYPASS_PATTERNS = [
 	/\.(json|jsonc|toml|ya?ml)$/i,
 	/\.env(\.|$)/i,
@@ -164,7 +164,7 @@ function envTruthy$3(value) {
 	const normalized = String(value ?? "").trim().toLowerCase();
 	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
 }
-function expandHome$3(value) {
+function expandHome$2(value) {
 	if (value === "~") return homedir();
 	if (value.startsWith("~/")) return resolve(homedir(), value.slice(2));
 	return value;
@@ -286,7 +286,8 @@ function queryByFile(dbPath, relativePath, project, limit) {
 	}
 }
 function resolveProject$1(payload) {
-	return resolveHookProject(typeof payload.cwd === "string" ? payload.cwd : null, payload.project);
+	const cwd = typeof payload.cwd === "string" ? payload.cwd : null;
+	return resolveHookProject(cwd, payload.project);
 }
 function sourceSessionId(payload) {
 	const value = payload.session_id;
@@ -360,7 +361,7 @@ async function buildClaudeFileContext(payload, opts, deps = {}) {
 		return finish(continueResult$2());
 	}
 	const cwd = typeof payload.cwd === "string" && payload.cwd.trim() ? payload.cwd : process.cwd();
-	const expandedPath = expandHome$3(filePath);
+	const expandedPath = expandHome$2(filePath);
 	const absolutePath = isAbsolute(expandedPath) ? expandedPath : resolve(cwd, expandedPath);
 	const relativePath = relative(cwd, absolutePath).split(sep).join("/");
 	const escapesCwd = relativePath === ".." || relativePath.startsWith("../") || isAbsolute(relativePath);
@@ -519,34 +520,22 @@ var claudeHookFileContextCommand = claudeHookFileContextCmd.action(async (opts)
 	emitJson$2(await buildClaudeFileContext(payload, opts));
 });
 //#endregion
-//#region src/commands/claude-hook-ingest-spool.ts
+//#region src/commands/hook-ingest-spool.ts
 /**
-* Durability layer for `claude-hook-ingest`: file-based mutex to
-* serialize concurrent invocations, on-disk spool that captures
-* payloads when both HTTP and direct ingestion paths fail, and a
-* recovery routine that promotes stale temp files back into the queue.
+* Shared durability layer for the hook ingest commands (claude, codex):
+* a file-based mutex that serializes concurrent invocations, an on-disk
+* spool that captures payloads when both HTTP and direct ingestion fail,
+* and a recovery routine that promotes stale temp files back into the
+* queue. Each client instantiates its own copy via `createHookIngestSpool`
+* with its own lock/spool dirs, TTL, retry budget, log prefix, and
+* client-specific `LockBusyError` name/message. Per-client flush
+* predicates stay in the client files.
+*/
+var LOCK_ACQUIRE_BACKOFF_MS = 50;
+/**
+* Boolean-shaped env toggle used by per-client flush predicates
+* (claude's `shouldForceBoundaryFlush`).
 */
-var DEFAULT_LOCK_TTL_S$1 = 300;
-var DEFAULT_LOCK_GRACE_S$1 = 2;
-var LOCK_ACQUIRE_ATTEMPTS$1 = 100;
-var LOCK_ACQUIRE_BACKOFF_MS$1 = 50;
-var LockBusyError = class extends Error {
-	constructor() {
-		super("claude-hook-ingest lock busy");
-		this.name = "LockBusyError";
-	}
-};
-function expandHome$2(value) {
-	if (value === "~") return homedir();
-	if (value.startsWith("~/")) return join(homedir(), value.slice(2));
-	return value;
-}
-function envInt$1(name, fallback) {
-	const raw = process.env[name];
-	if (raw === void 0) return fallback;
-	const parsed = Number.parseInt(raw, 10);
-	return Number.isFinite(parsed) ? parsed : fallback;
-}
 function envTruthy$2(name, fallback) {
 	const raw = process.env[name];
 	if (raw === void 0) return fallback;
@@ -565,336 +554,404 @@ function envTruthy$2(name, fallback) {
 	].includes(normalized)) return false;
 	return fallback;
 }
-function lockConfig$1() {
-	return {
-		lockDir: expandHome$2(process.env.CODEMEM_CLAUDE_HOOK_LOCK_DIR?.trim() || "~/.codemem/claude-hook-ingest.lock"),
-		ttlSeconds: Math.max(1, envInt$1("CODEMEM_CLAUDE_HOOK_LOCK_TTL_S", DEFAULT_LOCK_TTL_S$1)),
-		graceSeconds: Math.max(1, envInt$1("CODEMEM_CLAUDE_HOOK_LOCK_GRACE_S", DEFAULT_LOCK_GRACE_S$1))
-	};
+function expandHome$1(value) {
+	if (value === "~") return homedir();
+	if (value.startsWith("~/")) return join(homedir(), value.slice(2));
+	return value;
 }
-function spoolDir() {
-	return expandHome$2(process.env.CODEMEM_CLAUDE_HOOK_SPOOL_DIR?.trim() || "~/.codemem/claude-hook-spool");
+function envInt(name, fallback) {
+	const raw = process.env[name];
+	if (raw === void 0) return fallback;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) ? parsed : fallback;
 }
-/**
-* Cheap pre-check used by the unlocked HTTP-success path to decide
-* whether it needs to acquire the ingest lock and drain queued
-* payloads. Returns true when the spool directory contains at least
-* one active entry (a `*.json` file that is neither an in-flight
-* `.hook-tmp-*` nor a quarantined `.bad-*` file). Any I/O failure
-* is treated as "no entries" so callers stay on the fast path.
-*/
-function hasSpooledEntries() {
-	const dir = spoolDir();
-	let entries;
-	try {
-		entries = readdirSync(dir);
-	} catch {
+function createHookIngestSpool(cfg) {
+	class LockBusyError extends Error {
+		constructor() {
+			super(cfg.lockBusyErrorMessage);
+			this.name = cfg.lockBusyErrorName;
+		}
+	}
+	function lockConfig() {
+		return {
+			lockDir: expandHome$1(process.env[cfg.lockDirEnv]?.trim() || cfg.lockDirDefault),
+			ttlSeconds: Math.max(1, envInt(cfg.lockTtlEnv, cfg.lockTtlDefault)),
+			graceSeconds: Math.max(1, envInt(cfg.lockGraceEnv, cfg.lockGraceDefault))
+		};
+	}
+	function spoolDir() {
+		return expandHome$1(process.env[cfg.spoolDirEnv]?.trim() || cfg.spoolDirDefault);
+	}
+	/**
+	* Returns the configured lock TTL so callers (hook-ingest commands)
+	* can pass the same value to `recoverStaleTmpSpool` without re-reading
+	* the env.
+	*/
+	function lockTtlSeconds() {
+		return lockConfig().ttlSeconds;
+	}
+	/**
+	* Cheap pre-check used by the unlocked HTTP-success path to decide
+	* whether it needs to acquire the ingest lock and drain queued
+	* payloads. Returns true when the spool directory contains at least
+	* one active entry (a `*.json` file that is neither an in-flight
+	* `.hook-tmp-*` nor a quarantined `.bad-*` file). Any I/O failure
+	* is treated as "no entries" so callers stay on the fast path.
+	*/
+	function hasSpooledEntries() {
+		let entries;
+		try {
+			entries = readdirSync(spoolDir());
+		} catch {
+			return false;
+		}
+		for (const name of entries) {
+			if (!name.endsWith(".json")) continue;
+			if (name.startsWith(".hook-tmp-") || name.startsWith(".bad-")) continue;
+			return true;
+		}
 		return false;
 	}
-	for (const name of entries) {
-		if (!name.endsWith(".json")) continue;
-		if (name.startsWith(".hook-tmp-") || name.startsWith(".bad-")) continue;
-		return true;
+	function readFileTrimmedOrEmpty(path) {
+		try {
+			return readFileSync(path, "utf8").trim();
+		} catch {
+			return "";
+		}
 	}
-	return false;
-}
-function readFileTrimmedOrEmpty(path) {
-	try {
-		return readFileSync(path, "utf8").trim();
-	} catch {
-		return "";
+	function readLockMetadata(lockDir) {
+		const pid = readFileTrimmedOrEmpty(join(lockDir, "pid"));
+		const owner = readFileTrimmedOrEmpty(join(lockDir, "owner"));
+		const tsRaw = readFileTrimmedOrEmpty(join(lockDir, "ts"));
+		const ts = tsRaw === "" ? null : Number.parseInt(tsRaw, 10);
+		return {
+			pid,
+			ts: ts === null || !Number.isFinite(ts) ? null : ts,
+			owner
+		};
 	}
-}
-function readLockMetadata$1(lockDir) {
-	const pid = readFileTrimmedOrEmpty(join(lockDir, "pid"));
-	const owner = readFileTrimmedOrEmpty(join(lockDir, "owner"));
-	const tsRaw = readFileTrimmedOrEmpty(join(lockDir, "ts"));
-	const ts = tsRaw === "" ? null : Number.parseInt(tsRaw, 10);
-	return {
-		pid,
-		ts: ts === null || !Number.isFinite(ts) ? null : ts,
-		owner
-	};
-}
-function isPidAlive$1(pidText) {
-	const pid = Number.parseInt(pidText, 10);
-	if (!Number.isFinite(pid) || pid <= 0) return false;
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
+	function isPidAlive(pidText) {
+		const pid = Number.parseInt(pidText, 10);
+		if (!Number.isFinite(pid) || pid <= 0) return false;
+		try {
+			process.kill(pid, 0);
+			return true;
+		} catch {
+			return false;
+		}
 	}
-}
-function lockIsStale$1(cfg) {
-	const snapshot = readLockMetadata$1(cfg.lockDir);
-	const nowS = Math.floor(Date.now() / 1e3);
-	if (snapshot.pid) {
-		if (isPidAlive$1(snapshot.pid)) {
-			if (snapshot.ts === null) return {
-				stale: false,
-				snapshot
-			};
+	function lockIsStale(cfg) {
+		const snapshot = readLockMetadata(cfg.lockDir);
+		const nowS = Math.floor(Date.now() / 1e3);
+		if (snapshot.pid) {
+			if (isPidAlive(snapshot.pid)) {
+				if (snapshot.ts === null) return {
+					stale: false,
+					snapshot
+				};
+				return {
+					stale: nowS - snapshot.ts > cfg.ttlSeconds,
+					snapshot
+				};
+			}
 			return {
-				stale: nowS - snapshot.ts > cfg.ttlSeconds,
+				stale: true,
 				snapshot
 			};
 		}
-		return {
-			stale: true,
+		if (snapshot.ts !== null) return {
+			stale: nowS - snapshot.ts > cfg.graceSeconds,
 			snapshot
 		};
-	}
-	if (snapshot.ts !== null) return {
-		stale: nowS - snapshot.ts > cfg.graceSeconds,
-		snapshot
-	};
-	let mtimeS;
-	try {
-		mtimeS = Math.floor(statSync(cfg.lockDir).mtimeMs / 1e3);
-	} catch {
+		let mtimeS;
+		try {
+			mtimeS = Math.floor(statSync(cfg.lockDir).mtimeMs / 1e3);
+		} catch {
+			return {
+				stale: true,
+				snapshot
+			};
+		}
 		return {
-			stale: true,
+			stale: nowS - mtimeS > cfg.graceSeconds,
 			snapshot
 		};
 	}
-	return {
-		stale: nowS - mtimeS > cfg.graceSeconds,
-		snapshot
-	};
-}
-function cleanupLockDir$1(lockDir) {
-	for (const name of [
-		"pid",
-		"ts",
-		"owner"
-	]) try {
-		unlinkSync(join(lockDir, name));
-	} catch {}
-	try {
-		rmdirSync(lockDir);
-	} catch {}
-}
-function snapshotsEqual(a, b) {
-	return a.pid === b.pid && a.ts === b.ts && a.owner === b.owner;
-}
-function cleanupLockDirIfUnchanged$1(lockDir, snapshot) {
-	if (snapshotsEqual(readLockMetadata$1(lockDir), snapshot)) cleanupLockDir$1(lockDir);
-}
-function isErrnoException$1(err) {
-	return typeof err === "object" && err !== null && "code" in err;
-}
-async function sleep$1(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
-* Run `fn` while holding the claude-hook-ingest lock. Throws
-* `LockBusyError` when the lock cannot be acquired within
-* `LOCK_ACQUIRE_ATTEMPTS` attempts.
-*
-* The lock is a directory at `lockDir`, with three sentinel files
-* (`pid`, `ts`, `owner`) recording who currently holds it. Stale locks
-* are detected via PID liveness, TTL, and a grace window for the
-* race between mkdir and writing pid/ts.
-*/
-async function withClaudeHookIngestLock(fn) {
-	const cfg = lockConfig$1();
-	mkdirSync(dirname(cfg.lockDir), { recursive: true });
-	const ownerToken = `${process.pid}-${Math.floor(Date.now() / 1e3)}-${randomInt(1e3, 1e4)}`;
-	let acquired = false;
-	for (let attempt = 0; attempt < LOCK_ACQUIRE_ATTEMPTS$1; attempt++) {
+	function cleanupLockDir(lockDir) {
+		for (const name of [
+			"pid",
+			"ts",
+			"owner"
+		]) try {
+			unlinkSync(join(lockDir, name));
+		} catch {}
 		try {
-			mkdirSync(cfg.lockDir);
-		} catch (err) {
-			if (isErrnoException$1(err) && err.code === "EEXIST") {
-				const { stale, snapshot } = lockIsStale$1(cfg);
-				if (stale) cleanupLockDirIfUnchanged$1(cfg.lockDir, snapshot);
-				await sleep$1(LOCK_ACQUIRE_BACKOFF_MS$1);
+			rmdirSync(lockDir);
+		} catch {}
+	}
+	function snapshotsEqual(a, b) {
+		return a.pid === b.pid && a.ts === b.ts && a.owner === b.owner;
+	}
+	function cleanupLockDirIfUnchanged(lockDir, snapshot) {
+		if (snapshotsEqual(readLockMetadata(lockDir), snapshot)) cleanupLockDir(lockDir);
+	}
+	function isErrnoException(err) {
+		return typeof err === "object" && err !== null && "code" in err;
+	}
+	function sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	/**
+	* Run `fn` while holding the client's ingest lock. Throws the
+	* client-specific `LockBusyError` when the lock cannot be acquired
+	* within `cfg.lockAcquireAttempts` attempts.
+	*
+	* The lock is a directory at `lockDir`, with three sentinel files
+	* (`pid`, `ts`, `owner`) recording who currently holds it. Stale locks
+	* are detected via PID liveness, TTL, and a grace window for the
+	* race between mkdir and writing pid/ts.
+	*/
+	async function withLock(fn) {
+		const lock = lockConfig();
+		mkdirSync(dirname(lock.lockDir), { recursive: true });
+		const ownerToken = `${process.pid}-${Math.floor(Date.now() / 1e3)}-${randomInt(1e3, 1e4)}`;
+		let acquired = false;
+		for (let attempt = 0; attempt < cfg.lockAcquireAttempts; attempt++) {
+			try {
+				mkdirSync(lock.lockDir);
+			} catch (err) {
+				if (isErrnoException(err) && err.code === "EEXIST") {
+					const { stale, snapshot } = lockIsStale(lock);
+					if (stale) cleanupLockDirIfUnchanged(lock.lockDir, snapshot);
+				}
+				await sleep(LOCK_ACQUIRE_BACKOFF_MS);
 				continue;
 			}
-			await sleep$1(LOCK_ACQUIRE_BACKOFF_MS$1);
-			continue;
+			try {
+				writeFileSync(join(lock.lockDir, "ts"), String(Math.floor(Date.now() / 1e3)), { encoding: "utf8" });
+				writeFileSync(join(lock.lockDir, "pid"), String(process.pid), { encoding: "utf8" });
+				writeFileSync(join(lock.lockDir, "owner"), ownerToken, { encoding: "utf8" });
+				acquired = true;
+				break;
+			} catch {
+				cleanupLockDir(lock.lockDir);
+				await sleep(LOCK_ACQUIRE_BACKOFF_MS);
+			}
 		}
+		if (!acquired) throw new LockBusyError();
 		try {
-			writeFileSync(join(cfg.lockDir, "ts"), String(Math.floor(Date.now() / 1e3)), { encoding: "utf8" });
-			writeFileSync(join(cfg.lockDir, "pid"), String(process.pid), { encoding: "utf8" });
-			writeFileSync(join(cfg.lockDir, "owner"), ownerToken, { encoding: "utf8" });
-			acquired = true;
-			break;
-		} catch {
-			cleanupLockDir$1(cfg.lockDir);
-			await sleep$1(LOCK_ACQUIRE_BACKOFF_MS$1);
+			return await fn();
+		} finally {
+			if (readFileTrimmedOrEmpty(join(lock.lockDir, "owner")) === ownerToken) cleanupLockDir(lock.lockDir);
 		}
 	}
-	if (!acquired) throw new LockBusyError();
-	try {
-		return await fn();
-	} finally {
-		if (readFileTrimmedOrEmpty(join(cfg.lockDir, "owner")) === ownerToken) cleanupLockDir$1(cfg.lockDir);
-	}
-}
-/**
-* Persist a payload to the spool directory using a tmp+rename so that
-* a partially-written file is never visible to the drainer. Returns
-* true on success, false on any I/O failure.
-*/
-function spoolPayload(payload) {
-	const dir = spoolDir();
-	try {
-		mkdirSync(dir, { recursive: true });
-	} catch {
-		logHookEvent("codemem claude-hook-ingest failed to create spool dir");
-		return false;
-	}
-	const payloadText = JSON.stringify(payload);
-	const tmpPath = join(dir, `.hook-tmp-${process.pid}-${Date.now()}-${randomInt(1e3, 1e4)}.json`);
-	try {
-		writeFileSync(tmpPath, payloadText, { encoding: "utf8" });
-	} catch {
-		logHookEvent("codemem claude-hook-ingest failed to allocate spool temp file");
-		return false;
-	}
-	const finalPath = join(dir, `hook-${Math.floor(Date.now() / 1e3)}-${process.pid}-${randomInt(1e3, 1e4)}.json`);
-	try {
-		renameSync(tmpPath, finalPath);
-	} catch {
+	/**
+	* Persist a payload to the spool directory using a tmp+rename so that
+	* a partially-written file is never visible to the drainer. Returns
+	* true on success, false on any I/O failure.
+	*/
+	function spoolPayload(payload) {
+		const dir = spoolDir();
 		try {
-			unlinkSync(tmpPath);
-		} catch {}
-		logHookEvent("codemem claude-hook-ingest failed to spool payload");
-		return false;
-	}
-	logHookEvent(`codemem claude-hook-ingest spooled payload: ${finalPath}`);
-	return true;
-}
-/**
-* Promote any `.hook-tmp-*.json` files older than `ttlSeconds` to a
-* recovered name so they are picked up by the next drain. Caller is
-* responsible for passing the same TTL used by lock acquisition so
-* that an in-flight write inside an active locked region is never
-* mistaken for a crashed-writer leftover.
-*/
-function recoverStaleTmpSpool(ttlSeconds) {
-	const dir = spoolDir();
-	try {
-		mkdirSync(dir, { recursive: true });
-	} catch {
-		return;
-	}
-	let entries;
-	try {
-		entries = readdirSync(dir);
-	} catch {
-		return;
-	}
-	const nowS = Date.now() / 1e3;
-	for (const name of entries) {
-		if (!name.startsWith(".hook-tmp-") || !name.endsWith(".json")) continue;
-		const tmpPath = join(dir, name);
-		let mtimeS;
+			mkdirSync(dir, { recursive: true });
+		} catch {
+			logHookEvent(`${cfg.logPrefix} failed to create spool dir`);
+			return false;
+		}
+		const payloadText = JSON.stringify(payload);
+		const tmpName = `.hook-tmp-${process.pid}-${Date.now()}-${randomInt(1e3, 1e4)}.json`;
+		const tmpPath = join(dir, tmpName);
 		try {
-			mtimeS = statSync(tmpPath).mtimeMs / 1e3;
+			writeFileSync(tmpPath, payloadText, { encoding: "utf8" });
 		} catch {
-			continue;
+			logHookEvent(`${cfg.logPrefix} failed to allocate spool temp file`);
+			return false;
 		}
-		if (nowS - mtimeS <= ttlSeconds) continue;
-		const recoveredPath = join(dir, `hook-recovered-${Math.floor(nowS)}-${process.pid}-${randomInt(1e3, 1e4)}.json`);
+		const finalName = `hook-${Math.floor(Date.now() / 1e3)}-${process.pid}-${randomInt(1e3, 1e4)}.json`;
+		const finalPath = join(dir, finalName);
 		try {
-			renameSync(tmpPath, recoveredPath);
-			logHookEvent(`codemem claude-hook-ingest recovered stale temp spool payload: ${recoveredPath}`);
-		} catch {}
+			renameSync(tmpPath, finalPath);
+		} catch {
+			try {
+				unlinkSync(tmpPath);
+			} catch {}
+			logHookEvent(`${cfg.logPrefix} failed to spool payload`);
+			return false;
+		}
+		logHookEvent(`${cfg.logPrefix} spooled payload: ${finalPath}`);
+		return true;
 	}
-}
-/**
-* Move a permanently-broken spool entry out of the queue so that it
-* stops being picked up by future drains. The entry is renamed in
-* place with a `.bad-<reason>-` prefix so an operator can inspect or
-* delete it manually.
-*/
-function quarantineSpoolEntry$1(dir, name, reason) {
-	const sourcePath = join(dir, name);
-	const quarantineName = `.bad-${reason}-${Date.now()}-${randomInt(1e3, 1e4)}-${name}`;
-	try {
-		renameSync(sourcePath, join(dir, quarantineName));
-		logHookEvent(`codemem claude-hook-ingest quarantined corrupt spool payload (${reason}): ${quarantineName}`);
-	} catch {
+	/**
+	* Promote any `.hook-tmp-*.json` files older than `ttlSeconds` to a
+	* recovered name so they are picked up by the next drain. Caller is
+	* responsible for passing the same TTL used by lock acquisition so
+	* that an in-flight write inside an active locked region is never
+	* mistaken for a crashed-writer leftover.
+	*/
+	function recoverStaleTmpSpool(ttlSeconds) {
+		const dir = spoolDir();
 		try {
-			unlinkSync(sourcePath);
-			logHookEvent(`codemem claude-hook-ingest dropped corrupt spool payload (${reason}): ${name}`);
-		} catch {}
-	}
-}
-/**
-* Process every queued payload in the spool directory in lexicographic
-* order (which approximates oldest-first because filenames embed the
-* second-precision creation timestamp). The handler returns true to
-* indicate the payload has been durably accepted; only then is the
-* spool entry deleted. Failed entries are left on disk for the next
-* drain attempt.
-*/
-async function drainSpool(handler) {
-	const dir = spoolDir();
-	try {
-		mkdirSync(dir, { recursive: true });
-	} catch {
-		return {
-			processed: 0,
-			failed: 0
-		};
-	}
-	let entries;
-	try {
-		entries = readdirSync(dir);
-	} catch {
-		return {
-			processed: 0,
-			failed: 0
-		};
-	}
-	const queued = entries.filter((name) => name.endsWith(".json") && !name.startsWith(".hook-tmp-") && !name.startsWith(".bad-")).sort();
-	const result = {
-		processed: 0,
-		failed: 0
-	};
-	for (const name of queued) {
-		const path = join(dir, name);
-		let raw;
+			mkdirSync(dir, { recursive: true });
+		} catch {
+			return;
+		}
+		let entries;
 		try {
-			raw = readFileSync(path, "utf8");
+			entries = readdirSync(dir);
 		} catch {
-			logHookEvent(`codemem claude-hook-ingest failed to read spooled payload: ${path}`);
-			result.failed++;
-			continue;
+			return;
+		}
+		const nowS = Date.now() / 1e3;
+		for (const name of entries) {
+			if (!name.startsWith(".hook-tmp-") || !name.endsWith(".json")) continue;
+			const tmpPath = join(dir, name);
+			let mtimeS;
+			try {
+				mtimeS = statSync(tmpPath).mtimeMs / 1e3;
+			} catch {
+				continue;
+			}
+			if (nowS - mtimeS <= ttlSeconds) continue;
+			const recoveredName = `hook-recovered-${Math.floor(nowS)}-${process.pid}-${randomInt(1e3, 1e4)}.json`;
+			const recoveredPath = join(dir, recoveredName);
+			try {
+				renameSync(tmpPath, recoveredPath);
+				logHookEvent(`${cfg.logPrefix} recovered stale temp spool payload: ${recoveredPath}`);
+			} catch {}
 		}
-		let parsed;
+	}
+	/**
+	* Move a permanently-broken spool entry out of the queue so that it
+	* stops being picked up by future drains. The entry is renamed in
+	* place with a `.bad-<reason>-` prefix so an operator can inspect or
+	* delete it manually.
+	*/
+	function quarantineSpoolEntry(dir, name, reason) {
+		const sourcePath = join(dir, name);
+		const quarantineName = `.bad-${reason}-${Date.now()}-${randomInt(1e3, 1e4)}-${name}`;
 		try {
-			parsed = JSON.parse(raw);
+			renameSync(sourcePath, join(dir, quarantineName));
+			logHookEvent(`${cfg.logPrefix} quarantined corrupt spool payload (${reason}): ${quarantineName}`);
 		} catch {
-			quarantineSpoolEntry$1(dir, name, "parse-error");
-			result.failed++;
-			continue;
+			try {
+				unlinkSync(sourcePath);
+				logHookEvent(`${cfg.logPrefix} dropped corrupt spool payload (${reason}): ${name}`);
+			} catch {}
 		}
-		if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
-			quarantineSpoolEntry$1(dir, name, "wrong-shape");
-			continue;
+	}
+	/**
+	* Process every queued payload in the spool directory in lexicographic
+	* order (which approximates oldest-first because filenames embed the
+	* second-precision creation timestamp). The handler returns true to
+	* indicate the payload has been durably accepted; only then is the
+	* spool entry deleted. Failed entries are left on disk for the next
+	* drain attempt.
+	*/
+	async function drainSpool(handler) {
+		const dir = spoolDir();
+		try {
+			mkdirSync(dir, { recursive: true });
+		} catch {
+			return {
+				processed: 0,
+				failed: 0
+			};
 		}
-		let ok = false;
+		let entries;
 		try {
-			ok = await handler(parsed);
+			entries = readdirSync(dir);
 		} catch {
-			ok = false;
+			return {
+				processed: 0,
+				failed: 0
+			};
 		}
-		if (ok) try {
-			unlinkSync(path);
-			result.processed++;
-		} catch {}
-		else {
-			logHookEvent(`codemem claude-hook-ingest failed processing spooled payload: ${path}`);
-			result.failed++;
+		const queued = entries.filter((name) => name.endsWith(".json") && !name.startsWith(".hook-tmp-") && !name.startsWith(".bad-")).sort();
+		const result = {
+			processed: 0,
+			failed: 0
+		};
+		for (const name of queued) {
+			const path = join(dir, name);
+			let raw;
+			try {
+				raw = readFileSync(path, "utf8");
+			} catch {
+				logHookEvent(`${cfg.logPrefix} failed to read spooled payload: ${path}`);
+				result.failed++;
+				continue;
+			}
+			let parsed;
+			try {
+				parsed = JSON.parse(raw);
+			} catch {
+				quarantineSpoolEntry(dir, name, "parse-error");
+				result.failed++;
+				continue;
+			}
+			if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+				quarantineSpoolEntry(dir, name, "wrong-shape");
+				result.failed++;
+				continue;
+			}
+			let ok = false;
+			try {
+				ok = await handler(parsed);
+			} catch {
+				ok = false;
+			}
+			if (ok) try {
+				unlinkSync(path);
+				result.processed++;
+			} catch {}
+			else {
+				logHookEvent(`${cfg.logPrefix} failed processing spooled payload: ${path}`);
+				result.failed++;
+			}
 		}
+		return result;
 	}
-	return result;
+	return {
+		LockBusyError,
+		spoolDir,
+		lockTtlSeconds,
+		hasSpooledEntries,
+		withLock,
+		spoolPayload,
+		recoverStaleTmpSpool,
+		drainSpool
+	};
 }
+//#endregion
+//#region src/commands/claude-hook-ingest-spool.ts
+/**
+* Durability layer for `claude-hook-ingest`. The lock/spool/drain/
+* quarantine machinery is shared in `hook-ingest-spool.ts`; this file
+* wires the claude-specific config (dirs, TTL 300s, 100 acquire
+* attempts, error name/message) and keeps the claude flush predicate.
+*/
+var spool$1 = createHookIngestSpool({
+	logPrefix: "codemem claude-hook-ingest",
+	lockDirEnv: "CODEMEM_CLAUDE_HOOK_LOCK_DIR",
+	lockDirDefault: "~/.codemem/claude-hook-ingest.lock",
+	lockTtlEnv: "CODEMEM_CLAUDE_HOOK_LOCK_TTL_S",
+	lockTtlDefault: 300,
+	lockGraceEnv: "CODEMEM_CLAUDE_HOOK_LOCK_GRACE_S",
+	lockGraceDefault: 2,
+	lockAcquireAttempts: 100,
+	spoolDirEnv: "CODEMEM_CLAUDE_HOOK_SPOOL_DIR",
+	spoolDirDefault: "~/.codemem/claude-hook-spool",
+	lockBusyErrorName: "LockBusyError",
+	lockBusyErrorMessage: "claude-hook-ingest lock busy"
+});
+var LockBusyError = spool$1.LockBusyError;
+var withClaudeHookIngestLock = spool$1.withLock;
+var spoolPayload = spool$1.spoolPayload;
+var drainSpool = spool$1.drainSpool;
+var hasSpooledEntries = spool$1.hasSpooledEntries;
+var recoverStaleTmpSpool = spool$1.recoverStaleTmpSpool;
+var lockTtlSeconds = spool$1.lockTtlSeconds;
+spool$1.spoolDir;
 /**
 * Whether the boundary-flush write-through should run for this hook
 * payload. SessionEnd defaults to forcing a flush; Stop only flushes
@@ -908,14 +965,6 @@ function shouldForceBoundaryFlush(payload) {
 	if (!envTruthy$2("CODEMEM_CLAUDE_HOOK_FLUSH", false)) return false;
 	return envTruthy$2("CODEMEM_CLAUDE_HOOK_FLUSH_ON_STOP", false);
 }
-/**
-* Returns the configured lock TTL so callers (`claude-hook-ingest`)
-* can pass the same value to `recoverStaleTmpSpool` without re-reading
-* the env.
-*/
-function lockTtlSeconds() {
-	return lockConfig$1().ttlSeconds;
-}
 //#endregion
 //#region src/commands/claude-hook-session-state.ts
 /**
@@ -945,14 +994,14 @@ function defaultSessionState() {
 		updated_at: ""
 	};
 }
-function expandHome$1(value) {
+function expandHome(value) {
 	if (value === "~") return homedir();
 	if (value.startsWith("~/")) return join(homedir(), value.slice(2));
 	return value;
 }
 function contextDir() {
 	const override = process.env.CODEMEM_CLAUDE_HOOK_CONTEXT_DIR;
-	return expandHome$1(override?.trim() ? override : "~/.codemem/claude-hook-context");
+	return expandHome(override?.trim() ? override : "~/.codemem/claude-hook-context");
 }
 function sessionFileStem(sessionId) {
 	const trimmed = sessionId.trim();
@@ -1004,7 +1053,8 @@ function nowIso() {
 	return (/* @__PURE__ */ new Date()).toISOString();
 }
 function saveSessionState(sessionId, state) {
-	mkdirSync(contextDir(), { recursive: true });
+	const dir = contextDir();
+	mkdirSync(dir, { recursive: true });
 	const path = statePathForSession(sessionId);
 	const tmpPath = `${path}.tmp`;
 	const payload = {
@@ -1381,8 +1431,8 @@ async function ingestClaudeHookPayload(payload, opts, deps = {}) {
 	};
 	const httpResult = await httpIngest(httpPayload(payload), opts.host, port);
 	if (httpResult.ok) {
-		await flushOnBoundaryIfRequested();
 		await drainBacklogIfPresent();
+		await flushOnBoundaryIfRequested();
 		return {
 			inserted: httpResult.inserted,
 			skipped: httpResult.skipped,
@@ -1526,7 +1576,8 @@ function extractInjectContext(payload) {
 	return normalizePromptText(payload.prompt) || null;
 }
 function resolveInjectProject$1(payload) {
-	return resolveHookProject(typeof payload.cwd === "string" ? payload.cwd : null, payload.project);
+	const cwd = typeof payload.cwd === "string" ? payload.cwd : null;
+	return resolveHookProject(cwd, payload.project);
 }
 async function buildLocalPack$1(context, project, dbPath, workingSetPaths = []) {
 	const store = new MemoryStore(dbPath);
@@ -1622,273 +1673,34 @@ var claudeHookInjectCommand = claudeHookInjectCmd.action(async (opts) => {
 });
 //#endregion
 //#region src/commands/codex-hook-ingest-spool.ts
-var DEFAULT_LOCK_TTL_S = 120;
-var DEFAULT_LOCK_GRACE_S = 2;
-var LOCK_ACQUIRE_ATTEMPTS = 20;
-var LOCK_ACQUIRE_BACKOFF_MS = 50;
-var CodexHookLockBusyError = class extends Error {
-	constructor() {
-		super("codex-hook-ingest lock busy");
-		this.name = "CodexHookLockBusyError";
-	}
-};
-function expandHome(value) {
-	if (value === "~") return homedir();
-	if (value.startsWith("~/")) return join(homedir(), value.slice(2));
-	return value;
-}
-function envInt(name, fallback) {
-	const parsed = Number.parseInt(process.env[name] ?? "", 10);
-	return Number.isFinite(parsed) ? parsed : fallback;
-}
-function lockConfig() {
-	return {
-		lockDir: expandHome(process.env.CODEMEM_CODEX_HOOK_LOCK_DIR?.trim() || "~/.codemem/codex-hook-ingest.lock"),
-		ttlSeconds: Math.max(1, envInt("CODEMEM_CODEX_HOOK_LOCK_TTL_S", DEFAULT_LOCK_TTL_S)),
-		graceSeconds: Math.max(1, envInt("CODEMEM_CODEX_HOOK_LOCK_GRACE_S", DEFAULT_LOCK_GRACE_S))
-	};
-}
-function codexHookSpoolDir() {
-	return expandHome(process.env.CODEMEM_CODEX_HOOK_SPOOL_DIR?.trim() || "~/.codemem/codex-hook-spool");
-}
-function codexHookLockTtlSeconds() {
-	return lockConfig().ttlSeconds;
-}
-function hasCodexHookSpooledEntries() {
-	let entries;
-	try {
-		entries = readdirSync(codexHookSpoolDir());
-	} catch {
-		return false;
-	}
-	return entries.some((name) => name.endsWith(".json") && !name.startsWith(".hook-tmp-") && !name.startsWith(".bad-"));
-}
-function readTrimmed(path) {
-	try {
-		return readFileSync(path, "utf8").trim();
-	} catch {
-		return "";
-	}
-}
-function readLockMetadata(lockDir) {
-	const rawTs = readTrimmed(join(lockDir, "ts"));
-	const ts = rawTs === "" ? null : Number.parseInt(rawTs, 10);
-	return {
-		pid: readTrimmed(join(lockDir, "pid")),
-		ts: ts === null || !Number.isFinite(ts) ? null : ts,
-		owner: readTrimmed(join(lockDir, "owner"))
-	};
-}
-function isPidAlive(pidText) {
-	const pid = Number.parseInt(pidText, 10);
-	if (!Number.isFinite(pid) || pid <= 0) return false;
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function lockIsStale(cfg) {
-	const snapshot = readLockMetadata(cfg.lockDir);
-	const nowS = Math.floor(Date.now() / 1e3);
-	if (snapshot.pid) {
-		if (isPidAlive(snapshot.pid)) return {
-			stale: snapshot.ts !== null && nowS - snapshot.ts > cfg.ttlSeconds,
-			snapshot
-		};
-		return {
-			stale: true,
-			snapshot
-		};
-	}
-	if (snapshot.ts !== null) return {
-		stale: nowS - snapshot.ts > cfg.graceSeconds,
-		snapshot
-	};
-	try {
-		return {
-			stale: nowS - Math.floor(statSync(cfg.lockDir).mtimeMs / 1e3) > cfg.graceSeconds,
-			snapshot
-		};
-	} catch {
-		return {
-			stale: true,
-			snapshot
-		};
-	}
-}
-function cleanupLockDir(lockDir) {
-	for (const name of [
-		"pid",
-		"ts",
-		"owner"
-	]) try {
-		unlinkSync(join(lockDir, name));
-	} catch {}
-	try {
-		rmdirSync(lockDir);
-	} catch {}
-}
-function cleanupLockDirIfUnchanged(lockDir, snapshot) {
-	const current = readLockMetadata(lockDir);
-	if (current.pid === snapshot.pid && current.ts === snapshot.ts && current.owner === snapshot.owner) cleanupLockDir(lockDir);
-}
-function isErrnoException(err) {
-	return typeof err === "object" && err !== null && "code" in err;
-}
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function withCodexHookIngestLock(fn) {
-	const cfg = lockConfig();
-	mkdirSync(dirname(cfg.lockDir), { recursive: true });
-	const ownerToken = `${process.pid}-${Math.floor(Date.now() / 1e3)}-${randomInt(1e3, 1e4)}`;
-	let acquired = false;
-	for (let attempt = 0; attempt < LOCK_ACQUIRE_ATTEMPTS; attempt++) {
-		try {
-			mkdirSync(cfg.lockDir);
-		} catch (err) {
-			if (isErrnoException(err) && err.code === "EEXIST") {
-				const { stale, snapshot } = lockIsStale(cfg);
-				if (stale) cleanupLockDirIfUnchanged(cfg.lockDir, snapshot);
-			}
-			await sleep(LOCK_ACQUIRE_BACKOFF_MS);
-			continue;
-		}
-		try {
-			writeFileSync(join(cfg.lockDir, "ts"), String(Math.floor(Date.now() / 1e3)), "utf8");
-			writeFileSync(join(cfg.lockDir, "pid"), String(process.pid), "utf8");
-			writeFileSync(join(cfg.lockDir, "owner"), ownerToken, "utf8");
-			acquired = true;
-			break;
-		} catch {
-			cleanupLockDir(cfg.lockDir);
-			await sleep(LOCK_ACQUIRE_BACKOFF_MS);
-		}
-	}
-	if (!acquired) throw new CodexHookLockBusyError();
-	try {
-		return await fn();
-	} finally {
-		if (readTrimmed(join(cfg.lockDir, "owner")) === ownerToken) cleanupLockDir(cfg.lockDir);
-	}
-}
-function spoolCodexHookPayload(payload) {
-	const dir = codexHookSpoolDir();
-	try {
-		mkdirSync(dir, { recursive: true });
-	} catch {
-		logHookEvent("codemem codex-hook-ingest failed to create spool dir");
-		return false;
-	}
-	const tmpPath = join(dir, `.hook-tmp-${process.pid}-${Date.now()}-${randomInt(1e3, 1e4)}.json`);
-	try {
-		writeFileSync(tmpPath, JSON.stringify(payload), "utf8");
-	} catch {
-		logHookEvent("codemem codex-hook-ingest failed to allocate spool temp file");
-		return false;
-	}
-	const finalPath = join(dir, `hook-${Math.floor(Date.now() / 1e3)}-${process.pid}-${randomInt(1e3, 1e4)}.json`);
-	try {
-		renameSync(tmpPath, finalPath);
-	} catch {
-		try {
-			unlinkSync(tmpPath);
-		} catch {}
-		logHookEvent("codemem codex-hook-ingest failed to spool payload");
-		return false;
-	}
-	logHookEvent(`codemem codex-hook-ingest spooled payload: ${finalPath}`);
-	return true;
-}
-function recoverStaleCodexHookTmpSpool(ttlSeconds) {
-	const dir = codexHookSpoolDir();
-	try {
-		mkdirSync(dir, { recursive: true });
-	} catch {
-		return;
-	}
-	let entries;
-	try {
-		entries = readdirSync(dir);
-	} catch {
-		return;
-	}
-	const nowS = Date.now() / 1e3;
-	for (const name of entries) {
-		if (!name.startsWith(".hook-tmp-") || !name.endsWith(".json")) continue;
-		const tmpPath = join(dir, name);
-		try {
-			if (nowS - statSync(tmpPath).mtimeMs / 1e3 <= ttlSeconds) continue;
-			renameSync(tmpPath, join(dir, `hook-recovered-${Math.floor(nowS)}-${process.pid}-${randomInt(1e3, 1e4)}.json`));
-		} catch {}
-	}
-}
-function quarantineSpoolEntry(dir, name, reason) {
-	try {
-		renameSync(join(dir, name), join(dir, `.bad-${reason}-${Date.now()}-${randomInt(1e3, 1e4)}-${name}`));
-	} catch {
-		try {
-			unlinkSync(join(dir, name));
-		} catch {}
-	}
-}
-async function drainCodexHookSpool(handler) {
-	const dir = codexHookSpoolDir();
-	try {
-		mkdirSync(dir, { recursive: true });
-	} catch {
-		return {
-			processed: 0,
-			failed: 0
-		};
-	}
-	let entries;
-	try {
-		entries = readdirSync(dir);
-	} catch {
-		return {
-			processed: 0,
-			failed: 0
-		};
-	}
-	const result = {
-		processed: 0,
-		failed: 0
-	};
-	for (const name of entries.filter((entry) => entry.endsWith(".json") && !entry.startsWith(".hook-tmp-") && !entry.startsWith(".bad-")).sort()) {
-		const path = join(dir, name);
-		let parsed;
-		try {
-			parsed = JSON.parse(readFileSync(path, "utf8"));
-		} catch {
-			quarantineSpoolEntry(dir, name, "parse-error");
-			result.failed++;
-			continue;
-		}
-		if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
-			quarantineSpoolEntry(dir, name, "wrong-shape");
-			result.failed++;
-			continue;
-		}
-		let ok = false;
-		try {
-			ok = await handler(parsed);
-		} catch {
-			ok = false;
-		}
-		if (!ok) {
-			result.failed++;
-			continue;
-		}
-		try {
-			unlinkSync(path);
-			result.processed++;
-		} catch {}
-	}
-	return result;
-}
+/**
+* Durability layer for `codex-hook-ingest`. The lock/spool/drain/
+* quarantine machinery is shared in `hook-ingest-spool.ts`; this file
+* wires the codex-specific config (dirs, TTL 120s, 20 acquire attempts,
+* error name/message).
+*/
+var spool = createHookIngestSpool({
+	logPrefix: "codemem codex-hook-ingest",
+	lockDirEnv: "CODEMEM_CODEX_HOOK_LOCK_DIR",
+	lockDirDefault: "~/.codemem/codex-hook-ingest.lock",
+	lockTtlEnv: "CODEMEM_CODEX_HOOK_LOCK_TTL_S",
+	lockTtlDefault: 120,
+	lockGraceEnv: "CODEMEM_CODEX_HOOK_LOCK_GRACE_S",
+	lockGraceDefault: 2,
+	lockAcquireAttempts: 20,
+	spoolDirEnv: "CODEMEM_CODEX_HOOK_SPOOL_DIR",
+	spoolDirDefault: "~/.codemem/codex-hook-spool",
+	lockBusyErrorName: "CodexHookLockBusyError",
+	lockBusyErrorMessage: "codex-hook-ingest lock busy"
+});
+var CodexHookLockBusyError = spool.LockBusyError;
+var withCodexHookIngestLock = spool.withLock;
+var spoolCodexHookPayload = spool.spoolPayload;
+var drainCodexHookSpool = spool.drainSpool;
+var hasCodexHookSpooledEntries = spool.hasSpooledEntries;
+var recoverStaleCodexHookTmpSpool = spool.recoverStaleTmpSpool;
+var codexHookLockTtlSeconds = spool.lockTtlSeconds;
+spool.spoolDir;
 //#endregion
 //#region src/commands/codex-hook-ingest.ts
 /**
@@ -2388,7 +2200,8 @@ function formatCodexAdditionalContext(packText, maxChars) {
 	return `${CODEMEM_CONTEXT_HEADER}${truncateAdditionalContext(normalized, bodyMaxChars)}`;
 }
 function resolveInjectProject(payload) {
-	return resolveHookProject(typeof payload.cwd === "string" ? payload.cwd : null, payload.project);
+	const cwd = typeof payload.cwd === "string" ? payload.cwd : null;
+	return resolveHookProject(cwd, payload.project);
 }
 function buildCodexInjectQuery(prompt, project) {
 	return [prompt, project ?? ""].filter((part) => part.trim().length > 0).join(" ").slice(0, 500) || "recent work";
@@ -3426,8 +3239,8 @@ function escapeSqlLikePattern(value) {
 }
 function formatBytes(bytes) {
 	if (bytes < 1024) return `${bytes} B`;
-	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+	if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / 1048576).toFixed(1)} MB`;
 }
 function parseOptionalPositiveInt$1(value) {
 	if (!value) return void 0;
@@ -4116,8 +3929,9 @@ function resolveCandidateTarget(candidate) {
 		path: join(homedir(), ".config", "opencode", "AGENTS.md"),
 		display: "~/.config/opencode/AGENTS.md"
 	};
+	const root = resolveProjectRoot(process.cwd()) ?? process.cwd();
 	return {
-		path: join(resolveProjectRoot(process.cwd()) ?? process.cwd(), "AGENTS.md"),
+		path: join(root, "AGENTS.md"),
 		display: "AGENTS.md"
 	};
 }
@@ -4358,7 +4172,8 @@ function emitStructuredError(errorCode, message) {
 async function runEnqueueRawEvent(opts, dependencies = {}) {
 	try {
 		const payload = await (dependencies.readPayload ?? readStdinJson)();
-		const store = new MemoryStore(resolveDbPath(resolveDbOpt(opts)));
+		const dbPath = resolveDbPath(resolveDbOpt(opts));
+		const store = new MemoryStore(dbPath);
 		try {
 			ingestRawEvents(store, payload);
 		} finally {
@@ -4480,7 +4295,8 @@ var defaultLogger = {
 	error: (message) => console.error(`Error: ${message}`)
 };
 function readWorkerSyncConfig(configPath) {
-	return readCoordinatorSyncConfig(configPath ? readCodememConfigFileAtPath(configPath) : readCodememConfigFile());
+	const config = configPath ? readCodememConfigFileAtPath(configPath) : readCodememConfigFile();
+	return readCoordinatorSyncConfig(config);
 }
 function createSequentialBackfillCoordinator(store, jobPlans, options) {
 	const pollIntervalMs = 1e3;
@@ -4575,7 +4391,7 @@ function startMaintenanceWorkerRuntime(options = {}) {
 		} catch (error) {
 			logger.warn(`WAL checkpoint failed: ${error instanceof Error ? error.message : String(error)}`);
 		}
-	}, 300 * 1e3);
+	}, 3e5);
 	walCheckpointTimer.unref();
 	if (!isEmbeddingDisabled()) runners.push(new VectorModelMigrationRunner({
 		dbPath,
@@ -5319,7 +5135,7 @@ function createMemoryExtractionReplayCommand() {
 				observerReasoningEffort: opts.reasoningEffort === void 0 ? observerConfig.observerReasoningEffort : opts.reasoningEffort.trim() || null,
 				observerReasoningSummary: opts.reasoningSummary === void 0 ? observerConfig.observerReasoningSummary : opts.reasoningSummary.trim() || null,
 				observerMaxOutputTokens: maxOutputTokens ?? observerConfig.observerMaxOutputTokens ?? observerConfig.observerMaxTokens,
-				observerExplicitConfigKeys: maxOutputTokens === null ? observerConfig.observerExplicitConfigKeys : [...new Set([...observerConfig.observerExplicitConfigKeys ?? [], "observerMaxOutputTokens"])]
+				observerExplicitConfigKeys: maxOutputTokens === null ? observerConfig.observerExplicitConfigKeys : [.../* @__PURE__ */ new Set([...observerConfig.observerExplicitConfigKeys ?? [], "observerMaxOutputTokens"])]
 			};
 			const observer = new ObserverClient(observerConfigWithOverrides);
 			const result = opts.observerTierRouting === true ? await replayBatchExtractionWithTierRouting(resolveDbOpt(opts), observerConfigWithOverrides, {
@@ -5436,7 +5252,7 @@ function createMemoryExtractionBenchmarkCommand() {
 				observerReasoningEffort: opts.reasoningEffort === void 0 ? observerConfig.observerReasoningEffort : opts.reasoningEffort.trim() || null,
 				observerReasoningSummary: opts.reasoningSummary === void 0 ? observerConfig.observerReasoningSummary : opts.reasoningSummary.trim() || null,
 				observerMaxOutputTokens: maxOutputTokens ?? observerConfig.observerMaxOutputTokens ?? observerConfig.observerMaxTokens,
-				observerExplicitConfigKeys: maxOutputTokens === null ? observerConfig.observerExplicitConfigKeys : [...new Set([...observerConfig.observerExplicitConfigKeys ?? [], "observerMaxOutputTokens"])]
+				observerExplicitConfigKeys: maxOutputTokens === null ? observerConfig.observerExplicitConfigKeys : [.../* @__PURE__ */ new Set([...observerConfig.observerExplicitConfigKeys ?? [], "observerMaxOutputTokens"])]
 			};
 			const observer = new ObserverClient(observerConfigWithOverrides);
 			const runs = [];
@@ -5778,9 +5594,9 @@ memoryCommand.addCommand(createMemoryRelinkReportCommand());
 memoryCommand.addCommand(createMemoryRelinkPlanCommand());
 //#endregion
 //#region src/commands/pack.ts
-var MAX_INTERNAL_LEDGER_INPUT_BYTES = 16 * 1024;
+var MAX_INTERNAL_LEDGER_INPUT_BYTES = 16384;
 var INTERNAL_LEDGER_INPUT_TIMEOUT_MS = 1e3;
-var FORBIDDEN_INTERNAL_KEYS = new Set([
+var FORBIDDEN_INTERNAL_KEYS = /* @__PURE__ */ new Set([
 	"body",
 	"context",
 	"pack",
@@ -5792,7 +5608,7 @@ var FORBIDDEN_INTERNAL_KEYS = new Set([
 	"raw_prompt",
 	"title"
 ]);
-var INTERNAL_LEDGER_KEYS = new Set([
+var INTERNAL_LEDGER_KEYS = /* @__PURE__ */ new Set([
 	"action",
 	"attempt_id",
 	"started_at",
@@ -5807,13 +5623,13 @@ var INTERNAL_LEDGER_KEYS = new Set([
 	"failure_stage",
 	"original_attempt_id"
 ]);
-var INTERNAL_LEDGER_ACTIONS = new Set([
+var INTERNAL_LEDGER_ACTIONS = /* @__PURE__ */ new Set([
 	"record",
 	"delivery",
 	"cache_reuse"
 ]);
-var INTERNAL_RETRIEVAL_STATUSES = new Set(["skipped", "failed"]);
-var INTERNAL_DELIVERY_STATUSES = new Set([
+var INTERNAL_RETRIEVAL_STATUSES = /* @__PURE__ */ new Set(["skipped", "failed"]);
+var INTERNAL_DELIVERY_STATUSES = /* @__PURE__ */ new Set([
 	"handed_off",
 	"failed",
 	"unknown"
@@ -6724,7 +6540,8 @@ async function startForegroundViewer(invocation) {
 	const sweeper = new RawEventSweeper(store, { observer });
 	sweeper.start();
 	const syncAbort = new AbortController();
-	const syncConfig = readCoordinatorSyncConfig(invocation.configPath ? readCodememConfigFileAtPath(invocation.configPath) : readCodememConfigFile());
+	const config = invocation.configPath ? readCodememConfigFileAtPath(invocation.configPath) : readCodememConfigFile();
+	const syncConfig = readCoordinatorSyncConfig(config);
 	const syncEnabled = syncConfig.syncEnabled;
 	const dbPath = resolveDbPath(invocation.dbPath ?? void 0);
 	if (!await terminateTrustedMaintenanceWorker(dbPath, {
@@ -7020,29 +6837,39 @@ function migrateLegacyOpencodePlugin() {
 		p.log.step("Removed legacy compat lib: ~/.config/opencode/lib/compat.js");
 	} catch {}
 }
-/** Detect and upgrade legacy uvx/uv-based MCP entries in OpenCode config. */
+function isExactStringArray(value, expected) {
+	return Array.isArray(value) && value.length === expected.length && value.every((entry, index) => entry === expected[index]);
+}
+/** Detect and upgrade legacy uvx/uv or managed single-package MCP entries in OpenCode config. */
 function migrateLegacyOpencodeMcp(config) {
 	const mcpConfig = config.mcp;
 	if (!mcpConfig || typeof mcpConfig !== "object") return false;
 	const entry = mcpConfig.codemem;
 	if (!entry || typeof entry !== "object") return false;
 	const command = entry.command;
-	if (Array.isArray(command) && command.some((arg) => typeof arg === "string" && (arg === "uvx" || arg === "uv")) || typeof command === "string" && (command === "uvx" || command === "uv")) {
-		p.log.step("Upgrading legacy uvx MCP entry to npx");
+	const isLegacyUv = Array.isArray(command) && command.some((arg) => typeof arg === "string" && (arg === "uvx" || arg === "uv")) || typeof command === "string" && (command === "uvx" || command === "uv");
+	const isManagedSinglePackageNpx = isExactStringArray(command, [
+		"npx",
+		"-y",
+		"codemem",
+		"mcp"
+	]) || isExactStringArray(command, [
+		"npx",
+		"codemem",
+		"mcp"
+	]);
+	if (isLegacyUv || isManagedSinglePackageNpx) {
+		p.log.step("Upgrading managed MCP entry to the current npm launcher");
+		const launcher = codememMcpLauncher();
 		mcpConfig.codemem = {
-			type: "local",
-			command: [
-				"npx",
-				"codemem",
-				"mcp"
-			],
-			enabled: true
+			...entry,
+			command: [launcher.command, ...launcher.args]
 		};
 		return true;
 	}
 	return false;
 }
-/** Detect and upgrade legacy uvx-based MCP entries in Claude settings. */
+/** Detect and upgrade legacy uvx or managed single-package MCP entries in Claude settings. */
 function migrateLegacyClaudeMcp(settings) {
 	const mcpServers = settings.mcpServers;
 	if (!mcpServers || typeof mcpServers !== "object") return false;
@@ -7050,15 +6877,19 @@ function migrateLegacyClaudeMcp(settings) {
 	if (!entry || typeof entry !== "object") return false;
 	const command = entry.command;
 	const args = entry.args;
-	if (typeof command === "string" && (command === "uvx" || command === "uv") || Array.isArray(args) && args.some((arg) => typeof arg === "string" && (arg.startsWith("codemem==") || arg === "uvx"))) {
-		p.log.step("Upgrading legacy uvx Claude MCP entry to npx");
+	const isLegacyUv = typeof command === "string" && (command === "uvx" || command === "uv") || Array.isArray(args) && args.some((arg) => typeof arg === "string" && (arg.startsWith("codemem==") || arg === "uvx"));
+	const isManagedSinglePackageNpx = command === "npx" && isExactStringArray(args, [
+		"-y",
+		"codemem",
+		"mcp"
+	]);
+	if (isLegacyUv || isManagedSinglePackageNpx) {
+		p.log.step("Upgrading managed Claude MCP entry to the current npm launcher");
+		const launcher = codememMcpLauncher();
 		mcpServers.codemem = {
-			command: "npx",
-			args: [
-				"-y",
-				"codemem",
-				"mcp"
-			]
+			...entry,
+			command: launcher.command,
+			args: launcher.args
 		};
 		return true;
 	}
@@ -7113,13 +6944,10 @@ function installMcp(force) {
 		return true;
 	}
 	if (!migrated) {
+		const launcher = codememMcpLauncher();
 		mcpConfig.codemem = {
 			type: "local",
-			command: [
-				"npx",
-				"codemem",
-				"mcp"
-			],
+			command: [launcher.command, ...launcher.args],
 			enabled: true
 		};
 		config.mcp = mcpConfig;
@@ -7136,7 +6964,8 @@ function installMcp(force) {
 function isClaudeHooksPluginInstalled() {
 	const pluginDir = join(claudeConfigDir(), "plugins", "codemem");
 	if (existsSync(pluginDir)) return true;
-	if (existsSync(join(pluginDir, "hooks", "hooks.json"))) return true;
+	const hooksJson = join(pluginDir, "hooks", "hooks.json");
+	if (existsSync(hooksJson)) return true;
 	return false;
 }
 function installClaudeMcp(force) {
@@ -7153,13 +6982,10 @@ function installClaudeMcp(force) {
 	if ("codemem" in mcpServers && !force && !migrated) p.log.info(`Claude MCP entry already exists in ${settingsPath}`);
 	else {
 		if (!migrated) {
+			const launcher = codememMcpLauncher();
 			mcpServers.codemem = {
-				command: "npx",
-				args: [
-					"-y",
-					"codemem",
-					"mcp"
-				]
+				command: launcher.command,
+				args: launcher.args
 			};
 			settings.mcpServers = mcpServers;
 		}
@@ -7182,25 +7008,47 @@ function installClaudeMcp(force) {
 	return true;
 }
 /** The MCP server table appended to Codex config.toml. */
-var CODEX_MCP_BLOCK = [
-	"[mcp_servers.codemem]",
-	"command = \"npx\"",
-	"args = [\"-y\", \"codemem\", \"mcp\"]",
-	"startup_timeout_sec = 30",
-	"tool_timeout_sec = 60"
-].join("\n");
+function codexMcpBlock() {
+	const launcher = codememMcpLauncher();
+	const args = launcher.args.map((arg) => JSON.stringify(arg)).join(", ");
+	return [
+		"[mcp_servers.codemem]",
+		`command = ${JSON.stringify(launcher.command)}`,
+		`args = [${args}]`,
+		"startup_timeout_sec = 30",
+		"tool_timeout_sec = 60"
+	].join("\n");
+}
 var CODEX_MCP_TABLE_RE = /^[ \t]*\[[ \t]*mcp_servers[ \t]*\.[ \t]*("?)codemem\1[ \t]*\]/m;
+function migrateManagedCodexMcp(existing) {
+	const tableMatch = CODEX_MCP_TABLE_RE.exec(existing);
+	if (!tableMatch || tableMatch.index == null) return null;
+	const blockStart = tableMatch.index;
+	const nextTable = /^[ \t]*\[/gm;
+	nextTable.lastIndex = blockStart + tableMatch[0].length;
+	const blockEnd = nextTable.exec(existing)?.index ?? existing.length;
+	const block = existing.slice(blockStart, blockEnd);
+	const commandPattern = /^([ \t]*command[ \t]*=[ \t]*)"npx"([ \t]*(?:#.*)?)$/m;
+	const argsPattern = /^([ \t]*args[ \t]*=[ \t]*)\[[ \t]*"-y"[ \t]*,[ \t]*"codemem"[ \t]*,[ \t]*"mcp"[ \t]*\]([ \t]*(?:#.*)?)$/m;
+	if (!commandPattern.test(block) || !argsPattern.test(block)) return null;
+	const launcher = codememMcpLauncher();
+	const args = launcher.args.map((arg) => JSON.stringify(arg)).join(", ");
+	const migrated = block.replace(commandPattern, `$1${JSON.stringify(launcher.command)}$2`).replace(argsPattern, `$1[${args}]$2`);
+	return `${existing.slice(0, blockStart)}${migrated}${existing.slice(blockEnd)}`;
+}
 /** Marker substring identifying codemem-owned hook commands. */
 var CODEMEM_HOOK_MARKER = "codemem codex-hook-";
 /**
 * Resolve how Codex hooks should invoke codemem. Prefer a direct `codemem` call
-* when it's on PATH (fast — no per-hook resolution); fall back to `npx -y codemem`
-* only when codemem isn't installed (e.g. setup was run via `npx codemem setup`),
-* so capture/recall still work without a global install. Mirrors the plugin
-* wrapper's `codemem`-first / `npx` fallback model.
+* when it's on PATH (fast — no per-hook resolution); fall back to an `npx`
+* invocation that requests both `codemem` and `@codemem/embeddings` when codemem
+* isn't installed (e.g. setup was run via `npx codemem setup`). The paired
+* runtime keeps the local-store inject path (codex-hook-inject) able to embed
+* instead of degrading to FTS. Mirrors the MCP launcher's two-package model.
 */
 function codememCodexHookBase() {
-	return codememOnPath() ? "codemem" : "npx -y codemem";
+	if (codememOnPath(true)) return "codemem";
+	return "npx -y --package codemem --package @codemem/embeddings codemem";
 }
 /**
 * Build the codemem-owned hook groups keyed by Codex event name, given the
@@ -7242,28 +7090,127 @@ function isCodememHookGroup(group) {
 	return hooks.some((h) => h != null && typeof h === "object" && typeof h.command === "string" && h.command.includes(CODEMEM_HOOK_MARKER));
 }
 /**
-* True if a resolved bin path is a transient npx/dlx cache bin. When setup runs
-* via `npx -y codemem setup --codex-only`, npx exposes this package's bin on PATH for
-* the duration of the run, then removes it — so Codex would later fail to find a
-* bare `codemem`. Such paths must NOT count as "on PATH" for hook command baking.
+* True if a resolved bin path is a transient/project-local bin that will not be
+* on PATH for the globally-configured MCP hosts (OpenCode/Claude/Codex).
+*
+* - `_npx` / `.pnpm/dlx`: npx/dlx caches exposed only for the duration of a
+*   `npx -y codemem setup` run, then removed.
+* - `node_modules/.bin`: a project-local install exposed only while setup runs
+*   through `npm exec` / `pnpm exec` / a package script. The global hosts do not
+*   inherit that project-local PATH, so baking a bare `codemem` command would
+*   later fail to resolve.
+*
+* Such paths must NOT count as "on PATH" for launcher/hook command baking.
 */
 function isTransientNpxBinPath(resolved) {
-	return /[/\\]_npx[/\\]/.test(resolved) || /[/\\]\.pnpm[/\\]dlx[/\\]/.test(resolved);
+	return /[/\\]_npx[/\\]/.test(resolved) || /[/\\]\.pnpm[/\\]dlx[/\\]/.test(resolved) || /[/\\]node_modules[/\\]\.bin[/\\]/.test(resolved);
+}
+/** Parse a semver core (major.minor.patch) plus optional prerelease tail. */
+function parseSetupSemver(version) {
+	const match = /^(\d+)\.(\d+)\.(\d+)(?:-.+)?$/.exec(version.trim());
+	if (!match) return null;
+	return {
+		core: [
+			Number(match[1]),
+			Number(match[2]),
+			Number(match[3])
+		],
+		prerelease: version.includes("-")
+	};
+}
+/**
+* True when a durable `codemem --version` output should be trusted to launch
+* `codemem mcp` directly. Mirrors the OpenCode plugin's runner check: accept the
+* exact build version, or a clean (non-prerelease) release at least as new as
+* this build. This prevents baking a bare launcher that later resolves to an
+* older global install sitting alongside the transient npx bin.
+*/
+function isDurableCodememVersionTrusted(versionOutput) {
+	if (versionOutput === VERSION) return true;
+	const candidate = parseSetupSemver(versionOutput);
+	const current = parseSetupSemver(VERSION);
+	if (!candidate || !current || candidate.prerelease) return false;
+	for (let i = 0; i < 3; i++) {
+		const c = candidate.core[i] ?? 0;
+		const v = current.core[i] ?? 0;
+		if (c > v) return true;
+		if (c < v) return false;
+	}
+	return true;
 }
 /**
 * Detect whether a durable `codemem` resolves on PATH (excluding a transient
-* npx/dlx bin that vanishes after this process exits).
+* npx/dlx bin that vanishes after this process exits). When `requireTrustedVersion`
+* is set, the durable binary must also report a version compatible with this
+* build before it is trusted, so setup never bakes a bare launcher that resolves
+* to a stale global install.
 */
-function codememOnPath() {
-	try {
-		const resolved = execFileSync(process.platform === "win32" ? "where" : "which", ["codemem"], { encoding: "utf-8" }).split(/\r?\n/).map((line) => line.trim()).find(Boolean);
-		if (!resolved) return false;
-		return !isTransientNpxBinPath(resolved);
+function codememOnPath(requireTrustedVersion = false) {
+	try {
+		const command = process.platform === "win32" ? "where" : "which";
+		const args = process.platform === "win32" ? ["codemem"] : ["-a", "codemem"];
+		const durable = execFileSync(command, args, { encoding: "utf-8" }).split(/\r?\n/).map((line) => line.trim()).filter(Boolean).filter((candidate) => !isTransientNpxBinPath(candidate));
+		if (durable.length === 0) return false;
+		if (!requireTrustedVersion) return true;
+		const [firstDurable] = durable;
+		if (firstDurable == null) return false;
+		const version = probeDurableCodememVersion(firstDurable);
+		return version != null && isDurableCodememVersionTrusted(version);
 	} catch {
 		return false;
 	}
 }
 /**
+* Run `<binary> --version`, returning trimmed stdout or null on failure. On
+* Windows a global npm install resolves to a `.cmd`/`.bat` shim that Node's
+* shell-less execFileSync cannot execute directly, so invoke it through
+* `cmd.exe /c` there; POSIX binaries run directly.
+*/
+function probeDurableCodememVersion(binaryPath) {
+	try {
+		return (process.platform === "win32" ? execFileSync("cmd.exe", [
+			"/c",
+			binaryPath,
+			"--version"
+		], {
+			encoding: "utf-8",
+			timeout: 3e3,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}) : execFileSync(binaryPath, ["--version"], {
+			encoding: "utf-8",
+			timeout: 3e3,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		})).trim();
+	} catch {
+		return null;
+	}
+}
+function codememMcpLauncher(onPath = codememOnPath(true)) {
+	return onPath ? {
+		command: "codemem",
+		args: ["mcp"]
+	} : {
+		command: "npx",
+		args: [
+			"-y",
+			"--package",
+			"codemem",
+			"--package",
+			"@codemem/embeddings",
+			"codemem",
+			"mcp"
+		]
+	};
+}
+/**
 * Append the codemem MCP server table to Codex config.toml without rewriting
 * unrelated content. Returns true on success.
 */
@@ -7271,6 +7218,20 @@ function installCodexMcp(codexHome, force) {
 	const configPath = join(codexHome, "config.toml");
 	const existing = existsSync(configPath) ? readFileSync(configPath, "utf-8") : "";
 	if (CODEX_MCP_TABLE_RE.test(existing)) {
+		const migrated = migrateManagedCodexMcp(existing);
+		if (migrated != null) {
+			try {
+				copyFileSync(configPath, `${configPath}.codemem.bak`);
+			} catch {}
+			try {
+				writeFileSync(configPath, migrated, "utf-8");
+				p.log.success(`Codex MCP entry upgraded: ${configPath}`);
+				return true;
+			} catch (err) {
+				p.log.error(`Failed to write ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+				return false;
+			}
+		}
 		if (force) p.log.info(`Codex MCP entry already exists in ${configPath} — left as-is (TOML is not rewritten in place)`);
 		else p.log.info(`Codex MCP entry already exists in ${configPath}`);
 		return true;
@@ -7280,7 +7241,7 @@ function installCodexMcp(codexHome, force) {
 	} catch {}
 	let next = existing;
 	if (next.length > 0 && !next.endsWith("\n\n")) next += next.endsWith("\n") ? "\n" : "\n\n";
-	next += `${CODEX_MCP_BLOCK}\n`;
+	next += `${codexMcpBlock()}\n`;
 	try {
 		writeFileSync(configPath, next, "utf-8");
 		p.log.success(`Codex MCP entry installed: ${configPath}`);
@@ -7307,12 +7268,38 @@ function installCodexHooks(codexHome, force) {
 	let hooks = config.hooks;
 	if (hooks == null || typeof hooks !== "object" || Array.isArray(hooks)) hooks = {};
 	const ours = buildCodememCodexHookGroups(codememCodexHookBase());
+	const currentCommands = new Set(Object.values(ours).flatMap((groups) => groups.flatMap((group) => group.hooks.map((hook) => hook.command))));
+	const groupNeedsMigration = (group) => {
+		if (!isCodememHookGroup(group)) return false;
+		const hooksList = group.hooks;
+		if (!Array.isArray(hooksList)) return false;
+		return hooksList.some((hook) => {
+			if (hook == null || typeof hook !== "object") return false;
+			const command = hook.command;
+			if (typeof command !== "string") return false;
+			return command.includes(CODEMEM_HOOK_MARKER) && !currentCommands.has(command);
+		});
+	};
 	let changed = false;
+	const isCodememOwnedHook = (hook) => hook != null && typeof hook === "object" && typeof hook.command === "string" && hook.command.includes(CODEMEM_HOOK_MARKER);
+	const stripCodememHooks = (group) => {
+		if (!isCodememHookGroup(group)) return group;
+		const hooksList = group.hooks;
+		if (!Array.isArray(hooksList)) return null;
+		const preservedHooks = hooksList.filter((hook) => !isCodememOwnedHook(hook));
+		if (preservedHooks.length === 0) return null;
+		return {
+			...group,
+			hooks: preservedHooks
+		};
+	};
 	for (const [event, ourGroups] of Object.entries(ours)) {
 		const current = hooks[event];
 		const existingGroups = Array.isArray(current) ? [...current] : [];
-		if (existingGroups.some(isCodememHookGroup) && !force) continue;
-		const preserved = existingGroups.filter((g) => !isCodememHookGroup(g));
+		const hasCodemem = existingGroups.some(isCodememHookGroup);
+		const needsMigration = existingGroups.some(groupNeedsMigration);
+		if (hasCodemem && !force && !needsMigration) continue;
+		const preserved = existingGroups.map((group) => stripCodememHooks(group)).filter((group) => group != null);
 		hooks[event] = [...preserved, ...ourGroups];
 		changed = true;
 	}
@@ -7348,8 +7335,11 @@ function installCodex(force) {
 		p.log.error(`Failed to create Codex home ${codexHome}: ${err instanceof Error ? err.message : String(err)}`);
 		return false;
 	}
-	if (codememOnPath()) p.log.info("Codex hooks will call `codemem` directly (found on PATH).");
-	else p.log.info("`codemem` is not on PATH, so Codex hooks will run via `npx -y codemem` (works without a global install). For lower hook latency: npm i -g codemem");
+	if (codememOnPath(true)) p.log.info("Codex hooks will call `codemem` directly (found on PATH).");
+	else {
+		const globalInstallCommand = process.platform === "linux" ? "env ONNXRUNTIME_NODE_INSTALL=skip npm install -g codemem @codemem/embeddings" : "npm install -g codemem @codemem/embeddings";
+		p.log.info(`\`codemem\` is not on PATH, so Codex hooks will run via \`npx -y --package codemem --package @codemem/embeddings codemem\` (works without a global install). For lower hook latency: ${globalInstallCommand}`);
+	}
 	let ok = true;
 	ok = installCodexMcp(codexHome, force) && ok;
 	ok = installCodexHooks(codexHome, force) && ok;
@@ -7479,7 +7469,7 @@ var statsCommand = statsCmd.action((opts) => {
 //#region src/commands/status.ts
 var MAX_ATTENTION = 20;
 var DEFAULT_VIEWER_PORT = 38888;
-var RECENT_FAILURE_WINDOW_MS = 1440 * 60 * 1e3;
+var RECENT_FAILURE_WINDOW_MS = 864e5;
 var OBSERVER_IDENTITY_KEYS = [
 	"observer_provider",
 	"observer_model",
@@ -8626,7 +8616,8 @@ bootstrapCmd.action(async (peerArg, opts) => {
 		process.exitCode = 2;
 		return;
 	}
-	const store = new MemoryStore(resolveDbPath(resolveDbOpt(opts)));
+	const dbPath = resolveDbPath(resolveDbOpt(opts));
+	const store = new MemoryStore(dbPath);
 	try {
 		const pageSize = Math.max(1, Number.parseInt(opts.pageSize, 10) || 2e3);
 		const keysDir = opts.keysDir ?? void 0;
@@ -8797,7 +8788,7 @@ syncCoordinatorAlias.hook("preAction", (_thisCmd, actionCmd) => {
 syncCommand.addCommand(syncCoordinatorAlias, { hidden: true });
 //#endregion
 //#region src/commands/update.ts
-var INSTALL_TIMEOUT_MS = 300 * 1e3;
+var INSTALL_TIMEOUT_MS = 42e4;
 var VERIFY_TIMEOUT_MS = 3e4;
 var PUBLIC_NPM_REGISTRY = "https://registry.npmjs.org/";
 var UPDATE_LOCK_FILE = "update-install.lock";
@@ -8819,7 +8810,7 @@ async function removeStaleInstallLock(lockPath) {
 		const pid = Number.parseInt(rawPid.trim(), 10);
 		if (Number.isSafeInteger(pid) && pid > 0) {
 			if (isProcessAlive(pid)) return false;
-		} else if (Date.now() - lockStat.mtimeMs <= 33e4) return false;
+		} else if (Date.now() - lockStat.mtimeMs <= 45e4) return false;
 		await unlink(lockPath);
 		return true;
 	} catch {
@@ -8850,6 +8841,7 @@ function runCommand(command, args, timeoutMs, options = {}) {
 		const child = spawn(command, args, {
 			cwd: options.cwd,
 			detached: process.platform !== "win32",
+			env: options.env,
 			shell: false,
 			stdio: [
 				"ignore",
@@ -8983,12 +8975,13 @@ function renderHumanStatus(status) {
 }
 var checkCommand = addJsonOption(new Command("check").description("Check for a newer stable codemem release")).addOption(new Option("-r, --refresh", "bypass the six-hour release cache")).configureHelp(helpStyle).action(async (options) => {
 	try {
+		const installKind = detectInstallKind({
+			entryPath: process.argv[1] ?? "",
+			env: process.env
+		});
 		const status = await getUpdateStatus({
 			currentVersion: VERSION,
-			installKind: detectInstallKind({
-				entryPath: process.argv[1] ?? "",
-				env: process.env
-			}),
+			installKind,
 			refresh: options.refresh
 		});
 		if (status.latest_version === null) {
@@ -9014,15 +9007,29 @@ var checkCommand = addJsonOption(new Command("check").description("Check for a n
 		}
 	}
 });
-var installCommand = addJsonOption(new Command("install").description("Install an eligible stable codemem update")).configureHelp(helpStyle).action(async (options) => {
+function updateInstallArgs(npmArgs, targetVersion) {
+	const installArgs = [
+		"install",
+		"-g",
+		"--registry",
+		PUBLIC_NPM_REGISTRY,
+		`--@codemem:registry=${PUBLIC_NPM_REGISTRY}`,
+		`codemem@${targetVersion}`,
+		`@codemem/embeddings@${targetVersion}`
+	];
+	if (process.platform !== "win32") return installArgs;
+	return [...npmArgs.slice(0, 3), windowsCommandLine(npmArgs[3] ?? "", installArgs)];
+}
+async function installUpdate(options) {
 	let releaseInstallLock = null;
 	try {
+		const installKind = detectInstallKind({
+			entryPath: process.argv[1] ?? "",
+			env: process.env
+		});
 		const status = await getUpdateStatus({
 			currentVersion: VERSION,
-			installKind: detectInstallKind({
-				entryPath: process.argv[1] ?? "",
-				env: process.env
-			}),
+			installKind,
 			refresh: true
 		});
 		if (!status.auto_update_eligible || !status.latest_version) {
@@ -9036,20 +9043,12 @@ var installCommand = addJsonOption(new Command("install").description("Install a
 		}
 		releaseInstallLock = await acquireInstallLock();
 		const npm = await resolveInstallCommand();
-		const installation = await runCommand(npm.command, process.platform === "win32" ? [...npm.args.slice(0, 3), windowsCommandLine(npm.args[3] ?? "", [
-			"install",
-			"-g",
-			"--registry",
-			PUBLIC_NPM_REGISTRY,
-			`codemem@${targetVersion}`
-		])] : [
-			"install",
-			"-g",
-			"--registry",
-			PUBLIC_NPM_REGISTRY,
-			`codemem@${targetVersion}`
-		], INSTALL_TIMEOUT_MS, {
+		const installation = await runCommand(npm.command, updateInstallArgs(npm.args, targetVersion), INSTALL_TIMEOUT_MS, {
 			cwd: npm.cwd,
+			env: process.platform === "linux" ? {
+				...process.env,
+				ONNXRUNTIME_NODE_INSTALL: "skip"
+			} : void 0,
 			windowsVerbatimArguments: process.platform === "win32"
 		});
 		if (installation.exitCode !== 0) {
@@ -9076,8 +9075,9 @@ var installCommand = addJsonOption(new Command("install").description("Install a
 	} finally {
 		await releaseInstallLock?.();
 	}
-});
-var updateCommand = new Command("update").description("Inspect and manage codemem updates").configureHelp(helpStyle).addCommand(checkCommand).addCommand(installCommand);
+}
+var installCommand = addJsonOption(new Command("install").description("Install an eligible stable codemem update")).configureHelp(helpStyle).action(installUpdate);
+var updateCommand = new Command("update").description("Inspect and manage codemem updates").enablePositionalOptions().configureHelp(helpStyle).addCommand(checkCommand).addCommand(installCommand);
 //#endregion
 //#region src/commands/version.ts
 var versionCommand = new Command("version").configureHelp(helpStyle).description("Print codemem version").action(() => {