Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

fix(memory): don't serve cached values another process has changed (#3360)

Mr. Mak7879ce7fa65d
diff --git a/v3/@claude-flow/cli/__tests__/memory-cache-cross-process-3360.test.ts b/v3/@claude-flow/cli/__tests__/memory-cache-cross-process-3360.test.ts
new file mode 100644
index 0000000000..628c55acea
--- /dev/null
+++ b/v3/@claude-flow/cli/__tests__/memory-cache-cross-process-3360.test.ts
@@ -0,0 +1,401 @@
+/**
+ * Regression guard β€” `memory_retrieve` served stale values after ANOTHER
+ * process wrote to the same store.
+ *
+ * Several MCP servers routinely share one database file: Claude Code, Codex
+ * and Grok each start their own `mcp start` against the same `.swarm/`
+ * store. `bridgeGetEntry` consults a per-process TieredCache first, and each
+ * process only invalidated that cache on its own writes. Once server B had
+ * read a key, an update or delete made by server A never reached B: B kept
+ * returning the old value (`found: true`) until its cache entry expired
+ * (5-minute TieredCache TTL by default).
+ *
+ * A second better-sqlite3 connection to the same file stands in for the
+ * other server process β€” that is exactly the distinction SQLite's
+ * `PRAGMA data_version` draws (commits by a different connection), which the
+ * fix relies on.
+ */
+
+import { describe, it, expect, afterAll, beforeEach } from 'vitest';
+import Database from 'better-sqlite3';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const root = mkdtempSync(join(tmpdir(), 'ruflo-cache-cross-process-'));
+const dbPath = join(root, 'memory.db');
+
+function makeDb(): Database.Database {
+ const d = new Database(dbPath);
+ d.pragma('journal_mode = WAL');
+ d.exec(`
+ CREATE TABLE IF NOT EXISTS memory_entries (
+ id TEXT PRIMARY KEY,
+ key TEXT NOT NULL,
+ namespace TEXT DEFAULT 'default',
+ content TEXT NOT NULL,
+ type TEXT DEFAULT 'semantic',
+ embedding TEXT,
+ embedding_dimensions INTEGER,
+ embedding_model TEXT,
+ tags TEXT,
+ metadata TEXT,
+ provenance_type TEXT DEFAULT 'unknown',
+ created_at INTEGER,
+ updated_at INTEGER,
+ last_accessed_at INTEGER,
+ access_count INTEGER DEFAULT 0,
+ expires_at INTEGER,
+ status TEXT DEFAULT 'active',
+ UNIQUE(namespace, key)
+ );
+ CREATE TABLE IF NOT EXISTS vector_indexes (
+ id TEXT PRIMARY KEY,
+ name TEXT,
+ dimensions INTEGER
+ );
+ `);
+ return d;
+}
+
+/** Map-backed stand-in for TieredCacheManager (get/set/delete/clear). */
+function makeTieredCache() {
+ const store = new Map<string, unknown>();
+ return {
+ get: (k: string) => store.get(k),
+ set: (k: string, v: unknown) => { store.set(k, v); },
+ delete: (k: string) => { store.delete(k); },
+ clear: () => { store.clear(); },
+ };
+}
+
+// `db` is this process's connection (what agentdb hands the bridge);
+// `otherProcess` is a second connection to the same file.
+const db = makeDb();
+const otherProcess = new Database(dbPath);
+
+afterAll(() => {
+ otherProcess.close();
+ db.close();
+ rmSync(root, { recursive: true, force: true });
+});
+
+async function bridge() {
+ const mod = await import('../src/memory/memory-bridge.js');
+ mod.__setMemoryBridgeRegistryForTests({
+ getAgentDB: () => ({ database: db, embedder: null }),
+ get: (kind: string) => (kind === 'tieredCache' ? cache : null),
+ });
+ return mod;
+}
+
+let cache = makeTieredCache();
+
+beforeEach(() => {
+ cache = makeTieredCache();
+});
+
+describe('bridgeGetEntry β€” writes by another process sharing the store', () => {
+ it('returns the value another process updated, not the cached one', async () => {
+ const { bridgeStoreEntry, bridgeGetEntry } = await bridge();
+ const ns = 'cross-process-update';
+ await bridgeStoreEntry({ key: 'k', value: 'v1', namespace: ns, generateEmbeddingFlag: false, dbPath });
+
+ const first = await bridgeGetEntry({ key: 'k', namespace: ns, dbPath });
+ expect(first!.entry!.content).toBe('v1');
+
+ // The cache still does its job when nobody else has written.
+ const second = await bridgeGetEntry({ key: 'k', namespace: ns, dbPath });
+ expect(second!.cacheHit).toBe(true);
+ expect(second!.entry!.content).toBe('v1');
+
+ otherProcess
+ .prepare('UPDATE memory_entries SET content = ?, updated_at = ? WHERE namespace = ? AND key = ?')
+ .run('v2', Date.now(), ns, 'k');
+
+ const third = await bridgeGetEntry({ key: 'k', namespace: ns, dbPath });
+ expect(third!.entry!.content).toBe('v2');
+ expect(third!.cacheHit).toBe(false);
+ });
+
+ it('reports not-found for a key another process deleted', async () => {
+ const { bridgeStoreEntry, bridgeGetEntry } = await bridge();
+ const ns = 'cross-process-delete';
+ await bridgeStoreEntry({ key: 'k', value: 'doomed', namespace: ns, generateEmbeddingFlag: false, dbPath });
+ expect((await bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.entry!.content).toBe('doomed');
+
+ // Same soft delete bridgeDeleteEntry performs.
+ otherProcess
+ .prepare(`UPDATE memory_entries SET status = 'deleted', updated_at = ? WHERE namespace = ? AND key = ?`)
+ .run(Date.now(), ns, 'k');
+
+ const after = await bridgeGetEntry({ key: 'k', namespace: ns, dbPath });
+ expect(after!.success).toBe(true);
+ expect(after!.found).toBe(false);
+ });
+
+ it("never queries data_version on agentdb's sql.js fallback (isWasm)", async () => {
+ const mod = await import('../src/memory/memory-bridge.js');
+ const probes: string[] = [];
+ // agentdb's SqlJsDatabase has pragma()/prepare() but rejects data_version
+ // (with a console error); the bridge must not ask it.
+ const wasmDb = new Proxy(db, {
+ get(target, prop) {
+ if (prop === 'pragma') return (sql: string, ...a: unknown[]) => { probes.push(`pragma ${sql}`); return (target as any).pragma(sql, ...a); };
+ if (prop === 'prepare') return (sql: string) => { if (/data_version/i.test(sql)) probes.push(sql); return target.prepare(sql); };
+ const v = Reflect.get(target, prop, target);
+ return typeof v === 'function' ? v.bind(target) : v;
+ },
+ });
+ mod.__setMemoryBridgeRegistryForTests({
+ getAgentDB: () => ({ database: wasmDb, embedder: null, isWasm: true }),
+ get: (kind: string) => (kind === 'tieredCache' ? cache : null),
+ });
+ const ns = 'wasm-fallback';
+ await mod.bridgeStoreEntry({ key: 'k', value: 'w', namespace: ns, generateEmbeddingFlag: false, dbPath });
+ expect((await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.entry!.content).toBe('w');
+ expect((await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.cacheHit).toBe(true);
+ expect(probes.filter((p) => /data_version/i.test(p))).toEqual([]);
+ });
+
+ it('stops probing a handle whose data_version check throws', async () => {
+ const mod = await import('../src/memory/memory-bridge.js');
+ let attempts = 0;
+ const brokenDb = new Proxy(db, {
+ get(target, prop) {
+ if (prop === 'prepare') {
+ return (sql: string) => {
+ if (/data_version/i.test(sql)) { attempts++; throw new Error('unsupported pragma'); }
+ return target.prepare(sql);
+ };
+ }
+ if (prop === 'pragma') {
+ return (sql: string, ...a: unknown[]) => {
+ if (/data_version/i.test(sql)) { attempts++; throw new Error('unsupported pragma'); }
+ return (target as any).pragma(sql, ...a);
+ };
+ }
+ const v = Reflect.get(target, prop, target);
+ return typeof v === 'function' ? v.bind(target) : v;
+ },
+ });
+ mod.__setMemoryBridgeRegistryForTests({
+ getAgentDB: () => ({ database: brokenDb, embedder: null }),
+ get: (kind: string) => (kind === 'tieredCache' ? cache : null),
+ });
+ const ns = 'broken-probe';
+ await mod.bridgeStoreEntry({ key: 'k', value: 'b', namespace: ns, generateEmbeddingFlag: false, dbPath });
+ for (let i = 0; i < 3; i++) {
+ expect((await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.entry!.content).toBe('b');
+ }
+ expect(attempts).toBe(1);
+ });
+
+ it('never probes a non-native handle even when isWasm is not reported', async () => {
+ const mod = await import('../src/memory/memory-bridge.js');
+ const probes: string[] = [];
+ // Shape of agentdb's SqlJsDatabase: has pragma()/prepare(), but no
+ // better-sqlite3 `inTransaction`. (A forwarding object, not a Proxy of the
+ // real handle: a Proxy can't hide the native class's own properties.)
+ const sqlJsLike = new Proxy({} as Record<string | symbol, unknown>, {
+ has: (_t, p) => p !== 'inTransaction' && Reflect.has(db, p),
+ get(_t, prop) {
+ if (prop === 'pragma') return (sql: string, ...a: unknown[]) => { probes.push(`pragma ${sql}`); return (db as any).pragma(sql, ...a); };
+ if (prop === 'prepare') return (sql: string) => { if (/data_version/i.test(sql)) probes.push(sql); return db.prepare(sql); };
+ if (prop === 'inTransaction') return undefined;
+ const v = Reflect.get(db, prop, db);
+ return typeof v === 'function' ? v.bind(db) : v;
+ },
+ });
+ mod.__setMemoryBridgeRegistryForTests({
+ getAgentDB: () => ({ database: sqlJsLike, embedder: null }),
+ get: (kind: string) => (kind === 'tieredCache' ? cache : null),
+ });
+ const ns = 'no-intransaction';
+ await mod.bridgeStoreEntry({ key: 'k', value: 's', namespace: ns, generateEmbeddingFlag: false, dbPath });
+ expect((await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.entry!.content).toBe('s');
+ expect((await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.cacheHit).toBe(true);
+ expect(probes.filter((p) => /data_version/i.test(p))).toEqual([]);
+ });
+
+ it('keeps checking after a transient failure of the check', async () => {
+ const mod = await import('../src/memory/memory-bridge.js');
+ let failNext = true;
+ // A handle whose data_version read fails once (e.g. SQLITE_BUSY), then works.
+ const flakyDb = new Proxy(db, {
+ get(target, prop) {
+ if (prop === 'prepare') {
+ return (sql: string) => {
+ const stmt = target.prepare(sql);
+ if (!/data_version/i.test(sql)) return stmt;
+ return { get: () => { if (failNext) { failNext = false; throw new Error('SQLITE_BUSY'); } return stmt.get(); } };
+ };
+ }
+ const v = Reflect.get(target, prop, target);
+ return typeof v === 'function' ? v.bind(target) : v;
+ },
+ });
+ mod.__setMemoryBridgeRegistryForTests({
+ getAgentDB: () => ({ database: flakyDb, embedder: null }),
+ get: (kind: string) => (kind === 'tieredCache' ? cache : null),
+ });
+ const ns = 'transient-failure';
+ await mod.bridgeStoreEntry({ key: 'k', value: 'v1', namespace: ns, generateEmbeddingFlag: false, dbPath });
+ expect((await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.entry!.content).toBe('v1'); // check throws here
+ expect((await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.entry!.content).toBe('v1');
+
+ otherProcess
+ .prepare('UPDATE memory_entries SET content = ?, updated_at = ? WHERE namespace = ? AND key = ?')
+ .run('v2', Date.now(), ns, 'k');
+
+ expect((await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.entry!.content).toBe('v2');
+ });
+
+ it('drops an already-warm cache when the check itself fails', async () => {
+ const mod = await import('../src/memory/memory-bridge.js');
+ let failNext = false;
+ // Same flaky handle, but the failure is armed AFTER the cache is warm and
+ // after another process has written: the read must not trust the cache it
+ // could not validate.
+ const flakyDb = new Proxy(db, {
+ get(target, prop) {
+ if (prop === 'prepare') {
+ return (sql: string) => {
+ const stmt = target.prepare(sql);
+ if (!/data_version/i.test(sql)) return stmt;
+ return { get: () => { if (failNext) { failNext = false; throw new Error('SQLITE_BUSY'); } return stmt.get(); } };
+ };
+ }
+ const v = Reflect.get(target, prop, target);
+ return typeof v === 'function' ? v.bind(target) : v;
+ },
+ });
+ mod.__setMemoryBridgeRegistryForTests({
+ getAgentDB: () => ({ database: flakyDb, embedder: null }),
+ get: (kind: string) => (kind === 'tieredCache' ? cache : null),
+ });
+ const ns = 'transient-failure-warm-cache';
+ await mod.bridgeStoreEntry({ key: 'k', value: 'v1', namespace: ns, generateEmbeddingFlag: false, dbPath });
+ await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }); // warms the cache
+ expect((await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.cacheHit).toBe(true);
+
+ otherProcess
+ .prepare('UPDATE memory_entries SET content = ?, updated_at = ? WHERE namespace = ? AND key = ?')
+ .run('v2', Date.now(), ns, 'k');
+
+ failNext = true; // the check can't see the foreign commit β€” it must fail safe
+ const after = await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath });
+ expect(after!.cacheHit).toBe(false);
+ expect(after!.entry!.content).toBe('v2');
+ });
+
+ it('drops an already-warm cache when the check returns an unusable answer', async () => {
+ const mod = await import('../src/memory/memory-bridge.js');
+ let breakNext = false;
+ // The check neither throws nor answers: `PRAGMA data_version` yields a row
+ // without a usable number. That is no more evidence the store is unchanged
+ // than a throw is, so it must take the same path as the throwing case.
+ const oddDb = new Proxy(db, {
+ get(target, prop) {
+ if (prop === 'prepare') {
+ return (sql: string) => {
+ const stmt = target.prepare(sql);
+ if (!/data_version/i.test(sql)) return stmt;
+ return { get: () => (breakNext ? { data_version: undefined } : stmt.get()) };
+ };
+ }
+ const v = Reflect.get(target, prop, target);
+ return typeof v === 'function' ? v.bind(target) : v;
+ },
+ });
+ mod.__setMemoryBridgeRegistryForTests({
+ getAgentDB: () => ({ database: oddDb, embedder: null }),
+ get: (kind: string) => (kind === 'tieredCache' ? cache : null),
+ });
+ const ns = 'unusable-answer-warm-cache';
+ await mod.bridgeStoreEntry({ key: 'k', value: 'v1', namespace: ns, generateEmbeddingFlag: false, dbPath });
+ await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }); // warms the cache
+ expect((await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.cacheHit).toBe(true);
+
+ otherProcess
+ .prepare('UPDATE memory_entries SET content = ?, updated_at = ? WHERE namespace = ? AND key = ?')
+ .run('v2', Date.now(), ns, 'k');
+
+ breakNext = true; // the check cannot validate β€” it must not trust the cache
+ const after = await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath });
+ expect(after!.cacheHit).toBe(false);
+ expect(after!.entry!.content).toBe('v2');
+
+ // And the baseline was not advanced on an unusable answer: once the check
+ // works again it still sees the foreign commit rather than skipping it.
+ breakNext = false;
+ expect((await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.entry!.content).toBe('v2');
+ });
+
+ it('clears the cache it inherits when the handle is replaced', async () => {
+ const { bridgeStoreEntry, bridgeGetEntry } = await bridge();
+ const ns = 'replaced-handle';
+ await bridgeStoreEntry({ key: 'k', value: 'v', namespace: ns, generateEmbeddingFlag: false, dbPath });
+ await bridgeGetEntry({ key: 'k', namespace: ns, dbPath }); // warms the cache
+ expect((await bridgeGetEntry({ key: 'k', namespace: ns, dbPath }))!.cacheHit).toBe(true);
+
+ // A new handle (e.g. the registry reopened the database) has no baseline
+ // of its own, so its first check must not trust the cache it inherits.
+ const mod = await import('../src/memory/memory-bridge.js');
+ const reopened = new Proxy(db, {
+ get(target, prop) {
+ const v = Reflect.get(target, prop, target);
+ return typeof v === 'function' ? v.bind(target) : v;
+ },
+ });
+ mod.__setMemoryBridgeRegistryForTests({
+ getAgentDB: () => ({ database: reopened, embedder: null }),
+ get: (kind: string) => (kind === 'tieredCache' ? cache : null),
+ });
+ const first = await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath });
+ expect(first!.cacheHit).toBe(false);
+ expect(first!.entry!.content).toBe('v');
+ });
+
+ it('still answers the read when the handle itself throws on the `in` check', async () => {
+ const { bridgeStoreEntry, bridgeGetEntry } = await bridge();
+ const ns = 'hostile-handle';
+ await bridgeStoreEntry({ key: 'k', value: 'hostile', namespace: ns, generateEmbeddingFlag: false, dbPath });
+
+ const mod = await import('../src/memory/memory-bridge.js');
+ // An exotic handle whose `has` trap explodes, so `'inTransaction' in db`
+ // throws. The check must swallow it and leave the read intact.
+ const hostileDb = new Proxy(db, {
+ has() { throw new Error('exotic handle: `in` explodes'); },
+ get(target, prop) {
+ const v = Reflect.get(target, prop, target);
+ return typeof v === 'function' ? v.bind(target) : v;
+ },
+ });
+ mod.__setMemoryBridgeRegistryForTests({
+ getAgentDB: () => ({ database: hostileDb, embedder: null }),
+ get: (kind: string) => (kind === 'tieredCache' ? cache : null),
+ });
+ const r = await mod.bridgeGetEntry({ key: 'k', namespace: ns, dbPath });
+ expect(r).not.toBeNull();
+ expect(r!.found).toBe(true);
+ expect(r!.entry!.content).toBe('hostile');
+ });
+
+ it("this process's own writes do not flush the cache", async () => {
+ const { bridgeStoreEntry, bridgeGetEntry } = await bridge();
+ const ns = 'own-writes';
+ await bridgeStoreEntry({ key: 'a', value: 'A', namespace: ns, generateEmbeddingFlag: false, dbPath });
+ await bridgeStoreEntry({ key: 'b', value: 'B', namespace: ns, generateEmbeddingFlag: false, dbPath });
+ await bridgeGetEntry({ key: 'a', namespace: ns, dbPath }); // populates 'a'
+
+ // An unrelated write on this connection (plus the access_count bumps the
+ // reads themselves perform) must not look like a foreign commit.
+ await bridgeStoreEntry({ key: 'c', value: 'C', namespace: ns, generateEmbeddingFlag: false, dbPath });
+ await bridgeGetEntry({ key: 'b', namespace: ns, dbPath });
+
+ const again = await bridgeGetEntry({ key: 'a', namespace: ns, dbPath });
+ expect(again!.cacheHit).toBe(true);
+ expect(again!.entry!.content).toBe('A');
+ });
+});
diff --git a/v3/@claude-flow/cli/src/memory/memory-bridge.ts b/v3/@claude-flow/cli/src/memory/memory-bridge.ts
index e247c93900..3305c90ccb 100644
--- a/v3/@claude-flow/cli/src/memory/memory-bridge.ts
+++ b/v3/@claude-flow/cli/src/memory/memory-bridge.ts
@@ -573,6 +573,79 @@ async function cacheGet(registry: any, cacheKey: string): Promise<any | null> {
}
}
+/**
+ * Cross-process cache coherence.
+ *
+ * The TieredCache lives in this process, but the database file is shared:
+ * Claude Code, Codex and Grok each run their own `mcp start` against the
+ * same `.swarm/` store, and each process only invalidates entries on its
+ * OWN writes. A key another process updated or deleted kept coming back
+ * from this process's cache β€” old value, `found: true` β€” until the cached
+ * entry expired (TieredCache TTL, 5 minutes by default; reads don't extend
+ * it).
+ *
+ * SQLite's `PRAGMA data_version` changes whenever a DIFFERENT connection has
+ * committed to the database file since this connection last asked, and never
+ * for this connection's own writes (https://sqlite.org/pragma.html#pragma_data_version).
+ * Checking it before a cached read is an exact "has anyone else written?"
+ * test that costs one pragma call. When it moves, drop the whole cache:
+ * every cached shape was derived from the old database state. The first
+ * check on a handle records its baseline and clears: a no-op for a fresh
+ * handle, and the right thing if a handle is ever replaced under a live
+ * cache.
+ *
+ * Native better-sqlite3 handles only. agentdb's sql.js fallback works on a
+ * private in-memory image that never sees another process's commits, so
+ * there is nothing to detect; it is skipped rather than probed. A handle
+ * that cannot prepare the check is remembered and never probed again; a
+ * check that fails on a given read (e.g. SQLITE_BUSY) clears the cache for
+ * safety and is simply retried on the next read.
+ */
+const _cacheDataVersionStmts = new WeakMap<object, { get(): { data_version?: unknown } | undefined }>();
+const _cacheDataVersions = new WeakMap<object, number>();
+const _cacheDataVersionUnsupported = new WeakSet<object>();
+
+function dropCacheIfDbChangedElsewhere(registry: any, ctx: { db: any; agentdb?: any }): void {
+ // Never let this check break the read it guards: any throw falls back to
+ // the pre-fix behaviour (a possibly stale hit).
+ try {
+ const db = ctx.db;
+ if (!db || ctx.agentdb?.isWasm === true || !('inTransaction' in db)) return;
+ if (_cacheDataVersionUnsupported.has(db)) return;
+ let stmt = _cacheDataVersionStmts.get(db);
+ if (!stmt) {
+ try {
+ stmt = db.prepare('PRAGMA data_version');
+ _cacheDataVersionStmts.set(db, stmt!);
+ } catch {
+ _cacheDataVersionUnsupported.add(db); // structural: this handle can't answer
+ return;
+ }
+ }
+ let cache: any = null;
+ try { cache = registry.get('tieredCache'); } catch { /* no cache, nothing to drop */ }
+ try {
+ const version = stmt!.get()?.data_version;
+ if (typeof version !== 'number') {
+ // #3360: an unusable answer is not evidence the store is unchanged.
+ // Same posture as the catch below β€” a check we cannot validate drops
+ // the cache rather than trusting it, and leaves the baseline alone so
+ // the next read re-checks.
+ if (cache && typeof cache.clear === 'function') cache.clear();
+ return;
+ }
+ if (_cacheDataVersions.get(db) === version) return;
+ if (cache && typeof cache.clear === 'function') cache.clear();
+ _cacheDataVersions.set(db, version);
+ } catch {
+ // Transient (e.g. SQLITE_BUSY): don't trust the cache for this read.
+ if (cache && typeof cache.clear === 'function') cache.clear();
+ }
+ } catch {
+ // Non-fatal.
+ }
+}
+
/**
* Write to TieredCache after DB write.
*/
@@ -1451,6 +1524,7 @@ export async function bridgeGetEntry(options: {
const safeNs = String(namespace).replace(/:/g, '_');
const safeKey = String(key).replace(/:/g, '_');
const cacheKey = `entry:${safeNs}:${safeKey}`;
+ dropCacheIfDbChangedElsewhere(registry, ctx);
const cached = await cacheGet(registry, cacheKey);
if (cached && cached.content) {
return {