### Durable index appeared valid

CLI/deep status previously reported healthy builtin memory:


backend: builtin
provider: openai
model: text-embedding-3-small
dirty: false
vector.semanticAvailable: true
vector.dims: 1536
custom.indexIdentity.status: valid
embeddingProbe.ok: true


Direct DB inspection found the expected metadata row/table:


memory_index_meta_v1


A fresh Node process using the same installed manager could search successfully and reported `indexIdentity: valid` before/after.

A single first-class `memory_search` could return genuine semantic/vector hits, e.g.:


vectorScore > 0
textScore: 0


### Live failure observed

During live tool testing, parallel/overlapping `memory_search` calls produced:


{
  "disabled": true,
  "unavailable": true,
  "error": "index metadata is missing"
}


and once:


{
  "disabled": true,
  "unavailable": true,
  "error": "memory_search timed out after 15s"
}


Then later single searches could succeed again.

### Suspected source-level race

In OpenClaw `2026.6.1` dist, source tracing found:


manager-dZw31DAG2.js
  ~903   function resolveMemoryIndexIdentityState(params)
  ~2202  async runSafeReindex(params)
  ~2230  this.db = tempDb\n  ~3564  refreshIndexIdentityDirty(params)
  ~3577  async search(query, opts)
  ~3763  async sync(params)
  ~3863  status() {


In `tools-CcIzM8pz.js`, the memory-search wrapper does roughly:


rawResults = await activeMemory.manager.search(query, searchOptions);
pausedIndexIdentityReason = resolvePausedMemoryIndexIdentityReason(activeMemory.manager.status());
if (pausedIndexIdentityReason) return;


There is a similar post-force-sync status check.

Hypothesis:

1. `memory_search` starts.
2. `MemoryIndexManager.search()` calls `startAsyncSearchSync()` before the current search finishes.
3. Async sync may enter `runSafeReindex()`.
4. `runSafeReindex()` temporarily assigns the shared live manager DB handle to a temp DB:


this.db = tempDb;
this.resetVectorState();
this.fts.available = false;
this.fts.loadError = void 0;
this.ensureSchema();


5. The temp DB has schema but may not yet have `memory_index_meta_v1`.
6. A concurrent search or post-search `status()` call reads identity from the temp DB rather than the durable main DB.
7. `status()` reports `index metadata is missing`.
8. The tool wrapper treats that as a hard unavailable state even though the durable main DB is valid.

### Local mitigation applied

I applied a local two-file dist hotfix, then restarted gateway.

Patched files:


/home/<user>/.npm-global/lib/node_modules/openclaw/dist/tools-CcIzM8pz.js
/home/<user>/.npm-global/lib/node_modules/openclaw/dist/manager-dZw31DAG2.js


Mitigation behavior:

1. Tool wrapper: if `manager.search()` returns nonempty hits and the only post-search pause reason is exactly `index metadata is missing`, preserve the hits and add debug warning instead of returning disabled/unavailable. True mismatches still block.

2. Memory manager: defer `startAsyncSearchSync()` until after the current search finishes, so a search is less likely to trigger reindex under its own feet.

`node --check` passed on both patched files before restart.

After gateway restart, a single first-class `memory_search` returned semantic/vector hits again with no missing-metadata error:


provider: openai
model: text-embedding-3-small
backend: builtin
hits: 5
vectorScore: 0.6357942223548889
textScore: 0


### Beta check

I inspected `[email protected]` from npm without installing it. The same suspicious patterns appear present:


package/dist/manager-B5STWg-k.js
  2229: async runSafeReindex(params)
  2257: this.db = tempDb
  3605: async search(query, opts)
  3626: startAsyncSearchSync({


and:


package/dist/tools-DUysl7tx.js
  rawResults = await activeMemory.manager.search(...)
  pausedIndexIdentityReason = resolvePausedMemoryIndexIdentityReason(activeMemory.manager.status())


So I do not see evidence that `2026.6.2-beta.1` has fixed this specific suspected race. So I'm premptively offering this fix to the openclaw team to improve the reliability of the native memory search function.