memorix 1.6.0 → 1.6.2

package/docs/AGENT_OPERATOR_PLAYBOOK.md

@@ -58,7 +58,7 @@ An unbound terminal is intentionally project-scoped: it reads and writes project
 
 Long-term memory is a reviewed layer, not a generic global note store. `memorix memory long-term add` creates a candidate; `qualify` and `approve` are explicit audit transitions before it can appear in a bounded task Workset. A project-derived observation, code fact, Git fact, test, session, Claim, or workflow stays project-bound. Only manual or user-confirmed `user + portable` records can cross local projects for the same local installation identity. When one is task-matched in a Workset, it is intentionally usable background even if its origin differs; use its `durable:<id>` reference with `memorix_detail` only when the full record is needed. Use `archive` or `supersede` when a durable item is no longer current.
 
-`--cwd <git-project>` is the canonical way to run direct CLI work from outside a repository. It changes the command's project anchor only; Git remains the source of truth for final project identity.
+`--cwd <git-project>` is the canonical way to run direct CLI work from outside a repository. It changes the command's project anchor only; Git remains the source of truth for final project identity. Existing directories are canonicalized to their real filesystem paths before binding, which prevents macOS aliases such as `/var` and `/private/var` from splitting one project or hiding a Claude local MCP entry.
 
 Use MCP when:
 
@@ -164,7 +164,12 @@ Do not assume the HTTP connection alone tells Memorix which project the user mea
 
 The HTTP service is normally started with `memorix background start`; the same project-binding rules apply when you run `memorix serve-http --port 3211` in the foreground.
 
-HTTP MCP sessions idle out after 30 minutes by default. If the user's HTTP MCP client is sensitive to stale session IDs after long idle periods, set `MEMORIX_SESSION_TIMEOUT_MS` before starting or restarting the service. Example: `MEMORIX_SESSION_TIMEOUT_MS=86400000` keeps sessions alive for 24 hours.
+HTTP MCP sessions idle out after 12 hours by default. An expired session now
+receives a fast `404` reinitialize hint instead of a generic transport failure.
+If the user's HTTP MCP client needs a longer idle period, set
+`MEMORIX_SESSION_TIMEOUT_MS` before starting or restarting the service.
+Example: `MEMORIX_SESSION_TIMEOUT_MS=86400000` keeps sessions alive for 24
+hours. Set it to `0` only when the host has its own reliable session cleanup.
 
 ### Do not confuse project config and global config
 
@@ -702,7 +707,10 @@ If it shows "Not running" or "dead":
 memorix background ensure
 ```
 
-If the client is connected but starts failing after roughly 30 minutes of no Memorix tool use, check for stale HTTP session expiry rather than treating it as project binding failure. Restart the service with a longer idle timeout:
+If the client is connected but starts failing after a long inactive period,
+check for the explicit stale-session `404` reinitialize hint rather than
+treating it as a project-binding failure. The default idle window is 12 hours;
+restart with a longer window only when the client genuinely needs it:
 
 ```powershell
 $env:MEMORIX_SESSION_TIMEOUT_MS = "86400000"

package/docs/API_REFERENCE.md

@@ -652,7 +652,7 @@ Coordination state is opt-in project state for tasks, handoff messages, locks, a
 
 Runtime environment:
 
-- `MEMORIX_SESSION_TIMEOUT_MS` — HTTP MCP session idle timeout in milliseconds. Default: `1800000` (30 minutes). Increase this for clients that do not transparently reinitialize after stale HTTP session IDs, for example `86400000` for 24 hours.
+- `MEMORIX_SESSION_TIMEOUT_MS` — HTTP MCP session idle timeout in milliseconds. Default: `43200000` (12 hours). Expired session IDs receive a fast `404` with a reinitialize hint. Increase this for long-lived clients, for example `86400000` for 24 hours; set `0` only when the host provides reliable lifecycle cleanup.
 
 ### `team_manage`
 

package/docs/DOCKER.md

@@ -128,7 +128,11 @@ docker compose ps
 
 ### HTTP session idle timeout
 
