memorix 1.1.11 → 1.1.13

package/src/cli/commands/agent-integrations.ts

@@ -1,3 +1,4 @@
+import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { basename, dirname, resolve } from 'node:path';
@@ -9,9 +10,12 @@ import {
   buildMemorixServer,
   getMcpAdapter,
   getSetupAgentTargets,
+  installPluginPackage,
   installMcpConfig,
+  tryInstallCodexPlugin,
   type McpConfigAgent,
 } from './setup.js';
+import { getCliVersion } from '../version.js';
 
 export type AgentIntegrationScope = 'local' | 'project' | 'global' | 'all';
 export type AgentIntegrationStatus = 'ok' | 'missing' | 'repairable' | 'skipped';
@@ -40,6 +44,35 @@ export interface AgentGuidanceCheck {
   issues: string[];
 }
 
+export interface AgentPluginCheck {
+  scope: 'global';
+  kind: 'bundle' | 'marketplace' | 'runtime' | 'hook-trust';
+  path: string;
+  exists: boolean;
+  status: AgentIntegrationStatus;
+  issues: string[];
+  version?: string;
+  hooks?: {
+    declared: string[];
+    expected: string[];
+  };
+  runtime?: {
+    installed: boolean;
+    enabled: boolean;
+    version?: string;
+  };
+  hookTrust?: {
+    trusted: string[];
+    expected: string[];
+  };
+}
+
+export interface AgentPluginStatus {
+  status: AgentIntegrationStatus;
+  issues: string[];
+  checks: AgentPluginCheck[];
+}
+
 export interface AgentIntegrationEntry {
   agent: AgentName;
   mcp: {
@@ -52,6 +85,7 @@ export interface AgentIntegrationEntry {
     issues: string[];
     checks: AgentGuidanceCheck[];
   };
+  plugin: AgentPluginStatus;
 }
 
 export interface AgentIntegrationReport {
@@ -89,6 +123,12 @@ const GUIDANCE_AGENTS = new Set<AgentName>([
   'trae',
 ]);
 
+const CODEX_PLUGIN_NAME = 'memorix';
+const CODEX_PLUGIN_MARKETPLACE = 'personal';
+const CODEX_PLUGIN_ID = `${CODEX_PLUGIN_NAME}@${CODEX_PLUGIN_MARKETPLACE}`;
+const CODEX_HOOK_EVENTS = ['SessionStart', 'UserPromptSubmit', 'PostToolUse', 'PreCompact', 'Stop'];
+const CODEX_HOOK_STATE_NAMES = ['session_start', 'user_prompt_submit', 'post_tool_use', 'pre_compact', 'stop'];
+
 type ConcreteAgentIntegrationScope = Exclude<AgentIntegrationScope, 'all'>;
 type JsonRecord = Record<string, unknown>;
 
@@ -179,6 +219,310 @@ function asRecord(value: unknown): JsonRecord | null {
   return value && typeof value === 'object' && !Array.isArray(value) ? value as JsonRecord : null;
 }
 
+function asRecordArray(value: unknown): JsonRecord[] {
+  return Array.isArray(value)
+    ? value.map(asRecord).filter((entry): entry is JsonRecord => entry !== null)
+    : [];
+}
+
+function codexPluginPath(): string {
+  return `${homedir()}/.codex/plugins/${CODEX_PLUGIN_NAME}`;
+}
+
+function codexMarketplacePath(): string {
+  return `${homedir()}/.agents/plugins/marketplace.json`;
+}
+
+function codexConfigPath(): string {
+  return `${homedir()}/.codex/config.toml`;
+}
+
+function normalizeMarketplacePath(value: string): string {
+  return value.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+function isMemorixCodexPlugin(value: JsonRecord): boolean {
+  return value.pluginId === CODEX_PLUGIN_ID
+    || (value.name === CODEX_PLUGIN_NAME && value.marketplaceName === CODEX_PLUGIN_MARKETPLACE);
+}
+
+export function parseCodexPluginList(output: string): AgentPluginCheck['runtime'] | null {
+  try {
+    const parsed = asRecord(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(): Promise<AgentPluginCheck> {
+  const pluginPath = codexPluginPath();
+  const manifestPath = `${pluginPath}/.codex-plugin/plugin.json`;
+  const hooksPath = `${pluginPath}/hooks/hooks.json`;
+  if (!existsSync(pluginPath)) {
+    return {
+      scope: 'global',
+      kind: 'bundle',
+      path: pluginPath,
+      exists: false,
+      status: 'missing',
+      issues: ['codex-plugin-bundle-missing'],
+    };
+  }
+  if (!existsSync(manifestPath)) {
+    return {
+      scope: 'global',
+      kind: 'bundle',
+      path: manifestPath,
+      exists: false,
+      status: 'repairable',
+      issues: ['codex-plugin-manifest-missing'],
+    };
+  }
+
+  let manifest: JsonRecord | null = null;
+  try {
+    manifest = asRecord(JSON.parse(await readFile(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 version = typeof manifest.version === 'string' ? manifest.version : undefined;
+  const issues: string[] = [];
+  if (version !== getCliVersion()) issues.push('codex-plugin-version-mismatch');
+  if (manifest.hooks !== './hooks/hooks.json') issues.push('codex-hook-manifest-missing');
+
+  let declared: string[] = [];
+  if (!existsSync(hooksPath)) {
+    issues.push('codex-hook-manifest-missing');
+  } else {
+    try {
+      const hooksConfig = asRecord(JSON.parse(await readFile(hooksPath, 'utf-8')));
+      const hooks = asRecord(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),
+    ...(version ? { version } : {}),
+    hooks: { declared, expected: [...CODEX_HOOK_EVENTS] },
+  };
+}
+
+async function inspectCodexMarketplace(): Promise<AgentPluginCheck> {
+  const marketplacePath = codexMarketplacePath();
+  if (!existsSync(marketplacePath)) {
+    return {
+      scope: 'global',
+      kind: 'marketplace',
+      path: marketplacePath,
+      exists: false,
+      status: 'missing',
+      issues: ['codex-marketplace-missing'],
+    };
+  }
+
+  let catalog: JsonRecord | null = null;
+  try {
+    catalog = asRecord(JSON.parse(await readFile(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 = asRecord(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(): AgentPluginCheck {
+  const command = 'codex plugin list --marketplace personal --available --json';
+  const result = spawnSync('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: string[] = [];
+  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(): Promise<AgentPluginCheck> {
+  const configPath = codexConfigPath();
+  if (!existsSync(configPath)) {
+    return {
+      scope: 'global',
+      kind: 'hook-trust',
+      path: configPath,
+      exists: false,
+      status: 'skipped',
+      issues: ['codex-hook-trust-unavailable'],
+    };
+  }
+
+  let config = '';
+  try {
+    config = await readFile(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) =>
+    config.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: AgentPluginCheck[]): AgentIntegrationStatus {
+  if (checks.length === 0) return 'skipped';
+  return worstStatus(checks.map((check) => check.status));
+}
+
+function aggregatePluginIssues(checks: AgentPluginCheck[]): string[] {
+  const status = aggregatePluginStatus(checks);
+  if (status === 'ok') {
+    return unique(checks.filter((check) => check.status === 'skipped').flatMap((check) => check.issues));
+  }
+  if (status === 'repairable') {
+    return unique(checks
+      .filter((check) => check.status === 'repairable' || check.status === 'missing')
+      .flatMap((check) => check.issues));
+  }
+  return unique(checks
+    .filter((check) => check.status === status)
+    .flatMap((check) => check.issues));
+}
+
+async function inspectPlugin(agent: AgentName, scope: AgentIntegrationScope): Promise<AgentPluginStatus> {
+  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: MCPServerEntry): boolean {
   const text = [server.command, ...(server.args ?? [])].join(' ');
   return /[\\/]\.worktrees[\\/]/i.test(text) || /[\\/]dist[\\/]cli[\\/]index\.js/i.test(text);
@@ -492,10 +836,11 @@ export async function inspectAgentIntegrations(options: {
       agent,
       mcp: await inspectMcp(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,
@@ -519,10 +864,11 @@ export function formatAgentIntegrationReport(report: AgentIntegrationReport): st
   ];
 
   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('');
@@ -586,6 +932,42 @@ export async function repairAgentIntegrations(options: {
     } else {
       skipped.push(`${entry.agent}:guidance`);
     }
+
+    if (entry.agent === 'codex' && entry.plugin.status !== 'ok' && entry.plugin.status !== 'skipped') {
+      const bundleOrMarketplaceNeedsRepair = entry.plugin.checks.some((check) =>
+        (check.kind === 'bundle' || check.kind === 'marketplace') && check.status !== 'ok'
+      );
+      const runtime = entry.plugin.checks.find((check) => check.kind === 'runtime');
+      const hookTrust = entry.plugin.checks.find((check) => check.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((check) =>
+        (check.kind === 'bundle' || check.kind === 'marketplace') && check.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 (!options.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 {

package/src/cli/commands/hooks-install.ts

@@ -142,6 +142,7 @@ async function installSingleAgent(agent: string, cwd: string, global: boolean):
 function getAgentLabel(agent: string): string {
   const labels: Record<string, string> = {
     claude: 'Claude Code',
+    codex: 'Codex',
     windsurf: 'Windsurf',
     cursor: 'Cursor',
     copilot: 'VS Code Copilot',
@@ -171,7 +172,7 @@ function getAgentHint(agent: string): string {
     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] || '';
 }

package/src/cli/commands/setup.ts

@@ -192,6 +192,7 @@ export function buildSetupPlan(options: {
   hooks?: boolean;
   rules?: boolean;
   plugin?: boolean;
+  global?: boolean;
 }): SetupPlan {
   const mcp = options.mcp ?? 'stdio';
   const actions: SetupAction[] = [];
@@ -206,7 +207,7 @@ export function buildSetupPlan(options: {
   if (wantsPlugin && options.agent !== 'all') {
     if (options.agent === 'opencode') {
       actions.push('opencode-local-plugin');
-    } else if (PLUGIN_PACKAGE_AGENTS.has(options.agent)) {
+    } else if (PLUGIN_PACKAGE_AGENTS.has(options.agent) && options.global) {
       actions.push('plugin-package');
     } else if (EXTENSION_PACKAGE_AGENTS.has(options.agent)) {
       actions.push('extension-package');
@@ -299,6 +300,17 @@ async function stripHookCaptureFromPlugin(pluginPath: string, agent: PluginInsta
   }
 }
 
+async function stampCodexPluginVersion(pluginPath: string): Promise<void> {
+  const manifestPath = path.join(pluginPath, '.codex-plugin', 'plugin.json');
+  const manifest = JSON.parse(await readFile(manifestPath, 'utf-8')) as Record<string, unknown>;
+  if (manifest.name !== 'memorix') {
+    throw new Error(`Unexpected Codex plugin manifest at ${manifestPath}`);
+  }
+
+  manifest.version = getCliVersion();
+  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf-8');
+}
+
 async function stripHookCaptureFromOpenClawBundle(bundlePath: string): Promise<void> {
   await rm(path.join(bundlePath, 'hooks'), { recursive: true, force: true });
 
@@ -635,6 +647,7 @@ export async function installPluginPackage(options: PluginInstallOptions): Promi
     const pluginPath = path.join(home, '.codex', 'plugins', 'memorix');
     const marketplacePath = path.join(home, '.agents', 'plugins', 'marketplace.json');
     await copyDir(source, pluginPath);
+    await stampCodexPluginVersion(pluginPath);
     if (!includeHooks) await stripHookCaptureFromPlugin(pluginPath, 'codex');
     await writeOfficialSkills(path.join(pluginPath, 'skills'));
     await upsertCodexMarketplace(marketplacePath, pluginPath);
@@ -861,7 +874,7 @@ function tryInstallClaudePlugin(marketplaceRoot: string): { ok: boolean; message
   };
 }
 
-function tryInstallCodexPlugin(): { ok: boolean; message: string } {
+export function tryInstallCodexPlugin(): { ok: boolean; message: string } {
   const result = spawnSync('codex', ['plugin', 'add', 'memorix@personal', '--json'], {
     encoding: 'utf-8',
     stdio: 'pipe',
@@ -1061,6 +1074,10 @@ async function installAgentSetup(agent: AgentName, plan: SetupPlan, global: bool
   const hasOmpPackage = plan.actions.includes('omp-package') && agent === 'omp';
   const wantsMcpConfig = plan.mcp !== 'none' && agent !== 'pi';
 
+  if (PLUGIN_PACKAGE_AGENTS.has(agent) && plan.includePlugin && !global) {
+    p.log.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: agent as PluginInstallOptions['agent'],
@@ -1322,6 +1339,7 @@ export default defineCommand({
         hooks: !args.noHooks,
         rules: !args.noRules,
         plugin: !args.noPlugin,
+        global: Boolean(args.global),
       });
       await installAgentSetup(agent, plan, Boolean(args.global));
     }

package/src/cli/tui/chat-service.ts

@@ -2,11 +2,10 @@ import { compactDetail, compactSearch } from '../../compact/engine.js';
 import { loadDotenv } from '../../config/dotenv-loader.js';
 import { initLLM, isLLMEnabled, getLLMConfig, callLLMWithTools } from '../../llm/provider.js';
 import type { ChatMessage, ToolDefinition, ToolCall } from '../../llm/provider.js';
-import { initObservations, storeObservation, resolveObservations, getObservation, getAllObservations } from '../../memory/observations.js';
+import { initObservations, prepareSearchIndex, storeObservation, resolveObservations, getObservation, getAllObservations } from '../../memory/observations.js';
 import type { ObservationType } from '../../types.js';
 import { detectProject } from '../../project/detector.js';
-import { initObservationStore } from '../../store/obs-store.js';
-import { getDb, getLastSearchMode, hydrateIndex } from '../../store/orama-store.js';
+import { getLastSearchMode } from '../../store/orama-store.js';
 import { getProjectDataDir } from '../../store/persistence.js';
 import type { MemorixDocument } from '../../types.js';
 
@@ -200,13 +199,8 @@ const preparedProjects = new Set<string>();
 async function prepareProjectSearch(projectId: string, dataDir: string): Promise<void> {
   if (preparedProjects.has(projectId)) return;
 
-  await initObservationStore(dataDir);
   await initObservations(dataDir);      // loads observations into memory once
-  await getDb();
-  // Use the already-loaded in-memory observations (from initObservations)
-  // instead of calling loadAll() a second time.
-  const allObs = getAllObservations() as any[];
-  await hydrateIndex(allObs);           // idempotent: skips if index already populated
+  await prepareSearchIndex();            // lexical-ready now; vector recovery stays in the background
   preparedProjects.add(projectId);
 }
 

package/src/cli/tui/data.ts

@@ -15,7 +15,7 @@ export interface ProjectInfo {
 }
 
 export interface HealthInfo {
-  embeddingProvider: 'ready' | 'unavailable' | 'disabled';
+  embeddingProvider: 'ready' | 'pending' | 'unavailable' | 'disabled';
   embeddingProviderName?: string;
   embeddingLabel: string;
   searchMode: string;
@@ -84,6 +84,7 @@ function formatEmbeddingLabel(
   providerName?: string,
 ): string {
   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';
@@ -165,8 +166,8 @@ export async function getHealthInfo(projectId?: string): Promise<HealthInfo> {
       if (isEmbeddingExplicitlyDisabled()) {
         defaults.embeddingProvider = 'disabled';
       } else {
-        const provider = await getEmbeddingProvider();
-        defaults.embeddingProvider = provider ? 'ready' : 'unavailable';
+        const provider = await getEmbeddingProvider({ allowNetworkProbe: false });
+        defaults.embeddingProvider = provider ? 'ready' : 'pending';
         defaults.embeddingProviderName = provider?.name;
       }
       defaults.embeddingLabel = formatEmbeddingLabel(
@@ -197,6 +198,8 @@ export async function getHealthInfo(projectId?: string): Promise<HealthInfo> {
         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 {
@@ -247,22 +250,17 @@ export async function getRecentMemories(limit = 8, projectId?: string): Promise<
 
 export async function searchMemories(query: string, limit = 10): Promise<SearchResult[]> {
   try {
-    const { searchObservations, getDb, hydrateIndex } = await import('../../store/orama-store.js');
+    const { searchObservations } = await import('../../store/orama-store.js');
     const { getProjectDataDir } = await import('../../store/persistence.js');
     const { detectProject } = await import('../../project/detector.js');
-    const { initObservations } = await import('../../memory/observations.js');
-    const { initObservationStore, getObservationStore: getStore } = await import('../../store/obs-store.js');
+    const { initObservations, prepareSearchIndex } = await import('../../memory/observations.js');
 
     const proj = detectProject(process.cwd());
     if (!proj) return [];
 
     const dataDir = await getProjectDataDir(proj.id);
-    await initObservationStore(dataDir);
     await initObservations(dataDir);
-    await getDb();
-
-    const allObs = (await getStore().loadAll()) as any[];
-    await hydrateIndex(allObs);
+    await prepareSearchIndex();
 
     const results = await searchObservations({ query, limit, projectId: proj.id });