Bug: openclaw memory search times out when eager context-window warmup runs for the memory command

Summary

openclaw memory search can time out during Gemini query embedding generation even though:

• the Gemini API works directly;
• OpenClaw's Gemini embedding provider works when invoked directly;
• MemoryIndexManager.search() works when invoked directly;
• runMemorySearch() works when invoked directly;
• runCli(argv) works when called with an explicit argv array.

The failure appears only when process.argv globally looks like a real OpenClaw memory command. In that case, context-DxSDN9vA.js eagerly starts context-window cache warmup at module import time:

if (shouldEagerWarmContextWindowCache()) ensureContextWindowCacheLoaded();

Since memory is not in SKIP_EAGER_WARMUP_PRIMARY_COMMANDS, the warmup runs concurrently with the memory search command. Adding "memory" to SKIP_EAGER_WARMUP_PRIMARY_COMMANDS fixes the issue locally.

Environment

• OpenClaw version: OpenClaw 2026.4.25 (aa36ee6)
• Node.js version: v22.22.2
• OS: Linux x64
• Shell: bash
• Install path: /usr/lib/node_modules/openclaw
• CLI wrapper: /usr/local/bin/openclaw -> /usr/lib/node_modules/openclaw/openclaw.mjs
• Memory backend: builtin SQLite/FTS
• Memory provider: gemini
• Memory model: gemini-embedding-001
• Memory vector store: disabled via store.vector.enabled=false
• Memory index status after fix: 120 files, 447 chunks, dirty=false

Actual behavior

Running the real CLI wrapper hangs until the embedding query timeout:

OPENCLAW_DEBUG_MEMORY_EMBEDDINGS=1 \
openclaw memory search \
  --query 'openclaw memory search diagnostic' \
  --max-results 3 \
  --json \
  --agent main

Observed result before the patch:

memory embeddings: gemini client {"rawBaseUrl":"https://generativelanguage.googleapis.com/v1beta", ...}
Memory search failed: memory embeddings query timed out after 60s

Other runs of the same command also failed with:

Memory search failed: fetch failed | other side closed

Expected behavior

openclaw memory search should complete normally, just like the direct runtime invocation does.

Key isolation tests

1. Gemini API itself works

Direct Gemini embedding request with the same resolved API key returned HTTP 200 and a 3072-dimensional vector.

2. OpenClaw Gemini embedding provider works directly

Importing and calling the installed provider directly succeeded:

import { createGeminiEmbeddingProvider } from '/usr/lib/node_modules/openclaw/dist/extensions/google/embedding-provider.js';

Result:

ok=true, model=gemini-embedding-001, valuesLen=3072

3. Memory manager works directly

Direct MemoryIndexManager.get(...).search(...) returned 3 results in about 10s.

4. runMemorySearch() works directly

Direct import from cli.runtime-Xk5Be4LD.js returned 3 JSON results in about 10s.

5. runCli(argv) works if process.argv is not set to the real memory command

This succeeds:

import { runCli } from '/usr/lib/node_modules/openclaw/dist/run-main-C0UBGHN3.js';

await runCli([
  process.execPath,
  '/usr/lib/node_modules/openclaw/openclaw.mjs',
  'memory',
  'search',
  '--query',
  'openclaw memory search diagnostic',
  '--max-results',
  '3',
  '--json',
  '--agent',
  'main'
]);

6. The same runCli(argv) fails when process.argv globally matches the memory command

This reproduces the timeout:

import { runCli } from '/usr/lib/node_modules/openclaw/dist/run-main-C0UBGHN3.js';

const argv = [
  process.execPath,
  '/usr/lib/node_modules/openclaw/openclaw.mjs',
  'memory',
  'search',
  '--query',
  'openclaw memory search diagnostic',
  '--max-results',
  '3',
  '--json',
  '--agent',
  'main'
];

process.argv = argv;
await runCli(argv);

Observed result:

Memory search failed: memory embeddings query timed out after 60s

7. Changing only global process.argv to a skipped command makes the same memory search succeed

This succeeds:

import { runCli } from '/usr/lib/node_modules/openclaw/dist/run-main-C0UBGHN3.js';

const realArgv = [
  process.execPath,
  '/usr/lib/node_modules/openclaw/openclaw.mjs',
  'memory',
  'search',
  '--query',
  'openclaw memory search diagnostic',
  '--max-results',
  '3',
  '--json',
  '--agent',
  'main'
];

process.argv = [process.execPath, '/usr/lib/node_modules/openclaw/openclaw.mjs', 'status'];
await runCli(realArgv);

Result:

exit=0, returned 3 results

This points to the eager context-window warmup, because status is already in SKIP_EAGER_WARMUP_PRIMARY_COMMANDS, while memory is not.

Local workaround / proposed fix

Patch:

--- a/dist/context-DxSDN9vA.js
+++ b/dist/context-DxSDN9vA.js
@@ -113,6 +113,7 @@
   "health",
   "hooks",
   "logs",
+  "memory",
   "models",
   "pairing",
   "plugins",

After adding "memory" to SKIP_EAGER_WARMUP_PRIMARY_COMMANDS, the real CLI wrapper works:

actual_cli_after_patch_exit=0
duration_s=16
stdout: 3 JSON results

openclaw memory status --json --agent main also works:

exit=0
duration_s=8
files=120
chunks=447
dirty=false
provider=gemini
model=gemini-embedding-001
fts.enabled=true
fts.available=true
vector.enabled=false

Root cause hypothesis

src/agents/context.ts or the compiled equivalent starts async context-window warmup at import time whenever process.argv looks like an OpenClaw CLI command and the primary command is not skipped:

if (shouldEagerWarmContextWindowCache()) ensureContextWindowCacheLoaded();

For the memory command, this warmup is unnecessary and can interfere with memory embedding fetches. The command-specific memory runtime already manages its own provider and index lifecycle.

Suggested upstream fix

Add memory to SKIP_EAGER_WARMUP_PRIMARY_COMMANDS, or otherwise prevent eager context-window warmup from running for memory/index/search/status commands.

Related issues / prior fixes checked

• #56901: Gemini memory indexing/search can fail with fetch failed while direct Gemini calls work.
• #52162 / #71506: remote memory embeddings proxy/guarded-fetch fix. This install already includes the v2026.4.25 fix, so this report appears to be a separate issue.
• #26792: FTS-only memory search/index behavior; related as a fallback path but not the cause here.

Impact

High for users using remote embeddings with openclaw memory search: the CLI can consistently time out even though the provider and memory runtime work. The workaround is a local dist patch, but that will be lost on package updates.