-The HTTP MCP transport defaults to a 30-minute idle timeout. The example `compose.yaml` raises this to 24 hours for IDEs that keep one HTTP MCP session open while the user reads diffs, runs tests, or switches focus.
+The HTTP MCP transport defaults to a 12-hour idle timeout. The example
+`compose.yaml` raises this to 24 hours for IDEs that keep one HTTP MCP session
+open while the user reads diffs, runs tests, or switches focus. When a session
+does expire, the service returns a fast `404` so the client can initialize a
+fresh MCP session.
 
 To change it:
 

package/docs/PERFORMANCE.md

@@ -71,13 +71,14 @@ On the release development machine used for this check, the healthy HTTP service
 
 | Knob | Default | Use When |
 | --- | --- | --- |
-| `MEMORIX_SESSION_TIMEOUT_MS` | `1800000` (30 min) | Increase for HTTP MCP clients that do not recover from stale session IDs after idle time |
+| `MEMORIX_SESSION_TIMEOUT_MS` | `43200000` (12 h) | Set a shorter GC window for supervised clients, or `0` to disable idle session GC |
 | `MEMORIX_FORMATION_TIMEOUT_MS` | `12000` (12 s) | Raise when LLM-backed formation should outlive slow proxy/provider hops |
 | `MEMORIX_LLM_API_KEY` / `OPENAI_API_KEY` | unset | Enable LLM-backed enrichment, extraction, rerank, or skill generation |
 | `MEMORIX_LLM_TIMEOUT_MS` | `30000` (30 s) | Bound a single LLM-backed extraction/resolve call |
 | `MEMORIX_RERANK_TIMEOUT_MS` | provider default | Bound slow LLM rerank calls |
 | `memorix memory search --quality fast` | n/a | Force a fully local retrieval path for a latency-sensitive call |
 | `npm run benchmark:retrieval -- --records 1000 --runs 100` | n/a | Reproduce hot in-process lexical retrieval latency; not an end-to-end claim |
+| `npm run gate:large-store -- --records 40000` | n/a | Exercise SDK, HTTP MCP, hook persistence, cache integrity, and reopen behavior against a large isolated store |
 | `[codegraph].max_file_bytes` | `2097152` | Raise only when a large file is intentional source that should enter Code Memory |
 | `memorix retention status` | report only | Inspect whether memory growth needs cleanup |
 | `memorix retention archive` | explicit | Archive expired memories when the project gets noisy |
@@ -86,7 +87,7 @@ On the release development machine used for this check, the healthy HTTP service
 ## Operator Guidance
 
 - For memory-only use, prefer stdio MCP or a lightweight `memorix_session_start`; do not join orchestration coordination state by default.
-- For long-lived IDE sessions over HTTP, set `MEMORIX_SESSION_TIMEOUT_MS=86400000` before `memorix background start` if your client is stale-session-sensitive.
+- HTTP sessions now default to 12 hours and return a fast `404` with a reinitialize hint after expiry. Set `MEMORIX_SESSION_TIMEOUT_MS=0` only when the host has its own reliable lifecycle cleanup; otherwise retain a bounded GC window.
 - If LLM-backed formation is timing out against a slow proxy/provider, raise `MEMORIX_FORMATION_TIMEOUT_MS` and keep it higher than `MEMORIX_LLM_TIMEOUT_MS`, because the full pipeline can include multiple LLM-backed stages.
 - For Docker, use it when you want a managed HTTP service. Do not use image size alone as the runtime memory estimate.
 - For orchestrated subagent work, expect CPU and disk activity proportional to the spawned agents and verification commands.
@@ -96,6 +97,20 @@ On the release development machine used for this check, the healthy HTTP service
   `/api/maintenance` on that local dashboard before assuming a Code Memory scan
   or lifecycle task completed.
 
