Mnemopi memory ${namespace} not found in any scoped bank. Us

Error message

Mnemopi memory ${namespace} not found in any scoped bank. Use `recall` to list available ids.

What it means

When a mnemopi backend is live, any non-'root' host is looked up as a memory id across all scoped session banks via tryResolveMnemopiMemory. If no bank contains that id, resolve throws pointing the caller at `recall` to discover valid ids — the id may be stale, from another project, or mistyped.

Source

Thrown at packages/coding-agent/src/internal-urls/memory-protocol.ts:333

			if (hindsightActive) {
				// Hindsight keeps memories server-side and exposes no
				// `memory://<id>` addressing, yet the shared `recall` tool
				// description still steers a follow-up `read memory://<id>`.
				// Return a corrective pointer so that stray read self-corrects in
				// one turn instead of derailing on the generic namespace error
				// (issue #7587).
				throw new Error(
					"Hindsight memories are not addressable via memory://. Recall results are final — use `recall` to search or `reflect` to synthesize. `read memory://<id>` is only available with memory.backend=mnemopi.",
				);
			}
			if (mnemopiStates.length === 0) {
				throw new Error(
					`Unknown memory namespace: ${namespace}. Supported: ${MEMORY_NAMESPACE} (file-backed memory summary), or a mnemopi memory id when memory.backend=mnemopi is active.`,
				);
			}
			const hit = tryResolveMnemopiMemory(namespace);
			if (hit) return renderMnemopiMemory(url, hit);
			throw new Error(
				`Mnemopi memory ${namespace} not found in any scoped bank. Use \`recall\` to list available ids.`,
			);
		}

		const roots = memoryRootsForContext(context);
		if (roots.length === 0) {
			throw new Error(
				"Memory artifacts are not available for this project yet. Run a session with memories enabled first.",
			);
		}

		let anyExists = false;
		for (const root of roots) {
			try {
				await fs.stat(root);
				anyExists = true;
			} catch (error) {
				if (isEnoent(error)) continue;

View on GitHub (pinned to 9690622007)

Solutions

Run `recall` to list the memory ids currently available in scoped banks.
Re-run the recall query that produced the id and use the fresh id from its output.
Check the id for truncation or transcription errors before retrying.

Example fix

// before
read("memory://mem_old_session_id")
// after
const { id } = await recall({ query: "<topic>" });
read(`memory://${id}`);

Defensive patterns

Strategy: try-catch

Validate before calling

// obtain ids only from a current recall() call; never reuse ids across sessions

Try / catch

try {
  return await handler.resolve(parseInternalUrl(`memory://${id}`), ctx);
} catch (err) {
  if (err instanceof Error && err.message.includes("not found in any scoped bank")) {
    const fresh = await recall({ query: topic });
    return await handler.resolve(parseInternalUrl(`memory://${fresh.id}`), ctx);
  }
  throw err;
}

Prevention

Re-recall instead of caching memory ids across turns or sessions.
Run recall to enumerate valid ids before reading.
Copy ids exactly — no truncation or manual transcription.

When it happens

Trigger: Resolving memory://<id> with mnemopi active but getScopedMemory(id) returns null in every registered session's scoped banks — expired/evicted row, id from a different session or project, or a typo.

Common situations: Agent recalls an id earlier in the session but the row was later updated/evicted via memory_edit; resuming work referencing ids from a previous session's banks; cross-project id reuse.

Related errors

AI-assisted analysis of can1357/oh-my-pi@9690622007 (2026-08-31). Data as JSON: /api/errors/908cad617522333c. Report an issue: GitHub.