codemem 0.43.1 → 0.43.2

package/dist/index.js

@@ -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
@@ -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;
@@ -360,7 +360,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 +519,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 +553,401 @@ 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 tmpPath = join(dir, `.hook-tmp-${process.pid}-${Date.now()}-${randomInt(1e3, 1e4)}.json`);
 		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 finalPath = join(dir, `hook-${Math.floor(Date.now() / 1e3)}-${process.pid}-${randomInt(1e3, 1e4)}.json`);
 		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;
 		}
-		let parsed;
+		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 recoveredPath = join(dir, `hook-recovered-${Math.floor(nowS)}-${process.pid}-${randomInt(1e3, 1e4)}.json`);
+			try {
+				renameSync(tmpPath, recoveredPath);
+				logHookEvent(`${cfg.logPrefix} recovered stale temp spool payload: ${recoveredPath}`);
+			} catch {}
+		}
+	}
+	/**
+	* 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 +961,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 +990,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();
@@ -1381,8 +1426,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,
@@ -1622,273 +1667,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
 /**