+## Large-Store Release Gate
+
+`npm run gate:large-store -- --records 40000` builds Memorix and creates a
+temporary Git project with an isolated data directory. It runs with embeddings
+disabled, so it does not use provider credentials or make paid network calls.
+The gate measures steady-state writes, first lexical search, process memory,
+HTTP MCP and hook persistence, and an SDK close/reopen cycle. It also verifies
+that the personal hook candidate remains durable on disk without becoming
+visible to an unbound SDK reader.
+
+Results are machine-specific and should be compared on the same OS and Node
+version. The release gate is an integrity and regression check, not a public
+latency guarantee.
+
 ## Current Optimization Opportunities
 
 These are not release blockers, but they are reasonable future improvements:

package/docs/README.md

@@ -117,11 +117,13 @@ Historical/deep-reference documents may describe older designs. If they conflict
 
 ## Current Product Line
 
-The released product is on the **1.4 line**. The current baseline has:
+The released product is on the **1.6 line**. The current baseline has:
 
 - `memorix setup --agent <agent> --global` is the default agent integration command
 - `memorix serve` is the manual stdio MCP server for external agents
 - `memorix background start` runs the shared HTTP MCP service and dashboard
+- context and CodeGraph commands return bounded task receipts before detailed diagnostics
+- HTTP MCP sessions have a bounded, explicit lifecycle and fail with a reinitialize hint after expiry
 - `memorix integrate --agent <agent>` and `memorix hooks install --agent <agent>` remain manual/fallback generation commands
 - `memorix` / `memcode` open memcode, the bundled terminal agent that uses the same Memorix memory pool
 - `~/.memorix/config.toml` and project `memorix.toml` are the user-facing configuration model

package/docs/SETUP.md

@@ -42,7 +42,7 @@ Memorix project identity comes from Git. Open or initialize a real Git repositor
 git init
 ```
 
-`projectRoot` and current working directory are detection anchors. The final project identity is derived from the real Git root and remote metadata.
+`projectRoot` and current working directory are detection anchors. The final project identity is derived from the real Git root and remote metadata. Memorix resolves an existing project directory to its real filesystem path before binding it, so equivalent macOS paths such as `/var/...` and `/private/var/...` do not create separate project or Claude local-MCP entries.
 
 ---
 
@@ -247,13 +247,19 @@ Generic HTTP MCP config:
 
 For multi-project HTTP usage, agents should call `memorix_session_start(projectRoot=...)` with the absolute workspace path when available. This prevents cross-project drift when the background service is shared.
 
-HTTP sessions idle out after 30 minutes by default. For clients that do not recover gracefully from stale HTTP session IDs:
+HTTP sessions idle out after 12 hours by default. An expired session receives a
+fast `404` that tells the client to initialize again, rather than being treated
+as a project-binding failure. For clients that intentionally need a longer
+window:
 
 ```powershell
 $env:MEMORIX_SESSION_TIMEOUT_MS = "86400000"
 memorix background restart
 ```
 
+Set `MEMORIX_SESSION_TIMEOUT_MS=0` only when the host has its own reliable
+session cleanup; otherwise keep a bounded idle window.
+
 ### Option E: Docker HTTP service
 
 ```bash

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "memorix",
   "mcpName": "io.github.AVIDS2/memorix",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Local-first shared memory layer for AI coding agents across MCP clients, Git history, reasoning context, and project sessions.",
   "type": "module",
   "sideEffects": false,
@@ -67,6 +67,7 @@
     "test:e2e": "vitest run tests/e2e/",
     "benchmark:codegraph": "node scripts/benchmark-codegraph-provider.cjs",
     "benchmark:retrieval": "npm run build && node scripts/benchmark-retrieval.mjs",
+    "gate:large-store": "npm run build && node scripts/large-store-gate.mjs",
     "generate:star-history": "node scripts/generate-star-history.mjs",
     "sync:mcp-registry": "node scripts/sync-mcp-registry-manifest.mjs",
     "check:mcp-registry": "node scripts/check-mcp-registry-manifest.mjs",

