memorix 1.1.11 → 1.1.13

package/dist/memcode-runtime/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to this project will be documented in this file.
 
+## [Unreleased]
+
+## [1.1.13] - 2026-07-17
+
+### Added
+- **Codex installation proof** -- `memorix doctor agents --agent codex --scope global` now checks the local plugin bundle, Personal marketplace entry, five declared and trusted lifecycle hooks, and the installed/enabled state reported by `codex plugin list`.
+
+### Fixed
+- **Codex plugin version drift** -- Global setup now stamps the copied Codex plugin manifest with the installed Memorix version, so Codex no longer reports the old template version after an upgrade. The source template is covered by a release regression test as well.
+- **Workspace package publish trap** -- `@memorix/ai`, `@memorix/agent-core`, `@memorix/tui`, and `@memorix/memcode` are now explicitly internal workspaces. The root `memorix` package ships their bundled runtime, and the release workflow publishes only that supported public package.
+
+## [1.1.12] - 2026-07-17
+
+### Added
+- **Codex lifecycle hook capture** -- The Memorix Codex plugin now bundles the documented `SessionStart`, `UserPromptSubmit`, `PostToolUse`, `PreCompact`, and `Stop` hook events, with a Windows-safe `commandWindows` command override.
+
+### Fixed
+- **Codex hook normalization and injection** -- Codex lifecycle payloads now preserve their event names, `SessionStart` returns Codex-native `hookSpecificOutput.additionalContext`, and capture-only events stay quiet instead of filling the agent context with save-status messages.
+- **OpenCode hooks on Windows** -- The generated plugin resolves the installed npm `memorix.cmd` shim while setup runs and uses that stable path inside OpenCode, instead of relying on OpenCode's inherited `PATH`. Hook delivery stays quiet unless `MEMORIX_HOOK_DEBUG=1` is explicitly set. Fixes #125.
+- **Setup scope isolation** -- Project-level setup no longer installs Claude, Codex, or Copilot plugin bundles in the user home. Use `--global` for user-level plugins, skills, and lifecycle hooks.
+- **TUI embedding startup** -- TUI health, chat, and quick-search paths now use the same lexical-ready startup flow as MCP instead of making a remote dimension probe during the first screen or search.
+- **Semantic recall after restart** -- API-backed embeddings now restore compatible vectors from the local cache during index hydration, without placing remote embedding calls on the MCP startup path. Redundant namespace-scoped cache metadata survives a lost dimensions cache; cache misses enter the existing bounded background recovery lane, and the first successful vector upgrades a cache-less lexical index in the same process. Based on the diagnosis in #126 by @Tom-Ma-Ming.
+- **Concurrent index startup** -- Cache-only startup and ordinary database callers now share one Orama initialization, so a later vector-schema attempt cannot replace an already hydrated lexical index. Resets also discard obsolete in-flight instances.
+- **Lazy API vector-cache I/O** -- A cache-only start with no trusted dimension metadata now skips parsing the potentially large API vector cache entirely; the cache is loaded only after compatible local metadata or a normal embedding initialization establishes its dimensions.
+
 ## [1.1.11] - 2026-07-16
 
 ### Added

package/dist/memcode-runtime/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "@memorix/memcode",
-	"version": "1.1.11",
+	"version": "1.1.12",
+	"private": true,
 	"description": "Memorix-native coding agent CLI with terminal chat, project memory, hooks, and session management",
 	"type": "module",
 	"piConfig": {
@@ -34,9 +35,9 @@
 		"prepublishOnly": "npm run clean && npm run build"
 	},
 	"dependencies": {
-		"@memorix/agent-core": "1.1.11",
-		"@memorix/ai": "1.1.11",
-		"@memorix/tui": "1.1.11",
+		"@memorix/agent-core": "1.1.12",
+		"@memorix/ai": "1.1.12",
+		"@memorix/tui": "1.1.12",
 		"@opentui/core": "^0.3.4",
 		"@opentui/react": "^0.3.4",
 		"@silvia-odwyer/photon-node": "0.3.4",

package/dist/sdk.js

@@ -2813,6 +2813,45 @@ function dimsCacheKey(config) {
     config.requestedDimensions ?? "native"
   ].join("|");
 }
