codemem 0.34.0 → 0.35.1

package/dist/index.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import { DEDUP_KEY_BACKFILL_JOB, DEFAULT_COORDINATOR_DB_PATH, DedupKeyBackfillRunner, MUTATING_TOOL_NAMES, MemoryStore, ObserverClient, REF_BACKFILL_JOB, RawEventSweeper, RefBackfillRunner, SCOPE_BACKFILL_JOB, SESSION_CONTEXT_BACKFILL_JOB, SUMMARY_DEDUP_BACKFILL_JOB, ScopeBackfillRunner, SessionContextBackfillRunner, SummaryDedupBackfillRunner, SyncRetentionRunner, VERSION, VectorModelMigrationRunner, aiBackfillStructuredContent, applyBootstrapSnapshot, backfillMemoryDedupKeys, backfillNarrativeFromBody, backfillTagsText, backfillVectors, buildAuthHeaders, buildBaseUrl, buildRawEventEnvelopeFromHook, compareMemoryRoleReports, connect, coordinatorCreateGroupAction, coordinatorCreateInviteAction, coordinatorCreateScopeAction, coordinatorDisableDeviceAction, coordinatorEnrollDeviceAction, coordinatorGrantScopeMembershipAction, coordinatorImportInviteAction, coordinatorListBootstrapGrantsAction, coordinatorListDevicesAction, coordinatorListGroupsAction, coordinatorListJoinRequestsAction, coordinatorListScopeMembershipsAction, coordinatorListScopesAction, coordinatorRemoveDeviceAction, coordinatorRenameDeviceAction, coordinatorReviewJoinRequestAction, coordinatorRevokeBootstrapGrantAction, coordinatorRevokeScopeMembershipAction, coordinatorUpdateScopeAction, createBetterSqliteCoordinatorApp, deactivateLowSignalMemories, deactivateLowSignalObservations, dedupNearDuplicateMemories, ensureDeviceIdentity, ensureSchemaBootstrapped, exportMemories, extractApplyPatchPaths, fetchAllSnapshotPages, fingerprintPublicKey, flushRawEvents, formatHostPort, getExtractionBenchmarkProfile, getInjectionEvalScenarioPack, getInjectionEvalScenarioPrompts, getMaintenanceJob, getMemoryRoleReport, getRawEventRelinkPlan, getRawEventRelinkReport, getRawEventStatus, getSemanticIndexDiagnostics, getSessionExtractionEval, getSessionExtractionEvalScenario, getWorkspaceCodememConfigPath, hasPendingDedupKeyBackfill, hasPendingRefBackfill, hasPendingScopeBackfill, hasPendingSessionContextBackfill, hasPendingSummaryDedupBackfill, hasUnsyncedSharedMemoryChanges, importMemories, initDatabase, isEmbeddingDisabled, listMaintenanceJobs, listPerPeerScopeSyncState, loadObserverConfig, loadPublicKey, loadSqliteVec, mdnsEnabled, planReplicationOpsAgePrune, pruneReplicationOpsUntilCaughtUp, rawEventsGate, readCodememConfigFile, readCodememConfigFileAtPath, readCoordinatorSyncConfig, readImportPayload, replayBatchExtraction, replayBatchExtractionWithTierRouting, requestJson, resolveCodememConfigPath, resolveDbPath, resolveHookProject, resolveProject, retryRawEventFailures, runSyncDaemon, runSyncPass, scanSecretsRetroactive, schema, setPeerProjectFilter, stripJsonComments, stripPrivateObj, stripTrailingCommas, syncPassPreflight, updatePeerAddresses, vacuumDatabase, writeCodememConfigFile } from "@codemem/core";
+import { DEDUP_KEY_BACKFILL_JOB, DEFAULT_COORDINATOR_DB_PATH, DedupKeyBackfillRunner, MUTATING_TOOL_NAMES, MemoryStore, ObserverClient, REF_BACKFILL_JOB, RawEventSweeper, RefBackfillRunner, SCOPE_BACKFILL_JOB, SESSION_CONTEXT_BACKFILL_JOB, SUMMARY_DEDUP_BACKFILL_JOB, ScopeBackfillRunner, SessionContextBackfillRunner, SummaryDedupBackfillRunner, SyncRetentionRunner, VERSION, VectorModelMigrationRunner, aiBackfillStructuredContent, applyBootstrapSnapshot, backfillMemoryDedupKeys, backfillNarrativeFromBody, backfillTagsText, backfillVectors, buildAuthHeaders, buildBaseUrl, buildRawEventEnvelopeFromCodexHook, buildRawEventEnvelopeFromHook, compareMemoryRoleReports, connect, coordinatorCreateGroupAction, coordinatorCreateInviteAction, coordinatorCreateScopeAction, coordinatorDisableDeviceAction, coordinatorEnrollDeviceAction, coordinatorGrantScopeMembershipAction, coordinatorImportInviteAction, coordinatorListBootstrapGrantsAction, coordinatorListDevicesAction, coordinatorListGroupsAction, coordinatorListJoinRequestsAction, coordinatorListScopeMembershipsAction, coordinatorListScopesAction, coordinatorRemoveDeviceAction, coordinatorRenameDeviceAction, coordinatorReviewJoinRequestAction, coordinatorRevokeBootstrapGrantAction, coordinatorRevokeScopeMembershipAction, coordinatorUpdateScopeAction, createBetterSqliteCoordinatorApp, deactivateLowSignalMemories, deactivateLowSignalObservations, dedupNearDuplicateMemories, ensureDeviceIdentity, ensureSchemaBootstrapped, exportMemories, extractApplyPatchPaths, fetchAllSnapshotPages, fingerprintPublicKey, flushRawEvents, formatHostPort, getExtractionBenchmarkProfile, getInjectionEvalScenarioPack, getInjectionEvalScenarioPrompts, getMaintenanceJob, getMemoryRoleReport, getRawEventRelinkPlan, getRawEventRelinkReport, getRawEventStatus, getSemanticIndexDiagnostics, getSessionExtractionEval, getSessionExtractionEvalScenario, getWorkspaceCodememConfigPath, hasPendingDedupKeyBackfill, hasPendingRefBackfill, hasPendingScopeBackfill, hasPendingSessionContextBackfill, hasPendingSummaryDedupBackfill, hasUnsyncedSharedMemoryChanges, importMemories, initDatabase, isEmbeddingDisabled, listMaintenanceJobs, listPerPeerScopeSyncState, loadObserverConfig, loadPublicKey, loadSqliteVec, mdnsEnabled, planReplicationOpsAgePrune, pruneReplicationOpsUntilCaughtUp, rawEventsGate, readCodememConfigFile, readCodememConfigFileAtPath, readCoordinatorSyncConfig, readImportPayload, replayBatchExtraction, replayBatchExtractionWithTierRouting, requestJson, resolveCodememConfigPath, resolveDbPath, resolveHookProject, resolveProject, retryRawEventFailures, runSyncDaemon, runSyncPass, scanSecretsRetroactive, schema, setPeerProjectFilter, stripJsonComments, stripPrivateObj, stripTrailingCommas, syncPassPreflight, updatePeerAddresses, vacuumDatabase, writeCodememConfigFile } from "@codemem/core";
 import { Command, Option } from "commander";
 import omelette from "omelette";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir, networkInterfaces } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { styleText } from "node:util";
-import { randomInt } from "node:crypto";
+import { randomInt, randomUUID } from "node:crypto";
 import * as p from "@clack/prompts";
 import { serve } from "@hono/node-server";
-import { spawn, spawnSync } from "node:child_process";
+import { execFileSync, spawn, spawnSync } from "node:child_process";
 import net from "node:net";
 import { desc, eq } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/better-sqlite3";
@@ -101,7 +101,7 @@ var BOOLEAN_TOGGLE_VALUES = new Set([
 	"on",
 	"no"
 ]);
