claude-memory-layer 2.2.5 → 2.2.6

package/dist/cli/index.js

@@ -9,8 +9,8 @@ const __dirname = dirname(__filename);
 // src/apps/cli/index.ts
 import { Command } from "commander";
 import { exec } from "child_process";
-import * as fs22 from "fs";
-import * as path31 from "path";
+import * as fs23 from "fs";
+import * as path33 from "path";
 import * as os15 from "os";
 
 // src/services/memory-service.ts
@@ -1780,13 +1780,13 @@ async function clearModelCacheDirectory(modelName, cacheDir) {
   try {
     const resolvedCacheDirInput = cacheDir ?? await resolveTransformersCacheDir();
     if (!resolvedCacheDirInput) return false;
-    const fs23 = await import("node:fs/promises");
-    const path32 = await import("node:path");
-    const modelDir = path32.join(resolvedCacheDirInput, modelName);
-    const resolvedCacheDir = path32.resolve(resolvedCacheDirInput);
-    const resolvedModelDir = path32.resolve(modelDir);
-    if (!resolvedModelDir.startsWith(resolvedCacheDir + path32.sep)) return false;
-    await fs23.rm(resolvedModelDir, { recursive: true, force: true });
+    const fs24 = await import("node:fs/promises");
+    const path34 = await import("node:path");
+    const modelDir = path34.join(resolvedCacheDirInput, modelName);
+    const resolvedCacheDir = path34.resolve(resolvedCacheDirInput);
+    const resolvedModelDir = path34.resolve(modelDir);
+    if (!resolvedModelDir.startsWith(resolvedCacheDir + path34.sep)) return false;
+    await fs24.rm(resolvedModelDir, { recursive: true, force: true });
     return true;
   } catch {
     return false;
@@ -2432,12 +2432,12 @@ import * as nodePath2 from "path";
 import Database from "better-sqlite3";
 import * as fs4 from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path32, options) {
-  const dir = nodePath.dirname(path32);
+function createSQLiteDatabase(path34, options) {
+  const dir = nodePath.dirname(path34);
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path32, {
+  const db = new Database(path34, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -3096,17 +3096,17 @@ function emptyOutboxRecoveryResult() {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getNestedRecord(root, path32) {
+function getNestedRecord(root, path34) {
   let cursor = root;
-  for (const key of path32) {
+  for (const key of path34) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
   return isRecord(cursor) ? cursor : void 0;
 }
-function getNestedString(root, path32) {
+function getNestedString(root, path34) {
   let cursor = root;
-  for (const key of path32) {
+  for (const key of path34) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
@@ -8963,9 +8963,9 @@ function safeParseObject(value) {
     return void 0;
   }
 }
-function nestedString(root, path32) {
+function nestedString(root, path34) {
   let cursor = root;
-  for (const key of path32) {
+  for (const key of path34) {
     if (!isRecord2(cursor)) return void 0;
     cursor = cursor[key];
   }
@@ -9040,12 +9040,12 @@ var GraphPathService = class {
         }
       }
     }
-    const paths = Array.from(bestByTarget.entries()).map(([key, path32]) => ({
+    const paths = Array.from(bestByTarget.entries()).map(([key, path34]) => ({
       target: graph.node(nodeFromKey(key)),
-      hops: path32.hops,
-      totalCost: path32.totalCost,
-      scoreContribution: path32.totalCost > 0 ? 1 / path32.totalCost : 0,
-      steps: path32.steps
+      hops: path34.hops,
+      totalCost: path34.totalCost,
+      scoreContribution: path34.totalCost > 0 ? 1 / path34.totalCost : 0,
+      steps: path34.steps
     })).sort((a, b) => b.scoreContribution - a.scoreContribution || a.hops - b.hops || a.target.name.localeCompare(b.target.name)).slice(0, maxResults);
     return { startNodes, effectiveMaxHops, paths };
   }
@@ -9864,16 +9864,16 @@ function parseMetadata(value) {
     return void 0;
   }
 }
-function nestedValue(root, path32) {
+function nestedValue(root, path34) {
   let cursor = root;
-  for (const key of path32) {
+  for (const key of path34) {
     if (!isRecord3(cursor)) return void 0;
     cursor = cursor[key];
   }
   return cursor;
 }
-function nestedString2(root, path32) {
-  const value = nestedValue(root, path32);
+function nestedString2(root, path34) {
+  const value = nestedValue(root, path34);
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
 function projectHashFromMetadata(metadata) {
@@ -9928,15 +9928,15 @@ function extractFileCategories(content) {
   const pathPattern = /(?:^|[\s`"'(])((?:src|tests|specs|docs)\/[A-Za-z0-9._/@-]+(?:\/[A-Za-z0-9._@-]+)*\.(?:ts|tsx|js|jsx|mjs|cjs|md|json|yaml|yml|py))/g;
   let match;
   while ((match = pathPattern.exec(content)) !== null) {
-    const path32 = match[1] ?? "";
-    const extensionMatch = /\.([A-Za-z0-9]+)$/.exec(path32);
+    const path34 = match[1] ?? "";
+    const extensionMatch = /\.([A-Za-z0-9]+)$/.exec(path34);
     const extension = extensionMatch?.[1]?.toLowerCase();
     if (!extension) continue;
-    if (path32.startsWith("tests/")) {
+    if (path34.startsWith("tests/")) {
       categories.add(`test:${extension}`);
-    } else if (path32.startsWith("src/")) {
+    } else if (path34.startsWith("src/")) {
       categories.add(`source:${extension}`);
-    } else if (path32.startsWith("docs/") || path32.startsWith("specs/")) {
+    } else if (path34.startsWith("docs/") || path34.startsWith("specs/")) {
       categories.add(`docs:${extension}`);
     }
   }
@@ -10263,16 +10263,16 @@ function parseMetadata2(value) {
     return void 0;
   }
 }
-function nestedValue2(root, path32) {
+function nestedValue2(root, path34) {
   let cursor = root;
-  for (const key of path32) {
+  for (const key of path34) {
     if (!isRecord4(cursor)) return void 0;
     cursor = cursor[key];
   }
   return cursor;
 }
-function nestedString3(root, path32) {
-  const value = nestedValue2(root, path32);
+function nestedString3(root, path34) {
+  const value = nestedValue2(root, path34);
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
 function projectHashFromMetadata2(metadata) {
@@ -13184,7 +13184,7 @@ function isLanceCommitConflict(error) {
   return message.includes("commit conflict") && message.includes("concurrent commit") && message.includes("rerun the operation");
 }
 function delay(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
 // src/core/ingest-interceptor.ts
@@ -14595,12 +14595,12 @@ var Retriever = class {
         maxResults: opts.limit,
         direction: "both"
       });
-      for (const path32 of expansion.paths) {
-        if (path32.target.type !== "event") continue;
-        const target = await this.eventStore.getEvent(path32.target.id);
+      for (const path34 of expansion.paths) {
+        if (path34.target.type !== "event") continue;
+        const target = await this.eventStore.getEvent(path34.target.id);
         if (!target || target.sessionId === sessionId) continue;
-        const graphPath = toRetrievalGraphPathDebug(path32, /* @__PURE__ */ new Map());
-        const score = graphPathScore(path32, opts.hopPenalty);
+        const graphPath = toRetrievalGraphPathDebug(path34, /* @__PURE__ */ new Map());
+        const score = graphPathScore(path34, opts.hopPenalty);
         const existing = byId.get(target.id);
         const graphPaths = mergeGraphPaths(existing?.graphPaths ?? [], [graphPath]);
         const graphLane = {
@@ -14609,7 +14609,7 @@ var Retriever = class {
           score
         };
         const row = {
-          id: existing?.id ?? `session-file-link-${path32.hops}-${target.id}`,
+          id: existing?.id ?? `session-file-link-${path34.hops}-${target.id}`,
           eventId: target.id,
           content: target.content,
           score: Math.max(existing?.score ?? 0, score),
@@ -14647,12 +14647,12 @@ var Retriever = class {
         direction: "both"
       });
       const titleByEntityId = new Map(startNodes.map((node) => [node.entityId, node.title]));
-      for (const path32 of expansion.paths) {
-        if (path32.target.type !== "event") continue;
-        const target = await this.eventStore.getEvent(path32.target.id);
+      for (const path34 of expansion.paths) {
+        if (path34.target.type !== "event") continue;
+        const target = await this.eventStore.getEvent(path34.target.id);
         if (!target) continue;
-        const graphPath = toRetrievalGraphPathDebug(path32, titleByEntityId);
-        const score = graphPathScore(path32, opts.hopPenalty);
+        const graphPath = toRetrievalGraphPathDebug(path34, titleByEntityId);
+        const score = graphPathScore(path34, opts.hopPenalty);
         const existing = byId.get(target.id);
         const graphPaths = mergeGraphPaths(existing?.graphPaths ?? [], [graphPath]);
         const graphLane = {
@@ -14661,7 +14661,7 @@ var Retriever = class {
           score
         };
         const row = {
-          id: existing?.id ?? `graph-path-${path32.hops}-${target.id}`,
+          id: existing?.id ?? `graph-path-${path34.hops}-${target.id}`,
           eventId: target.id,
           content: target.content,
           score: Math.max(existing?.score ?? 0, score),
@@ -15001,8 +15001,8 @@ _Context:_ ${sessionContext}`;
   }
   matchesMetadataScope(metadata, expected) {
     if (!metadata) return false;
-    return Object.entries(expected).every(([path32, value]) => {
-      const actual = path32.split(".").reduce((acc, key) => {
+    return Object.entries(expected).every(([path34, value]) => {
+      const actual = path34.split(".").reduce((acc, key) => {
         if (typeof acc !== "object" || acc === null) return void 0;
         return acc[key];
       }, metadata);
@@ -15053,22 +15053,22 @@ function uniqueEntityStartNodes(candidates) {
   }
   return nodes;
 }
-function toRetrievalGraphPathDebug(path32, titleByEntityId) {
-  const firstStep = path32.steps[0];
+function toRetrievalGraphPathDebug(path34, titleByEntityId) {
+  const firstStep = path34.steps[0];
   const startNode = firstStep?.direction === "incoming" ? firstStep.to : firstStep?.from;
   const startEntityId = startNode?.type === "entity" ? startNode.id : "";
   return {
     startEntityId,
     startEntityTitle: titleByEntityId.get(startEntityId) ?? startNode?.name,
-    targetId: path32.target.id,
-    targetType: path32.target.type,
-    hops: path32.hops,
-    relationPath: path32.steps.map((step) => step.relationType)
+    targetId: path34.target.id,
+    targetType: path34.target.type,
+    hops: path34.hops,
+    relationPath: path34.steps.map((step) => step.relationType)
   };
 }
-function graphPathScore(path32, hopPenalty) {
-  const base = Math.min(0.95, Math.max(0, path32.scoreContribution));
-  return Math.max(0.05, base - hopPenalty * Math.max(0, path32.hops - 1));
+function graphPathScore(path34, hopPenalty) {
+  const base = Math.min(0.95, Math.max(0, path34.scoreContribution));
+  return Math.max(0.05, base - hopPenalty * Math.max(0, path34.hops - 1));
 }
 function clampGraphHops(maxHops) {
   if (!Number.isFinite(maxHops)) return 2;
@@ -15076,14 +15076,14 @@ function clampGraphHops(maxHops) {
 }
 function mergeGraphPaths(existing, incoming) {
   const byKey = /* @__PURE__ */ new Map();
-  for (const path32 of [...existing, ...incoming]) {
-    const key = [path32.startEntityId, path32.targetType, path32.targetId, path32.hops, ...path32.relationPath].join("\0");
-    if (!byKey.has(key)) byKey.set(key, path32);
+  for (const path34 of [...existing, ...incoming]) {
+    const key = [path34.startEntityId, path34.targetType, path34.targetId, path34.hops, ...path34.relationPath].join("\0");
+    if (!byKey.has(key)) byKey.set(key, path34);
   }
   return [...byKey.values()].sort((a, b) => a.hops - b.hops || compareStable(graphPathSignature(a), graphPathSignature(b))).slice(0, 3);
 }
-function graphPathSignature(path32) {
-  return [path32.startEntityId, path32.targetType, path32.targetId, path32.hops, ...path32.relationPath].join("|");
+function graphPathSignature(path34) {
+  return [path34.startEntityId, path34.targetType, path34.targetId, path34.hops, ...path34.relationPath].join("|");
 }
 function compareStable(a, b) {
   if (a < b) return -1;
@@ -23360,7 +23360,7 @@ function buildPrompt(statsContext, memoryContext, history, currentMessage) {
   return parts.join("\n");
 }
 function streamClaudeResponse(prompt, stream) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const proc = spawn("claude", [
       "-p",
       "--output-format",
@@ -23433,7 +23433,7 @@ function streamClaudeResponse(prompt, stream) {
       if (code !== 0 && code !== null) {
         reject(classifyProviderFailure(stderrText || `Claude CLI exited with code ${code}`));
       } else {
-        resolve9();
+        resolve10();
       }
     });
   });
@@ -25036,9 +25036,140 @@ function mergePluginHooksIntoSettings(settings, pluginPath) {
   return next;
 }
 
+// src/apps/cli/codex-hooks-config.ts
+import * as path25 from "node:path";
+var REQUIRED_CODEX_HOOK_FILES = [
+  "codex-session-start.js",
+  "codex-session-end.js",
+  "codex-session-import-worker.js"
+];
+var CODEX_HOOK_FILES = {
+  SessionStart: "codex-session-start.js",
+  SessionEnd: "codex-session-end.js"
+};
+function buildCodexHookCommand(pluginPath, fileName) {
+  const absolutePluginPath = path25.resolve(pluginPath);
+  return `node ${shellQuotePathForNode(path25.join(absolutePluginPath, "hooks", fileName))}`;
+}
+function buildCodexHookWindowsCommand(pluginPath, fileName) {
+  const absolutePluginPath = path25.resolve(pluginPath);
+  return `node "${path25.join(absolutePluginPath, "hooks", fileName).replace(/"/g, '""')}"`;
+}
+function getCodexMemoryHooks(pluginPath) {
+  return {
+    SessionStart: [
+      {
+        matcher: "startup|resume|clear|compact",
+        hooks: [
+          {
+            type: "command",
+            command: buildCodexHookCommand(pluginPath, CODEX_HOOK_FILES.SessionStart),
+            commandWindows: buildCodexHookWindowsCommand(pluginPath, CODEX_HOOK_FILES.SessionStart),
+            statusMessage: "Loading project memory",
+            additionalContextLimit: 5e3
+          }
+        ]
+      }
+    ],
+    SessionEnd: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: buildCodexHookCommand(pluginPath, CODEX_HOOK_FILES.SessionEnd),
+            commandWindows: buildCodexHookWindowsCommand(pluginPath, CODEX_HOOK_FILES.SessionEnd),
+            statusMessage: "Saving session memory",
+            timeout: 3
+          }
+        ]
+      }
+    ]
+  };
+}
+function isCodexMemoryHookCommand(command, pluginPath) {
+  if (!command) return false;
+  const normalized = command.replace(/\\/g, "/");
+  const normalizedPluginPath = pluginPath?.replace(/\\/g, "/").replace(/\/$/, "");
+  return Object.values(CODEX_HOOK_FILES).some((fileName) => {
+    if (normalizedPluginPath && normalized.includes(`${normalizedPluginPath}/hooks/${fileName}`)) {
+      return true;
+    }
+    return normalized.includes("claude-memory-layer") && normalized.includes(`/hooks/${fileName}`);
+  });
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseCodexHooksConfig(value) {
+  if (!isRecord6(value)) {
+    throw new Error("Codex hooks config must be a JSON object");
+  }
+  if (value.hooks === void 0) return value;
+  if (!isRecord6(value.hooks)) {
+    throw new Error('Codex hooks config "hooks" must be a JSON object');
+  }
+  for (const [eventName, entries] of Object.entries(value.hooks)) {
+    if (!Array.isArray(entries)) {
+      throw new Error(`Codex hooks config "hooks.${eventName}" must be an array`);
+    }
+    for (const [entryIndex, entry] of entries.entries()) {
+      if (!isRecord6(entry) || !Array.isArray(entry.hooks)) {
+        throw new Error(`Codex hooks config "hooks.${eventName}[${entryIndex}].hooks" must be an array`);
+      }
+      for (const [hookIndex, hook] of entry.hooks.entries()) {
+        if (!isRecord6(hook)) {
+          throw new Error(`Codex hook "hooks.${eventName}[${entryIndex}].hooks[${hookIndex}]" must be a JSON object`);
+        }
+        if (hook.command !== void 0 && typeof hook.command !== "string") {
+          throw new Error(`Codex hook "hooks.${eventName}[${entryIndex}].hooks[${hookIndex}].command" must be a string`);
+        }
+      }
+    }
+  }
+  return value;
+}
+function removeCodexMemoryHooks(config, pluginPath) {
+  const next = { ...config };
+  if (!config.hooks) return next;
+  const hooks = { ...config.hooks };
+  for (const hookName of Object.keys(CODEX_HOOK_FILES)) {
+    const entries = hooks[hookName] ?? [];
+    const cleaned = entries.map((entry) => ({
+      ...entry,
+      hooks: (entry.hooks ?? []).filter((hook) => !isCodexMemoryHookCommand(hook.command, pluginPath) && !isCodexMemoryHookCommand(hook.commandWindows, pluginPath))
+    })).filter((entry) => entry.hooks.length > 0);
+    if (cleaned.length > 0) {
+      hooks[hookName] = cleaned;
+    } else {
+      delete hooks[hookName];
+    }
+  }
+  if (Object.keys(hooks).length > 0) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+  return next;
+}
+function mergeCodexMemoryHooks(config, pluginPath) {
+  const cleaned = removeCodexMemoryHooks(config, pluginPath);
+  const next = { ...cleaned, hooks: { ...cleaned.hooks ?? {} } };
+  const pluginHooks = getCodexMemoryHooks(pluginPath);
+  for (const hookName of Object.keys(CODEX_HOOK_FILES)) {
+    next.hooks[hookName] = [
+      ...next.hooks[hookName] ?? [],
+      ...pluginHooks[hookName]
+    ];
+  }
+  return next;
+}
+function hasCodexMemoryHook(config, hookName, pluginPath) {
+  return (config.hooks?.[hookName] ?? []).some((entry) => entry.hooks.some((hook) => isCodexMemoryHookCommand(hook.command, pluginPath) || isCodexMemoryHookCommand(hook.commandWindows, pluginPath)));
+}
+
 // src/apps/cli/codex-validation-output.ts
 import * as fs20 from "fs";
-import * as path25 from "path";
+import * as path26 from "path";
 function formatNumber(value) {
   return Number.isFinite(value) ? value.toLocaleString("en-US") : String(value);
 }
@@ -25112,14 +25243,14 @@ function formatCodexValidationReport(report, format = "markdown") {
   return lines.join("\n");
 }
 function writeCodexValidationReport(outputPath, report, format = "markdown") {
-  const dir = path25.dirname(outputPath);
+  const dir = path26.dirname(outputPath);
   fs20.mkdirSync(dir, { recursive: true });
   fs20.writeFileSync(outputPath, formatCodexValidationReport(report, format), "utf8");
 }
 
 // src/apps/cli/hermes-validation-output.ts
 import * as fs21 from "fs";
-import * as path26 from "path";
+import * as path27 from "path";
 function formatNumber2(value) {
   return Number.isFinite(value) ? value.toLocaleString("en-US") : String(value);
 }
@@ -25189,7 +25320,7 @@ function formatHermesValidationReport(report, format = "markdown") {
   return lines.join("\n");
 }
 function writeHermesValidationReport(outputPath, report, format = "markdown") {
-  const dir = path26.dirname(outputPath);
+  const dir = path27.dirname(outputPath);
   fs21.mkdirSync(dir, { recursive: true });
   fs21.writeFileSync(outputPath, formatHermesValidationReport(report, format), "utf8");
 }
@@ -25262,6 +25393,22 @@ async function runCodexImportOnce(options, deps = realDeps) {
   }
 }
 
+// src/services/codex-session-auto-import.ts
+import * as fs22 from "node:fs";
+import * as path28 from "node:path";
+function getCodexAutoImportStatusPath(projectPath) {
+  return path28.join(getProjectStoragePath(projectPath), "codex-auto-import-status.json");
+}
+function readCodexAutoImportStatus(projectPath) {
+  try {
+    const value = JSON.parse(fs22.readFileSync(getCodexAutoImportStatusPath(projectPath), "utf8"));
+    if (value.status !== "success" && value.status !== "failed" || typeof value.updatedAt !== "string") return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+
 // src/apps/cli/hermes-import-runner.ts
 var realDeps2 = {
   cwd: () => process.cwd(),
@@ -25953,7 +26100,7 @@ function redactSecrets(input) {
 }
 
 // src/apps/cli/process-command.ts
-import * as path27 from "node:path";
+import * as path29 from "node:path";
 function resolveProcessCommandOptions(options, cwd = process.cwd(), deps = {}) {
   const explicitProject = options.project;
   if (explicitProject !== void 0 && explicitProject.trim().length === 0) {
@@ -25976,7 +26123,7 @@ function resolveProcessCommandOptions(options, cwd = process.cwd(), deps = {}) {
     recoverStuck,
     dryRunRecovery,
     graduation,
-    lockPath: explicitLockPath ?? path27.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
+    lockPath: explicitLockPath ?? path29.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
   };
 }
 function formatProcessLockBusy(input) {
@@ -26037,17 +26184,17 @@ function quoteCliArg(value) {
 
 // src/apps/cli/import-command.ts
 import * as os13 from "node:os";
-import * as path28 from "node:path";
+import * as path30 from "node:path";
 function resolveImportCommandLockOptions(options, deps = {}) {
   if (options.lockPath !== void 0 && options.lockPath.trim().length === 0) {
     throw new Error("--lock-path must not be empty");
   }
   const useGlobalStorage = options.all === true && !options.project && !options.session;
   if (useGlobalStorage) {
-    const globalStoragePath = path28.join((deps.homedir ?? os13.homedir)(), ".claude-code", "memory");
+    const globalStoragePath = path30.join((deps.homedir ?? os13.homedir)(), ".claude-code", "memory");
     return {
       storageScope: "global",
-      lockPath: options.lockPath ?? path28.join(globalStoragePath, "vector-worker.lock")
+      lockPath: options.lockPath ?? path30.join(globalStoragePath, "vector-worker.lock")
     };
   }
   const projectPath = options.project ?? (deps.cwd ?? (() => process.cwd()))();
@@ -26055,7 +26202,7 @@ function resolveImportCommandLockOptions(options, deps = {}) {
   return {
     storageScope: "project",
     projectPath,
-    lockPath: options.lockPath ?? path28.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
+    lockPath: options.lockPath ?? path30.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
   };
 }
 function formatImportLockBusy(options, holderPid) {
@@ -26188,12 +26335,12 @@ function formatDuration2(ms) {
 }
 
 // src/apps/cli/mongo-sync-command.ts
-import * as path30 from "node:path";
+import * as path32 from "node:path";
 
 // src/core/worker-lock.ts
-import { closeSync, existsSync as existsSync19, mkdirSync as mkdirSync10, openSync, readFileSync as readFileSync10, unlinkSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { closeSync, existsSync as existsSync20, mkdirSync as mkdirSync11, openSync, readFileSync as readFileSync11, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "node:fs";
 import * as os14 from "node:os";
-import * as path29 from "node:path";
+import * as path31 from "node:path";
 import { randomUUID as randomUUID23 } from "node:crypto";
 var WorkerLock = class {
   lockPath;
@@ -26202,7 +26349,7 @@ var WorkerLock = class {
   now;
   isProcessRunning;
   acquired = false;
-  constructor(lockPath = path29.join(os14.tmpdir(), "claude-memory-layer", "vector-worker.lock"), options = {}) {
+  constructor(lockPath = path31.join(os14.tmpdir(), "claude-memory-layer", "vector-worker.lock"), options = {}) {
     this.lockPath = lockPath;
     this.pid = options.pid ?? process.pid;
     this.ownerId = options.ownerId ?? randomUUID23();
@@ -26215,7 +26362,7 @@ var WorkerLock = class {
   acquire() {
     let staleRecovered = false;
     for (; ; ) {
-      mkdirSync10(path29.dirname(this.lockPath), { recursive: true });
+      mkdirSync11(path31.dirname(this.lockPath), { recursive: true });
       const createResult = this.tryCreateLockFile();
       if (createResult === "created") {
         this.acquired = true;
@@ -26249,11 +26396,11 @@ var WorkerLock = class {
     }
   }
   release() {
-    if (!this.acquired || !existsSync19(this.lockPath)) return false;
+    if (!this.acquired || !existsSync20(this.lockPath)) return false;
     const existing = this.readPayload();
     if (!this.isOwnedPayload(existing)) return false;
     try {
-      unlinkSync(this.lockPath);
+      unlinkSync2(this.lockPath);
       this.acquired = false;
       return true;
     } catch {
@@ -26264,7 +26411,7 @@ var WorkerLock = class {
     let fd = null;
     try {
       fd = openSync(this.lockPath, "wx");
-      writeFileSync8(fd, JSON.stringify({
+      writeFileSync9(fd, JSON.stringify({
         pid: this.pid,
         ownerId: this.ownerId,
         acquiredAt: this.now().toISOString()
@@ -26280,7 +26427,7 @@ var WorkerLock = class {
   }
   readPayload() {
     try {
-      const raw = readFileSync10(this.lockPath, "utf8").trim();
+      const raw = readFileSync11(this.lockPath, "utf8").trim();
       if (!raw) return null;
       if (/^\d+$/.test(raw)) {
         return {
@@ -26307,7 +26454,7 @@ var WorkerLock = class {
   }
   removeExistingLock() {
     try {
-      unlinkSync(this.lockPath);
+      unlinkSync2(this.lockPath);
       return true;
     } catch (error) {
       const code = error.code;
@@ -26347,7 +26494,7 @@ function resolveMongoSyncProcessOptions(options, cwd = process.cwd(), deps = {})
     projectPath,
     processAfterSync: options.processAfterSync === true,
     processIntervalMs,
-    lockPath: explicitLockPath ?? path30.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
+    lockPath: explicitLockPath ?? path32.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
   };
 }
 function createMongoSyncPostProcessor(options, deps = {}) {
@@ -26430,28 +26577,29 @@ function parsePositiveIntegerOption2(raw, flagName) {
 }
 
 // src/apps/cli/index.ts
-var CLAUDE_SETTINGS_PATH = path31.join(os15.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = path33.join(os15.homedir(), ".claude", "settings.json");
+var CODEX_HOOKS_PATH = path33.join(os15.homedir(), ".codex", "hooks.json");
 function getPluginPath() {
   const possiblePaths = [
-    path31.join(__dirname, ".."),
+    path33.join(__dirname, ".."),
     // When running from dist/cli
-    path31.join(__dirname, "../..", "dist"),
+    path33.join(__dirname, "../..", "dist"),
     // When running from src
-    path31.join(process.cwd(), "dist")
+    path33.join(process.cwd(), "dist")
     // Current working directory
   ];
   for (const p of possiblePaths) {
-    const hooksPath = path31.join(p, "hooks", "user-prompt-submit.js");
-    if (fs22.existsSync(hooksPath)) {
+    const hooksPath = path33.join(p, "hooks", "user-prompt-submit.js");
+    if (fs23.existsSync(hooksPath)) {
       return p;
     }
   }
-  return path31.join(os15.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
+  return path33.join(os15.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
 }
 function loadClaudeSettings() {
   try {
-    if (fs22.existsSync(CLAUDE_SETTINGS_PATH)) {
-      const content = fs22.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+    if (fs23.existsSync(CLAUDE_SETTINGS_PATH)) {
+      const content = fs23.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
       return JSON.parse(content);
     }
   } catch (error) {
@@ -26460,13 +26608,35 @@ function loadClaudeSettings() {
   return {};
 }
 function saveClaudeSettings(settings) {
-  const dir = path31.dirname(CLAUDE_SETTINGS_PATH);
-  if (!fs22.existsSync(dir)) {
-    fs22.mkdirSync(dir, { recursive: true });
+  const dir = path33.dirname(CLAUDE_SETTINGS_PATH);
+  if (!fs23.existsSync(dir)) {
+    fs23.mkdirSync(dir, { recursive: true });
   }
   const tempPath = CLAUDE_SETTINGS_PATH + ".tmp";
-  fs22.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
-  fs22.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+  fs23.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
+  fs23.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+}
+function loadCodexHooksConfig(configPath = CODEX_HOOKS_PATH) {
+  try {
+    if (fs23.existsSync(configPath)) {
+      return parseCodexHooksConfig(JSON.parse(fs23.readFileSync(configPath, "utf-8")));
+    }
+  } catch (error) {
+    throw new Error(`Could not read Codex hooks config at ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return {};
+}
+function saveCodexHooksConfig(config, configPath = CODEX_HOOKS_PATH) {
+  const dir = path33.dirname(configPath);
+  fs23.mkdirSync(dir, { recursive: true });
+  const tempPath = `${configPath}.${process.pid}.tmp`;
+  try {
+    fs23.writeFileSync(tempPath, `${JSON.stringify(config, null, 2)}
+`);
+    fs23.renameSync(tempPath, configPath);
+  } finally {
+    if (fs23.existsSync(tempPath)) fs23.unlinkSync(tempPath);
+  }
 }
 function resolveHealthProjectIdentity(projectPath) {
   if (!projectPath || projectPath.trim().length === 0) return { scope: "global", id: "global" };
@@ -26475,7 +26645,7 @@ function resolveHealthProjectIdentity(projectPath) {
 }
 function resolveHealthStoragePath(projectPathOrHash) {
   const normalized = projectPathOrHash?.trim();
-  return normalized && normalized.length > 0 ? resolveProjectStoragePath(normalized) : path31.join(os15.homedir(), ".claude-code", "memory");
+  return normalized && normalized.length > 0 ? resolveProjectStoragePath(normalized) : path33.join(os15.homedir(), ".claude-code", "memory");
 }
 function createHealthMemoryService(projectPathOrHash) {
   const project = resolveHealthProjectIdentity(projectPathOrHash);
@@ -26489,7 +26659,7 @@ function createHealthMemoryService(projectPathOrHash) {
   });
 }
 function healthStoreExists(projectPathOrHash) {
-  return fs22.existsSync(path31.join(resolveHealthStoragePath(projectPathOrHash), "events.sqlite"));
+  return fs23.existsSync(path33.join(resolveHealthStoragePath(projectPathOrHash), "events.sqlite"));
 }
 function emptyHealthStats() {
   return { totalEvents: 0, vectorCount: 0, levelStats: [] };
@@ -26522,20 +26692,20 @@ function emptyHealthDerivationLiveness() {
   };
 }
 function scanCanonicalProjectStores(canonicalId) {
-  const projectsRoot = path31.join(os15.homedir(), ".claude-code", "memory", "projects");
+  const projectsRoot = path33.join(os15.homedir(), ".claude-code", "memory", "projects");
   let scannedStoreCount = 0;
   let matchingStoreCount = 0;
   let unreadableStoreCount = 0;
   let entries;
   try {
-    entries = fs22.readdirSync(projectsRoot, { withFileTypes: true });
+    entries = fs23.readdirSync(projectsRoot, { withFileTypes: true });
   } catch {
     return { scannedStoreCount, matchingStoreCount, unreadableStoreCount };
   }
   for (const entry of entries) {
     if (!entry.isDirectory() || !/^[a-f0-9]{8}$/.test(entry.name)) continue;
-    const dbPath = path31.join(projectsRoot, entry.name, "events.sqlite");
-    if (!fs22.existsSync(dbPath)) continue;
+    const dbPath = path33.join(projectsRoot, entry.name, "events.sqlite");
+    if (!fs23.existsSync(dbPath)) continue;
     scannedStoreCount++;
     let db;
     try {
@@ -26627,7 +26797,7 @@ async function runCodexValidationCommand(options) {
   process.stdout.write(rendered.endsWith("\n") ? rendered : `${rendered}
 `);
   if (options.output) {
-    const outputPath = path31.resolve(options.output);
+    const outputPath = path33.resolve(options.output);
     writeCodexValidationReport(outputPath, report, format);
     console.log(`
 Report written to ${outputPath}`);
@@ -26647,7 +26817,7 @@ async function runHermesValidationCommand(options) {
   process.stdout.write(rendered.endsWith("\n") ? rendered : `${rendered}
 `);
   if (options.output) {
-    const outputPath = path31.resolve(options.output);
+    const outputPath = path33.resolve(options.output);
     writeHermesValidationReport(outputPath, report, format);
     console.log(`
 Report written to ${outputPath}`);
@@ -26681,18 +26851,18 @@ var OPERATION_PRIVACY_CONFIG = {
   }
 };
 function resolveOperationProject(project) {
-  const projectPath = path31.resolve(project ?? process.cwd());
+  const projectPath = path33.resolve(project ?? process.cwd());
   const projectHash = hashProjectPath(projectPath);
   const storagePath = getProjectStoragePath(projectPath);
   return {
     projectPath,
     projectHash,
     storagePath,
-    dbPath: path31.join(storagePath, "events.sqlite")
+    dbPath: path33.join(storagePath, "events.sqlite")
   };
 }
 function openOperationReadDatabase(context) {
-  if (!fs22.existsSync(context.dbPath)) return null;
+  if (!fs23.existsSync(context.dbPath)) return null;
   return createSQLiteDatabase(context.dbPath, { readonly: true, walMode: false });
 }
 async function withOperationWriteDatabase(context, callback) {
@@ -26925,7 +27095,7 @@ async function runOperationCli(action, label) {
   }
 }
 var program = new Command();
-program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("2.2.5");
+program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("2.2.6");
 program.command("market-context").description("Fetch read-only DART/FRED/Finnhub context with structured MarketContextSnapshot bull/bear/risk/catalyst analysis").option("--company <name>", "Company name for DART fallback search and report subject").option("--dart-corp-code <code>", "Exact DART corp_code for issuer-specific filings").option("--symbol <ticker>", "Listed ticker for Finnhub company profile").option("--providers <list>", "Comma-separated providers: dart,fred,finnhub").option("--fred-series <list>", "Comma-separated FRED series IDs").option("--json", "Print structured JSON including analysis.marketSnapshot").option("--no-snapshot", "Disable MarketContextSnapshot and DART company snapshot analysis").action(async (options) => {
   try {
     await runMarketContextCommand(options);
@@ -26938,7 +27108,7 @@ program.command("install").description("Install hooks into Claude Code settings"
   try {
     const pluginPath = options.path || getPluginPath();
     const missingHooks = REQUIRED_HOOK_FILES.filter(
-      (file) => !fs22.existsSync(path31.join(pluginPath, "hooks", file))
+      (file) => !fs23.existsSync(path33.join(pluginPath, "hooks", file))
     );
     if (missingHooks.length > 0) {
       console.error(`
@@ -27004,7 +27174,7 @@ program.command("status").description("Check plugin installation status").action
     console.log(`  PostToolUse: ${hasPostToolHook ? "\u2705 Installed" : "\u274C Not installed"}`);
     console.log(`  Stop: ${hasStopHook ? "\u2705 Installed" : "\u274C Not installed"}`);
     console.log(`  SessionEnd: ${hasSessionEndHook ? "\u2705 Installed" : "\u274C Not installed"}`);
-    const hooksExist = REQUIRED_HOOK_FILES.every((file) => fs22.existsSync(path31.join(pluginPath, "hooks", file)));
+    const hooksExist = REQUIRED_HOOK_FILES.every((file) => fs23.existsSync(path33.join(pluginPath, "hooks", file)));
     console.log(`
 Plugin files: ${hooksExist ? "\u2705 Found" : "\u274C Not found"}`);
     console.log(`  Path: ${pluginPath}`);
@@ -27281,8 +27451,8 @@ repairCommand.command("legacy-project-scope").description("Dry-run or apply proj
       apply: options.apply
     });
     const storagePath = projectPath ? getProjectStoragePath(projectPath) : resolveProjectStoragePath(repairOptions.projectHash);
-    const dbPath = path31.join(storagePath, "events.sqlite");
-    if (repairOptions.dryRun && !fs22.existsSync(dbPath)) {
+    const dbPath = path33.join(storagePath, "events.sqlite");
+    if (repairOptions.dryRun && !fs23.existsSync(dbPath)) {
       const projectHash = repairOptions.projectHash || hashProjectPath(repairOptions.projectPath);
       console.log(formatLegacyProjectScopeRepairResult({
         dryRun: true,
@@ -27315,8 +27485,8 @@ repairCommand.command("prune-tool-observation-vectors").description("Delete alre
   try {
     const pruneOptions = resolvePruneToolObservationVectorsOptions(options);
     const storagePath = getProjectStoragePath(pruneOptions.projectPath);
-    const dbPath = path31.join(storagePath, "events.sqlite");
-    if (pruneOptions.dryRun && !fs22.existsSync(dbPath)) {
+    const dbPath = path33.join(storagePath, "events.sqlite");
+    if (pruneOptions.dryRun && !fs23.existsSync(dbPath)) {
       console.log(formatPruneToolObservationVectorsResult({
         dryRun: true,
         scanned: 0,
@@ -27327,7 +27497,7 @@ repairCommand.command("prune-tool-observation-vectors").description("Delete alre
       return;
     }
     const store = new SQLiteEventStore(dbPath, { readonly: pruneOptions.dryRun });
-    const vectorStore = new VectorStore(path31.join(storagePath, "vectors"));
+    const vectorStore = new VectorStore(path33.join(storagePath, "vectors"));
     try {
       const result = await pruneToolObservationVectors(store, vectorStore, { dryRun: pruneOptions.dryRun });
       console.log(formatPruneToolObservationVectorsResult(result));
@@ -27345,8 +27515,8 @@ repairCommand.command("redact-credentials").description("Redact credentials alre
     const projectPath = options.project ?? process.cwd();
     const dryRun = options.apply !== true;
     const storagePath = getProjectStoragePath(projectPath);
-    const dbPath = path31.join(storagePath, "events.sqlite");
-    if (!fs22.existsSync(dbPath)) {
+    const dbPath = path33.join(storagePath, "events.sqlite");
+    if (!fs23.existsSync(dbPath)) {
       console.log(formatRedactionPlan({
         dryRun,
         rowChanges: [],
@@ -27366,7 +27536,7 @@ repairCommand.command("redact-credentials").description("Redact credentials alre
       const { rowChanges, affectedEventIds } = planSqliteRedaction(db, { apply: !dryRun });
       const fileChanges = planMarkdownRedaction(storagePath, { apply: !dryRun });
       if (!dryRun && affectedEventIds.length > 0) {
-        const vectorStore = new VectorStore(path31.join(storagePath, "vectors"));
+        const vectorStore = new VectorStore(path33.join(storagePath, "vectors"));
         for (const eventId of affectedEventIds) {
           try {
             await vectorStore.deleteEventEverywhere(eventId);
@@ -27399,12 +27569,12 @@ repairCommand.command("auto-heal-tool-observation-vectors").description("Interna
   try {
     const healOptions = resolveAutoHealToolObservationVectorsOptions(options);
     const storagePath = getProjectStoragePath(healOptions.projectPath);
-    const dbPath = path31.join(storagePath, "events.sqlite");
-    if (!fs22.existsSync(dbPath)) {
+    const dbPath = path33.join(storagePath, "events.sqlite");
+    if (!fs23.existsSync(dbPath)) {
       console.log(formatAutoHealToolObservationVectorsResult({ status: "no-store" }));
       return;
     }
-    const lockPath = healOptions.lockPath ?? path31.join(storagePath, "auto-heal.lock");
+    const lockPath = healOptions.lockPath ?? path33.join(storagePath, "auto-heal.lock");
     workerLock = new WorkerLock(lockPath);
     const lockResult = workerLock.acquire();
     if (!lockResult.acquired) {
@@ -27417,7 +27587,7 @@ repairCommand.command("auto-heal-tool-observation-vectors").description("Interna
       console.log(formatAutoHealToolObservationVectorsResult({ status: "already-healed" }));
       return;
     }
-    const vectorStore = new VectorStore(path31.join(storagePath, "vectors"));
+    const vectorStore = new VectorStore(path33.join(storagePath, "vectors"));
     const result = await runToolObservationVectorAutoHeal(store, vectorStore);
     console.log(formatAutoHealToolObservationVectorsResult({ status: "healed", result }));
   } catch (error) {
@@ -27693,8 +27863,8 @@ retentionCommand.command("audit").description("Run a dry-run retention audit for
     });
     const projectHash = auditOptions.projectHash ?? hashProjectPath(auditOptions.projectPath);
     const storagePath = auditOptions.projectPath ? getProjectStoragePath(auditOptions.projectPath) : resolveProjectStoragePath(projectHash);
-    const dbPath = path31.join(storagePath, "events.sqlite");
-    if (!fs22.existsSync(dbPath)) {
+    const dbPath = path33.join(storagePath, "events.sqlite");
+    if (!fs23.existsSync(dbPath)) {
       const emptyReport = emptyRetentionAuditReport(projectHash, auditOptions.limit);
       console.log(formatRetentionAuditReport(emptyReport, { json: auditOptions.json }));
       return;
@@ -27721,7 +27891,7 @@ program.command("mongo-sync").description("Sync events with MongoDB for multi-se
   const projectPath = options.project || process.cwd();
   const mongoUri = options.mongoUri || process.env.CLAUDE_MEMORY_MONGO_URI;
   const mongoDb = options.mongoDb || process.env.CLAUDE_MEMORY_MONGO_DB;
-  const projectKey = options.mongoProject || process.env.CLAUDE_MEMORY_MONGO_PROJECT || path31.basename(projectPath);
+  const projectKey = options.mongoProject || process.env.CLAUDE_MEMORY_MONGO_PROJECT || path33.basename(projectPath);
   const direction = String(options.direction || "both").toLowerCase();
   if (!mongoUri || !mongoDb) {
     console.error("\n\u274C MongoDB sync is not configured.");
@@ -27751,14 +27921,14 @@ program.command("mongo-sync").description("Sync events with MongoDB for multi-se
     }
   })();
   const storagePath = getProjectStoragePath(projectPath);
-  if (!fs22.existsSync(storagePath)) {
-    fs22.mkdirSync(storagePath, { recursive: true });
+  if (!fs23.existsSync(storagePath)) {
+    fs23.mkdirSync(storagePath, { recursive: true });
   }
   const postProcessor = createMongoSyncPostProcessor(processOptions, {
     log: (message) => process.stdout.write(`${message}
 `)
   });
-  const sqliteStore = new SQLiteEventStore(path31.join(storagePath, "events.sqlite"));
+  const sqliteStore = new SQLiteEventStore(path33.join(storagePath, "events.sqlite"));
   const worker = new MongoSyncWorker(sqliteStore, {
     uri: mongoUri,
     dbName: mongoDb,
@@ -27818,7 +27988,7 @@ function renderProgress(event) {
       break;
     case "session-start": {
       const pct = Math.round(event.sessionIndex / event.totalSessions * 100);
-      const sessionName = path31.basename(event.filePath, ".jsonl").slice(0, 8);
+      const sessionName = path33.basename(event.filePath, ".jsonl").slice(0, 8);
       process.stdout.write(
         `\r  \u{1F4C4} [${event.sessionIndex + 1}/${event.totalSessions}] ${pct}% | Session ${sessionName}... `
       );
@@ -27893,9 +28063,9 @@ async function listMarkdownFiles(root) {
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
-    const entries = await fs22.promises.readdir(dir, { withFileTypes: true });
+    const entries = await fs23.promises.readdir(dir, { withFileTypes: true });
     for (const e of entries) {
-      const full = path31.join(dir, e.name);
+      const full = path33.join(dir, e.name);
       if (e.isDirectory()) stack.push(full);
       else if (e.isFile() && e.name.endsWith(".md") && e.name !== "_index.md") out.push(full);
     }
@@ -27903,8 +28073,8 @@ async function listMarkdownFiles(root) {
   return out.sort();
 }
 function deriveNamespaceCategory(sourceRoot, filePath) {
-  const rel = path31.relative(sourceRoot, filePath);
-  const dirSeg = path31.dirname(rel).split(path31.sep).filter(Boolean);
+  const rel = path33.relative(sourceRoot, filePath);
+  const dirSeg = path33.dirname(rel).split(path33.sep).filter(Boolean);
   if (dirSeg.length >= 2) {
     const namespace = sanitizeSegment3(dirSeg[0], "default");
     const categoryPath = dirSeg.slice(1).map((s) => sanitizeSegment3(s, "uncategorized"));
@@ -27923,10 +28093,10 @@ function extractImportEvidence(markdown) {
 program.command("organize-import [sourceDir]").description("Import existing markdown memory files, or bootstrap knowledge docs from codebase/git when markdown is missing").option("-p, --project <path>", "Project path (defaults to cwd)").option("--session <id>", "Session id for imported events (default: import:organized)").option("--limit <n>", "Limit number of files to import").option("--dry-run", "Preview mapping without writing").option("--bootstrap", "Force-generate structured markdown from codebase + git history before import").option("--bootstrap-if-empty", "Auto-bootstrap when source has no markdown files (default: true)", true).option("--no-bootstrap-if-empty", "Disable auto-bootstrap when source has no markdown files").option("--force-bootstrap", "Run bootstrap even when markdown files exist").option("--repo <path>", "Repository root for bootstrap analysis (default: project path)").option("--out <path>", "Output directory for generated bootstrap markdown (default: <sourceDir>/bootstrap-kb)").option("--since <range>", 'Git history range for bootstrap (default: "180 days ago")').option("--max-commits <n>", "Max commits to analyze for bootstrap (default: 1000)").option("--incremental", "Use previous bootstrap manifest as baseline for incremental updates (default: true)", true).option("--no-incremental", "Disable incremental bootstrap; regenerate full snapshot").action(async (sourceDir, options) => {
   const projectPath = options.project || process.cwd();
   const sessionId = options.session || "import:organized";
-  const sourceRoot = path31.resolve(sourceDir || options.out || projectPath);
-  const repoPath = path31.resolve(options.repo || projectPath);
-  if (!fs22.existsSync(sourceRoot)) {
-    fs22.mkdirSync(sourceRoot, { recursive: true });
+  const sourceRoot = path33.resolve(sourceDir || options.out || projectPath);
+  const repoPath = path33.resolve(options.repo || projectPath);
+  if (!fs23.existsSync(sourceRoot)) {
+    fs23.mkdirSync(sourceRoot, { recursive: true });
   }
   const service = getMemoryServiceForProject(projectPath);
   try {
@@ -27936,7 +28106,7 @@ program.command("organize-import [sourceDir]").description("Import existing mark
     const hasMarkdown = files.length > 0;
     const shouldBootstrap = Boolean(options.forceBootstrap || options.bootstrap || !hasMarkdown && options.bootstrapIfEmpty);
     if (shouldBootstrap) {
-      const outDir = path31.resolve(options.out || path31.join(sourceRoot, "bootstrap-kb"));
+      const outDir = path33.resolve(options.out || path33.join(sourceRoot, "bootstrap-kb"));
       const since = options.since || "180 days ago";
       const maxCommits = options.maxCommits ? Math.max(1, parseInt(options.maxCommits, 10)) : 1e3;
       console.log("\n\u{1F9E0} Bootstrapping markdown knowledge base...");
@@ -27975,13 +28145,13 @@ program.command("organize-import [sourceDir]").description("Import existing mark
     let imported = 0;
     let skipped = 0;
     for (const file of targets) {
-      const text = await fs22.promises.readFile(file, "utf8");
+      const text = await fs23.promises.readFile(file, "utf8");
       if (!text.trim()) {
         skipped += 1;
         continue;
       }
       const { namespace, categoryPath } = deriveNamespaceCategory(activeSourceRoot, file);
-      const rel = path31.relative(activeSourceRoot, file);
+      const rel = path33.relative(activeSourceRoot, file);
       const evidence = extractImportEvidence(text);
       if (options.dryRun) {
         console.log(`- ${rel} -> namespace=${namespace} category=${categoryPath.join("/")} confidence=${evidence.confidence || "n/a"} sources=${evidence.sources.length}`);
@@ -28136,7 +28306,81 @@ program.command("list").description("List available Claude Code sessions").optio
     process.exit(1);
   }
 });
-var codexCmd = program.command("codex").description("Read-only Codex session scan/replay validation");
+var codexCmd = program.command("codex").description("Codex session import, validation, and lifecycle hook integration");
+var codexHooksCmd = codexCmd.command("hooks").description("Manage Codex lifecycle hooks for automatic memory loading and ingestion");
+codexHooksCmd.command("install").description("Install Codex SessionStart and SessionEnd memory hooks").option("--path <path>", "Custom plugin path (defaults to auto-detect)").option("--config-path <path>", "Codex hooks config path (default: ~/.codex/hooks.json)").action(async (options) => {
+  try {
+    const pluginPath = path33.resolve(options.path || getPluginPath());
+    const configPath = options.configPath || CODEX_HOOKS_PATH;
+    const missingHooks = REQUIRED_CODEX_HOOK_FILES.filter((file) => !fs23.existsSync(path33.join(pluginPath, "hooks", file)));
+    if (missingHooks.length > 0) {
+      throw new Error(`Codex hook files not found at ${pluginPath}; missing: ${missingHooks.join(", ")}`);
+    }
+    const config = loadCodexHooksConfig(configPath);
+    saveCodexHooksConfig(mergeCodexMemoryHooks(config, pluginPath), configPath);
+    console.log("\n\u2705 Codex automatic memory hooks installed!\n");
+    console.log("  SessionStart: Load project memory into Codex context");
+    console.log("  SessionEnd: Import the completed Codex transcript");
+    console.log(`  Config: ${configPath}`);
+    console.log(`  Plugin path: ${pluginPath}`);
+    console.log("\n\u26A0\uFE0F  Restart Codex, open /hooks, and trust the new hook definitions.\n");
+  } catch (error) {
+    console.error("Codex hooks install failed:", error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+  }
+});
+codexHooksCmd.command("status").description("Check Codex automatic memory hook status").option("--path <path>", "Custom plugin path (defaults to auto-detect)").option("--config-path <path>", "Codex hooks config path (default: ~/.codex/hooks.json)").option("-p, --project <path>", "Project whose most recent automatic import status should be shown (default: cwd)").action(async (options) => {
+  try {
+    const pluginPath = path33.resolve(options.path || getPluginPath());
+    const configPath = options.configPath || CODEX_HOOKS_PATH;
+    const config = loadCodexHooksConfig(configPath);
+    const sessionStart = hasCodexMemoryHook(config, "SessionStart", pluginPath);
+    const sessionEnd = hasCodexMemoryHook(config, "SessionEnd", pluginPath);
+    const filesExist = REQUIRED_CODEX_HOOK_FILES.every((file) => fs23.existsSync(path33.join(pluginPath, "hooks", file)));
+    console.log("\n\u{1F9E0} Codex Automatic Memory Status\n");
+    console.log(`  SessionStart: ${sessionStart ? "\u2705 Installed" : "\u274C Not installed"}`);
+    console.log(`  SessionEnd: ${sessionEnd ? "\u2705 Installed" : "\u274C Not installed"}`);
+    console.log(`  Hook files: ${filesExist ? "\u2705 Found" : "\u274C Not found"}`);
+    console.log(`  Config: ${configPath}`);
+    const importStatus = readCodexAutoImportStatus(path33.resolve(options.project || process.cwd()));
+    if (importStatus) {
+      const counts = importStatus.status === "success" ? ` \xB7 ${importStatus.importedPrompts ?? 0} prompts \xB7 ${importStatus.importedResponses ?? 0} responses \xB7 ${importStatus.skippedDuplicates ?? 0} duplicates` : ` \xB7 ${importStatus.error ?? "unknown error"}`;
+      console.log(`  Last auto-import: ${importStatus.status === "success" ? "\u2705" : "\u274C"} ${importStatus.status} at ${importStatus.updatedAt}${counts}`);
+    } else {
+      console.log("  Last auto-import: \u2014 No recorded run for this project");
+    }
+    if (sessionStart && sessionEnd && filesExist) {
+      console.log("\n\u2705 Automatic loading and ingestion are configured. Verify trust with /hooks in Codex.\n");
+    } else {
+      console.log('\n\u{1F4A1} Run "claude-memory-layer codex hooks install" to configure automatic memory.\n');
+    }
+  } catch (error) {
+    console.error("Codex hooks status failed:", error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+  }
+});
+codexHooksCmd.command("uninstall").description("Remove only claude-memory-layer hooks from Codex").option("--path <path>", "Custom plugin path (defaults to auto-detect)").option("--config-path <path>", "Codex hooks config path (default: ~/.codex/hooks.json)").action(async (options) => {
+  try {
+    const pluginPath = path33.resolve(options.path || getPluginPath());
+    const configPath = options.configPath || CODEX_HOOKS_PATH;
+    if (!fs23.existsSync(configPath)) {
+      console.log("\n\u{1F4CB} No Codex memory hooks installed.\n");
+      return;
+    }
+    const config = loadCodexHooksConfig(configPath);
+    const nextConfig = removeCodexMemoryHooks(config, pluginPath);
+    if (Object.keys(nextConfig).length === 0) {
+      fs23.unlinkSync(configPath);
+    } else {
+      saveCodexHooksConfig(nextConfig, configPath);
+    }
+    console.log("\n\u2705 Claude Memory Layer hooks removed from Codex.\n");
+    console.log("Memory data was preserved. Restart Codex for the change to take effect.\n");
+  } catch (error) {
+    console.error("Codex hooks uninstall failed:", error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+  }
+});
 codexCmd.command("validate").description("Dry-run validate Codex JSONL sessions without importing or mutating memory").option("-p, --project <path>", "Filter sessions by session_meta.payload.cwd").option("--sessions-dir <path>", "Codex sessions directory (default: ~/.codex/sessions)").option("-l, --limit <number>", "Limit number of session files to scan").option("--format <format>", "Report format: json or markdown", "markdown").option("-o, --output <path>", "Write report to file").option("--dry-run", "Read-only validation mode (default; no imports or writes)", true).option("--anonymize-projects", "Show hashed project labels instead of raw cwd paths").action(async (options) => {
   try {
     await runCodexValidationCommand(options);