+function isValidDimension(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+async function loadCachedVectorDimensions(config) {
+  try {
+    const raw = await readFile2(CACHE_META_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    const namespace = cacheNamespace(config);
+    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(config, 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(config);
+    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(config) {
   try {
     const raw = await readFile2(DIMS_CACHE_FILE, "utf-8");
@@ -2875,6 +2914,7 @@ async function saveCachedDims(config, dimensions) {
     await writeFile2(DIMS_CACHE_FILE, JSON.stringify({ entries }));
   } catch {
   }
+  await saveCachedVectorDimensions(config, dimensions);
 }
 async function saveDiskCacheNow() {
   if (!diskCacheDirty2) return;
@@ -2957,7 +2997,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";
@@ -2965,6 +3005,7 @@ var init_api_provider = __esm({
     CACHE_DIR2 = process.env.MEMORIX_DATA_DIR || join3(homedir7(), ".memorix", "data");
     CACHE_FILE2 = join3(CACHE_DIR2, ".embedding-api-cache.json");
     DIMS_CACHE_FILE = join3(CACHE_DIR2, ".embedding-dims-cache.json");
+    CACHE_META_FILE = join3(CACHE_DIR2, ".embedding-api-cache-meta.json");
     cache3 = /* @__PURE__ */ new Map();
     MAX_CACHE_SIZE3 = 1e4;
     diskCacheDirty2 = false;
@@ -2991,13 +3032,22 @@ var init_api_provider = __esm({
         this.dimensions = detectedDimensions;
         this.name = `api-${config.model.replace(/\//g, "-")}`;
       }
-      static async create() {
+      static async create(options = {}) {
         const config = _APIEmbeddingProvider.resolveConfig();
-        startDiskCacheLoad();
+        const allowNetworkProbe = options.allowNetworkProbe !== false;
         let probeDimensions = await loadCachedDims(config);
+        let dimensionSource = "dims-cache";
+        if (probeDimensions === null) {
+          probeDimensions = await loadCachedVectorDimensions(config);
+          if (probeDimensions !== null) dimensionSource = "vector-cache";
+        }
         if (probeDimensions !== null) {
-          console.error(`[memorix] API embedding: ${config.model} @ ${config.baseUrl} (${probeDimensions}d) [cached dims]`);
+          console.error(`[memorix] API embedding: ${config.model} @ ${config.baseUrl} (${probeDimensions}d) [${dimensionSource}]`);
+          if (dimensionSource === "dims-cache") {
+            void saveCachedVectorDimensions(config, probeDimensions);
+          }
         } else {
+          if (!allowNetworkProbe) return null;
           probeDimensions = await _APIEmbeddingProvider.probeAPI(config);
           console.error(`[memorix] API embedding: ${config.model} @ ${config.baseUrl} (${probeDimensions}d)`);
           saveCachedDims(config, probeDimensions).catch(() => {
@@ -3006,6 +3056,7 @@ var init_api_provider = __esm({
         if (config.requestedDimensions) {
           console.error(`[memorix] Dimension shortening: ${config.requestedDimensions}d requested`);
         }
+        startDiskCacheLoad();
         return new _APIEmbeddingProvider(config, probeDimensions);
       }
       static resolveConfig() {
@@ -3184,6 +3235,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,
@@ -3292,10 +3350,10 @@ async function createTransformersProvider() {
     return null;
   }
 }
-async function createAPIProvider() {
+async function createAPIProvider(options) {
   try {
     const { APIEmbeddingProvider: APIEmbeddingProvider2 } = await Promise.resolve().then(() => (init_api_provider(), api_provider_exports));
-    return await APIEmbeddingProvider2.create();
+    return await APIEmbeddingProvider2.create(options ?? {});
   } catch (e) {
     warnOnce(`[memorix] Failed to init API embedding: ${e instanceof Error ? e.message : e}`);
     return null;
@@ -3350,11 +3408,24 @@ function wrapProvider(candidate) {
         }
         throw error;
       }
-    }
+    },
+    ...candidate.getCachedEmbeddings ? {
+      async getCachedEmbeddings(texts) {
+        return candidate.getCachedEmbeddings(texts);
+      }
+    } : {}
   };
 }
-async function getEmbeddingProvider() {
+async function getEmbeddingProvider(options = {}) {
   if (provider) return provider;
+  if (options.allowNetworkProbe === false) {
+    const mode = getEmbeddingMode2();
+    if (mode !== "api" && !(mode === "auto" && hasAPIEmbeddingConfig())) {
+      return null;
+    }
+    const cached = await createAPIProvider({ allowNetworkProbe: false });
+    return cached ? wrapProvider(cached) : null;
+  }
   if (lastInitWasTemporaryFailure) {
     const elapsed = Date.now() - lastFailureTimestamp;
     if (elapsed < RETRY_COOLDOWN_MS) {
@@ -4867,12 +4938,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,
@@ -4933,11 +5007,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(options, generation) {
+  const provider2 = await getEmbeddingProvider({ allowNetworkProbe: options.allowNetworkProbe });
+  const nextEmbeddingEnabled = provider2 !== null;
+  const nextEmbeddingDimensions = provider2?.dimensions ?? null;
   const baseSchema = {
     id: "string",
     observationId: "number",
@@ -4960,15 +5033,39 @@ async function getDb() {
     documentType: "string",
     knowledgeLayer: "string"
   };
-  const dims = embeddingDimensions ?? 384;
-  const schema = embeddingEnabled ? { ...baseSchema, embedding: `vector[${dims}]` } : baseSchema;
-  db = await create({ schema });
-  return db;
+  const dims = nextEmbeddingDimensions ?? 384;
+  const schema = nextEmbeddingEnabled ? { ...baseSchema, embedding: `vector[${dims}]` } : baseSchema;
+  const nextDb = await create({ schema });
+  if (generation !== dbGeneration) {
+    return getDb(options);
+  }
+  indexEmbeddingProvider = provider2;
+  embeddingEnabled = nextEmbeddingEnabled;
+  embeddingDimensions = nextEmbeddingDimensions;
+  db = nextDb;
+  return nextDb;
+}
+async function getDb(options = {}) {
+  if (db) return db;
+  if (dbInitPromise) return dbInitPromise;
+  const initPromise2 = initializeDb(options, 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();
 }
@@ -4996,14 +5093,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, options = {}) {
+  const database = await getDb({ allowNetworkProbe: options.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 = options.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,
@@ -5022,7 +5169,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 insert2(database, doc);
       rememberObservationDoc(doc);
@@ -5030,8 +5178,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 insert2(database, doc);
@@ -5565,7 +5729,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";
@@ -5577,8 +5741,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();
@@ -7359,7 +7527,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;
@@ -7369,6 +7548,7 @@ async function initObservations(dir) {
   nextId = await store.loadIdCounter();
   projectDir = dir;
   searchIndexPrepared = false;
+  vectorSchemaUpgradePromise = null;
 }
 async function ensureFreshObservations() {
   if (!projectDir) return false;
@@ -7548,6 +7728,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(
@@ -7658,6 +7841,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));
@@ -7802,14 +7992,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 {
     }
@@ -7862,16 +8059,31 @@ async function reindexObservations() {
 }
 async function prepareSearchIndex() {
   if (searchIndexPrepared) return 0;
-  const count2 = await hydrateIndex(observations);
+  const count2 = await hydrateIndexForStartup(observations);
   if (count2 === 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 count2;
@@ -7931,6 +8143,9 @@ async function backfillVectorEmbeddings(options = {}) {
       try {
         const embedding = await generateEmbedding(text);
         if (embedding) {
+          if (!isVectorCompatibleWithCurrentIndex(embedding)) {
+            await upgradeVectorSchemaAfterFirstEmbedding(embedding);
+          }
           if (!isVectorCompatibleWithCurrentIndex(embedding)) {
             const vectorDimensions = getVectorDimensions();
             console.error(
@@ -7993,7 +8208,7 @@ async function backfillVectorEmbeddings(options = {}) {
   }
   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";
@@ -8011,6 +8226,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;
@@ -16434,6 +16650,7 @@ __export(installers_exports, {
   getProjectConfigPath: () => getProjectConfigPath,
   installAgentGuidance: () => installAgentGuidance,
   installHooks: () => installHooks,
+  resolveOpenCodeHookCommand: () => resolveOpenCodeHookCommand,
   uninstallHooks: () => uninstallHooks
 });
 import * as fs14 from "fs/promises";
@@ -16446,6 +16663,22 @@ function resolveHookCommand() {
   }
   return "memorix";
 }
+function resolveWindowsMemorixShim() {
+  try {
+    const output = String(execSync3("where.exe memorix.cmd", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    }));
+    return output.split(/\r?\n/).map((candidate) => candidate.trim()).find((candidate) => path19.isAbsolute(candidate)) ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveOpenCodeHookCommand(platform = process.platform, resolveWindowsShim = resolveWindowsMemorixShim) {
+  if (platform !== "win32") return "memorix";
+  return resolveWindowsShim() ?? "memorix.cmd";
+}
 function generateClaudeConfig() {
   const cmd = `${resolveHookCommand()} hook`;
   const hookEntry = {
@@ -16645,6 +16878,7 @@ async function installOfficialSkillsForAgent(agent, projectRoot, global = false)
   return skillPaths;
 }
 function generateOpenCodePlugin() {
+  const hookCommand = JSON.stringify(resolveOpenCodeHookCommand());
   return `/**
  * Memorix - Cross-Agent Memory Bridge Plugin for OpenCode
  * @generated-version ${OPENCODE_PLUGIN_VERSION}
@@ -16663,6 +16897,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.
@@ -16678,8 +16922,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',
@@ -16687,12 +16930,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);
     }
   }
 
@@ -17519,7 +17764,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: path19.join(".cursor", "skills"), global: path19.join(".cursor", "skills") },
       windsurf: { project: path19.join(".windsurf", "skills"), global: path19.join(".windsurf", "skills") },
@@ -21554,7 +21799,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) => {