package/plugins/claude/memorix/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "memorix",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Shared workspace memory for Claude Code and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/codebuddy/memorix/.codebuddy-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Local-first project memory for CodeBuddy Code and other coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/codex/memorix/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Shared workspace memory for Codex and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/copilot/memorix/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Shared local workspace memory for GitHub Copilot CLI and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/gemini/memorix/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "mcpServers": {
     "memorix": {
       "command": "memorix",

package/plugins/omp/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-omp-package",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Memorix shared workspace memory package for Oh-my-Pi.",
   "license": "Apache-2.0",
   "keywords": [

package/plugins/openclaw/memorix/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Shared workspace memory for OpenClaw and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/pi/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-pi-package",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Memorix shared workspace memory package for Pi coding agent.",
   "license": "Apache-2.0",
   "keywords": [

package/server.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/AVIDS2/memorix",
     "source": "github"
   },
-  "version": "1.6.0",
+  "version": "1.6.2",
   "websiteUrl": "https://github.com/AVIDS2/memorix#readme",
   "icons": [
     {
@@ -22,7 +22,7 @@
     {
       "registryType": "npm",
       "identifier": "memorix",
-      "version": "1.6.0",
+      "version": "1.6.2",
       "runtimeHint": "npx",
       "packageArguments": [
         {

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

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { basename, dirname, resolve } from 'node:path';
 import { homedir } from 'node:os';
@@ -580,11 +580,17 @@ function sanitizeServer(server: MCPServerEntry): AgentMcpCheck['server'] {
 }
 
 function normalizeProjectKey(projectRoot: string): string {
-  return resolve(projectRoot).replace(/\\/g, '/').toLowerCase();
+  return canonicalProjectPath(projectRoot).toLowerCase();
 }
 
 function defaultClaudeProjectKey(projectRoot: string): string {
-  return resolve(projectRoot).replace(/\\/g, '/');
+  return canonicalProjectPath(projectRoot);
+}
+
+function canonicalProjectPath(projectRoot: string): string {
+  const resolved = resolve(projectRoot);
+  const canonical = existsSync(resolved) ? realpathSync(resolved) : resolved;
+  return canonical.replace(/\\/g, '/');
 }
 
 function getClaudeLocalConfigPath(): string {

package/src/cli/commands/background.ts

@@ -19,6 +19,8 @@
 
 import { defineCommand } from 'citty';
 import * as fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { spawn, execFileSync } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import { parseTcpPort } from '../port.js';
@@ -73,6 +75,33 @@ function parseBackgroundPort(value: string | undefined): number {
   return parseTcpPort(value, 3211);
 }
 
+/**
+ * Resolve the CLI file that `background start` should spawn.
+ * `process.argv[1]` follows the launcher shim and can point at a different
+ * install (for example `$HOME/node_modules/memorix` after `bun add` in $HOME).
+ * When this module is bundled into `dist/cli/index.js`, `../index.js` is the
+ * library stdio entry (`dist/index.js`) — never spawn that.
+ */
+function resolveBackgroundCliEntryFrom(here: string, argv1: string): string {
+  const dir = path.dirname(here);
+  if (path.basename(here) === 'index.js' && path.basename(dir) === 'cli') {
+    return here;
+  }
+  const compiledSibling = path.resolve(dir, '..', 'index.js');
+  if (fs.existsSync(compiledSibling) && path.basename(path.dirname(compiledSibling)) === 'cli') {
+    return compiledSibling;
+  }
+  return argv1;
+}
+
+function resolveBackgroundCliEntry(argv1 = process.argv[1]): string {
+  try {
+    return resolveBackgroundCliEntryFrom(fileURLToPath(import.meta.url), argv1);
+  } catch {
+    return argv1;
+  }
+}
+
 function parseLogLines(value: string | undefined): number {
   return parseBoundedPositiveInteger(value, 50, 'Log line count', 10_000);
 }
@@ -343,8 +372,9 @@ export async function doStart(port: number): Promise<void> {
 
   // 5. Find the memorix CLI entry point
   // We need to spawn `node <cli-entry> serve-http --port <port>`
-  // The entry point is the same binary that's running now
-  const cliEntry = process.argv[1]; // e.g., dist/cli/index.js or node_modules/.bin/memorix
+  // Prefer this package's compiled CLI so a bun/npm shim cannot spawn a
+  // different (often unpatched) memorix from ~/node_modules.
+  const cliEntry = resolveBackgroundCliEntry();
 
   // 6. Start the service without a visible console. A regular non-detached child
   // can be reclaimed with its parent by terminal hosts on Windows; a detached Node
@@ -792,4 +822,6 @@ export const _testing = {
   parseBackgroundPort,
   parseLogLines,
   formatBackgroundCommandError,
+  resolveBackgroundCliEntry,
+  resolveBackgroundCliEntryFrom,
 };

package/src/cli/commands/doctor.ts

@@ -131,6 +131,7 @@ export default defineCommand({
     let bgRunning = false;
     let bgPort = 0;
     let bgPid = 0;
+    let backgroundHealthy = false;
 
     try {
       if (existsSync(bgStatePath)) {
@@ -148,7 +149,7 @@ export default defineCommand({
       // Health check
       try {
         const http = await import('node:http');
-        const healthy = await new Promise<boolean>((resolve) => {
+        backgroundHealthy = await new Promise<boolean>((resolve) => {
           const req = http.request({ hostname: '127.0.0.1', port: bgPort, path: '/api/team', timeout: 3000 }, (res) => {
             res.resume();
             resolve(res.statusCode === 200);
@@ -157,7 +158,7 @@ export default defineCommand({
           req.on('timeout', () => { req.destroy(); resolve(false); });
           req.end();
         });
-        if (healthy) {
+        if (backgroundHealthy) {
           lines.push(ok('Health check: OK'));
         } else {
           lines.push(warn('Health check: FAILED (process alive but not responding)'));
@@ -165,8 +166,9 @@ export default defineCommand({
         }
       } catch {
         lines.push(warn('Health check: could not connect'));
+        issues.push('Background process is alive but its health endpoint could not be reached. Try "memorix background restart".');
       }
-      report.mode = { type: 'background', pid: bgPid, port: bgPort, healthy: true };
+      report.mode = { type: 'background', pid: bgPid, port: bgPort, healthy: backgroundHealthy };
     } else {
       lines.push(info('Background control plane: not running'));
       lines.push(info('Current invocation: CLI (stdio)'));
@@ -210,20 +212,49 @@ export default defineCommand({
       } else {
         lines.push(ok(`Mode: ${mode}`));
 
-        // Try to initialize provider to check real status
-        const { getEmbeddingProvider } = await import('../../embedding/provider.js');
-        const provider = await getEmbeddingProvider();
+        // A running control plane is the source of truth for runtime health.
+        // A fresh doctor process must not overwrite a live 401/402/timeout
+        // diagnosis with a static "configured = ready" result.
+        let controlPlaneEmbedding: {
+          status?: string;
+          provider?: { name?: string; dimensions?: number };
+          failure?: { kind?: string; retryAfterMs?: number };
+        } | undefined;
+        if (bgRunning) {
+          try {
+            const response = await fetch(`http://127.0.0.1:${bgPort}/health`, { signal: AbortSignal.timeout(3_000) });
+            if (response.ok) {
+              const health = await response.json() as { embedding?: typeof controlPlaneEmbedding };
+              controlPlaneEmbedding = health.embedding;
+            }
+          } catch { /* health is advisory; fall back to a local probe */ }
+        }
 
-        if (provider) {
-          lines.push(ok(`Provider: ${provider.name} (${provider.dimensions}d)`));
-          lines.push(ok('Status: ready'));
-          lines.push(info('Search: hybrid (BM25 + vector)'));
-          report.embedding = { mode, status: 'ready', provider: provider.name, dimensions: provider.dimensions };
+        if (controlPlaneEmbedding?.status === 'degraded') {
+          const kind = controlPlaneEmbedding.failure?.kind ?? 'upstream';
+          const retryAfterMs = controlPlaneEmbedding.failure?.retryAfterMs;
+          const retry = typeof retryAfterMs === 'number' && retryAfterMs > 0
+            ? `; retry in ${Math.ceil(retryAfterMs / 1000)}s`
+            : '';
+          lines.push(warn(`Status: degraded in the running control plane (${kind}${retry})`));
+          lines.push(info('Search: degraded to BM25 fulltext until the provider recovers'));
+          issues.push('The running control plane has an unavailable embedding provider. Check provider credentials, billing, or connectivity.');
+          report.embedding = { mode, status: 'degraded', failure: kind };
         } else {
-          lines.push(warn('Status: temporarily unavailable'));
-          lines.push(info('Search: degraded to BM25 fulltext (no vector similarity)'));
-          issues.push(`Embedding mode is "${mode}" but provider failed to initialize. Check API keys/connectivity.`);
-          report.embedding = { mode, status: 'temporarily_unavailable' };
+          const { getEmbeddingProvider } = await import('../../embedding/provider.js');
+          const provider = await getEmbeddingProvider();
+
+          if (provider) {
+            lines.push(ok(`Provider: ${provider.name} (${provider.dimensions}d)`));
+            lines.push(ok('Status: ready'));
+            lines.push(info('Search: hybrid (BM25 + vector)'));
+            report.embedding = { mode, status: 'ready', provider: provider.name, dimensions: provider.dimensions };
+          } else {
+            lines.push(warn('Status: temporarily unavailable'));
+            lines.push(info('Search: degraded to BM25 fulltext (no vector similarity)'));
+            issues.push(`Embedding mode is "${mode}" but provider failed to initialize. Check API keys/connectivity.`);
+            report.embedding = { mode, status: 'temporarily_unavailable' };
+          }
         }
 
         // Check cached embeddings count

package/src/cli/commands/hook.ts

@@ -4,8 +4,16 @@
  * Entry point called by agent hooks via stdin/stdout.
  * Reads agent's JSON from stdin, normalizes, auto-stores, outputs response.
  *
+ * This command is short-lived. A leftover `memorix hook` process is a bug:
+ * hosts invoke it on every event, and hung copies exhaust RAM.
+ *
  * Usage (called by agent hook configs, not by users directly):
  *   memorix hook
+ *
+ * Env:
+ *   MEMORIX_HOOK_TIMEOUT_MS — wall-clock budget (default 20000)
+ *   MEMORIX_HOOK_STDIN_TIMEOUT_MS — stdin idle budget (default 3000)
+ *   MEMORIX_HOOK_HEAP_MB — V8 heap for this command only (default 512)
  */
 
 import { defineCommand } from 'citty';
@@ -29,6 +37,10 @@ export default defineCommand({
   },
   run: async ({ args }) => {
     const { runHook } = await import('../../hooks/handler.js');
-    await runHook(args.agent as string | undefined, args.event as string | undefined);
+    const { resolveHookTimeoutMs, runHookWithDeadline } = await import('../../hooks/lifecycle.js');
+    await runHookWithDeadline({
+      timeoutMs: resolveHookTimeoutMs(),
+      run: () => runHook(args.agent as string | undefined, args.event as string | undefined),
+    });
   },
 });

package/src/cli/commands/operator-shared.ts

@@ -65,10 +65,13 @@ async function resolveCliProjectContext(options?: CliContextOptions): Promise<{
  */
 export async function getCliReadContext(options?: CliContextOptions): Promise<CliReadContext> {
   const { project, dataDir, invocation } = await resolveCliProjectContext(options);
-  await initObservations(dataDir);
+  await initObservations(dataDir, {
+    embeddingWriteMode: 'deferred',
+    projectRoot: project.rootPath,
+  });
 
   if (options?.searchIndex) {
-    await prepareSearchIndex();
+    await prepareSearchIndex({ skipCachedVectors: true });
   }
 
   const storedIdentity = await loadCliIdentity(dataDir, project.id);
@@ -118,7 +121,7 @@ export async function getCliProjectContext(options?: CliContextOptions): Promise
   const teamStore = await initTeamStore(dataDir);
 
   if (options?.searchIndex) {
-    await prepareSearchIndex();
+    await prepareSearchIndex({ skipCachedVectors: true });
   }
 
   const identity = await resolveCliIdentity({