memorix 1.1.11 → 1.1.13

package/dist/cli/index.js

@@ -3212,7 +3212,7 @@ ${import_picocolors.default.gray(m3)}  ${s2}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.1.11" : pkg.version;
+  return true ? "1.1.13" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -13667,6 +13667,45 @@ function dimsCacheKey(config2) {
     config2.requestedDimensions ?? "native"
   ].join("|");
 }
+function isValidDimension(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+async function loadCachedVectorDimensions(config2) {
+  try {
+    const raw = await readFile2(CACHE_META_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    const namespace = cacheNamespace(config2);
+    if (!Array.isArray(data?.entries)) return null;
+    const entry = data.entries.find(
+      (candidate) => typeof candidate === "object" && candidate !== null && candidate.namespace === namespace && isValidDimension(candidate.dimensions)
+    );
+    return entry?.dimensions ?? null;
+  } catch {
+    return null;
+  }
+}
+async function saveCachedVectorDimensions(config2, dimensions) {
+  if (!isValidDimension(dimensions)) return;
+  try {
+    await mkdir2(CACHE_DIR2, { recursive: true });
+    let entries = [];
+    try {
+      const raw = await readFile2(CACHE_META_FILE, "utf-8");
+      const data = JSON.parse(raw);
+      if (Array.isArray(data?.entries)) {
+        entries = data.entries.filter(
+          (candidate) => typeof candidate === "object" && candidate !== null && typeof candidate.namespace === "string" && isValidDimension(candidate.dimensions) && typeof candidate.ts === "number"
+        );
+      }
+    } catch {
+    }
+    const namespace = cacheNamespace(config2);
+    entries = entries.filter((entry) => entry.namespace !== namespace);
+    entries.push({ namespace, dimensions, ts: Date.now() });
+    await writeFile2(CACHE_META_FILE, JSON.stringify({ version: 1, entries }));
+  } catch {
+  }
+}
 async function loadCachedDims(config2) {
   try {
     const raw = await readFile2(DIMS_CACHE_FILE, "utf-8");
@@ -13729,6 +13768,7 @@ async function saveCachedDims(config2, dimensions) {
     await writeFile2(DIMS_CACHE_FILE, JSON.stringify({ entries }));
   } catch {
   }
+  await saveCachedVectorDimensions(config2, dimensions);
 }
 async function saveDiskCacheNow() {
   if (!diskCacheDirty2) return;
@@ -13811,7 +13851,7 @@ async function fetchWithRetry(url, apiKey, body, attempt = 0) {
   const errorText2 = await response.text().catch(() => "unknown error");
   throw new Error(`Embedding API error (${response.status}): ${errorText2}`);
 }
-var CACHE_DIR2, CACHE_FILE2, DIMS_CACHE_FILE, cache3, MAX_CACHE_SIZE3, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES, BASE_DELAY_MS, APIEmbeddingProvider;
+var CACHE_DIR2, CACHE_FILE2, DIMS_CACHE_FILE, CACHE_META_FILE, cache3, MAX_CACHE_SIZE3, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES, BASE_DELAY_MS, APIEmbeddingProvider;
 var init_api_provider = __esm({
   "src/embedding/api-provider.ts"() {
     "use strict";
@@ -13819,6 +13859,7 @@ var init_api_provider = __esm({
     CACHE_DIR2 = process.env.MEMORIX_DATA_DIR || join4(homedir7(), ".memorix", "data");
     CACHE_FILE2 = join4(CACHE_DIR2, ".embedding-api-cache.json");
     DIMS_CACHE_FILE = join4(CACHE_DIR2, ".embedding-dims-cache.json");
+    CACHE_META_FILE = join4(CACHE_DIR2, ".embedding-api-cache-meta.json");
     cache3 = /* @__PURE__ */ new Map();
     MAX_CACHE_SIZE3 = 1e4;
     diskCacheDirty2 = false;
@@ -13845,13 +13886,22 @@ var init_api_provider = __esm({
         this.dimensions = detectedDimensions;
         this.name = `api-${config2.model.replace(/\//g, "-")}`;
       }
-      static async create() {
+      static async create(options2 = {}) {
         const config2 = _APIEmbeddingProvider.resolveConfig();
-        startDiskCacheLoad();
+        const allowNetworkProbe = options2.allowNetworkProbe !== false;
         let probeDimensions = await loadCachedDims(config2);
+        let dimensionSource = "dims-cache";
+        if (probeDimensions === null) {
+          probeDimensions = await loadCachedVectorDimensions(config2);
+          if (probeDimensions !== null) dimensionSource = "vector-cache";
+        }
         if (probeDimensions !== null) {
-          console.error(`[memorix] API embedding: ${config2.model} @ ${config2.baseUrl} (${probeDimensions}d) [cached dims]`);
+          console.error(`[memorix] API embedding: ${config2.model} @ ${config2.baseUrl} (${probeDimensions}d) [${dimensionSource}]`);
+          if (dimensionSource === "dims-cache") {
+            void saveCachedVectorDimensions(config2, probeDimensions);
+          }
         } else {
+          if (!allowNetworkProbe) return null;
           probeDimensions = await _APIEmbeddingProvider.probeAPI(config2);
           console.error(`[memorix] API embedding: ${config2.model} @ ${config2.baseUrl} (${probeDimensions}d)`);
           saveCachedDims(config2, probeDimensions).catch(() => {
@@ -13860,6 +13910,7 @@ var init_api_provider = __esm({
         if (config2.requestedDimensions) {
           console.error(`[memorix] Dimension shortening: ${config2.requestedDimensions}d requested`);
         }
+        startDiskCacheLoad();
         return new _APIEmbeddingProvider(config2, probeDimensions);
       }
       static resolveConfig() {
@@ -14038,6 +14089,13 @@ var init_api_provider = __esm({
         scheduleDiskSave();
         return results;
       }
+      async getCachedEmbeddings(texts) {
+        await ensureDiskCacheLoaded();
+        return texts.map((text) => {
+          const hash = textHash2(normalizeText(text), this.cacheKeyNamespace);
+          return cache3.get(hash) ?? null;
+        });
+      }
       getStats() {
         return {
           totalTokens: this.totalTokensUsed,
@@ -14146,10 +14204,10 @@ async function createTransformersProvider() {
     return null;
   }
 }
-async function createAPIProvider() {
+async function createAPIProvider(options2) {
   try {
     const { APIEmbeddingProvider: APIEmbeddingProvider2 } = await Promise.resolve().then(() => (init_api_provider(), api_provider_exports));
-    return await APIEmbeddingProvider2.create();
+    return await APIEmbeddingProvider2.create(options2 ?? {});
   } catch (e3) {
     warnOnce(`[memorix] Failed to init API embedding: ${e3 instanceof Error ? e3.message : e3}`);
     return null;
@@ -14204,11 +14262,24 @@ function wrapProvider(candidate) {
         }
         throw error2;
       }
-    }
+    },
+    ...candidate.getCachedEmbeddings ? {
+      async getCachedEmbeddings(texts) {
+        return candidate.getCachedEmbeddings(texts);
+      }
+    } : {}
   };
 }
-async function getEmbeddingProvider() {
+async function getEmbeddingProvider(options2 = {}) {
   if (provider) return provider;
+  if (options2.allowNetworkProbe === false) {
+    const mode = getEmbeddingMode2();
+    if (mode !== "api" && !(mode === "auto" && hasAPIEmbeddingConfig())) {
+      return null;
+    }
+    const cached2 = await createAPIProvider({ allowNetworkProbe: false });
+    return cached2 ? wrapProvider(cached2) : null;
+  }
   if (lastInitWasTemporaryFailure) {
     const elapsed = Date.now() - lastFailureTimestamp;
     if (elapsed < RETRY_COOLDOWN_MS) {
@@ -15721,12 +15792,15 @@ __export(orama_store_exports, {
   batchGenerateEmbeddings: () => batchGenerateEmbeddings,
   generateEmbedding: () => generateEmbedding,
   getDb: () => getDb,
+  getDeferredCachedVectorHydration: () => getDeferredCachedVectorHydration,
   getLastSearchMode: () => getLastSearchMode,
   getObservationCount: () => getObservationCount,
   getObservationsByIds: () => getObservationsByIds,
   getTimeline: () => getTimeline,
   getVectorDimensions: () => getVectorDimensions,
+  hasObservationVector: () => hasObservationVector,
   hydrateIndex: () => hydrateIndex,
+  hydrateIndexForStartup: () => hydrateIndexForStartup,
   insertObservation: () => insertObservation,
   isEmbeddingEnabled: () => isEmbeddingEnabled,
   makeOramaObservationId: () => makeOramaObservationId,
@@ -15786,11 +15860,10 @@ function stripVectorSearchParams(params) {
   const { mode, vector, similarity, hybridWeights, ...rest } = params;
   return rest;
 }
-async function getDb() {
-  if (db) return db;
-  const provider2 = await getEmbeddingProvider();
-  embeddingEnabled = provider2 !== null;
-  embeddingDimensions = provider2?.dimensions ?? null;
+async function initializeDb(options2, generation) {
+  const provider2 = await getEmbeddingProvider({ allowNetworkProbe: options2.allowNetworkProbe });
+  const nextEmbeddingEnabled = provider2 !== null;
+  const nextEmbeddingDimensions = provider2?.dimensions ?? null;
   const baseSchema = {
     id: "string",
     observationId: "number",
@@ -15813,15 +15886,39 @@ async function getDb() {
     documentType: "string",
     knowledgeLayer: "string"
   };
-  const dims = embeddingDimensions ?? 384;
-  const schema = embeddingEnabled ? { ...baseSchema, embedding: `vector[${dims}]` } : baseSchema;
-  db = await create5({ schema });
-  return db;
+  const dims = nextEmbeddingDimensions ?? 384;
+  const schema = nextEmbeddingEnabled ? { ...baseSchema, embedding: `vector[${dims}]` } : baseSchema;
+  const nextDb = await create5({ schema });
+  if (generation !== dbGeneration) {
+    return getDb(options2);
+  }
+  indexEmbeddingProvider = provider2;
+  embeddingEnabled = nextEmbeddingEnabled;
+  embeddingDimensions = nextEmbeddingDimensions;
+  db = nextDb;
+  return nextDb;
+}
+async function getDb(options2 = {}) {
+  if (db) return db;
+  if (dbInitPromise) return dbInitPromise;
+  const initPromise2 = initializeDb(options2, dbGeneration);
+  dbInitPromise = initPromise2;
+  try {
+    return await initPromise2;
+  } finally {
+    if (dbInitPromise === initPromise2) {
+      dbInitPromise = null;
+    }
+  }
 }
 async function resetDb() {
+  dbGeneration++;
   db = null;
+  dbInitPromise = null;
   embeddingEnabled = false;
   embeddingDimensions = null;
+  indexEmbeddingProvider = null;
+  deferredCachedVectorHydration = null;
   lastSearchModeByProject.clear();
   docByObservationKey.clear();
 }
@@ -15849,14 +15946,64 @@ async function batchGenerateEmbeddings(texts) {
     return texts.map(() => null);
   }
 }
-async function hydrateIndex(observations2) {
-  const database = await getDb();
+async function getCachedEmbeddings(texts) {
+  if (!embeddingEnabled || texts.length === 0) return texts.map(() => null);
+  const provider2 = indexEmbeddingProvider;
+  if (!provider2?.getCachedEmbeddings) return texts.map(() => null);
+  try {
+    return await provider2.getCachedEmbeddings(texts);
+  } catch {
+    return texts.map(() => null);
+  }
+}
+function observationEmbeddingText(observation) {
+  return [
+    observation.title ?? "",
+    observation.narrative ?? "",
+    ...Array.isArray(observation.facts) ? observation.facts : []
+  ].join(" ");
+}
+function documentEmbeddingText(document) {
+  return [document.title ?? "", document.narrative ?? "", document.facts ?? ""].join(" ");
+}
+function isCompatibleCachedVector(vector) {
+  return Boolean(
+    vector && embeddingDimensions !== null && vector.length === embeddingDimensions && vector.every(Number.isFinite)
+  );
+}
+async function attachCachedVectors(database, candidates) {
+  const cachedVectors = await getCachedEmbeddings(
+    candidates.map(({ observation }) => observationEmbeddingText(observation))
+  );
+  if (db !== database) return;
+  for (let index = 0; index < candidates.length; index++) {
+    const vector = cachedVectors[index];
+    if (!isCompatibleCachedVector(vector)) continue;
+    const existing = getByID(database, candidates[index].id);
+    if (!existing || documentEmbeddingText(existing) !== observationEmbeddingText(candidates[index].observation)) continue;
+    try {
+      await update(database, candidates[index].id, { ...existing, embedding: vector });
+    } catch {
+    }
+  }
+}
+async function hydrateIndex(observations2, options2 = {}) {
+  const database = await getDb({ allowNetworkProbe: options2.allowNetworkProbe });
+  const candidates = [];
+  for (const observation of observations2) {
+    if (!observation || !observation.id || !observation.projectId) continue;
+    const id = makeOramaObservationId(observation.projectId, observation.id);
+    if (getByID(database, id)) continue;
+    candidates.push({ observation, id });
+  }
+  const deferCachedVectors = options2.deferCachedVectors === true && Boolean(indexEmbeddingProvider?.getCachedEmbeddings);
+  const cachedVectors = deferCachedVectors ? candidates.map(() => null) : await getCachedEmbeddings(candidates.map(({ observation }) => observationEmbeddingText(observation)));
   let inserted = 0;
-  for (const obs of observations2) {
-    if (!obs || !obs.id || !obs.projectId) continue;
+  for (let index = 0; index < candidates.length; index++) {
+    const { observation: obs, id } = candidates[index];
     try {
-      const id = makeOramaObservationId(obs.projectId, obs.id);
-      if (getByID(database, id)) continue;
+      const vector = cachedVectors[index];
+      const compatibleVector = isCompatibleCachedVector(vector) ? vector : null;
       const doc = {
         id,
         observationId: obs.id,
@@ -15875,7 +16022,8 @@ async function hydrateIndex(observations2) {
         status: obs.status ?? "active",
         source: obs.source || "agent",
         documentType: "observation",
-        knowledgeLayer: resolveKnowledgeLayer("observation", obs.sourceDetail, obs.source)
+        knowledgeLayer: resolveKnowledgeLayer("observation", obs.sourceDetail, obs.source),
+        ...compatibleVector ? { embedding: compatibleVector } : {}
       };
       await insert3(database, doc);
       rememberObservationDoc(doc);
@@ -15883,8 +16031,24 @@ async function hydrateIndex(observations2) {
     } catch {
     }
   }
+  deferredCachedVectorHydration = deferCachedVectors ? attachCachedVectors(database, candidates).catch(() => {
+  }) : null;
   return inserted;
 }
+async function hydrateIndexForStartup(observations2) {
+  return hydrateIndex(observations2, {
+    allowNetworkProbe: false,
+    deferCachedVectors: true
+  });
+}
+function getDeferredCachedVectorHydration() {
+  return deferredCachedVectorHydration;
+}
+function hasObservationVector(projectId, observationId) {
+  if (!db || !embeddingEnabled || embeddingDimensions === null) return false;
+  const document = getByID(db, makeOramaObservationId(projectId, observationId));
+  return Array.isArray(document?.embedding) && document.embedding.length === embeddingDimensions && document.embedding.every(Number.isFinite);
+}
 async function insertObservation(doc) {
   const database = await getDb();
   await insert3(database, doc);
@@ -16418,7 +16582,7 @@ function formatTime(isoDate) {
     return isoDate;
   }
 }
-var db, embeddingEnabled, embeddingDimensions, docByObservationKey, NON_CJK_HYBRID_SIMILARITY, lastSearchModeByProject, SEARCH_MODE_DEFAULT_KEY, COMMAND_LOG_TITLE2, COMMAND_STYLE_TITLE, COMMAND_LIKE_QUERY2, COMMAND_INTENT_QUERY, NATURAL_LANGUAGE_MARKERS;
+var db, dbInitPromise, dbGeneration, embeddingEnabled, embeddingDimensions, indexEmbeddingProvider, deferredCachedVectorHydration, docByObservationKey, NON_CJK_HYBRID_SIMILARITY, lastSearchModeByProject, SEARCH_MODE_DEFAULT_KEY, COMMAND_LOG_TITLE2, COMMAND_STYLE_TITLE, COMMAND_LIKE_QUERY2, COMMAND_INTENT_QUERY, NATURAL_LANGUAGE_MARKERS;
 var init_orama_store = __esm({
   "src/store/orama-store.ts"() {
     "use strict";
@@ -16431,8 +16595,12 @@ var init_orama_store = __esm({
     init_intent_detector();
     init_query_expansion();
     db = null;
+    dbInitPromise = null;
+    dbGeneration = 0;
     embeddingEnabled = false;
     embeddingDimensions = null;
+    indexEmbeddingProvider = null;
+    deferredCachedVectorHydration = null;
     docByObservationKey = /* @__PURE__ */ new Map();
     NON_CJK_HYBRID_SIMILARITY = 0.45;
     lastSearchModeByProject = /* @__PURE__ */ new Map();
@@ -18213,7 +18381,18 @@ async function bindObservationCodeRefsBestEffort(observation) {
 function isVectorCompatibleWithCurrentIndex(embedding) {
   if (!embedding) return false;
   const vectorDimensions = getVectorDimensions();
-  return vectorDimensions === null || embedding.length === vectorDimensions;
+  return vectorDimensions !== null && embedding.length === vectorDimensions && embedding.every(Number.isFinite);
+}
+async function upgradeVectorSchemaAfterFirstEmbedding(embedding) {
+  if (isVectorCompatibleWithCurrentIndex(embedding)) return true;
+  if (getVectorDimensions() !== null || !embedding.every(Number.isFinite)) return false;
+  const targetProjectDir = projectDir;
+  if (!vectorSchemaUpgradePromise) {
+    vectorSchemaUpgradePromise = reindexObservations().then(() => projectDir === targetProjectDir && isVectorCompatibleWithCurrentIndex(embedding)).catch(() => false).finally(() => {
+      vectorSchemaUpgradePromise = null;
+    });
+  }
+  return vectorSchemaUpgradePromise;
 }
 async function initObservations(dir) {
   if (projectDir === dir) return;
@@ -18223,6 +18402,7 @@ async function initObservations(dir) {
   nextId = await store2.loadIdCounter();
   projectDir = dir;
   searchIndexPrepared = false;
+  vectorSchemaUpgradePromise = null;
 }
 async function ensureFreshObservations() {
   if (!projectDir) return false;
@@ -18402,6 +18582,9 @@ async function storeObservation(input) {
   const searchableText = [input.title, input.narrative, ...input.facts ?? []].join(" ");
   generateEmbedding(searchableText).then(async (embedding) => {
     if (embedding) {
+      if (!isVectorCompatibleWithCurrentIndex(embedding)) {
+        await upgradeVectorSchemaAfterFirstEmbedding(embedding);
+      }
       if (!isVectorCompatibleWithCurrentIndex(embedding)) {
         const vectorDimensions = getVectorDimensions();
         console.error(
@@ -18512,6 +18695,13 @@ async function upsertObservation(existing, input, now) {
   vectorMissingIds.add(obsId);
   generateEmbedding(searchableText).then(async (embedding) => {
     if (embedding) {
+      if (!isVectorCompatibleWithCurrentIndex(embedding)) {
+        await upgradeVectorSchemaAfterFirstEmbedding(embedding);
+      }
+      if (!isVectorCompatibleWithCurrentIndex(embedding)) {
+        queueVectorBackfill(existing.projectId);
+        return;
+      }
       try {
         const { removeObservation: removeObs } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
         await removeObs(makeOramaObservationId(existing.projectId, obsId));
@@ -18656,14 +18846,21 @@ async function reindexObservations() {
   let embeddings = observations.map(() => null);
   const provider2 = await getEmbeddingProvider();
   const canBatchEmbedAtStartup = provider2 !== null && !provider2.name.startsWith("api-");
+  await getDb();
+  const texts = observations.map(
+    (obs) => [obs.title, obs.narrative, ...obs.facts].join(" ")
+  );
+  if (provider2?.getCachedEmbeddings) {
+    try {
+      embeddings = await provider2.getCachedEmbeddings(texts);
+    } catch {
+    }
+  }
   if (provider2 && !canBatchEmbedAtStartup) {
-    console.error("[memorix] Startup reindex: skipping synchronous API embeddings; background backfill will hydrate vectors");
+    console.error("[memorix] Startup reindex: restored cached API embeddings; uncached vectors stay in background recovery");
   }
   if (canBatchEmbedAtStartup) {
     try {
-      const texts = observations.map(
-        (obs) => [obs.title, obs.narrative, ...obs.facts].join(" ")
-      );
       embeddings = await batchGenerateEmbeddings(texts);
     } catch {
     }
@@ -18716,16 +18913,31 @@ async function reindexObservations() {
 }
 async function prepareSearchIndex() {
   if (searchIndexPrepared) return 0;
-  const count3 = await hydrateIndex(observations);
+  const count3 = await hydrateIndexForStartup(observations);
   if (count3 === 0) {
     searchIndexPrepared = true;
     return 0;
   }
-  vectorMissingIds.clear();
-  if (isEmbeddingEnabled()) {
-    for (const obs of observations) {
-      vectorMissingIds.add(obs.id);
+  const hydratedProjectDir = projectDir;
+  const queueMissingVectors = () => {
+    if (projectDir !== hydratedProjectDir) return;
+    vectorMissingIds.clear();
+    if (!isEmbeddingExplicitlyDisabled()) {
+      const projectsWithMissingVectors = /* @__PURE__ */ new Set();
+      for (const obs of observations) {
+        if (!hasObservationVector(obs.projectId, obs.id)) {
+          vectorMissingIds.add(obs.id);
+          projectsWithMissingVectors.add(obs.projectId);
+        }
+      }
+      for (const projectId of projectsWithMissingVectors) queueVectorBackfill(projectId);
     }
+  };
+  const cacheHydration = getDeferredCachedVectorHydration();
+  if (cacheHydration) {
+    void cacheHydration.finally(queueMissingVectors);
+  } else {
+    queueMissingVectors();
   }
   searchIndexPrepared = true;
   return count3;
@@ -18785,6 +18997,9 @@ async function backfillVectorEmbeddings(options2 = {}) {
       try {
         const embedding = await generateEmbedding(text);
         if (embedding) {
+          if (!isVectorCompatibleWithCurrentIndex(embedding)) {
+            await upgradeVectorSchemaAfterFirstEmbedding(embedding);
+          }
           if (!isVectorCompatibleWithCurrentIndex(embedding)) {
             const vectorDimensions = getVectorDimensions();
             console.error(
@@ -18847,7 +19062,7 @@ async function backfillVectorEmbeddings(options2 = {}) {
   }
   return { attempted: ids.length, succeeded, failed };
 }
-var observations, nextId, projectDir, searchIndexPrepared, vectorMissingIds, vectorBackfillRunning, lastVectorBackfill, embeddingFailureLogTimestamps, EMBEDDING_FAILURE_LOG_COOLDOWN_MS;
+var observations, nextId, projectDir, searchIndexPrepared, vectorMissingIds, vectorBackfillRunning, vectorSchemaUpgradePromise, lastVectorBackfill, embeddingFailureLogTimestamps, EMBEDDING_FAILURE_LOG_COOLDOWN_MS;
 var init_observations = __esm({
   "src/memory/observations.ts"() {
     "use strict";
@@ -18865,6 +19080,7 @@ var init_observations = __esm({
     searchIndexPrepared = false;
     vectorMissingIds = /* @__PURE__ */ new Set();
     vectorBackfillRunning = false;
+    vectorSchemaUpgradePromise = null;
     lastVectorBackfill = null;
     embeddingFailureLogTimestamps = /* @__PURE__ */ new Map();
     EMBEDDING_FAILURE_LOG_COOLDOWN_MS = 3e4;
@@ -19574,11 +19790,8 @@ function normalizeSearchMode(raw) {
 }
 async function prepareProjectSearch(projectId, dataDir) {
   if (preparedProjects.has(projectId)) return;
-  await initObservationStore(dataDir);
   await initObservations(dataDir);
-  await getDb();
-  const allObs = getAllObservations();
-  await hydrateIndex(allObs);
+  await prepareSearchIndex();
   preparedProjects.add(projectId);
 }
 function executeSearchMemories(args, ctx) {
@@ -19984,7 +20197,6 @@ var init_chat_service = __esm({
     init_provider2();
     init_observations();
     init_detector();
-    init_obs_store();
     init_orama_store();
     init_persistence();
     SEARCH_LIMIT = 6;
@@ -21931,6 +22143,7 @@ __export(installers_exports, {
   getProjectConfigPath: () => getProjectConfigPath,
   installAgentGuidance: () => installAgentGuidance,
   installHooks: () => installHooks,
+  resolveOpenCodeHookCommand: () => resolveOpenCodeHookCommand,
   uninstallHooks: () => uninstallHooks
 });
 import * as fs9 from "fs/promises";
@@ -21943,6 +22156,22 @@ function resolveHookCommand() {
   }
   return "memorix";
 }
+function resolveWindowsMemorixShim() {
+  try {
+    const output = String(execSync2("where.exe memorix.cmd", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    }));
+    return output.split(/\r?\n/).map((candidate) => candidate.trim()).find((candidate) => path13.isAbsolute(candidate)) ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveOpenCodeHookCommand(platform2 = process.platform, resolveWindowsShim = resolveWindowsMemorixShim) {
+  if (platform2 !== "win32") return "memorix";
+  return resolveWindowsShim() ?? "memorix.cmd";
+}
 function generateClaudeConfig() {
   const cmd = `${resolveHookCommand()} hook`;
   const hookEntry = {
@@ -22142,6 +22371,7 @@ async function installOfficialSkillsForAgent(agent, projectRoot, global2 = false
   return skillPaths;
 }
 function generateOpenCodePlugin() {
+  const hookCommand = JSON.stringify(resolveOpenCodeHookCommand());
   return `/**
  * Memorix - Cross-Agent Memory Bridge Plugin for OpenCode
  * @generated-version ${OPENCODE_PLUGIN_VERSION}
@@ -22160,6 +22390,16 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
   const sessionId = \`opencode-\${Date.now().toString(36)}-\${Math.random().toString(36).slice(2, 8)}\`;
   let pendingAssistantResponse = null;
   let lastDeliveredAssistantKey = '';
+  let hookFailureReported = false;
+  const hookCommand = ${hookCommand};
+
+  function reportHookFailure(eventName, detail) {
+    // OpenCode renders console.error output inside the conversation. Delivery is
+    // best-effort, so keep normal sessions quiet while retaining opt-in diagnostics.
+    if (process.env.MEMORIX_HOOK_DEBUG !== '1' || hookFailureReported) return;
+    hookFailureReported = true;
+    console.error('[memorix-plugin] hook delivery failed:', eventName, detail);
+  }
 
   /**
    * Send event JSON to \`memorix hook\` via child_process.spawnSync.
@@ -22175,8 +22415,7 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
     const data = JSON.stringify(payload);
     const eventName = payload.hook_event_name || 'unknown';
     try {
-      const cmd = process.platform === 'win32' ? 'memorix.cmd' : 'memorix';
-      const result = spawnSync(cmd, ['hook'], {
+      const result = spawnSync(hookCommand, ['hook'], {
         input: data,
         timeout: 10_000,
         encoding: 'utf-8',
@@ -22184,12 +22423,14 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
         shell: process.platform === 'win32',
       });
       if (result.status !== 0) {
-        console.error('[memorix-plugin] hook failed:', eventName,
-          'exit=', result.status,
-          'stderr=', (result.stderr || '').slice(0, 200));
+        reportHookFailure(eventName, {
+          exit: result.status,
+          stderr: (result.stderr || '').slice(0, 200),
+          error: result.error?.message,
+        });
       }
     } catch (e) {
-      console.error('[memorix-plugin] hook delivery failed:', eventName, e?.message ?? e);
+      reportHookFailure(eventName, e?.message ?? e);
     }
   }
 
@@ -23016,7 +23257,7 @@ var init_installers = __esm({
     "use strict";
     init_esm_shims();
     init_official_skills();
-    OPENCODE_PLUGIN_VERSION = 6;
+    OPENCODE_PLUGIN_VERSION = 7;
     AGENT_SKILL_DIRS = {
       cursor: { project: path13.join(".cursor", "skills"), global: path13.join(".cursor", "skills") },
       windsurf: { project: path13.join(".windsurf", "skills"), global: path13.join(".windsurf", "skills") },
@@ -23044,7 +23285,8 @@ __export(setup_exports, {
   installOmpPackage: () => installOmpPackage,
   installOpenClawBundlePackage: () => installOpenClawBundlePackage,
   installPiPackage: () => installPiPackage,
-  installPluginPackage: () => installPluginPackage
+  installPluginPackage: () => installPluginPackage,
+  tryInstallCodexPlugin: () => tryInstallCodexPlugin
 });
 import { spawnSync } from "child_process";
 import { existsSync as existsSync9 } from "fs";
@@ -23068,7 +23310,7 @@ function buildSetupPlan(options2) {
   if (wantsPlugin && options2.agent !== "all") {
     if (options2.agent === "opencode") {
       actions.push("opencode-local-plugin");
-    } else if (PLUGIN_PACKAGE_AGENTS.has(options2.agent)) {
+    } else if (PLUGIN_PACKAGE_AGENTS.has(options2.agent) && options2.global) {
       actions.push("plugin-package");
     } else if (EXTENSION_PACKAGE_AGENTS.has(options2.agent)) {
       actions.push("extension-package");
@@ -23142,6 +23384,16 @@ async function stripHookCaptureFromPlugin(pluginPath, agent) {
   } catch {
   }
 }
+async function stampCodexPluginVersion(pluginPath) {
+  const manifestPath = path14.join(pluginPath, ".codex-plugin", "plugin.json");
+  const manifest = JSON.parse(await readFile5(manifestPath, "utf-8"));
+  if (manifest.name !== "memorix") {
+    throw new Error(`Unexpected Codex plugin manifest at ${manifestPath}`);
+  }
+  manifest.version = getCliVersion();
+  await writeFile5(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
+}
 async function stripHookCaptureFromOpenClawBundle(bundlePath) {
   await rm(path14.join(bundlePath, "hooks"), { recursive: true, force: true });
   const manifestPath = path14.join(bundlePath, ".codex-plugin", "plugin.json");
@@ -23406,6 +23658,7 @@ async function installPluginPackage(options2) {
     const pluginPath2 = path14.join(home, ".codex", "plugins", "memorix");
     const marketplacePath2 = path14.join(home, ".agents", "plugins", "marketplace.json");
     await copyDir(source, pluginPath2);
+    await stampCodexPluginVersion(pluginPath2);
     if (!includeHooks) await stripHookCaptureFromPlugin(pluginPath2, "codex");
     await writeOfficialSkills(path14.join(pluginPath2, "skills"));
     await upsertCodexMarketplace(marketplacePath2, pluginPath2);
@@ -23745,6 +23998,9 @@ async function installAgentSetup(agent, plan, global2) {
   const hasHermesPlugin = plan.actions.includes("hermes-plugin") && agent === "hermes";
   const hasOmpPackage = plan.actions.includes("omp-package") && agent === "omp";
   const wantsMcpConfig = plan.mcp !== "none" && agent !== "pi";
+  if (PLUGIN_PACKAGE_AGENTS.has(agent) && plan.includePlugin && !global2) {
+    v3.info(`${agent}: project setup leaves user-level plugins untouched. Run \`memorix setup --agent ${agent} --global\` to install its plugin, skills, and lifecycle hooks.`);
+  }
   if (hasPluginPackage) {
     const result = await installPluginPackage({
       agent,
@@ -24030,7 +24286,8 @@ var init_setup = __esm({
             mcp,
             hooks: !args.noHooks,
             rules: !args.noRules,
-            plugin: !args.noPlugin
+            plugin: !args.noPlugin,
+            global: Boolean(args.global)
           });
           await installAgentSetup(agent, plan, Boolean(args.global));
         }
@@ -63609,7 +63866,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.1.11" : "1.0.1"
+    version: true ? "1.1.13" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -70349,6 +70606,8 @@ function extractEventName(payload, agent) {
       return payload.hook_event_name ?? inferCursorEvent(payload);
     case "claude":
       return payload.hook_event_name ?? "";
+    case "codex":
+      return payload.hook_event_name ?? "";
     case "antigravity":
     case "gemini-cli":
       return payload._memorix_event ?? payload.hook_event_name ?? "";
@@ -70397,6 +70656,13 @@ function normalizeClaude(payload, event) {
   if (payload.prompt) {
     result.userPrompt = payload.prompt;
   }
+  const assistantMessage = firstString(
+    payload.last_assistant_message,
+    payload.assistant_message
+  );
+  if (assistantMessage) {
+    result.aiResponse = assistantMessage;
+  }
   return result;
 }
 function normalizeWindsurf(payload, event) {
@@ -71213,6 +71479,7 @@ var init_significance_filter = __esm({
 var handler_exports = {};
 __export(handler_exports, {
   TYPE_EMOJI: () => TYPE_EMOJI2,
+  formatHookOutput: () => formatHookOutput,
   handleHookEvent: () => handleHookEvent,
   resetCooldowns: () => resetCooldowns,
   runHook: () => runHook
@@ -71465,6 +71732,38 @@ async function handleHookEvent(input) {
     output: defaultOutput
   };
 }
+function formatHookOutput(agent, rawEventName, output) {
+  if (agent === "codex") {
+    const codexOutput = { continue: output.continue };
+    if (output.stopReason) codexOutput.stopReason = output.stopReason;
+    if (rawEventName === "SessionStart" && output.systemMessage) {
+      codexOutput.hookSpecificOutput = {
+        hookEventName: "SessionStart",
+        additionalContext: output.systemMessage
+      };
+    }
+    return codexOutput;
+  }
+  const finalOutput = { ...output };
+  const hookSpecificOutputEvents = /* @__PURE__ */ new Set([
+    "PreToolUse",
+    "UserPromptSubmit",
+    "PostToolUse",
+    "postToolUse",
+    "preToolUse",
+    "userPromptSubmitted"
+  ]);
+  if (rawEventName && hookSpecificOutputEvents.has(rawEventName)) {
+    const hookSpecificOutput = { hookEventName: rawEventName };
+    if (output.systemMessage) {
+      hookSpecificOutput.additionalContext = output.systemMessage;
+    } else if (rawEventName === "UserPromptSubmit") {
+      hookSpecificOutput.additionalContext = "";
+    }
+    finalOutput.hookSpecificOutput = hookSpecificOutput;
+  }
+  return finalOutput;
+}
 async function runHook(agentOverride, eventOverride) {
   const rawInput = await new Promise((resolve4) => {
     const chunks = [];
@@ -71597,21 +71896,11 @@ ${emoji2} Memorix saved: ${observation.title} [${observation.type}]`;
     }
   }
   const rawEventName = payload._memorix_event ?? payload.hook_event_name ?? payload.hookEventName ?? "";
-  const finalOutput = { ...output };
   if (input.agent === "antigravity") {
     process.stdout.write(JSON.stringify(toAntigravityHookOutput(rawEventName, output)));
     return;
   }
-  const HSO_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "UserPromptSubmit", "PostToolUse", "postToolUse", "preToolUse", "userPromptSubmitted"]);
-  if (rawEventName && HSO_EVENTS.has(rawEventName)) {
-    const hso = { hookEventName: rawEventName };
-    if (output.systemMessage) {
-      hso.additionalContext = output.systemMessage;
-    } else if (rawEventName === "UserPromptSubmit") {
-      hso.additionalContext = "";
-    }
-    finalOutput.hookSpecificOutput = hso;
-  }
+  const finalOutput = formatHookOutput(input.agent, rawEventName, output);
   process.stdout.write(JSON.stringify(finalOutput));
 }
 function toAntigravityHookOutput(rawEventName, output) {
@@ -71770,6 +72059,7 @@ async function installSingleAgent2(agent, cwd, global2) {
 function getAgentLabel2(agent) {
   const labels = {
     claude: "Claude Code",
+    codex: "Codex",
     windsurf: "Windsurf",
     cursor: "Cursor",
     copilot: "VS Code Copilot",
@@ -71798,7 +72088,7 @@ function getAgentHint2(agent) {
     hermes: "Hermes plugin hooks; use `memorix setup --agent hermes`",
     omp: "Oh-my-Pi package hooks; use `memorix setup --agent omp`",
     trae: ".trae/rules/project_rules.md (rules only, no hooks system)",
-    codex: "AGENTS.md (rules only, hooks are experimental)"
+    codex: "Codex plugin hooks; use `memorix setup --agent codex`"
   };
   return hints[agent] || "";
 }
@@ -73630,8 +73920,10 @@ __export(agent_integrations_exports, {
   formatAgentIntegrationReport: () => formatAgentIntegrationReport,
   formatAgentRepairResult: () => formatAgentRepairResult,
   inspectAgentIntegrations: () => inspectAgentIntegrations,
+  parseCodexPluginList: () => parseCodexPluginList,
   repairAgentIntegrations: () => repairAgentIntegrations
 });
+import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync23 } from "fs";
 import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
 import { basename as basename3, dirname as dirname7, resolve as resolve2 } from "path";
@@ -73709,6 +74001,275 @@ function aggregateGuidanceIssues(checks) {
 function asRecord2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
+function asRecordArray(value) {
+  return Array.isArray(value) ? value.map(asRecord2).filter((entry) => entry !== null) : [];
+}
+function codexPluginPath() {
+  return `${homedir32()}/.codex/plugins/${CODEX_PLUGIN_NAME}`;
+}
+function codexMarketplacePath() {
+  return `${homedir32()}/.agents/plugins/marketplace.json`;
+}
+function codexConfigPath() {
+  return `${homedir32()}/.codex/config.toml`;
+}
+function normalizeMarketplacePath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isMemorixCodexPlugin(value) {
+  return value.pluginId === CODEX_PLUGIN_ID || value.name === CODEX_PLUGIN_NAME && value.marketplaceName === CODEX_PLUGIN_MARKETPLACE;
+}
+function parseCodexPluginList(output) {
+  try {
+    const parsed = asRecord2(JSON.parse(output));
+    if (!parsed) return null;
+    const entries = [...asRecordArray(parsed.installed), ...asRecordArray(parsed.available)];
+    const plugin = entries.find(isMemorixCodexPlugin);
+    if (!plugin) return { installed: false, enabled: false };
+    return {
+      installed: plugin.installed === true,
+      enabled: plugin.enabled === true,
+      ...typeof plugin.version === "string" ? { version: plugin.version } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+async function inspectCodexPluginBundle() {
+  const pluginPath = codexPluginPath();
+  const manifestPath = `${pluginPath}/.codex-plugin/plugin.json`;
+  const hooksPath = `${pluginPath}/hooks/hooks.json`;
+  if (!existsSync23(pluginPath)) {
+    return {
+      scope: "global",
+      kind: "bundle",
+      path: pluginPath,
+      exists: false,
+      status: "missing",
+      issues: ["codex-plugin-bundle-missing"]
+    };
+  }
+  if (!existsSync23(manifestPath)) {
+    return {
+      scope: "global",
+      kind: "bundle",
+      path: manifestPath,
+      exists: false,
+      status: "repairable",
+      issues: ["codex-plugin-manifest-missing"]
+    };
+  }
+  let manifest = null;
+  try {
+    manifest = asRecord2(JSON.parse(await readFile7(manifestPath, "utf-8")));
+  } catch {
+    return {
+      scope: "global",
+      kind: "bundle",
+      path: manifestPath,
+      exists: true,
+      status: "repairable",
+      issues: ["codex-plugin-manifest-unreadable"]
+    };
+  }
+  if (!manifest || manifest.name !== CODEX_PLUGIN_NAME) {
+    return {
+      scope: "global",
+      kind: "bundle",
+      path: manifestPath,
+      exists: true,
+      status: "repairable",
+      issues: ["codex-plugin-manifest-invalid"]
+    };
+  }
+  const version2 = typeof manifest.version === "string" ? manifest.version : void 0;
+  const issues = [];
+  if (version2 !== getCliVersion()) issues.push("codex-plugin-version-mismatch");
+  if (manifest.hooks !== "./hooks/hooks.json") issues.push("codex-hook-manifest-missing");
+  let declared = [];
+  if (!existsSync23(hooksPath)) {
+    issues.push("codex-hook-manifest-missing");
+  } else {
+    try {
+      const hooksConfig = asRecord2(JSON.parse(await readFile7(hooksPath, "utf-8")));
+      const hooks = asRecord2(hooksConfig?.hooks);
+      declared = hooks ? Object.keys(hooks) : [];
+      if (CODEX_HOOK_EVENTS.some((event) => !declared.includes(event))) {
+        issues.push("codex-hook-events-missing");
+      }
+    } catch {
+      issues.push("codex-hook-manifest-unreadable");
+    }
+  }
+  return {
+    scope: "global",
+    kind: "bundle",
+    path: pluginPath,
+    exists: true,
+    status: issues.length > 0 ? "repairable" : "ok",
+    issues: unique(issues),
+    ...version2 ? { version: version2 } : {},
+    hooks: { declared, expected: [...CODEX_HOOK_EVENTS] }
+  };
+}
+async function inspectCodexMarketplace() {
+  const marketplacePath = codexMarketplacePath();
+  if (!existsSync23(marketplacePath)) {
+    return {
+      scope: "global",
+      kind: "marketplace",
+      path: marketplacePath,
+      exists: false,
+      status: "missing",
+      issues: ["codex-marketplace-missing"]
+    };
+  }
+  let catalog = null;
+  try {
+    catalog = asRecord2(JSON.parse(await readFile7(marketplacePath, "utf-8")));
+  } catch {
+    return {
+      scope: "global",
+      kind: "marketplace",
+      path: marketplacePath,
+      exists: true,
+      status: "repairable",
+      issues: ["codex-marketplace-unreadable"]
+    };
+  }
+  const entry = asRecordArray(catalog?.plugins).find((plugin) => plugin.name === CODEX_PLUGIN_NAME);
+  if (!entry) {
+    return {
+      scope: "global",
+      kind: "marketplace",
+      path: marketplacePath,
+      exists: true,
+      status: "repairable",
+      issues: ["codex-marketplace-entry-missing"]
+    };
+  }
+  const source = asRecord2(entry.source);
+  const sourcePath = typeof source?.path === "string" ? source.path : "";
+  const issues = source?.source === "local" && normalizeMarketplacePath(sourcePath) === ".codex/plugins/memorix" ? [] : ["codex-marketplace-entry-stale"];
+  return {
+    scope: "global",
+    kind: "marketplace",
+    path: marketplacePath,
+    exists: true,
+    status: issues.length > 0 ? "repairable" : "ok",
+    issues
+  };
+}
+function inspectCodexPluginRuntime() {
+  const command = "codex plugin list --marketplace personal --available --json";
+  const result = spawnSync2("codex", ["plugin", "list", "--marketplace", CODEX_PLUGIN_MARKETPLACE, "--available", "--json"], {
+    encoding: "utf-8",
+    stdio: "pipe",
+    shell: process.platform === "win32"
+  });
+  if (result.error || result.status !== 0) {
+    return {
+      scope: "global",
+      kind: "runtime",
+      path: command,
+      exists: false,
+      status: "skipped",
+      issues: ["codex-plugin-runtime-unavailable"]
+    };
+  }
+  const runtime = parseCodexPluginList(String(result.stdout ?? ""));
+  if (!runtime) {
+    return {
+      scope: "global",
+      kind: "runtime",
+      path: command,
+      exists: true,
+      status: "skipped",
+      issues: ["codex-plugin-runtime-unreadable"]
+    };
+  }
+  const issues = [];
+  if (!runtime.installed) issues.push("codex-plugin-not-installed");
+  else if (!runtime.enabled) issues.push("codex-plugin-disabled");
+  return {
+    scope: "global",
+    kind: "runtime",
+    path: command,
+    exists: true,
+    status: issues.length > 0 ? "repairable" : "ok",
+    issues,
+    runtime
+  };
+}
+async function inspectCodexHookTrust() {
+  const configPath = codexConfigPath();
+  if (!existsSync23(configPath)) {
+    return {
+      scope: "global",
+      kind: "hook-trust",
+      path: configPath,
+      exists: false,
+      status: "skipped",
+      issues: ["codex-hook-trust-unavailable"]
+    };
+  }
+  let config2 = "";
+  try {
+    config2 = await readFile7(configPath, "utf-8");
+  } catch {
+    return {
+      scope: "global",
+      kind: "hook-trust",
+      path: configPath,
+      exists: true,
+      status: "skipped",
+      issues: ["codex-hook-trust-unreadable"]
+    };
+  }
+  const trusted = CODEX_HOOK_STATE_NAMES.filter(
+    (event) => config2.includes(`[hooks.state."${CODEX_PLUGIN_ID}:hooks/hooks.json:${event}:`)
+  );
+  const issues = trusted.length === CODEX_HOOK_STATE_NAMES.length ? [] : ["codex-hook-trust-pending"];
+  return {
+    scope: "global",
+    kind: "hook-trust",
+    path: configPath,
+    exists: true,
+    status: issues.length > 0 ? "repairable" : "ok",
+    issues,
+    hookTrust: { trusted, expected: [...CODEX_HOOK_STATE_NAMES] }
+  };
+}
+function aggregatePluginStatus(checks) {
+  if (checks.length === 0) return "skipped";
+  return worstStatus(checks.map((check2) => check2.status));
+}
+function aggregatePluginIssues(checks) {
+  const status = aggregatePluginStatus(checks);
+  if (status === "ok") {
+    return unique(checks.filter((check2) => check2.status === "skipped").flatMap((check2) => check2.issues));
+  }
+  if (status === "repairable") {
+    return unique(checks.filter((check2) => check2.status === "repairable" || check2.status === "missing").flatMap((check2) => check2.issues));
+  }
+  return unique(checks.filter((check2) => check2.status === status).flatMap((check2) => check2.issues));
+}
+async function inspectPlugin(agent, scope) {
+  if (agent !== "codex" || scope === "local" || scope === "project") {
+    return { status: "skipped", issues: [], checks: [] };
+  }
+  const checks = [
+    await inspectCodexPluginBundle(),
+    await inspectCodexMarketplace(),
+    inspectCodexPluginRuntime(),
+    await inspectCodexHookTrust()
+  ];
+  return {
+    status: aggregatePluginStatus(checks),
+    issues: aggregatePluginIssues(checks),
+    checks
+  };
+}
 function looksLikeStaleMemorixCommand(server) {
   const text = [server.command, ...server.args ?? []].join(" ");
   return /[\\/]\.worktrees[\\/]/i.test(text) || /[\\/]dist[\\/]cli[\\/]index\.js/i.test(text);
@@ -73977,10 +74538,11 @@ async function inspectAgentIntegrations(options2 = {}) {
     entries.push({
       agent,
       mcp: await inspectMcp(agent, projectRoot, scope),
-      guidance: await inspectGuidance(agent, projectRoot, scope)
+      guidance: await inspectGuidance(agent, projectRoot, scope),
+      plugin: await inspectPlugin(agent, scope)
     });
   }
-  const entryStatuses = entries.map((entry) => worstStatus([entry.mcp.status, entry.guidance.status]));
+  const entryStatuses = entries.map((entry) => worstStatus([entry.mcp.status, entry.guidance.status, entry.plugin.status]));
   return {
     projectRoot,
     scope,
@@ -74002,10 +74564,11 @@ function formatAgentIntegrationReport(report) {
     ""
   ];
   for (const entry of report.entries) {
-    const status = worstStatus([entry.mcp.status, entry.guidance.status]);
+    const status = worstStatus([entry.mcp.status, entry.guidance.status, entry.plugin.status]);
     lines.push(`${entry.agent}: ${status}`);
     if (entry.mcp.issues.length > 0) lines.push(`  MCP: ${entry.mcp.issues.join(", ")}`);
     if (entry.guidance.issues.length > 0) lines.push(`  Guidance: ${entry.guidance.issues.join(", ")}`);
+    if (entry.plugin.issues.length > 0) lines.push(`  Plugin: ${entry.plugin.issues.join(", ")}`);
   }
   lines.push("");
   lines.push(`Repair: ${report.repairCommand}`);
@@ -74058,6 +74621,39 @@ async function repairAgentIntegrations(options2 = {}) {
     } else {
       skipped.push(`${entry.agent}:guidance`);
     }
+    if (entry.agent === "codex" && entry.plugin.status !== "ok" && entry.plugin.status !== "skipped") {
+      const bundleOrMarketplaceNeedsRepair = entry.plugin.checks.some(
+        (check2) => (check2.kind === "bundle" || check2.kind === "marketplace") && check2.status !== "ok"
+      );
+      const runtime = entry.plugin.checks.find((check2) => check2.kind === "runtime");
+      const hookTrust = entry.plugin.checks.find((check2) => check2.kind === "hook-trust");
+      const needsInstall = runtime?.runtime?.installed === false;
+      const needsManualEnable = runtime?.runtime?.installed === true && runtime.runtime.enabled === false;
+      const needsHookTrust = hookTrust?.status === "repairable";
+      const missingPluginFiles = entry.plugin.checks.some(
+        (check2) => (check2.kind === "bundle" || check2.kind === "marketplace") && check2.status === "missing"
+      );
+      if (needsManualEnable) {
+        skipped.push("codex:plugin:global:enable-in-plugin-browser");
+      }
+      if (needsHookTrust) {
+        skipped.push("codex:plugin:global:review-hooks");
+      }
+      if (bundleOrMarketplaceNeedsRepair || needsInstall) {
+        if ((missingPluginFiles || needsInstall) && !canInstallMissing) {
+          skipped.push("codex:plugin:global:missing");
+        } else {
+          if (!options2.dry) {
+            await installPluginPackage({ agent: "codex" });
+            if (needsInstall) {
+              const install = tryInstallCodexPlugin();
+              if (!install.ok) skipped.push("codex:plugin:global:install-pending");
+            }
+          }
+          changed.push("codex:plugin:global");
+        }
+      }
+    }
   }
   return {
     projectRoot,
@@ -74088,13 +74684,14 @@ function formatAgentRepairResult(result) {
   }
   return lines.join("\n");
 }
-var GUIDANCE_AGENTS;
+var GUIDANCE_AGENTS, CODEX_PLUGIN_NAME, CODEX_PLUGIN_MARKETPLACE, CODEX_PLUGIN_ID, CODEX_HOOK_EVENTS, CODEX_HOOK_STATE_NAMES;
 var init_agent_integrations = __esm({
   "src/cli/commands/agent-integrations.ts"() {
     "use strict";
     init_esm_shims();
     init_installers();
     init_setup();
+    init_version();
     GUIDANCE_AGENTS = /* @__PURE__ */ new Set([
       "claude",
       "codex",
@@ -74107,6 +74704,11 @@ var init_agent_integrations = __esm({
       "opencode",
       "trae"
     ]);
+    CODEX_PLUGIN_NAME = "memorix";
+    CODEX_PLUGIN_MARKETPLACE = "personal";
+    CODEX_PLUGIN_ID = `${CODEX_PLUGIN_NAME}@${CODEX_PLUGIN_MARKETPLACE}`;
+    CODEX_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PostToolUse", "PreCompact", "Stop"];
+    CODEX_HOOK_STATE_NAMES = ["session_start", "user_prompt_submit", "post_tool_use", "pre_compact", "stop"];
   }
 });
 
@@ -80450,6 +81052,7 @@ function formatSearchModeLabel(mode) {
 }
 function formatEmbeddingLabel(status, providerName) {
   if (status === "disabled") return "Disabled";
+  if (status === "pending") return "On demand";
   if (status === "unavailable") return "Unavailable";
   if ((providerName || "").startsWith("api-")) return "API ready";
   if (providerName) return "Local ready";
@@ -80519,8 +81122,8 @@ async function getHealthInfo(projectId) {
       if (isEmbeddingExplicitlyDisabled2()) {
         defaults.embeddingProvider = "disabled";
       } else {
-        const provider2 = await getEmbeddingProvider2();
-        defaults.embeddingProvider = provider2 ? "ready" : "unavailable";
+        const provider2 = await getEmbeddingProvider2({ allowNetworkProbe: false });
+        defaults.embeddingProvider = provider2 ? "ready" : "pending";
         defaults.embeddingProviderName = provider2?.name;
       }
       defaults.embeddingLabel = formatEmbeddingLabel(
@@ -80548,6 +81151,8 @@ async function getHealthInfo(projectId) {
         defaults.searchDiagnostic = "Vector index ready";
       } else if (defaults.embeddingProvider === "ready" && !vectorActive) {
         defaults.searchDiagnostic = "Provider ready, no index yet";
+      } else if (defaults.embeddingProvider === "pending") {
+        defaults.searchDiagnostic = "BM25 ready; embeddings initialize on demand";
       } else if (defaults.embeddingProvider === "unavailable") {
         defaults.searchDiagnostic = "BM25 only (no provider)";
       } else {
@@ -80591,19 +81196,15 @@ async function getRecentMemories(limit = 8, projectId) {
 }
 async function searchMemories(query, limit = 10) {
   try {
-    const { searchObservations: searchObservations2, getDb: getDb2, hydrateIndex: hydrateIndex2 } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
+    const { searchObservations: searchObservations2 } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
     const { getProjectDataDir: getProjectDataDir2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
     const { detectProject: detectProject2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
-    const { initObservations: initObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
-    const { initObservationStore: initObservationStore2, getObservationStore: getStore } = await Promise.resolve().then(() => (init_obs_store(), obs_store_exports));
+    const { initObservations: initObservations2, prepareSearchIndex: prepareSearchIndex2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
     const proj = detectProject2(process.cwd());
     if (!proj) return [];
     const dataDir = await getProjectDataDir2(proj.id);
-    await initObservationStore2(dataDir);
     await initObservations2(dataDir);
-    await getDb2();
-    const allObs = await getStore().loadAll();
-    await hydrateIndex2(allObs);
+    await prepareSearchIndex2();
     const results = await searchObservations2({ query, limit, projectId: proj.id });
     const typeIcons = {
       gotcha: "!",