-function expandHome$3(value) {
+function expandHome$4(value) {
 	const home = process.env.HOME?.trim() || homedir();
 	if (value === "~") return home;
 	if (value.startsWith("~/")) return join(home, value.slice(2));
@@ -110,8 +110,8 @@ function expandHome$3(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$3("~/.codemem/plugin.log");
-	return expandHome$3(raw.trim());
+	if (BOOLEAN_TOGGLE_VALUES.has(normalized)) return expandHome$4("~/.codemem/plugin.log");
+	return expandHome$4(raw.trim());
 }
 /**
 * Append a single timestamped line to the plugin log. Best-effort: any
@@ -146,24 +146,24 @@ var KIND_ICONS = {
 	change: "✅",
 	exploration: "🔬"
 };
-function emitJson$1(value) {
+function emitJson$2(value) {
 	console.log(JSON.stringify(value));
 }
-function emitError$1(value) {
+function emitError$2(value) {
 	process.stderr.write(`${JSON.stringify(value)}\n`);
 }
-function continueResult$1() {
+function continueResult$2() {
 	return { continue: true };
 }
-function envNotDisabled$1(value) {
+function envNotDisabled$2(value) {
 	const normalized = String(value ?? "").trim().toLowerCase();
 	return normalized !== "0" && normalized !== "false" && normalized !== "off";
 }
-function envTruthy$2(value) {
+function envTruthy$3(value) {
 	const normalized = String(value ?? "").trim().toLowerCase();
 	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
 }
-function expandHome$2(value) {
+function expandHome$3(value) {
 	if (value === "~") return homedir();
 	if (value.startsWith("~/")) return resolve(homedir(), value.slice(2));
 	return value;
@@ -288,30 +288,30 @@ function resolveProject$1(payload) {
 	return resolveHookProject(typeof payload.cwd === "string" ? payload.cwd : null, payload.project);
 }
 async function buildClaudeFileContext(payload, opts, deps = {}) {
-	if (envTruthy$2(process.env.CODEMEM_PLUGIN_IGNORE)) return continueResult$1();
-	if (!envNotDisabled$1(process.env.CODEMEM_FILE_CONTEXT || "1")) return continueResult$1();
+	if (envTruthy$3(process.env.CODEMEM_PLUGIN_IGNORE)) return continueResult$2();
+	if (!envNotDisabled$2(process.env.CODEMEM_FILE_CONTEXT || "1")) return continueResult$2();
 	const filePath = extractFilePath(payload);
-	if (!filePath) return continueResult$1();
+	if (!filePath) return continueResult$2();
 	const cwd = typeof payload.cwd === "string" && payload.cwd.trim() ? payload.cwd : process.cwd();
-	const expandedPath = expandHome$2(filePath);
+	const expandedPath = expandHome$3(filePath);
 	const absolutePath = isAbsolute(expandedPath) ? expandedPath : resolve(cwd, expandedPath);
 	const relativePath = relative(cwd, absolutePath).split(sep).join("/");
 	const escapesCwd = relativePath === ".." || relativePath.startsWith("../") || isAbsolute(relativePath);
 	if (!relativePath || escapesCwd) {
 		logHookEvent(`file_context.skip reason=outside_cwd path=${JSON.stringify(filePath)} cwd=${JSON.stringify(cwd)}`);
-		return continueResult$1();
+		return continueResult$2();
 	}
 	const minBytes = Number.parseInt(process.env.CODEMEM_FILE_CONTEXT_MIN_BYTES ?? `${FILE_GATE_MIN_BYTES}`, 10);
 	const minBytesEffective = Number.isFinite(minBytes) && minBytes >= 0 ? minBytes : FILE_GATE_MIN_BYTES;
 	const stat = (deps.statFile ?? statFile)(absolutePath);
 	if (!stat) {
 		logHookEvent(`file_context.skip reason=stat_failed path=${JSON.stringify(relativePath)}`);
-		return continueResult$1();
+		return continueResult$2();
 	}
 	const bypassSizeGate = SMALL_FILE_BYPASS_PATTERNS.some((p) => p.test(relativePath));
 	if (stat.sizeBytes < minBytesEffective && !bypassSizeGate) {
 		logHookEvent(`file_context.skip reason=below_size_gate path=${JSON.stringify(relativePath)} size=${stat.sizeBytes} gate=${minBytesEffective}`);
-		return continueResult$1();
+		return continueResult$2();
 	}
 	const project = resolveProject$1(payload);
 	const resolveDb = deps.resolveDb ?? resolveDbPath;
@@ -321,16 +321,16 @@ async function buildClaudeFileContext(payload, opts, deps = {}) {
 		rows = queryFn(resolveDb(resolveDbOpt(opts)), relativePath, project, FETCH_LIMIT);
 	} catch (err) {
 		logHookEvent(`codemem claude-hook-file-context query failed: ${err instanceof Error ? err.message : String(err)}`);
-		return continueResult$1();
+		return continueResult$2();
 	}
 	if (rows.length === 0) {
 		logHookEvent(`file_context.skip reason=no_observations path=${JSON.stringify(relativePath)} project=${JSON.stringify(project ?? "")}`);
-		return continueResult$1();
+		return continueResult$2();
 	}
 	const top = scoreAndDedupe(rows, relativePath, DISPLAY_LIMIT);
 	if (top.length === 0) {
 		logHookEvent(`file_context.skip reason=no_top_after_dedupe path=${JSON.stringify(relativePath)} candidates=${rows.length}`);
-		return continueResult$1();
+		return continueResult$2();
 	}
 	let staleness = null;
 	if (stat.mtimeMs > 0) {
@@ -358,14 +358,14 @@ var claudeHookFileContextCommand = claudeHookFileContextCmd.action(async (opts)
 	for await (const chunk of process.stdin) raw += String(chunk);
 	const trimmed = raw.trim();
 	if (!trimmed) {
-		emitJson$1(continueResult$1());
+		emitJson$2(continueResult$2());
 		return;
 	}
 	let payload;
 	try {
 		const parsed = JSON.parse(trimmed);
 		if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
-			emitError$1({
+			emitError$2({
 				error: "parse_error",
 				message: "payload must be a JSON object"
 			});
@@ -374,14 +374,14 @@ var claudeHookFileContextCommand = claudeHookFileContextCmd.action(async (opts)
 		}
 		payload = parsed;
 	} catch {
-		emitError$1({
+		emitError$2({
 			error: "parse_error",
 			message: "invalid JSON"
 		});
 		process.exitCode = 1;
 		return;
 	}
-	emitJson$1(await buildClaudeFileContext(payload, opts));
+	emitJson$2(await buildClaudeFileContext(payload, opts));
 });
 //#endregion
 //#region src/commands/claude-hook-ingest-spool.ts
@@ -391,28 +391,28 @@ var claudeHookFileContextCommand = claudeHookFileContextCmd.action(async (opts)
 * payloads when both HTTP and direct ingestion paths fail, and a
 * recovery routine that promotes stale temp files back into the queue.
 */
-var DEFAULT_LOCK_TTL_S = 300;
-var DEFAULT_LOCK_GRACE_S = 2;
-var LOCK_ACQUIRE_ATTEMPTS = 100;
-var LOCK_ACQUIRE_BACKOFF_MS = 50;
+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$1(value) {
+function expandHome$2(value) {
 	if (value === "~") return homedir();
 	if (value.startsWith("~/")) return join(homedir(), value.slice(2));
 	return value;
 }
-function envInt(name, fallback) {
+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$1(name, fallback) {
+function envTruthy$2(name, fallback) {
 	const raw = process.env[name];
 	if (raw === void 0) return fallback;
 	const normalized = raw.trim().toLowerCase();
@@ -430,15 +430,15 @@ function envTruthy$1(name, fallback) {
 	].includes(normalized)) return false;
 	return fallback;
 }
-function lockConfig() {
+function lockConfig$1() {
 	return {
-		lockDir: expandHome$1(process.env.CODEMEM_CLAUDE_HOOK_LOCK_DIR?.trim() || "~/.codemem/claude-hook-ingest.lock"),
-		ttlSeconds: Math.max(1, envInt("CODEMEM_CLAUDE_HOOK_LOCK_TTL_S", DEFAULT_LOCK_TTL_S)),
-		graceSeconds: Math.max(1, envInt("CODEMEM_CLAUDE_HOOK_LOCK_GRACE_S", DEFAULT_LOCK_GRACE_S))
+		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 spoolDir() {
-	return expandHome$1(process.env.CODEMEM_CLAUDE_HOOK_SPOOL_DIR?.trim() || "~/.codemem/claude-hook-spool");
+	return expandHome$2(process.env.CODEMEM_CLAUDE_HOOK_SPOOL_DIR?.trim() || "~/.codemem/claude-hook-spool");
 }
 /**
 * Cheap pre-check used by the unlocked HTTP-success path to decide
@@ -470,7 +470,7 @@ function readFileTrimmedOrEmpty(path) {
 		return "";
 	}
 }
-function readLockMetadata(lockDir) {
+function readLockMetadata$1(lockDir) {
 	const pid = readFileTrimmedOrEmpty(join(lockDir, "pid"));
 	const owner = readFileTrimmedOrEmpty(join(lockDir, "owner"));
 	const tsRaw = readFileTrimmedOrEmpty(join(lockDir, "ts"));
@@ -481,7 +481,7 @@ function readLockMetadata(lockDir) {
 		owner
 	};
 }
-function isPidAlive(pidText) {
+function isPidAlive$1(pidText) {
 	const pid = Number.parseInt(pidText, 10);
 	if (!Number.isFinite(pid) || pid <= 0) return false;
 	try {
@@ -491,11 +491,11 @@ function isPidAlive(pidText) {
 		return false;
 	}
 }
-function lockIsStale(cfg) {
-	const snapshot = readLockMetadata(cfg.lockDir);
+function lockIsStale$1(cfg) {
+	const snapshot = readLockMetadata$1(cfg.lockDir);
 	const nowS = Math.floor(Date.now() / 1e3);
 	if (snapshot.pid) {
-		if (isPidAlive(snapshot.pid)) {
+		if (isPidAlive$1(snapshot.pid)) {
 			if (snapshot.ts === null) return {
 				stale: false,
 				snapshot
@@ -528,7 +528,7 @@ function lockIsStale(cfg) {
 		snapshot
 	};
 }
-function cleanupLockDir(lockDir) {
+function cleanupLockDir$1(lockDir) {
 	for (const name of [
 		"pid",
 		"ts",
@@ -543,13 +543,13 @@ function cleanupLockDir(lockDir) {
 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 cleanupLockDirIfUnchanged$1(lockDir, snapshot) {
+	if (snapshotsEqual(readLockMetadata$1(lockDir), snapshot)) cleanupLockDir$1(lockDir);
 }
-function isErrnoException(err) {
+function isErrnoException$1(err) {
 	return typeof err === "object" && err !== null && "code" in err;
 }
-async function sleep(ms) {
+async function sleep$1(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 /**
@@ -563,21 +563,21 @@ async function sleep(ms) {
 * race between mkdir and writing pid/ts.
 */
 async function withClaudeHookIngestLock(fn) {
-	const cfg = lockConfig();
+	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; attempt++) {
+	for (let attempt = 0; attempt < LOCK_ACQUIRE_ATTEMPTS$1; 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);
+			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);
 				continue;
 			}
-			await sleep(LOCK_ACQUIRE_BACKOFF_MS);
+			await sleep$1(LOCK_ACQUIRE_BACKOFF_MS$1);
 			continue;
 		}
 		try {
@@ -587,15 +587,15 @@ async function withClaudeHookIngestLock(fn) {
 			acquired = true;
 			break;
 		} catch {
-			cleanupLockDir(cfg.lockDir);
-			await sleep(LOCK_ACQUIRE_BACKOFF_MS);
+			cleanupLockDir$1(cfg.lockDir);
+			await sleep$1(LOCK_ACQUIRE_BACKOFF_MS$1);
 		}
 	}
 	if (!acquired) throw new LockBusyError();
 	try {
 		return await fn();
 	} finally {
-		if (readFileTrimmedOrEmpty(join(cfg.lockDir, "owner")) === ownerToken) cleanupLockDir(cfg.lockDir);
+		if (readFileTrimmedOrEmpty(join(cfg.lockDir, "owner")) === ownerToken) cleanupLockDir$1(cfg.lockDir);
 	}
 }
 /**
@@ -676,7 +676,7 @@ function recoverStaleTmpSpool(ttlSeconds) {
 * place with a `.bad-<reason>-` prefix so an operator can inspect or
 * delete it manually.
 */
-function quarantineSpoolEntry(dir, name, reason) {
+function quarantineSpoolEntry$1(dir, name, reason) {
 	const sourcePath = join(dir, name);
 	const quarantineName = `.bad-${reason}-${Date.now()}-${randomInt(1e3, 1e4)}-${name}`;
 	try {
@@ -735,12 +735,12 @@ async function drainSpool(handler) {
 		try {
 			parsed = JSON.parse(raw);
 		} catch {
-			quarantineSpoolEntry(dir, name, "parse-error");
+			quarantineSpoolEntry$1(dir, name, "parse-error");
 			result.failed++;
 			continue;
 		}
 		if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
-			quarantineSpoolEntry(dir, name, "wrong-shape");
+			quarantineSpoolEntry$1(dir, name, "wrong-shape");
 			continue;
 		}
 		let ok = false;
@@ -769,9 +769,9 @@ async function drainSpool(handler) {
 function shouldForceBoundaryFlush(payload) {
 	const eventName = typeof payload.hook_event_name === "string" ? payload.hook_event_name.trim() : "";
 	if (eventName !== "Stop" && eventName !== "SessionEnd") return false;
-	if (eventName === "SessionEnd") return envTruthy$1("CODEMEM_CLAUDE_HOOK_FLUSH", true);
-	if (!envTruthy$1("CODEMEM_CLAUDE_HOOK_FLUSH", false)) return false;
-	return envTruthy$1("CODEMEM_CLAUDE_HOOK_FLUSH_ON_STOP", false);
+	if (eventName === "SessionEnd") return envTruthy$2("CODEMEM_CLAUDE_HOOK_FLUSH", true);
+	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`)
@@ -779,7 +779,7 @@ function shouldForceBoundaryFlush(payload) {
 * the env.
 */
 function lockTtlSeconds() {
-	return lockConfig().ttlSeconds;
+	return lockConfig$1().ttlSeconds;
 }
 //#endregion
 //#region src/commands/claude-hook-session-state.ts
@@ -812,14 +812,14 @@ function defaultSessionState() {
 		updated_at: ""
 	};
 }
-function expandHome(value) {
+function expandHome$1(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(override?.trim() ? override : "~/.codemem/claude-hook-context");
+	return expandHome$1(override?.trim() ? override : "~/.codemem/claude-hook-context");
 }
 function sessionFileStem(sessionId) {
 	const trimmed = sessionId.trim();
@@ -1014,7 +1014,7 @@ function workingSetPathsFromState(state) {
 *   echo '{"hook_event_name":"Stop","session_id":"...","last_assistant_message":"..."}' \
 *     | codemem claude-hook-ingest
 */
-function emitStructuredError$1(errorCode, message) {
+function emitStructuredError$2(errorCode, message) {
 	console.log(JSON.stringify({
 		error: errorCode,
 		message
@@ -1037,7 +1037,7 @@ function emitStructuredError$1(errorCode, message) {
 * transient, we'll need a reason field in the response and updated
 * client handling — not an unconditional fail-over.
 */
-async function tryHttpIngest(payload, host, port) {
+async function tryHttpIngest$1(payload, host, port) {
 	const url = `http://${host}:${port}/api/claude-hooks`;
 	const controller = new AbortController();
 	const timeout = setTimeout(() => controller.abort(), 5e3);
@@ -1053,19 +1053,796 @@ async function tryHttpIngest(payload, host, port) {
 			inserted: 0,
 			skipped: 0
 		};
-		let body;
-		try {
-			body = await res.json();
-		} catch {
-			logHookEvent("codemem claude-hook-ingest HTTP accepted with invalid response body");
-			return {
-				ok: false,
-				inserted: 0,
-				skipped: 0
-			};
-		}
+		let body;
+		try {
+			body = await res.json();
+		} catch {
+			logHookEvent("codemem claude-hook-ingest HTTP accepted with invalid response body");
+			return {
+				ok: false,
+				inserted: 0,
+				skipped: 0
+			};
+		}
+		if (body == null || typeof body !== "object" || Array.isArray(body)) {
+			logHookEvent("codemem claude-hook-ingest HTTP accepted with invalid response type");
+			return {
+				ok: false,
+				inserted: 0,
+				skipped: 0
+			};
+		}
+		const obj = body;
+		if (typeof obj.inserted !== "number" || typeof obj.skipped !== "number") {
+			logHookEvent("codemem claude-hook-ingest HTTP accepted with unexpected response body");
+			return {
+				ok: false,
+				inserted: 0,
+				skipped: 0
+			};
+		}
+		return {
+			ok: true,
+			inserted: obj.inserted,
+			skipped: obj.skipped
+		};
+	} catch {
+		return {
+			ok: false,
+			inserted: 0,
+			skipped: 0
+		};
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+/** Fall back to direct raw-event enqueue via the local SQLite store. */
+function directEnqueue(payload, dbPath) {
+	const envelope = buildRawEventEnvelopeFromHook(payload);
+	if (!envelope) return {
+		inserted: 0,
+		skipped: 1
+	};
+	const db = connect(dbPath);
+	try {
+		try {
+			loadSqliteVec(db);
+		} catch {}
+		ensureSchemaBootstrapped(db);
+		const strippedPayload = stripPrivateObj(envelope.payload);
+		if (db.prepare("SELECT 1 FROM raw_events WHERE source = ? AND stream_id = ? AND event_id = ? LIMIT 1").get(envelope.source, envelope.session_stream_id, envelope.event_id)) return {
+			inserted: 0,
+			skipped: 0
+		};
+		db.prepare(`INSERT INTO raw_events(
+				source, stream_id, opencode_session_id, event_id, event_seq,
+				event_type, ts_wall_ms, payload_json, created_at
+			) VALUES (?, ?, ?, ?, (
+				SELECT COALESCE(MAX(event_seq), 0) + 1
+				FROM raw_events WHERE source = ? AND stream_id = ?
+			), ?, ?, ?, datetime('now'))`).run(envelope.source, envelope.session_stream_id, envelope.opencode_session_id, envelope.event_id, envelope.source, envelope.session_stream_id, "claude.hook", envelope.ts_wall_ms, JSON.stringify(strippedPayload));
+		const currentMaxSeq = db.prepare("SELECT COALESCE(MAX(event_seq), 0) AS max_seq FROM raw_events WHERE source = ? AND stream_id = ?").get(envelope.source, envelope.session_stream_id).max_seq;
+		db.prepare(`INSERT INTO raw_event_sessions(
+				source, stream_id, opencode_session_id, cwd, project, started_at,
+				last_seen_ts_wall_ms, last_received_event_seq, last_flushed_event_seq, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, -1, datetime('now'))
+			ON CONFLICT(source, stream_id) DO UPDATE SET
+				cwd = COALESCE(excluded.cwd, cwd),
+				project = COALESCE(excluded.project, project),
+				started_at = COALESCE(excluded.started_at, started_at),
+				last_seen_ts_wall_ms = MAX(COALESCE(excluded.last_seen_ts_wall_ms, 0), COALESCE(last_seen_ts_wall_ms, 0)),
+				last_received_event_seq = MAX(excluded.last_received_event_seq, last_received_event_seq),
+				updated_at = datetime('now')`).run(envelope.source, envelope.session_stream_id, envelope.opencode_session_id, envelope.cwd, envelope.project, envelope.started_at, envelope.ts_wall_ms, currentMaxSeq);
+		return {
+			inserted: 1,
+			skipped: 0
+		};
+	} finally {
+		db.close();
+	}
+}
+/**
+* Best-effort boundary flush: write the payload through to the local
+* store (so the just-fired SessionEnd / Stop event is durable in
+* raw_events) and then run a synchronous flushRawEvents pass so that
+* the latest memories are extracted before the hook process exits and
+* the user closes their terminal.
+*
+* Any failure here \u2014 observer construction, store I/O, flush errors,
+* or simply running without observer credentials \u2014 is logged to
+* `~/.codemem/plugin.log` and swallowed. The hook command must never
+* crash on a boundary flush failure.
+*/
+async function flushBoundaryRawEvents(payload, dbPath) {
+	const envelope = buildRawEventEnvelopeFromHook(payload);
+	if (!envelope) return;
+	let observer;
+	try {
+		observer = new ObserverClient();
+	} catch (err) {
+		logHookEvent(`codemem claude-hook-ingest boundary flush observer init failed: ${err instanceof Error ? err.message : String(err)}`);
+		return;
+	}
+	let store;
+	try {
+		store = new MemoryStore(dbPath);
+	} catch (err) {
+		logHookEvent(`codemem claude-hook-ingest boundary flush store init failed: ${err instanceof Error ? err.message : String(err)}`);
+		return;
+	}
+	try {
+		await flushRawEvents(store, { observer }, {
+			opencodeSessionId: envelope.session_stream_id,
+			source: envelope.source,
+			cwd: envelope.cwd ?? null,
+			project: envelope.project ?? null,
+			startedAt: envelope.started_at ?? null,
+			maxEvents: null
+		});
+	} catch (err) {
+		logHookEvent(`codemem claude-hook-ingest boundary flush raw events failed: ${err instanceof Error ? err.message : String(err)}`);
+	} finally {
+		store.close();
+	}
+}
+/**
+* Ingest one Claude hook payload using the TS contract:
+* HTTP enqueue first, then locked drain + retry + direct fallback +
+* disk spool durability.
+*/
+async function ingestClaudeHookPayload(payload, opts, deps = {}) {
+	const httpIngest = deps.httpIngest ?? tryHttpIngest$1;
+	const directIngest = deps.directIngest ?? directEnqueue;
+	const resolveDb = deps.resolveDb ?? resolveDbPath;
+	const boundaryFlush = deps.boundaryFlush ?? flushBoundaryRawEvents;
+	try {
+		trackHookSessionState(payload);
+	} catch {}
+	const port = typeof opts.port === "number" ? opts.port : Number.parseInt(opts.port, 10);
+	let cachedDbPath = null;
+	const getDbPath = () => {
+		if (cachedDbPath === null) cachedDbPath = resolveDb(resolveDbOpt(opts));
+		return cachedDbPath;
+	};
+	const tryDirectFallback = (queued) => {
+		try {
+			return {
+				ok: true,
+				result: directIngest(queued, getDbPath())
+			};
+		} catch (err) {
+			logHookEvent(`codemem claude-hook-ingest direct fallback failed: ${err instanceof Error ? err.message : String(err)}`);
+			return { ok: false };
+		}
+	};
+	const flushOnBoundaryIfRequested = async () => {
+		if (!shouldForceBoundaryFlush(payload)) return;
+		try {
+			directIngest(payload, getDbPath());
+		} catch (err) {
+			logHookEvent(`codemem claude-hook-ingest boundary flush direct write failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		try {
+			await boundaryFlush(payload, getDbPath());
+		} catch (err) {
+			logHookEvent(`codemem claude-hook-ingest boundary flush failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	};
+	const drainBacklogIfPresent = async () => {
+		if (!hasSpooledEntries()) return;
+		try {
+			await withClaudeHookIngestLock(async () => {
+				recoverStaleTmpSpool(lockTtlSeconds());
+				await drainSpool(async (queuedPayload) => {
+					if ((await httpIngest(queuedPayload, opts.host, port)).ok) return true;
+					return tryDirectFallback(queuedPayload).ok;
+				});
+			});
+		} catch (err) {
+			if (err instanceof LockBusyError) return;
+			logHookEvent(`codemem claude-hook-ingest backlog drain failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	};
+	const httpResult = await httpIngest(payload, opts.host, port);
+	if (httpResult.ok) {
+		await flushOnBoundaryIfRequested();
+		await drainBacklogIfPresent();
+		return {
+			inserted: httpResult.inserted,
+			skipped: httpResult.skipped,
+			via: "http"
+		};
+	}
+	try {
+		return await withClaudeHookIngestLock(async () => {
+			recoverStaleTmpSpool(lockTtlSeconds());
+			await drainSpool(async (queuedPayload) => {
+				if ((await httpIngest(queuedPayload, opts.host, port)).ok) return true;
+				return tryDirectFallback(queuedPayload).ok;
+			});
+			const secondHttp = await httpIngest(payload, opts.host, port);
+			if (secondHttp.ok) {
+				await flushOnBoundaryIfRequested();
+				return {
+					inserted: secondHttp.inserted,
+					skipped: secondHttp.skipped,
+					via: "http"
+				};
+			}
+			const direct = tryDirectFallback(payload);
+			if (direct.ok) {
+				await flushOnBoundaryIfRequested();
+				return {
+					...direct.result,
+					via: "direct"
+				};
+			}
+			if (spoolPayload(payload)) return {
+				inserted: 0,
+				skipped: 0,
+				via: "spool"
+			};
+			logHookEvent("codemem claude-hook-ingest failed: fallback and spool failed");
+			throw new Error("claude-hook-ingest: fallback and spool both failed");
+		});
+	} catch (err) {
+		if (!(err instanceof LockBusyError)) throw err;
+		logHookEvent("codemem claude-hook-ingest lock busy; trying unlocked fallback");
+		const direct = tryDirectFallback(payload);
+		if (direct.ok) return {
+			...direct.result,
+			via: "direct"
+		};
+		if (spoolPayload(payload)) return {
+			inserted: 0,
+			skipped: 0,
+			via: "spool_lock_busy"
+		};
+		logHookEvent("codemem claude-hook-ingest failed: unlocked fallback and spool failed");
+		throw err;
+	}
+}
+var claudeHookCmd = new Command("claude-hook-ingest").configureHelp(helpStyle).description("Ingest Claude hook payload: HTTP first, direct DB fallback");
+addDbOption(claudeHookCmd);
+addViewerHostOptions(claudeHookCmd);
+function envTruthyValue$1(value) {
+	const normalized = String(value ?? "").trim().toLowerCase();
+	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+var claudeHookIngestCommand = claudeHookCmd.action(async (opts) => {
+	if (envTruthyValue$1(process.env.CODEMEM_PLUGIN_IGNORE)) return;
+	let raw;
+	try {
+		raw = readFileSync(0, "utf8").trim();
+	} catch {
+		emitStructuredError$2("read_error", "failed to read stdin");
+		return;
+	}
+	if (!raw) {
+		emitStructuredError$2("read_error", "empty stdin");
+		return;
+	}
+	let payload;
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+			emitStructuredError$2("parse_error", "payload must be a JSON object");
+			return;
+		}
+		payload = parsed;
+	} catch {
+		emitStructuredError$2("parse_error", "invalid JSON");
+		return;
+	}
+	try {
+		const result = await ingestClaudeHookPayload(payload, opts);
+		console.log(JSON.stringify(result));
+	} catch (err) {
+		emitStructuredError$2("ingest_error", err instanceof Error ? err.message : String(err));
+	}
+});
+//#endregion
+//#region src/commands/claude-hook-inject.ts
+var HOOK_EVENT_NAME$1 = "UserPromptSubmit";
+var EMPTY_PACK$1 = {
+	packText: "",
+	items: 0,
+	packTokens: 0
+};
+var DEFAULT_VIEWER_HOST$1 = "127.0.0.1";
+var DEFAULT_VIEWER_PORT$1 = 38888;
+var DEFAULT_MAX_CHARS$1 = 16e3;
+var DEFAULT_HTTP_MAX_TIME_S$1 = 2;
+function emitJson$1(value) {
+	console.log(JSON.stringify(value));
+}
+function emitError$1(value) {
+	process.stderr.write(`${JSON.stringify(value)}\n`);
+}
+function envNotDisabled$1(value) {
+	const normalized = String(value ?? "").trim().toLowerCase();
+	return normalized !== "0" && normalized !== "false" && normalized !== "off";
+}
+function envTruthy$1(value) {
+	const normalized = String(value ?? "").trim().toLowerCase();
+	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function parsePositiveInt$2(value, fallback) {
+	const parsed = Number.parseInt(String(value ?? ""), 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+	return parsed;
+}
+function continueResult$1(additionalContext) {
+	if (!additionalContext) return { continue: true };
+	return {
+		continue: true,
+		hookSpecificOutput: {
+			hookEventName: HOOK_EVENT_NAME$1,
+			additionalContext
+		}
+	};
+}
+function truncateAdditionalContext$1(text, maxChars) {
+	const normalized = text.trim();
+	if (!normalized) return "";
+	if (!Number.isFinite(maxChars) || maxChars <= 0 || normalized.length <= maxChars) return normalized;
+	return `${normalized.slice(0, maxChars).trimEnd()}\n\n[pack truncated]`;
+}
+function extractInjectContext(payload) {
+	return normalizePromptText(payload.prompt) || null;
+}
+function resolveInjectProject$1(payload) {
+	return resolveHookProject(typeof payload.cwd === "string" ? payload.cwd : null, payload.project);
+}
+async function buildLocalPack$1(context, project, dbPath, workingSetPaths = []) {
+	const store = new MemoryStore(dbPath);
+	try {
+		const limit = parsePositiveInt$2(process.env.CODEMEM_INJECT_LIMIT, 8);
+		const budget = parsePositiveInt$2(process.env.CODEMEM_INJECT_TOKEN_BUDGET, 800);
+		const filters = {};
+		if (project) filters.project = project;
+		if (workingSetPaths.length > 0) filters.working_set_paths = workingSetPaths;
+		const pack = await store.buildMemoryPackAsync(context, limit, budget, filters);
+		return {
+			packText: String(pack.pack_text ?? "").trim(),
+			items: Array.isArray(pack.items) ? pack.items.length : 0,
+			packTokens: Number.isFinite(Number(pack.metrics?.pack_tokens)) ? Number(pack.metrics.pack_tokens) : 0
+		};
+	} finally {
+		store.close();
+	}
+}
+async function tryHttpPack$1(context, project, maxTimeMs = DEFAULT_HTTP_MAX_TIME_S$1 * 1e3) {
+	const empty = {
+		packText: "",
+		items: 0,
+		packTokens: 0
+	};
+	const host = process.env.CODEMEM_VIEWER_HOST || DEFAULT_VIEWER_HOST$1;
+	const port = parsePositiveInt$2(process.env.CODEMEM_VIEWER_PORT, DEFAULT_VIEWER_PORT$1);
+	const url = new URL(`http://${host}:${port}/api/pack`);
+	url.searchParams.set("context", context);
+	url.searchParams.set("limit", String(parsePositiveInt$2(process.env.CODEMEM_INJECT_LIMIT, 8)));
+	url.searchParams.set("token_budget", String(parsePositiveInt$2(process.env.CODEMEM_INJECT_TOKEN_BUDGET, 800)));
+	if (project) url.searchParams.set("project", project);
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), maxTimeMs);
+	try {
+		const res = await fetch(url, { signal: controller.signal });
+		if (!res.ok) return empty;
+		const body = await res.json();
+		return {
+			packText: String(body.pack_text ?? "").trim(),
+			items: Array.isArray(body.items) ? body.items.length : 0,
+			packTokens: Number.isFinite(Number(body.metrics?.pack_tokens)) ? Number(body.metrics?.pack_tokens) : 0
+		};
+	} catch {
+		return empty;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+async function buildClaudeHookInjection(payload, opts, deps = {}) {
+	if (envTruthy$1(process.env.CODEMEM_PLUGIN_IGNORE)) return continueResult$1();
+	if (!envNotDisabled$1(process.env.CODEMEM_INJECT_CONTEXT || "1")) return continueResult$1();
+	let state = null;
+	try {
+		state = trackHookSessionState(payload);
+	} catch {
+		state = null;
+	}
+	const promptText = extractInjectContext(payload);
+	if (!promptText) return continueResult$1();
+	const buildPack = deps.buildLocalPack ?? buildLocalPack$1;
+	const httpPack = deps.httpPack ?? tryHttpPack$1;
+	const resolveDb = deps.resolveDb ?? resolveDbPath;
+	const project = resolveInjectProject$1(payload);
+	const query = buildInjectQuery({
+		prompt: promptText,
+		project,
+		state
+	});
+	const workingSetPaths = workingSetPathsFromState(state);
+	const maxChars = parsePositiveInt$2(process.env.CODEMEM_INJECT_MAX_CHARS, DEFAULT_MAX_CHARS$1);
+	const httpMaxTimeMs = parsePositiveInt$2(process.env.CODEMEM_INJECT_HTTP_MAX_TIME_S, DEFAULT_HTTP_MAX_TIME_S$1) * 1e3;
+	let pack = EMPTY_PACK$1;
+	let origin = "none";
+	try {
+		pack = await buildPack(query, project, resolveDb(resolveDbOpt(opts)), workingSetPaths);
+		if (pack.packText) origin = "local";
+	} catch (err) {
+		logHookEvent(`codemem claude-hook-inject local pack failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (!pack.packText && envNotDisabled$1(process.env.CODEMEM_INJECT_HTTP_FALLBACK || "1")) {
+		pack = await httpPack(query, project, httpMaxTimeMs);
+		if (pack.packText) origin = "http";
+	}
+	const fields = [
+		"inject.pack.ok",
+		"source=claude",
+		`origin=${origin}`,
+		`items=${pack.items}`,
+		`pack_tokens=${pack.packTokens}`,
+		`query_len=${query.length}`,
+		`empty=${pack.packText ? "false" : "true"}`
+	];
+	if (project) fields.push(`project=${JSON.stringify(project)}`);
+	logHookEvent(fields.join(" "));
+	return continueResult$1(truncateAdditionalContext$1(pack.packText, maxChars));
+}
+var claudeHookInjectCmd = new Command("claude-hook-inject").configureHelp(helpStyle).description("Return Claude hook additionalContext from local pack generation");
+addDbOption(claudeHookInjectCmd);
+var claudeHookInjectCommand = claudeHookInjectCmd.action(async (opts) => {
+	let raw = "";
+	for await (const chunk of process.stdin) raw += String(chunk);
+	const trimmed = raw.trim();
+	if (!trimmed) {
+		emitJson$1(continueResult$1());
+		return;
+	}
+	let payload;
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+			emitError$1({
+				error: "parse_error",
+				message: "payload must be a JSON object"
+			});
+			process.exitCode = 1;
+			return;
+		}
+		payload = parsed;
+	} catch {
+		emitError$1({
+			error: "parse_error",
+			message: "invalid JSON"
+		});
+		process.exitCode = 1;
+		return;
+	}
+	emitJson$1(await buildClaudeHookInjection(payload, 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;
+}
+//#endregion
+//#region src/commands/codex-hook-ingest.ts
+/**
+* codemem codex-hook-ingest — read a single Codex hook payload from stdin and
+* enqueue it for raw-event processing.
+*/
+var DEFAULT_HTTP_TIMEOUT_MS = 1e3;
+function httpTimeoutMs() {
+	const parsed = Number.parseInt(process.env.CODEMEM_CODEX_HOOK_HTTP_TIMEOUT_MS ?? "", 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_HTTP_TIMEOUT_MS;
+}
+function emitStructuredError$1(errorCode, message) {
+	console.log(JSON.stringify({
+		error: errorCode,
+		message
+	}));
+	process.exitCode = 1;
+}
+function envTruthyValue(value) {
+	const normalized = String(value ?? "").trim().toLowerCase();
+	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function hasPayloadTimestamp(payload) {
+	return typeof payload.timestamp === "string" && payload.timestamp.trim() !== "" || typeof payload.ts === "string" && payload.ts.trim() !== "";
+}
+function normalizePayloadForIngest(payload) {
+	if (hasPayloadTimestamp(payload)) return payload;
+	return {
+		...payload,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		codemem_generated_event_nonce: randomUUID()
+	};
+}
+async function tryHttpIngest(payload, host, port) {
+	const url = `http://${host}:${port}/api/codex-hooks`;
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), httpTimeoutMs());
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(payload),
+			signal: controller.signal
+		});
+		if (!res.ok) return {
+			ok: false,
+			inserted: 0,
+			skipped: 0
+		};
+		const body = await res.json();
 		if (body == null || typeof body !== "object" || Array.isArray(body)) {
-			logHookEvent("codemem claude-hook-ingest HTTP accepted with invalid response type");
+			logHookEvent("codemem codex-hook-ingest HTTP accepted with invalid response type");
 			return {
 				ok: false,
 				inserted: 0,
@@ -1074,7 +1851,7 @@ async function tryHttpIngest(payload, host, port) {
 		}
 		const obj = body;
 		if (typeof obj.inserted !== "number" || typeof obj.skipped !== "number") {
-			logHookEvent("codemem claude-hook-ingest HTTP accepted with unexpected response body");
+			logHookEvent("codemem codex-hook-ingest HTTP accepted with unexpected response body");
 			return {
 				ok: false,
 				inserted: 0,
@@ -1096,9 +1873,8 @@ async function tryHttpIngest(payload, host, port) {
 		clearTimeout(timeout);
 	}
 }
-/** Fall back to direct raw-event enqueue via the local SQLite store. */
-function directEnqueue(payload, dbPath) {
-	const envelope = buildRawEventEnvelopeFromHook(payload);
+function directEnqueueCodexHook(payload, dbPath) {
+	const envelope = buildRawEventEnvelopeFromCodexHook(payload);
 	if (!envelope) return {
 		inserted: 0,
 		skipped: 1
@@ -1118,10 +1894,10 @@ function directEnqueue(payload, dbPath) {
 				source, stream_id, opencode_session_id, event_id, event_seq,
 				event_type, ts_wall_ms, payload_json, created_at
 			) VALUES (?, ?, ?, ?, (
-				SELECT COALESCE(MAX(event_seq), 0) + 1
+				SELECT COALESCE(MAX(event_seq), -1) + 1
 				FROM raw_events WHERE source = ? AND stream_id = ?
-			), ?, ?, ?, datetime('now'))`).run(envelope.source, envelope.session_stream_id, envelope.opencode_session_id, envelope.event_id, envelope.source, envelope.session_stream_id, "claude.hook", envelope.ts_wall_ms, JSON.stringify(strippedPayload));
-		const currentMaxSeq = db.prepare("SELECT COALESCE(MAX(event_seq), 0) AS max_seq FROM raw_events WHERE source = ? AND stream_id = ?").get(envelope.source, envelope.session_stream_id).max_seq;
+			), ?, ?, ?, datetime('now'))`).run(envelope.source, envelope.session_stream_id, envelope.opencode_session_id, envelope.event_id, envelope.source, envelope.session_stream_id, envelope.event_type, envelope.ts_wall_ms, JSON.stringify(strippedPayload));
+		const maxSeqRow = db.prepare("SELECT COALESCE(MAX(event_seq), 0) AS max_seq FROM raw_events WHERE source = ? AND stream_id = ?").get(envelope.source, envelope.session_stream_id);
 		db.prepare(`INSERT INTO raw_event_sessions(
 				source, stream_id, opencode_session_id, cwd, project, started_at,
 				last_seen_ts_wall_ms, last_received_event_seq, last_flushed_event_seq, updated_at
@@ -1132,7 +1908,7 @@ function directEnqueue(payload, dbPath) {
 				started_at = COALESCE(excluded.started_at, started_at),
 				last_seen_ts_wall_ms = MAX(COALESCE(excluded.last_seen_ts_wall_ms, 0), COALESCE(last_seen_ts_wall_ms, 0)),
 				last_received_event_seq = MAX(excluded.last_received_event_seq, last_received_event_seq),
-				updated_at = datetime('now')`).run(envelope.source, envelope.session_stream_id, envelope.opencode_session_id, envelope.cwd, envelope.project, envelope.started_at, envelope.ts_wall_ms, currentMaxSeq);
+				updated_at = datetime('now')`).run(envelope.source, envelope.session_stream_id, envelope.opencode_session_id, envelope.cwd, envelope.project, envelope.started_at, envelope.ts_wall_ms, maxSeqRow.max_seq);
 		return {
 			inserted: 1,
 			skipped: 0
@@ -1141,111 +1917,42 @@ function directEnqueue(payload, dbPath) {
 		db.close();
 	}
 }
-/**
-* Best-effort boundary flush: write the payload through to the local
-* store (so the just-fired SessionEnd / Stop event is durable in
-* raw_events) and then run a synchronous flushRawEvents pass so that
-* the latest memories are extracted before the hook process exits and
-* the user closes their terminal.
-*
-* Any failure here \u2014 observer construction, store I/O, flush errors,
-* or simply running without observer credentials \u2014 is logged to
-* `~/.codemem/plugin.log` and swallowed. The hook command must never
-* crash on a boundary flush failure.
-*/
-async function flushBoundaryRawEvents(payload, dbPath) {
-	const envelope = buildRawEventEnvelopeFromHook(payload);
-	if (!envelope) return;
-	let observer;
-	try {
-		observer = new ObserverClient();
-	} catch (err) {
-		logHookEvent(`codemem claude-hook-ingest boundary flush observer init failed: ${err instanceof Error ? err.message : String(err)}`);
-		return;
-	}
-	let store;
-	try {
-		store = new MemoryStore(dbPath);
-	} catch (err) {
-		logHookEvent(`codemem claude-hook-ingest boundary flush store init failed: ${err instanceof Error ? err.message : String(err)}`);
-		return;
-	}
-	try {
-		await flushRawEvents(store, { observer }, {
-			opencodeSessionId: envelope.session_stream_id,
-			source: envelope.source,
-			cwd: envelope.cwd ?? null,
-			project: envelope.project ?? null,
-			startedAt: envelope.started_at ?? null,
-			maxEvents: null
-		});
-	} catch (err) {
-		logHookEvent(`codemem claude-hook-ingest boundary flush raw events failed: ${err instanceof Error ? err.message : String(err)}`);
-	} finally {
-		store.close();
-	}
-}
-/**
-* Ingest one Claude hook payload using the TS contract:
-* HTTP enqueue first, then locked drain + retry + direct fallback +
-* disk spool durability.
-*/
-async function ingestClaudeHookPayload(payload, opts, deps = {}) {
+async function ingestCodexHookPayload(payload, opts, deps = {}) {
 	const httpIngest = deps.httpIngest ?? tryHttpIngest;
-	const directIngest = deps.directIngest ?? directEnqueue;
+	const directIngest = deps.directIngest ?? directEnqueueCodexHook;
 	const resolveDb = deps.resolveDb ?? resolveDbPath;
-	const boundaryFlush = deps.boundaryFlush ?? flushBoundaryRawEvents;
-	try {
-		trackHookSessionState(payload);
-	} catch {}
 	const port = typeof opts.port === "number" ? opts.port : Number.parseInt(opts.port, 10);
+	const ingestPayload = normalizePayloadForIngest(payload);
 	let cachedDbPath = null;
 	const getDbPath = () => {
 		if (cachedDbPath === null) cachedDbPath = resolveDb(resolveDbOpt(opts));
 		return cachedDbPath;
 	};
-	const tryDirectFallback = (queued) => {
-		try {
-			return {
-				ok: true,
-				result: directIngest(queued, getDbPath())
-			};
-		} catch (err) {
-			logHookEvent(`codemem claude-hook-ingest direct fallback failed: ${err instanceof Error ? err.message : String(err)}`);
-			return { ok: false };
-		}
-	};
-	const flushOnBoundaryIfRequested = async () => {
-		if (!shouldForceBoundaryFlush(payload)) return;
-		try {
-			directIngest(payload, getDbPath());
-		} catch (err) {
-			logHookEvent(`codemem claude-hook-ingest boundary flush direct write failed: ${err instanceof Error ? err.message : String(err)}`);
-		}
+	const tryDirectFallback = (queuedPayload) => {
 		try {
-			await boundaryFlush(payload, getDbPath());
+			directIngest(queuedPayload, getDbPath());
+			return true;
 		} catch (err) {
-			logHookEvent(`codemem claude-hook-ingest boundary flush failed: ${err instanceof Error ? err.message : String(err)}`);
+			logHookEvent(`codemem codex-hook-ingest direct fallback failed: ${err instanceof Error ? err.message : String(err)}`);
+			return false;
 		}
 	};
 	const drainBacklogIfPresent = async () => {
-		if (!hasSpooledEntries()) return;
+		if (!hasCodexHookSpooledEntries()) return;
 		try {
-			await withClaudeHookIngestLock(async () => {
-				recoverStaleTmpSpool(lockTtlSeconds());
-				await drainSpool(async (queuedPayload) => {
-					if ((await httpIngest(queuedPayload, opts.host, port)).ok) return true;
-					return tryDirectFallback(queuedPayload).ok;
+			await withCodexHookIngestLock(async () => {
+				recoverStaleCodexHookTmpSpool(codexHookLockTtlSeconds());
+				await drainCodexHookSpool(async (queuedPayload) => {
+					return (await httpIngest(queuedPayload, opts.host, port)).ok || tryDirectFallback(queuedPayload);
 				});
 			});
 		} catch (err) {
-			if (err instanceof LockBusyError) return;
-			logHookEvent(`codemem claude-hook-ingest backlog drain failed: ${err instanceof Error ? err.message : String(err)}`);
+			if (err instanceof CodexHookLockBusyError) return;
+			logHookEvent(`codemem codex-hook-ingest backlog drain failed: ${err instanceof Error ? err.message : String(err)}`);
 		}
 	};
-	const httpResult = await httpIngest(payload, opts.host, port);
+	const httpResult = await httpIngest(ingestPayload, opts.host, port);
 	if (httpResult.ok) {
-		await flushOnBoundaryIfRequested();
 		await drainBacklogIfPresent();
 		return {
 			inserted: httpResult.inserted,
@@ -1254,62 +1961,49 @@ async function ingestClaudeHookPayload(payload, opts, deps = {}) {
 		};
 	}
 	try {
-		return await withClaudeHookIngestLock(async () => {
-			recoverStaleTmpSpool(lockTtlSeconds());
-			await drainSpool(async (queuedPayload) => {
-				if ((await httpIngest(queuedPayload, opts.host, port)).ok) return true;
-				return tryDirectFallback(queuedPayload).ok;
-			});
-			const secondHttp = await httpIngest(payload, opts.host, port);
-			if (secondHttp.ok) {
-				await flushOnBoundaryIfRequested();
-				return {
-					inserted: secondHttp.inserted,
-					skipped: secondHttp.skipped,
-					via: "http"
-				};
-			}
-			const direct = tryDirectFallback(payload);
-			if (direct.ok) {
-				await flushOnBoundaryIfRequested();
-				return {
-					...direct.result,
+		return await withCodexHookIngestLock(async () => {
+			recoverStaleCodexHookTmpSpool(codexHookLockTtlSeconds());
+			let currentResult;
+			try {
+				currentResult = {
+					...directIngest(ingestPayload, getDbPath()),
 					via: "direct"
 				};
+			} catch (err) {
+				logHookEvent(`codemem codex-hook-ingest direct fallback failed: ${err instanceof Error ? err.message : String(err)}`);
+				if (!spoolCodexHookPayload(ingestPayload)) throw new Error("codex-hook-ingest: fallback and spool both failed");
+				currentResult = {
+					inserted: 0,
+					skipped: 0,
+					via: "spool"
+				};
 			}
-			if (spoolPayload(payload)) return {
-				inserted: 0,
-				skipped: 0,
-				via: "spool"
-			};
-			logHookEvent("codemem claude-hook-ingest failed: fallback and spool failed");
-			throw new Error("claude-hook-ingest: fallback and spool both failed");
+			await drainCodexHookSpool((queuedPayload) => tryDirectFallback(queuedPayload));
+			return currentResult;
 		});
 	} catch (err) {
-		if (!(err instanceof LockBusyError)) throw err;
-		logHookEvent("codemem claude-hook-ingest lock busy; trying unlocked fallback");
-		const direct = tryDirectFallback(payload);
-		if (direct.ok) return {
-			...direct.result,
-			via: "direct"
-		};
-		if (spoolPayload(payload)) return {
+		if (!(err instanceof CodexHookLockBusyError)) throw err;
+		logHookEvent("codemem codex-hook-ingest lock busy; trying unlocked fallback");
+		try {
+			return {
+				...directIngest(ingestPayload, getDbPath()),
+				via: "direct"
+			};
+		} catch (directErr) {
+			logHookEvent(`codemem codex-hook-ingest unlocked direct fallback failed: ${directErr instanceof Error ? directErr.message : String(directErr)}`);
+		}
+		if (spoolCodexHookPayload(ingestPayload)) return {
 			inserted: 0,
 			skipped: 0,
 			via: "spool_lock_busy"
 		};
-		logHookEvent("codemem claude-hook-ingest failed: unlocked fallback and spool failed");
 		throw err;
 	}
 }
-var claudeHookCmd = new Command("claude-hook-ingest").configureHelp(helpStyle).description("Ingest Claude hook payload: HTTP first, direct DB fallback");
-addDbOption(claudeHookCmd);
-addViewerHostOptions(claudeHookCmd);
-function envTruthyValue(value) {
-	const normalized = String(value ?? "").trim().toLowerCase();
-	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
-}
-var claudeHookIngestCommand = claudeHookCmd.action(async (opts) => {
+var codexHookCmd = new Command("codex-hook-ingest").configureHelp(helpStyle).description("Ingest Codex hook payload: HTTP first, direct DB fallback");
+addDbOption(codexHookCmd);
+addViewerHostOptions(codexHookCmd);
+var codexHookIngestCommand = codexHookCmd.action(async (opts) => {
 	if (envTruthyValue(process.env.CODEMEM_PLUGIN_IGNORE)) return;
 	let raw;
 	try {
@@ -1335,14 +2029,14 @@ var claudeHookIngestCommand = claudeHookCmd.action(async (opts) => {
 		return;
 	}
 	try {
-		const result = await ingestClaudeHookPayload(payload, opts);
+		const result = await ingestCodexHookPayload(payload, opts);
 		console.log(JSON.stringify(result));
 	} catch (err) {
 		emitStructuredError$1("ingest_error", err instanceof Error ? err.message : String(err));
 	}
 });
 //#endregion
-//#region src/commands/claude-hook-inject.ts
+//#region src/commands/codex-hook-inject.ts
 var HOOK_EVENT_NAME = "UserPromptSubmit";
 var EMPTY_PACK = {
 	packText: "",
@@ -1369,8 +2063,7 @@ function envTruthy(value) {
 }
 function parsePositiveInt$1(value, fallback) {
 	const parsed = Number.parseInt(String(value ?? ""), 10);
-	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
-	return parsed;
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 function continueResult(additionalContext) {
 	if (!additionalContext) return { continue: true };
@@ -1388,36 +2081,30 @@ function truncateAdditionalContext(text, maxChars) {
 	if (!Number.isFinite(maxChars) || maxChars <= 0 || normalized.length <= maxChars) return normalized;
 	return `${normalized.slice(0, maxChars).trimEnd()}\n\n[pack truncated]`;
 }
-function extractInjectContext(payload) {
-	return normalizePromptText(payload.prompt) || null;
-}
 function resolveInjectProject(payload) {
 	return resolveHookProject(typeof payload.cwd === "string" ? payload.cwd : null, payload.project);
 }
-async function buildLocalPack(context, project, dbPath, workingSetPaths = []) {
+function buildCodexInjectQuery(prompt, project) {
+	return [prompt, project ?? ""].filter((part) => part.trim().length > 0).join(" ").slice(0, 500) || "recent work";
+}
+async function buildLocalPack(context, project, dbPath) {
 	const store = new MemoryStore(dbPath);
 	try {
 		const limit = parsePositiveInt$1(process.env.CODEMEM_INJECT_LIMIT, 8);
 		const budget = parsePositiveInt$1(process.env.CODEMEM_INJECT_TOKEN_BUDGET, 800);
 		const filters = {};
 		if (project) filters.project = project;
-		if (workingSetPaths.length > 0) filters.working_set_paths = workingSetPaths;
 		const pack = await store.buildMemoryPackAsync(context, limit, budget, filters);
 		return {
 			packText: String(pack.pack_text ?? "").trim(),
 			items: Array.isArray(pack.items) ? pack.items.length : 0,
-			packTokens: Number.isFinite(Number(pack.metrics?.pack_tokens)) ? Number(pack.metrics.pack_tokens) : 0
+			packTokens: Number.isFinite(Number(pack.metrics?.pack_tokens)) ? Number(pack.metrics?.pack_tokens) : 0
 		};
 	} finally {
 		store.close();
 	}
 }
 async function tryHttpPack(context, project, maxTimeMs = DEFAULT_HTTP_MAX_TIME_S * 1e3) {
-	const empty = {
-		packText: "",
-		items: 0,
-		packTokens: 0
-	};
 	const host = process.env.CODEMEM_VIEWER_HOST || DEFAULT_VIEWER_HOST;
 	const port = parsePositiveInt$1(process.env.CODEMEM_VIEWER_PORT, DEFAULT_VIEWER_PORT);
 	const url = new URL(`http://${host}:${port}/api/pack`);
@@ -1429,7 +2116,7 @@ async function tryHttpPack(context, project, maxTimeMs = DEFAULT_HTTP_MAX_TIME_S
 	const timeout = setTimeout(() => controller.abort(), maxTimeMs);
 	try {
 		const res = await fetch(url, { signal: controller.signal });
-		if (!res.ok) return empty;
+		if (!res.ok) return EMPTY_PACK;
 		const body = await res.json();
 		return {
 			packText: String(body.pack_text ?? "").trim(),
@@ -1437,41 +2124,30 @@ async function tryHttpPack(context, project, maxTimeMs = DEFAULT_HTTP_MAX_TIME_S
 			packTokens: Number.isFinite(Number(body.metrics?.pack_tokens)) ? Number(body.metrics?.pack_tokens) : 0
 		};
 	} catch {
-		return empty;
+		return EMPTY_PACK;
 	} finally {
 		clearTimeout(timeout);
 	}
 }
-async function buildClaudeHookInjection(payload, opts, deps = {}) {
+async function buildCodexHookInjection(payload, opts, deps = {}) {
 	if (envTruthy(process.env.CODEMEM_PLUGIN_IGNORE)) return continueResult();
 	if (!envNotDisabled(process.env.CODEMEM_INJECT_CONTEXT || "1")) return continueResult();
-	let state = null;
-	try {
-		state = trackHookSessionState(payload);
-	} catch {
-		state = null;
-	}
-	const promptText = extractInjectContext(payload);
+	const promptText = normalizePromptText(payload.prompt);
 	if (!promptText) return continueResult();
 	const buildPack = deps.buildLocalPack ?? buildLocalPack;
 	const httpPack = deps.httpPack ?? tryHttpPack;
 	const resolveDb = deps.resolveDb ?? resolveDbPath;
 	const project = resolveInjectProject(payload);
-	const query = buildInjectQuery({
-		prompt: promptText,
-		project,
-		state
-	});
-	const workingSetPaths = workingSetPathsFromState(state);
+	const query = buildCodexInjectQuery(promptText, project);
 	const maxChars = parsePositiveInt$1(process.env.CODEMEM_INJECT_MAX_CHARS, DEFAULT_MAX_CHARS);
 	const httpMaxTimeMs = parsePositiveInt$1(process.env.CODEMEM_INJECT_HTTP_MAX_TIME_S, DEFAULT_HTTP_MAX_TIME_S) * 1e3;
 	let pack = EMPTY_PACK;
 	let origin = "none";
 	try {
-		pack = await buildPack(query, project, resolveDb(resolveDbOpt(opts)), workingSetPaths);
+		pack = await buildPack(query, project, resolveDb(resolveDbOpt(opts)));
 		if (pack.packText) origin = "local";
 	} catch (err) {
-		logHookEvent(`codemem claude-hook-inject local pack failed: ${err instanceof Error ? err.message : String(err)}`);
+		logHookEvent(`codemem codex-hook-inject local pack failed: ${err instanceof Error ? err.message : String(err)}`);
 	}
 	if (!pack.packText && envNotDisabled(process.env.CODEMEM_INJECT_HTTP_FALLBACK || "1")) {
 		pack = await httpPack(query, project, httpMaxTimeMs);
@@ -1479,7 +2155,7 @@ async function buildClaudeHookInjection(payload, opts, deps = {}) {
 	}
 	const fields = [
 		"inject.pack.ok",
-		"source=claude",
+		"source=codex",
 		`origin=${origin}`,
 		`items=${pack.items}`,
 		`pack_tokens=${pack.packTokens}`,
@@ -1490,9 +2166,9 @@ async function buildClaudeHookInjection(payload, opts, deps = {}) {
 	logHookEvent(fields.join(" "));
 	return continueResult(truncateAdditionalContext(pack.packText, maxChars));
 }
-var claudeHookInjectCmd = new Command("claude-hook-inject").configureHelp(helpStyle).description("Return Claude hook additionalContext from local pack generation");
-addDbOption(claudeHookInjectCmd);
-var claudeHookInjectCommand = claudeHookInjectCmd.action(async (opts) => {
+var codexHookInjectCmd = new Command("codex-hook-inject").configureHelp(helpStyle).description("Return Codex hook additionalContext from local pack generation");
+addDbOption(codexHookInjectCmd);
+var codexHookInjectCommand = codexHookInjectCmd.action(async (opts) => {
 	let raw = "";
 	for await (const chunk of process.stdin) raw += String(chunk);
 	const trimmed = raw.trim();
@@ -1520,7 +2196,12 @@ var claudeHookInjectCommand = claudeHookInjectCmd.action(async (opts) => {
 		process.exitCode = 1;
 		return;
 	}
-	emitJson(await buildClaudeHookInjection(payload, opts));
+	try {
+		emitJson(await buildCodexHookInjection(payload, opts));
+	} catch (err) {
+		logHookEvent(`codemem codex-hook-inject failed: ${err instanceof Error ? err.message : String(err)}`);
+		emitJson(continueResult());
+	}
 });
 //#endregion
 //#region src/commands/config.ts
@@ -5126,6 +5807,10 @@ function opencodeConfigDir() {
 function claudeConfigDir() {
 	return join(homedir(), ".claude");
 }
+/** Resolve the Codex home directory, honoring CODEX_HOME. */
+function codexConfigDir() {
+	return process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+}
 /** The npm package name used in the OpenCode plugin array. */
 var OPENCODE_PLUGIN_SPEC = "@codemem/opencode-plugin";
 var LEGACY_OPENCODE_PLUGIN_SPECS = ["codemem", "@kunickiaj/codemem"];
@@ -5305,20 +5990,208 @@ function installClaudeMcp(force) {
 	} else p.log.info("Claude Code hooks plugin appears to be installed");
 	return true;
 }
-var setupCommand = new Command("setup").configureHelp(helpStyle).description("Install codemem plugin + MCP config for OpenCode and Claude Code").option("--force", "overwrite existing installations").option("--opencode-only", "only install for OpenCode").option("--claude-only", "only install for Claude Code").action((opts) => {
+/** 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");
+var CODEX_MCP_TABLE_RE = /^[ \t]*\[[ \t]*mcp_servers[ \t]*\.[ \t]*("?)codemem\1[ \t]*\]/m;
+/** 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.
+*/
+function codememCodexHookBase() {
+	return codememOnPath() ? "codemem" : "npx -y codemem";
+}
+/**
+* Build the codemem-owned hook groups keyed by Codex event name, given the
+* resolved command base (`codemem` or `npx -y codemem`). Timeouts are ceilings,
+* not expected runtimes; npx gets more headroom to absorb a cold resolve.
+*/
+function buildCodememCodexHookGroups(base) {
+	const isNpx = base !== "codemem";
+	const ingestTimeout = isNpx ? 30 : 10;
+	const injectTimeout = isNpx ? 20 : 10;
+	const ingest = {
+		type: "command",
+		command: `${base} codex-hook-ingest`,
+		timeout: ingestTimeout,
+		statusMessage: "codemem"
+	};
+	return {
+		SessionStart: [{ hooks: [{ ...ingest }] }],
+		UserPromptSubmit: [{ hooks: [{
+			type: "command",
+			command: `${base} codex-hook-ingest`,
+			timeout: ingestTimeout,
+			statusMessage: "codemem capture"
+		}, {
+			type: "command",
+			command: `${base} codex-hook-inject`,
+			timeout: injectTimeout,
+			statusMessage: "codemem recall"
+		}] }],
+		PostToolUse: [{ hooks: [{ ...ingest }] }],
+		Stop: [{ hooks: [{ ...ingest }] }]
+	};
+}
+/** True if a matcher group contains a codemem-owned hook command. */
+function isCodememHookGroup(group) {
+	if (group == null || typeof group !== "object") return false;
+	const hooks = group.hooks;
+	if (!Array.isArray(hooks)) return false;
+	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`, 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.
+*/
+function isTransientNpxBinPath(resolved) {
+	return /[/\\]_npx[/\\]/.test(resolved) || /[/\\]\.pnpm[/\\]dlx[/\\]/.test(resolved);
+}
+/**
+* Detect whether a durable `codemem` resolves on PATH (excluding a transient
+* npx/dlx bin that vanishes after this process exits).
+*/
+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);
+	} catch {
+		return false;
+	}
+}
+/**
+* Append the codemem MCP server table to Codex config.toml without rewriting
+* unrelated content. Returns true on success.
+*/
+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)) {
+		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;
+	}
+	if (existsSync(configPath)) try {
+		copyFileSync(configPath, `${configPath}.codemem.bak`);
+	} catch {}
+	let next = existing;
+	if (next.length > 0 && !next.endsWith("\n\n")) next += next.endsWith("\n") ? "\n" : "\n\n";
+	next += `${CODEX_MCP_BLOCK}\n`;
+	try {
+		writeFileSync(configPath, next, "utf-8");
+		p.log.success(`Codex MCP entry installed: ${configPath}`);
+	} catch (err) {
+		p.log.error(`Failed to write ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+	return true;
+}
+/**
+* Write/merge codemem hook registrations into Codex hooks.json, preserving any
+* unrelated user hooks. Returns true on success.
+*/
+function installCodexHooks(codexHome, force) {
+	const hooksPath = join(codexHome, "hooks.json");
+	let config = {};
+	if (existsSync(hooksPath)) try {
+		config = JSON.parse(readFileSync(hooksPath, "utf-8"));
+	} catch (err) {
+		p.log.error(`Failed to parse ${hooksPath}: ${err instanceof Error ? err.message : String(err)}`);
+		p.log.info(`Leaving ${hooksPath} untouched. Fix or remove the file, then re-run \`codemem setup --codex-only\`.`);
+		return false;
+	}
+	let hooks = config.hooks;
+	if (hooks == null || typeof hooks !== "object" || Array.isArray(hooks)) hooks = {};
+	const ours = buildCodememCodexHookGroups(codememCodexHookBase());
+	let changed = false;
+	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));
+		hooks[event] = [...preserved, ...ourGroups];
+		changed = true;
+	}
+	if (!changed && !force) {
+		p.log.info(`Codex hooks already configured in ${hooksPath}`);
+		config.hooks = hooks;
+		return true;
+	}
+	config.hooks = hooks;
+	if (existsSync(hooksPath)) try {
+		copyFileSync(hooksPath, `${hooksPath}.codemem.bak`);
+	} catch {}
+	try {
+		mkdirSync(codexHome, { recursive: true });
+		writeFileSync(hooksPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+		p.log.success(`Codex hooks installed: ${hooksPath}`);
+	} catch (err) {
+		p.log.error(`Failed to write ${hooksPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+	return true;
+}
+/**
+* Configure Codex via direct config files (MCP in config.toml + hooks in
+* hooks.json) without relying on the Codex plugin marketplace. Idempotent;
+* honors CODEX_HOME. Returns true on success.
+*/
+function installCodex(force) {
+	const codexHome = codexConfigDir();
+	try {
+		mkdirSync(codexHome, { recursive: true });
+	} catch (err) {
+		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");
+	let ok = true;
+	ok = installCodexMcp(codexHome, force) && ok;
+	ok = installCodexHooks(codexHome, force) && ok;
+	return ok;
+}
+var setupCommand = new Command("setup").configureHelp(helpStyle).description("Install codemem plugin + MCP config for OpenCode and Claude Code").option("--force", "overwrite existing installations").option("--opencode-only", "only install for OpenCode").option("--claude-only", "only install for Claude Code").option("--codex-only", "only install for Codex").option("--codex", "configure Codex only (alias for --codex-only)").action((opts) => {
 	p.intro(`codemem setup v${VERSION}`);
 	const force = opts.force ?? false;
 	let ok = true;
-	if (!opts.claudeOnly) {
+	const codexOnly = Boolean(opts.codexOnly || opts.codex);
+	const onlyFlag = Boolean(opts.opencodeOnly || opts.claudeOnly || codexOnly);
+	const doOpencode = opts.opencodeOnly || !onlyFlag;
+	const doClaude = opts.claudeOnly || !onlyFlag;
+	const doCodex = codexOnly || !onlyFlag && existsSync(codexConfigDir());
+	if (doOpencode) {
 		p.log.step("Installing OpenCode plugin...");
 		ok = installPlugin(force) && ok;
 		p.log.step("Installing OpenCode MCP config...");
 		ok = installMcp(force) && ok;
 	}
-	if (!opts.opencodeOnly) {
+	if (doClaude) {
 		p.log.step("Installing Claude Code MCP config...");
 		ok = installClaudeMcp(force) && ok;
 	}
+	if (doCodex) {
+		p.log.step("Configuring Codex (MCP + hooks)...");
+		ok = installCodex(force) && ok;
+		p.log.info("Codex next steps:");
+		p.log.info("  - Restart Codex to load the new configuration");
+		p.log.info("  - On first run, approve the one-time prompt to trust the codemem hooks");
+		p.log.info("  - MCP recall works immediately (no trust prompt required)");
+		p.log.info("  - Disable prompt-time injection with CODEMEM_INJECT_CONTEXT=0");
+	}
 	if (ok) p.outro("Setup complete — restart your editor to load the plugin");
 	else {
 		p.outro("Setup completed with warnings");
@@ -6325,6 +7198,8 @@ completion.on("command", ({ reply }) => {
 		"claude-hook-file-context",
 		"claude-hook-inject",
 		"claude-hook-ingest",
+		"codex-hook-inject",
+		"codex-hook-ingest",
 		"config",
 		"coordinator",
 		"db",
@@ -6403,6 +7278,8 @@ program.addCommand(mcpCommand);
 program.addCommand(claudeHookInjectCommand);
 program.addCommand(claudeHookIngestCommand);
 program.addCommand(claudeHookFileContextCommand);
+program.addCommand(codexHookInjectCommand);
+program.addCommand(codexHookIngestCommand);
 program.addCommand(dbCommand);
 program.addCommand(exportMemoriesCommand);
 program.addCommand(importMemoriesCommand);