memoryrouter-codex 1.6.1 → 1.7.0

package/README.md

@@ -2,22 +2,22 @@
 
 Native Codex integration for durable MemoryRouter memory. It uses Codex's current MCP, lifecycle hooks, and `AGENTS.md` surfaces rather than pretending that model-selected MCP calls alone are automatic memory.
 
-> **Release status:** `memoryrouter-codex@1.1.0` is the published npm release. Its automatic capture is message-only: one user request plus the final assistant response, with no tool payloads.
+> **Release status:** `memoryrouter-codex` is the published npm release. Its automatic capture is message-only: one user request plus the final assistant response, with no tool payloads.
 
 ## What this integration does
 
 | Layer | Behavior |
 | --- | --- |
-| `UserPromptSubmit` hook | Searches MemoryRouter before every prompt and injects bounded, project-scoped context as developer context. |
+| `UserPromptSubmit` hook | Searches your whole MemoryRouter vault before every prompt and injects bounded context as developer context. The vault is shared with Claude Code and every other MemoryRouter surface. |
 | `Stop` hook | Captures only the user request and final assistant response after each completed turn. Tool names, inputs, and results are excluded. |
 | `SubagentStop` hook | Captures the stable final outcome of completed subagents without parsing their unstable transcript files. |
 | `PreCompact` / compact `SessionStart` | Checkpoints only the current user request and final assistant response when present, then recalls context before Codex continues after compaction. |
 | `SessionEnd` | Best-effort message-only final checkpoint within Codex's three-second SessionEnd budget. |
 | Remote MCP | OAuth-based explicit search/store through `https://mcp.memoryrouter.ai/mcp`. |
-| Local MCP fallback | API-key-authenticated stdio tools with strict project filtering, handles, local suppression, status, and full-vault clear confirmation. |
+| Local MCP fallback | API-key-authenticated stdio tools over the same whole vault, with handles, local suppression, status, and full-vault clear confirmation. |
 | `AGENTS.md` | Tells Codex when to recall/store and how MemoryRouter coexists with native Memories. |
 
-MemoryRouter is the **cross-machine, cross-tool, team-shareable, and auditable** layer. Codex's native Memories remain useful as an automated local personal recall layer.
+MemoryRouter is the **cross-machine, cross-tool, team-shareable, and auditable** layer: one memory across every session, repo and tool, shared by Codex, Claude Code, ChatGPT, and Claude. Codex's native Memories remain useful as an automated local personal recall layer.
 
 ## Requirements and supported surfaces
 
@@ -39,13 +39,13 @@ Obtain a MemoryRouter memory key from your account. Pass it on stdin so it does
 
 ```bash
 printf '%s' "$MEMORYROUTER_API_KEY" | \
-  npx -y memoryrouter-codex@1.1.0 init --scope user --auth oauth --api-key-stdin
+  npx -y memoryrouter-codex init --scope user --auth oauth --api-key-stdin
 
 codex mcp login memoryrouter
 memoryrouter-codex doctor --scope user
 ```
 
-Then start Codex and inspect:
+Then start Codex and inspect (trust the MemoryRouter hook definitions in `/hooks`):
 
 ```text
 /mcp verbose
@@ -54,6 +54,8 @@ Then start Codex and inspect:
 
 The API key is written to `~/.memoryrouter/codex/config.json` with mode `0600`; the directory is `0700`. It is never written to `config.toml`, `hooks.json`, `AGENTS.md`, or a repository.
 
+Already using MemoryRouter in Claude Code? When no Codex key is configured, the hooks reuse the `memoryrouter-claude` key in `~/.memoryrouter/config.json`, so both agents use the same vault (one memory for every session, repo and tool) with no second paste. Key precedence: `MEMORYROUTER_API_KEY`, then the Codex private config, then the Claude Code config.
+
 If you prefer not to persist the key, omit `--api-key-stdin` and ensure `MEMORYROUTER_API_KEY` is in the environment of the Codex host. Without either source, remote OAuth MCP tools can work after login, but automatic hooks intentionally become no-op/fail-open.
 
 ### Project scope
@@ -61,7 +63,7 @@ If you prefer not to persist the key, omit `--api-key-stdin` and ensure `MEMORYR
 ```bash
 cd /path/to/repository
 printf '%s' "$MEMORYROUTER_API_KEY" | \
-  npx -y memoryrouter-codex@1.1.0 init --scope project --auth oauth --api-key-stdin
+  npx -y memoryrouter-codex init --scope project --auth oauth --api-key-stdin
 codex mcp login memoryrouter
 ```
 
@@ -71,7 +73,7 @@ This writes managed blocks/files under the repository's `AGENTS.md` and `.codex/
 
 ```bash
 printf '%s' "$MEMORYROUTER_API_KEY" | \
-  npx -y memoryrouter-codex@1.1.0 init --scope user --auth api-key --api-key-stdin
+  npx -y memoryrouter-codex init --scope user --auth api-key --api-key-stdin
 ```
 
 This uses a local stdio MCP server and the MemoryRouter API. It does not put the memory key in Codex config. The fallback tools are:
@@ -110,25 +112,27 @@ The installer preserves unrelated TOML byte-for-byte outside its managed block.
 
 Hooks are merged into `hooks.json`; foreign hooks remain. Re-running `init` upgrades/replaces only MemoryRouter-owned handlers. `uninstall` removes only owned handlers and managed blocks.
 
-## Project identity and scoping
+## One vault per user (shared with Claude Code and every MemoryRouter surface)
+
+Since **1.7.0**, every hook call (recall before each prompt, capture after each turn, compaction checkpoints, post-compaction recall) and every local MCP tool call reads and writes your **whole vault**. No `session_id` is sent, so there is no per-session or per-repository partition. That gives you:
 
-The runtime computes:
+- **A new Codex session recalls earlier sessions**, in this repository and every other one.
+- **Codex and Claude Code share one memory.** A decision captured in Claude Code in repo A is recalled by Codex in repo B, and the other way round (requires `memoryrouter-claude` 2.7.0 or newer on the same vault).
+- **Everything else on the vault is recalled too:** saves from the hosted MCP (`store_memory` from ChatGPT, Claude, or `codex mcp login`), consolidated reflections, the server's pending buffer, and Codex envelopes from any release. Only handles you suppressed locally with `memory_forget` are hidden.
+
+**Repository tag.** Codex still computes the same `ccp_` id as Claude Code:
 
 ```text
-proj_<first 20 hex chars of SHA-256(canonical project identity)>
+ccp_<first 24 hex chars of SHA-256(canonical project identity)>
 ```
 
-Identity preference:
-
-1. Canonical `origin` git URL, with credentials removed and `.git` normalized.
-2. Git common directory (so local worktrees share a project).
-3. Absolute path fallback.
+from, in order, an explicit id (`MEMORYROUTER_PROJECT_ID` or `projectId` in `.memoryrouter.json`), the normalized git remote, the git common directory, then the directory path. It is metadata only: Codex stamps it on the turns it saves and labels recalled entries from the current repository as `this repo`. It never limits what is recalled. Only the opaque hash leaves the machine.
 
-Only the opaque handle is stored remotely. Local paths are not sent as identity metadata. A canonical remote makes identity stable across worktrees and machines.
+**One user, one vault.** When you also connect MemoryRouter over OAuth (`codex mcp login memoryrouter`, ChatGPT, Claude), pick the same vault your hook key belongs to. `init` asks `https://auth.memoryrouter.ai/v1/vault-binding` whether the hook key is the vault your OAuth connections selected: on a mismatch it stops before writing anything and names the selected vault; with no connection yet it tells you which vault to pick at login. `doctor` reports the same `one-vault` check. The response never contains a key.
 
-Automatic memories use an envelope containing project handle, stable memory handle, kind, and capture time. Retrieval requests extra semantic candidates and then **strictly filters** to the current project handle before context injection. Legacy/unscoped vault records remain available through explicit remote MCP search but are not automatically injected in project mode.
+`.memoryrouterignore` (or `enabled: false` in `.memoryrouter.json`) still disables hooks for a repository. The pre-1.7 settings `retrievalScope`, `includeGlobal`, and `memoryScope` are ignored and removed from the private config.
 
-Set `retrievalScope` to `"vault"` in the private config only if you intentionally want unscoped automatic recall.
+**Upgrading from 1.6.x.** Releases before 1.7.0 used a per-Codex-session partition (`mrcodex:<project>:<session>`), so every new session started empty and Codex never saw Claude Code's memory. When 1.7.0 shipped, those partitions (and `memoryrouter-claude`'s per-repository `ccp_` partitions) were moved into each vault's main memory server-side, with stored embeddings kept, exact repeats skipped, and unflushed buffers saved, so old memories are recalled again with nothing lost or duplicated. Re-run `init` to upgrade the installed runtime.
 
 ## Historical import (agent-driven)
 
@@ -222,15 +226,15 @@ Doctor checks Codex version, managed config, runtime version, hook count, `AGENT
 Upgrade idempotently by re-running the pinned/new package:
 
 ```bash
-npx -y memoryrouter-codex@1.1.0 init --scope user
+npx -y memoryrouter-codex init --scope user
 ```
 
 Uninstall:
 
 ```bash
-npx -y memoryrouter-codex@1.1.0 uninstall --scope user
+npx -y memoryrouter-codex uninstall --scope user
 # or
-npx -y memoryrouter-codex@1.1.0 uninstall --scope project --project-dir /repo
+npx -y memoryrouter-codex uninstall --scope project --project-dir /repo
 ```
 
 Uninstall deliberately retains `~/.memoryrouter/codex/` because another project installation may use the credentials and local suppression state. Delete that private directory manually only when no integration uses it.
@@ -242,7 +246,7 @@ Uninstall deliberately retains `~/.memoryrouter/codex/` because another project
 - Tool-call records are intentionally excluded. MemoryRouter does not store tool names, tool IDs, tool inputs, tool results, commands, patches, or other `PostToolUse` payloads from automatic Codex capture. Important outcomes must appear in the final assistant response to be retained.
 - Some specialized tool paths can opt out of hooks. Codex documents hooks as a useful extension surface, not a complete enforcement boundary.
 - SessionEnd can happen after a 30-minute idle period and has a three-second maximum. It is a best-effort checkpoint; normal `Stop` capture is the primary write path.
-- Project scoping is strict for this package's automatic retrieval/local MCP. The existing hosted remote MCP server has no first-class project argument, so use local tools/hooks when cross-project isolation is required.
+- Everything shares one vault per user. Strict isolation between two bodies of work requires a separate account and vault.
 - Per-memory server deletion is not available through the current API. Local suppression and explicit full-vault clear are accurately labeled.
 - API-level idempotency is not yet available; timeout-after-acceptance duplicates remain possible.
 

package/bin/cli.cjs

@@ -23,7 +23,7 @@ function parseArgs(argv) {
 }
 
 function usage() {
-  return `memoryrouter-codex ${INTEGRATION_VERSION}\n\nUsage:\n  memoryrouter-codex init [--scope user|project] [--auth oauth|api-key]\n                          [--project-dir PATH] [--api-key-stdin]\n                          [--no-hooks] [--no-agents]\n  memoryrouter-codex doctor [--scope user|project] [--project-dir PATH] [--offline]\n  memoryrouter-codex uninstall [--scope user|project] [--project-dir PATH]\n  memoryrouter-codex reflect [--tier 1|2] [--batches N|all] [--max-tokens N] [--dry-run]\n  memoryrouter-codex import [--instructions [--run]] [--file PATH] [--dismiss] [--yes]\n  memoryrouter-codex mcp-server\n\nImport:\n  Import historical Codex conversations into your vault. --instructions\n  fetches the server's extraction prompt for the host agent to execute\n  (--run spawns it via codex exec); --file uploads a JSONL extract with a\n  preview, price quote, explicit approval (--yes for non-interactive),\n  idempotent batches, and resume; --dismiss silences the import nudge\n  permanently. Re-running --file is always safe: committed batches replay\n  for free and duplicates are never re-billed.\n\nReflect:\n  Consolidates unconsolidated memories into reflections using Codex itself as\n  the model (codex exec, you pay your own inference). Server-authored\n  instructions; resumable; no local state. --dry-run prints the checkout and\n  lets the lease expire without committing.\n  Automatic mode: when the server reports consolidation debt above its\n  threshold, the hooks spawn this same loop in the background (max 3 batches\n  per trigger, 30 minute cooldown, machine-wide lockfile at\n  ~/.memoryrouter/consolidate.lock). Opt out with "autoConsolidate": false in\n  ~/.memoryrouter/codex/config.json. Logs: ~/.memoryrouter/consolidate.log\n\nAuth modes:\n  oauth    Current remote MCP at ${'https://mcp.memoryrouter.ai/mcp'} (default).\n           Run \`codex mcp login memoryrouter\` after init. Hooks additionally\n           require MEMORYROUTER_API_KEY or a key saved with --api-key-stdin.\n  api-key  Local stdio MCP fallback plus automatic hooks. The key is read only\n           from the environment/private config, never from project files.\n\nSecure key setup:\n  printf '%s' "$MEMORYROUTER_API_KEY" | memoryrouter-codex init --api-key-stdin\n`;
+  return `memoryrouter-codex ${INTEGRATION_VERSION}\n\nUsage:\n  memoryrouter-codex init [--scope user|project] [--auth oauth|api-key]\n                          [--project-dir PATH] [--api-key-stdin]\n                          [--no-hooks] [--no-agents]\n  memoryrouter-codex doctor [--scope user|project] [--project-dir PATH] [--offline]\n  memoryrouter-codex uninstall [--scope user|project] [--project-dir PATH]\n  memoryrouter-codex reflect [--tier 1|2] [--batches N|all] [--max-tokens N] [--dry-run]\n  memoryrouter-codex import [--instructions [--run]] [--file PATH] [--dismiss] [--yes]\n  memoryrouter-codex mcp-server\n\nImport:\n  Import historical Codex conversations into your vault. --instructions\n  fetches the server's extraction prompt for the host agent to execute\n  (--run spawns it via codex exec); --file uploads a JSONL extract with a\n  preview, price quote, explicit approval (--yes for non-interactive),\n  idempotent batches, and resume; --dismiss silences the import nudge\n  permanently. Re-running --file is always safe: committed batches replay\n  for free and duplicates are never re-billed.\n\nReflect:\n  Consolidates unconsolidated memories into reflections using Codex itself as\n  the model (codex exec, you pay your own inference). Server-authored\n  instructions; resumable; no local state. --dry-run prints the checkout and\n  lets the lease expire without committing.\n  Automatic mode: when the server reports consolidation debt above its\n  threshold, the hooks spawn this same loop in the background (max 3 batches\n  per trigger, 30 minute cooldown, machine-wide lockfile at\n  ~/.memoryrouter/consolidate.lock). Opt out with "autoConsolidate": false in\n  ~/.memoryrouter/codex/config.json. Logs: ~/.memoryrouter/consolidate.log\n\nAuth modes:\n  oauth    Current remote MCP at ${'https://mcp.memoryrouter.ai/mcp'} (default).\n           Run \`codex mcp login memoryrouter\` after init. Hooks additionally\n           require MEMORYROUTER_API_KEY, a key saved with --api-key-stdin, or\n           an existing memoryrouter-claude key in ~/.memoryrouter/config.json.\n  api-key  Local stdio MCP fallback plus automatic hooks. The key is read only\n           from the environment/private config, never from project files.\n\nSecure key setup:\n  printf '%s' "$MEMORYROUTER_API_KEY" | memoryrouter-codex init --api-key-stdin\n`;
 }
 
 function optionsFromArgs(args) {
@@ -111,14 +111,34 @@ async function main() {
   }
   const options = optionsFromArgs(args);
   if (command === 'init') {
+    // One user = one vault: before writing anything, make sure the Memory Key
+    // the hooks will use is the vault selected in OAuth (codex mcp login).
+    const { loadConfig, getApiKey } = require('../runtime/config.cjs');
+    const { checkVaultBinding, vaultLabel, VaultMismatchError } = require('../runtime/vault-binding.cjs');
+    const hookKey = options.apiKey || getApiKey(process.env, loadConfig(process.env));
+    let binding = null;
+    if (hookKey && !options.offline) {
+      binding = await checkVaultBinding(hookKey);
+      if (binding.status === 'mismatch') throw new VaultMismatchError(binding);
+    }
     const result = init(options);
     process.stdout.write(`MemoryRouter Codex ${INTEGRATION_VERSION} installed (${result.layout.scope}, ${result.auth}).\n`);
     process.stdout.write(`  config: ${result.layout.configFile}\n`);
     if (options.hooks !== false) process.stdout.write(`  hooks:  ${result.layout.hooksFile}\n`);
     if (options.agents !== false) process.stdout.write(`  guide:  ${result.layout.agentsFile}\n`);
-    if (result.auth === 'oauth') process.stdout.write('\nNext: codex mcp login memoryrouter\nThen open Codex and run /mcp verbose and /hooks.\n');
+    if (binding && binding.status === 'match') process.stdout.write(`\nVault check: the hooks use the same vault you selected in OAuth, ${vaultLabel(binding)}.\n`);
+    else if (binding && binding.status === 'mixed') process.stdout.write(`\nVault check: ${binding.message}\n`);
+    else if (binding && binding.status === 'unknown') process.stdout.write(`\nVault check skipped (${binding.message}). Run doctor later to confirm one vault.\n`);
+    if (result.auth === 'oauth') {
+      const pick = binding && binding.vault ? ` and select the vault ${vaultLabel(binding)} (the one your hooks use)` : '';
+      process.stdout.write(`\nNext: codex mcp login memoryrouter${pick}\nThen open Codex, run /hooks and trust the MemoryRouter hooks, and check /mcp verbose.\n`);
+    }
+    else process.stdout.write('\nNext: open Codex, run /hooks, and trust the MemoryRouter hooks.\n');
+    if (result.keySource === 'claude-code-config') process.stdout.write('\nAutomatic hooks reuse your Claude Code Memory Key (~/.memoryrouter/config.json), so both agents share the same vault.\n');
     if (!result.automaticMemory) process.stdout.write('\nRemote MCP tools are configured, but automatic hooks are fail-open/no-op until MEMORYROUTER_API_KEY is available or init is re-run with --api-key-stdin.\n');
-    process.stdout.write('\nRun: memoryrouter-codex doctor\n');
+    const scopeArgs = result.layout.scope === 'project' ? `--scope project --project-dir ${JSON.stringify(result.layout.root)}` : '--scope user';
+    process.stdout.write(`\nVerify: npx -y memoryrouter-codex@${INTEGRATION_VERSION} doctor ${scopeArgs}\n`);
+    process.stdout.write('One memory across every session, repo and tool: Codex, Claude Code (memoryrouter-claude) and the MemoryRouter MCP all use the same vault.\n');
     return;
   }
   if (command === 'doctor') {

package/lib/installer.cjs

@@ -4,7 +4,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execFileSync } = require('child_process');
-const { codexHome, dataHome, loadConfig, saveConfig, configPath } = require('../runtime/config.cjs');
+const { codexHome, dataHome, loadConfig, saveConfig, configPath, getApiKey, apiKeySource } = require('../runtime/config.cjs');
 const { resolveProject } = require('../runtime/project.cjs');
 const { MCP_ENDPOINT, INTEGRATION_VERSION } = require('../runtime/constants.cjs');
 const {
@@ -90,7 +90,14 @@ function init(options = {}) {
   fs.mkdirSync(manifestDir, { recursive: true, mode: 0o700 });
   const manifestName = Buffer.from(`${layout.scope}:${layout.root}`).toString('base64url');
   fs.writeFileSync(path.join(manifestDir, `${manifestName}.json`), `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
-  return { layout, auth, results, automaticMemory: Boolean(options.apiKey || process.env.MEMORYROUTER_API_KEY || loadConfig(options.env).apiKey) };
+  const env = options.env || process.env;
+  return {
+    layout,
+    auth,
+    results,
+    automaticMemory: Boolean(options.apiKey || getApiKey(env, loadConfig(options.env))),
+    keySource: options.apiKey ? 'codex-config' : apiKeySource(env, loadConfig(options.env)),
+  };
 }
 
 function uninstall(options = {}) {
@@ -181,14 +188,26 @@ async function doctor(options = {}) {
   addCheck(checks, 'agents', agentsText.includes(AGENTS_START) ? 'pass' : 'warn', agentsText.includes(AGENTS_START) ? 'Managed AGENTS.md guidance is present.' : 'Managed AGENTS.md guidance is missing.');
 
   const cfg = loadConfig(options.env);
-  const key = process.env.MEMORYROUTER_API_KEY || cfg.apiKey;
+  const keyEnv = options.env || process.env;
+  const key = getApiKey(keyEnv, cfg);
+  const keyFrom = apiKeySource(keyEnv, cfg);
   if (!key) addCheck(checks, 'automatic-auth', 'warn', 'No MemoryRouter API key is available. Remote OAuth tools can work after `codex mcp login memoryrouter`, but automatic hook retrieval/capture is disabled.');
   else {
     try {
       const { stats } = require('../runtime/api.cjs');
       const response = options.offline ? { ok: true, status: 0 } : await stats(key, { apiBase: cfg.apiBase, timeoutMs: 6000, retries: 0 });
-      addCheck(checks, 'automatic-auth', response.ok ? 'pass' : 'error', options.offline ? 'API key is configured (network check skipped).' : response.ok ? 'API key is valid; automatic retrieval/capture is active.' : `API key validation failed (HTTP ${response.status}).`);
+      addCheck(checks, 'automatic-auth', response.ok ? 'pass' : 'error', options.offline ? 'API key is configured (network check skipped).' : response.ok ? `API key is valid${keyFrom === 'claude-code-config' ? ' (reusing the Claude Code key in ~/.memoryrouter/config.json)' : ''}; automatic retrieval/capture is active.` : `API key validation failed (HTTP ${response.status}).`);
     } catch (error) { addCheck(checks, 'automatic-auth', 'error', `API key validation failed: ${error.message}`); }
+    if (!options.offline) {
+      const { checkVaultBinding, vaultLabel } = require('../runtime/vault-binding.cjs');
+      const binding = await checkVaultBinding(key, { env: options.env || process.env, timeoutMs: 5000 });
+      const levels = { match: 'pass', mismatch: 'error', mixed: 'warn', 'not-connected': 'info', unknown: 'warn' };
+      addCheck(checks, 'one-vault', levels[binding.status] || 'warn',
+        binding.status === 'match' ? `Hooks and your OAuth connection use the same vault ${vaultLabel(binding)}.`
+          : binding.status === 'not-connected' ? `No MemoryRouter OAuth connection yet. When you run \`codex mcp login memoryrouter\`, select ${vaultLabel(binding)}.`
+          : binding.status === 'unknown' ? `Vault match not checked (${binding.message}).`
+          : binding.message);
+    }
   }
 
   if (configText.includes('auth = "oauth"')) {
@@ -222,10 +241,11 @@ async function doctor(options = {}) {
     ? `Codex native Memories are enabled${externalDisabled ? ' and external-context generation is disabled.' : '. Consider [memories] disable_on_external_context = true to avoid re-extracting MemoryRouter-assisted chats.'}`
     : 'Codex native Memories are off or configured in another layer. This integration does not overwrite native-memory settings.');
 
-  const project = resolveProject(layout.root);
-  addCheck(checks, 'project-identity', project.portable ? 'pass' : 'warn', project.portable
-    ? `Project handle ${project.handle} is derived from a canonical git remote and is stable across worktrees/machines.`
-    : `Project handle ${project.handle} falls back to a local ${project.source}; add an origin remote for cross-machine identity.`);
+  // One vault per user: report the scope plainly, plus the repository label
+  // that captures from this directory carry (metadata only, never a wall).
+  const identityDir = layout.scope === 'user' ? (options.projectDir || process.cwd()) : layout.root;
+  const project = resolveProject(identityDir, { env: options.env, config: loadConfig(options.env) });
+  addCheck(checks, 'memory-scope', 'pass', `One vault for everything: every Codex session, every repository, Claude Code (memoryrouter-claude), and the MemoryRouter MCP read and write the same memory. Captures from this directory are tagged ${project.handle} (${project.source}) so recall can label them; the tag never limits what is recalled.`);
   addCheck(checks, 'cloud-surface', layout.scope === 'project' ? 'info' : 'warn', layout.scope === 'project'
     ? 'Project config/hooks can travel with the repository, but cloud environments must trust the project, install Node, and provide MEMORYROUTER_API_KEY. ChatGPT web does not consume local Codex config; use a hosted plugin/connector there.'
     : 'User-scope config covers local CLI, desktop app, and IDE on this host. Codex cloud and ChatGPT web do not inherit this machine-local config.');

package/lib/managed.cjs

@@ -130,7 +130,7 @@ function uninstallToml(file) {
 }
 
 function agentsBlock() {
-  return `## MemoryRouter memory\n\n- MemoryRouter is the durable cross-machine, cross-tool, and team/auditable memory layer. Codex native Memories may remain enabled as the local personal recall layer.\n- Automatic hooks search project-scoped memory before each prompt and capture completed turns when a MemoryRouter API key is configured.\n- For explicit recall, search MemoryRouter before answering questions about prior decisions, preferences, incidents, or unfinished work. Depending on auth mode, the tool is named \`search_memories\` or \`memory_search\`.\n- Store only concise, durable decisions, preferences, facts, and incident outcomes. Depending on auth mode, use \`store_memory\` or \`memory_store\`. Do not duplicate a completed turn that hooks already captured.\n- Keep and cite returned \`mrh_...\` handles when a specific memory must be referenced later.\n- Project scope is derived from the canonical git remote when available, so worktrees and machines share identity without uploading local paths.\n- If MemoryRouter is offline, continue the task without memory; never block work on recall or capture.`;
+  return `## MemoryRouter memory\n\n- MemoryRouter is the durable cross-machine, cross-tool, and team/auditable memory layer. Codex native Memories may remain enabled as the local personal recall layer.\n- Automatic hooks search project-scoped memory before each prompt and capture completed turns when a MemoryRouter API key is configured.\n- For explicit recall, search MemoryRouter before answering questions about prior decisions, preferences, incidents, or unfinished work. Depending on auth mode, the tool is named \`search_memories\` or \`memory_search\`.\n- Store only concise, durable decisions, preferences, facts, and incident outcomes. Depending on auth mode, use \`store_memory\` or \`memory_store\`. Do not duplicate a completed turn that hooks already captured.\n- Keep and cite returned \`mrh_...\` handles when a specific memory must be referenced later.\n- Project scope is derived from the canonical git remote when available, so worktrees and machines share identity without uploading local paths. It is the same project memory Claude Code uses through memoryrouter-claude, so decisions made in either agent are available in both.\n- If MemoryRouter is offline, continue the task without memory; never block work on recall or capture.`;
 }
 
 function installAgents(file) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "memoryrouter-codex",
-  "version": "1.6.1",
-  "description": "Automatic, project-scoped MemoryRouter memory for OpenAI Codex",
+  "version": "1.7.0",
+  "description": "Automatic MemoryRouter memory for OpenAI Codex: one vault shared by every session, repo and tool, including Claude Code",
   "license": "MIT",
   "type": "commonjs",
   "bin": {

package/runtime/api.cjs

@@ -60,11 +60,15 @@ function search(key, query, limit, options = {}) {
   });
 }
 
+// session_id is only sent when a caller passes one explicitly. The hooks never
+// do (one vault per user since 1.7.0): a session_id is a hard vault partition.
 function ingest(key, messages, sessionId, options = {}) {
+  const body = { messages, model: 'codex' };
+  if (sessionId) body.session_id = sessionId;
   return request('POST', '/v1/memory/ingest', {
     ...options,
     key,
-    body: { messages, session_id: sessionId, model: 'codex' },
+    body,
     retries: 0,
   });
 }

package/runtime/config.cjs

@@ -38,26 +38,58 @@ function defaultConfig() {
     apiBase: API_BASE,
     contextChars: DEFAULT_CONTEXT_CHARS,
     maxSearchResults: DEFAULT_SEARCH_RESULTS,
-    retrievalScope: 'project',
     forgottenHandles: [],
   };
 }
 
+// Pre-1.7 scoping keys (retrievalScope, includeGlobal, memoryScope) are dropped
+// on load: there is one vault per user and nothing left to scope.
+const RETIRED_KEYS = ['retrievalScope', 'includeGlobal', 'memoryScope'];
+
 function loadConfig(env = process.env) {
   const file = configPath(env);
   let parsed = {};
   try { parsed = JSON.parse(fs.readFileSync(file, 'utf8')); } catch { /* defaults */ }
-  return { ...defaultConfig(), ...(parsed && typeof parsed === 'object' ? parsed : {}) };
+  const merged = { ...defaultConfig(), ...(parsed && typeof parsed === 'object' ? parsed : {}) };
+  for (const retired of RETIRED_KEYS) delete merged[retired];
+  return merged;
 }
 
 function saveConfig(config, env = process.env) {
   const safe = { ...defaultConfig(), ...config, version: RUNTIME_SCHEMA_VERSION };
+  for (const retired of RETIRED_KEYS) delete safe[retired];
   atomicWriteJson(configPath(env), safe, 0o600);
   return safe;
 }
 
+// memoryrouter-claude keeps its key in ~/.memoryrouter/config.json. When the
+// user already set up Claude Code, Codex reuses that key so both agents land in
+// the same vault (one memory for every session, repo and tool) with no second
+// paste.
+function claudeConfigPath(env = process.env) {
+  const dir = env.MEMORYROUTER_CONFIG_DIR || path.join(env.HOME || os.homedir(), '.memoryrouter');
+  return path.join(path.resolve(dir), 'config.json');
+}
+
+function claudeApiKey(env = process.env) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(claudeConfigPath(env), 'utf8'));
+    const key = parsed && typeof parsed.apiKey === 'string' ? parsed.apiKey.trim() : '';
+    return /^mk[-_]/.test(key) ? key : null;
+  } catch {
+    return null;
+  }
+}
+
+function apiKeySource(env = process.env, config = loadConfig(env)) {
+  if (env.MEMORYROUTER_API_KEY) return 'environment';
+  if (config.apiKey) return 'codex-config';
+  if (claudeApiKey(env)) return 'claude-code-config';
+  return null;
+}
+
 function getApiKey(env = process.env, config = loadConfig(env)) {
-  return env.MEMORYROUTER_API_KEY || config.apiKey || null;
+  return env.MEMORYROUTER_API_KEY || config.apiKey || claudeApiKey(env) || null;
 }
 
 function safeId(value) {
@@ -147,6 +179,9 @@ module.exports = {
   loadConfig,
   saveConfig,
   getApiKey,
+  apiKeySource,
+  claudeApiKey,
+  claudeConfigPath,
   safeId,
   stateDir,
   sessionStatePath,

package/runtime/constants.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const INTEGRATION_VERSION = '1.6.1';
+const INTEGRATION_VERSION = '1.7.0';
 const RUNTIME_SCHEMA_VERSION = 1;
 const API_BASE = 'https://api.memoryrouter.ai';
 const MCP_ENDPOINT = 'https://mcp.memoryrouter.ai/mcp';

package/runtime/hook.cjs

@@ -87,7 +87,6 @@ async function handleInject(input, context) {
 
   const result = await searchScoped(prompt, {
     ...context,
-    sessionId: `mrcodex:${context.project.handle}:${input.session_id}`,
     timeoutMs: 5500,
   });
   recordHealth('inject', {
@@ -103,12 +102,19 @@ async function handleInject(input, context) {
   emitContext('UserPromptSubmit', maybeAppendNudge(result.context, result.reflection, input.session_id, context, result.importState));
 }
 
+const SESSION_START_QUERY = 'Current project decisions, conventions, unresolved work, preferences, and recent implementation context';
+
+// SessionStart fires for new, resumed, cleared, and compacted sessions. After
+// compaction (and on resume) the most useful recall is whatever the user was
+// last working on, so the query is the session's last prompt when one exists.
 async function handleSessionStart(input, context) {
   try { pruneState(context.env); } catch { /* cleanup is best effort */ }
-  const result = await searchScoped(
-    'Current project decisions, conventions, unresolved work, preferences, and recent implementation context',
-    { ...context, sessionId: `mrcodex:${context.project.handle}:${input.session_id}`, timeoutMs: 6500 },
-  );
+  const state = input.session_id ? loadSessionState(input.session_id, context.env) : {};
+  const continuing = input.source === 'compact' || input.source === 'resume';
+  const query = continuing && state.lastPrompt
+    ? `${state.lastPrompt.slice(0, 4000)}\n\n${SESSION_START_QUERY}`
+    : SESSION_START_QUERY;
+  const result = await searchScoped(query, { ...context, timeoutMs: 6500 });
   recordHealth('session-start', {
     ok: result.ok,
     source: input.source,
@@ -139,7 +145,6 @@ async function captureTurn(input, context, partial = false) {
     ...context,
     kind,
     handle,
-    sessionId: `mrcodex:${context.project.handle}:${sessionId}`,
     skipRemoteDedupe: true,
     timeoutMs: partial ? 10000 : 15000,
     tags: ['codex', kind],
@@ -181,7 +186,6 @@ async function captureSubagent(input, context) {
     ...context,
     kind: 'subagent',
     handle,
-    sessionId: `mrcodex:${context.project.handle}:${input.session_id}`,
     skipRemoteDedupe: true,
     timeoutMs: 12000,
     tags: ['codex', 'subagent', input.agent_type || 'unknown'],
@@ -200,12 +204,19 @@ async function run(kind, input, options = {}) {
   const env = options.env || process.env;
   const config = options.config || loadConfig(env);
   const key = options.key || getApiKey(env, config);
-  const project = options.project || resolveProject(input.cwd || process.cwd());
+  // One vault per user: every Codex session (new, resumed, or compacted), every
+  // repository, and every Claude Code session read and write the same core
+  // vault. The repository identity is metadata only (capture labels).
+  const project = options.project || resolveProject(input.cwd || process.cwd(), { env, config });
   const context = { env, config, key, project, cwd: input.cwd || process.cwd() };
   if (!key) {
     recordHealth(kind, { ok: false, reason: 'no-api-key', project: project.handle }, env);
     return;
   }
+  if (project.ignored) {
+    recordHealth(kind, { ok: true, skipped: 'project-disabled', project: project.handle }, env);
+    return;
+  }
   switch (kind) {
     case 'inject': return handleInject(input, context);
     case 'session-start': return handleSessionStart(input, context);

package/runtime/mcp-stdio.cjs

@@ -3,24 +3,24 @@
 
 const readline = require('readline');
 const fs = require('fs');
-const { loadConfig, getApiKey, configPath, auditPath, recordAudit, healthPath } = require('./config.cjs');
+const { loadConfig, getApiKey, apiKeySource, configPath, auditPath, recordAudit, healthPath } = require('./config.cjs');
 const { resolveProject } = require('./project.cjs');
-const { searchScoped, storeScoped, forgetLocally, parseEnvelope } = require('./memory.cjs');
+const { searchScoped, storeScoped, forgetLocally, displayBody } = require('./memory.cjs');
 const api = require('./api.cjs');
 const { contractFrom, validateEntries } = require('./reflect.cjs');
 const { INTEGRATION_VERSION } = require('./constants.cjs');
 
-const SERVER_INSTRUCTIONS = 'MemoryRouter provides durable cross-machine, cross-tool, team-shareable memory. Search project memory before answering questions about prior decisions, preferences, incidents, or unfinished work. Store concise durable decisions and preferences after they are established. Automatic Codex hooks may already capture completed turns, so do not duplicate them. Use returned memory handles when referring to a record. Codex native Memories remain the local personal recall layer; MemoryRouter is the shared and auditable layer.';
+const SERVER_INSTRUCTIONS = 'MemoryRouter provides durable cross-machine, cross-tool, team-shareable memory. The vault is one memory shared by every session, repository, and connected tool (Codex, Claude Code via memoryrouter-claude, the hosted MemoryRouter MCP, ChatGPT, Claude), so decisions made anywhere are recalled everywhere. Search memory before answering questions about prior decisions, preferences, incidents, or unfinished work. Store concise durable decisions and preferences after they are established. Automatic Codex hooks may already capture completed turns, so do not duplicate them. Use returned memory handles when referring to a record. Codex native Memories remain the local personal recall layer; MemoryRouter is the shared and auditable layer.';
 
 const TOOLS = [
   {
     name: 'memory_search',
-    description: "Search durable MemoryRouter memories. Defaults to the current git project and filters other projects out. Tier guide: tier 3 holds the highest-level consolidated reflections (identity, principles, what matters most), tier 2 holds reflections of specific meaningful events, tier 1 holds raw verbatim memories. Match filters to the question. Broad 'most important things we have done' questions: tiers [3], importance 8 or higher, large limit such as 250. Big-picture overviews like 'what do you know about this area or period': tiers [3] with no importance filter. Specific lookups like 'find the decision about X': omit tiers to search all tiers blended and leave importance unset; a high importance filter hides the specific detail you are looking for. Specific meaningful events without raw noise: tiers [2] or [2, 3]. Exact verbatim detail: if the detail is not already in context, drill down by lineage: search tiers [3] to find the relevant thread, then use memory_inspect on the result to see the tier 2 reflections it consolidated, then inspect those to reach the raw memories underneath. Direct tiers [1] search works when you know exact wording to match. Mixing tiers is legitimate; adjust the importance threshold to the question rather than always setting it high. Only reflections (tiers 2 and 3) carry importance ratings. For time-window questions like 'what happened last week' or 'lately' use memory_date_search instead.",
+    description: "Search durable MemoryRouter memories across the whole vault: every session, repository, and tool connected to it, including Claude Code. Results saved from the current repository are labelled. Tier guide: tier 3 holds the highest-level consolidated reflections (identity, principles, what matters most), tier 2 holds reflections of specific meaningful events, tier 1 holds raw verbatim memories. Match filters to the question. Broad 'most important things we have done' questions: tiers [3], importance 8 or higher, large limit such as 250. Big-picture overviews like 'what do you know about this area or period': tiers [3] with no importance filter. Specific lookups like 'find the decision about X': omit tiers to search all tiers blended and leave importance unset; a high importance filter hides the specific detail you are looking for. Specific meaningful events without raw noise: tiers [2] or [2, 3]. Exact verbatim detail: if the detail is not already in context, drill down by lineage: search tiers [3] to find the relevant thread, then use memory_inspect on the result to see the tier 2 reflections it consolidated, then inspect those to reach the raw memories underneath. Direct tiers [1] search works when you know exact wording to match. Mixing tiers is legitimate; adjust the importance threshold to the question rather than always setting it high. Only reflections (tiers 2 and 3) carry importance ratings. For time-window questions like 'what happened last week' or 'lately' use memory_date_search instead.",
     inputSchema: {
       type: 'object',
       properties: {
         query: { type: 'string', description: 'Semantic search query.' },
-        limit: { type: 'integer', minimum: 1, maximum: 250, description: 'Candidate results before project filtering.' },
+        limit: { type: 'integer', minimum: 1, maximum: 250, description: 'Maximum results to return.' },
         tiers: { type: 'array', items: { type: 'integer', enum: [1, 2, 3] }, minItems: 1, uniqueItems: true, description: "Restrict results to these memory tiers. 3 highest-level consolidated reflections (identity, principles, what matters most), 2 reflections of specific meaningful events, 1 raw verbatim memories. Use [3] for broad 'most important' or big-picture questions, [2] or [2, 3] for specific meaningful events, [1] for exact verbatim detail when you know the wording to match; otherwise drill down from [3] with memory_inspect. Omit to search all tiers blended, the right default for specific lookups. Mixing tiers is fine. Only tiers 2 and 3 carry importance ratings." },
         importance: { type: 'integer', minimum: 1, maximum: 10, description: "Minimum importance threshold, 1 to 10. Only reflections (tiers 2 and 3) carry ratings, so raw memories are excluded whenever this is set. Use 8 or higher with tiers [3] for broad 'most important' questions. Leave unset for general or specific searches; a high threshold hides relevant material." },
       },
@@ -60,7 +60,7 @@ const TOOLS = [
   },
   {
     name: 'memory_store',
-    description: 'Store a concise durable project memory. Returns a stable content-derived handle and deduplicates exact repeats.',
+    description: 'Store a concise durable memory in the vault (tagged with the current repository). Returns a stable content-derived handle and deduplicates exact repeats.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -141,7 +141,7 @@ async function callTool(name, args = {}, options = {}) {
   const config = options.config || loadConfig(env);
   const key = options.key || getApiKey(env, config);
   const cwd = options.cwd || process.cwd();
-  const project = options.project || resolveProject(cwd);
+  const project = options.project || resolveProject(cwd, { env, config });
   if (!key) return textResult('MemoryRouter API key is not configured. Run `memoryrouter-codex init` or set MEMORYROUTER_API_KEY.', true);
 
   if (name === 'memory_search') {
@@ -160,7 +160,7 @@ async function callTool(name, args = {}, options = {}) {
       ...(args.importance !== undefined ? { importance: args.importance } : {}),
     });
     if (!result.ok) return textResult(`Memory search failed${result.status ? ` (HTTP ${result.status})` : ''}.`, true);
-    if (!result.context) return textResult(`No memories matched current project ${project.handle}.`);
+    if (!result.context) return textResult('No memories matched in this vault.');
     let text = result.context;
     const debt = result.reflection;
     if (debt && debt.suggestion) {
@@ -197,8 +197,7 @@ async function callTool(name, args = {}, options = {}) {
     const rows = Array.isArray(data.results) ? data.results : [];
     if (!rows.length) return textResult('No memories in that window matched the filters.');
     const lines = rows.map(row => {
-      const parsed = parseEnvelope(row.content);
-      const body = parsed ? parsed.body : String(row.content || '');
+      const body = displayBody(row.content);
       const tierTag = row.tier != null ? ` | tier ${row.tier}` : '';
       const importanceTag = row.importance != null ? ` | importance ${row.importance}` : '';
       return `[${row.date || 'unknown date'}${tierTag}${importanceTag}]\n${body}`;
@@ -219,7 +218,7 @@ async function callTool(name, args = {}, options = {}) {
     if (!result.ok) return textResult(`Memory store failed${result.status ? ` (HTTP ${result.status})` : ''}.`, true);
     return textResult(result.deduplicated
       ? `Already stored. Memory handle: ${result.handle}`
-      : `Stored for project ${project.handle}. Memory handle: ${result.handle}`);
+      : `Stored in your vault (from repository ${project.handle}). Memory handle: ${result.handle}`);
   }
   if (name === 'memory_status') {
     const [response, probe] = await Promise.all([
@@ -233,10 +232,10 @@ async function callTool(name, args = {}, options = {}) {
       connected: response.ok,
       status: response.status,
       project: { handle: project.handle, identitySource: project.source, crossMachineStable: project.portable },
-      auth: process.env.MEMORYROUTER_API_KEY ? 'environment' : 'private-config-file',
+      auth: apiKeySource(env, config) || 'none',
       configFile: configPath(env),
       localAuditFile: auditPath(env),
-      retrievalScope: config.retrievalScope,
+      memoryScope: 'vault (one memory for every session, repository, and tool)',
       vault: response.ok ? response.data : null,
       reflection: debt,
       recentHooks: health,

package/runtime/memory.cjs

@@ -6,6 +6,8 @@ const { ENVELOPE_HEADER } = require('./constants.cjs');
 const { loadConfig, getApiKey, forgetHandle, recordAudit } = require('./config.cjs');
 const { resolveProject } = require('./project.cjs');
 
+const PROJECT_HANDLE = '(?:proj|ccp)_[a-f0-9]+';
+
 function normalizeContent(content) {
   return String(content || '').replace(/\r\n/g, '\n').replace(/[ \t]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
 }
@@ -37,7 +39,7 @@ function envelope({ projectHandle, handle, kind = 'note', content, capturedAt =
   return [
     ENVELOPE_HEADER,
     `project: ${projectHandle}`,
-    'scope: project',
+    'scope: vault',
     `handle: ${handle}`,
     `kind: ${kind}`,
     `captured_at: ${capturedAt}`,
@@ -49,56 +51,128 @@ function envelope({ projectHandle, handle, kind = 'note', content, capturedAt =
 
 function parseEnvelope(content) {
   const text = String(content || '');
-  const headerProject = text.match(/^project:\s*(proj_[a-f0-9]+)\s*$/m)?.[1];
+  const headerProject = text.match(new RegExp(`^project:\\s*(${PROJECT_HANDLE})\\s*$`, 'm'))?.[1];
   const headerHandle = text.match(/^handle:\s*(mrh_[a-f0-9]+)\s*$/m)?.[1];
-  const stamp = text.match(/\[MR_SCOPE project=(proj_[a-f0-9]+) handle=(mrh_[a-f0-9]+)\]/);
+  const stamp = text.match(new RegExp(`\\[MR_SCOPE project=(${PROJECT_HANDLE}) handle=(mrh_[a-f0-9]+)\\]`));
   const project = headerProject || stamp?.[1];
   const handle = headerHandle || stamp?.[2];
   if (!project || !handle) return null;
   const kind = text.match(/^kind:\s*([^\n]+)$/m)?.[1]?.trim();
   const separator = text.indexOf('\n---\n');
   const rawBody = separator >= 0 ? text.slice(separator + 5) : text;
-  const body = rawBody.replace(/^\[MR_SCOPE project=proj_[a-f0-9]+ handle=mrh_[a-f0-9]+\]\n?/gm, '');
+  const body = rawBody.replace(new RegExp(`^\\[MR_SCOPE project=${PROJECT_HANDLE} handle=mrh_[a-f0-9]+\\]\\n?`, 'gm'), '');
   return { project, handle, kind, body };
 }
 
-function filterMemories(memories, projectHandle, config, options = {}) {
-  const scope = config.retrievalScope || 'project';
+// In one shared vault a stored chunk can hold several writers' text back to
+// back: a Claude Code "[USER] ..." turn, then a Codex envelope, then another
+// turn. Rendering must keep ALL of it and drop only envelope metadata (header
+// blocks, a header fragment cut at a chunk boundary, and MR_SCOPE stamps).
+const HEADER_BLOCK = new RegExp(
+  `(?:\\[(?:USER|ASSISTANT)\\] )?\\[MemoryRouter Codex Memory v1\\]\\n(?:(?:project|scope|handle|kind|captured_at|tags):[^\\n]*\\n)*---\\n`,
+  'g',
+);
+const LEADING_HEADER_FRAGMENT = /^(?:(?:project|scope|handle|kind|captured_at|tags):[^\n]*\n){1,6}---\n/;
+const STAMP = new RegExp(`\\[MR_SCOPE project=${PROJECT_HANDLE} handle=mrh_[a-f0-9]+\\]\\n?`, 'g');
+
+function displayBody(content) {
+  return String(content || '')
+    .replace(HEADER_BLOCK, '')
+    .replace(LEADING_HEADER_FRAGMENT, '')
+    .replace(STAMP, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+// True when the row is exactly one Codex envelope (its handle can label it).
+function isSingleEnvelope(content) {
+  const text = String(content || '');
+  return /^(?:\[(?:USER|ASSISTANT)\] )?\[MemoryRouter Codex Memory v1\]\n/.test(text)
+    && (text.match(/\[MemoryRouter Codex Memory v1\]/g) || []).length === 1;
+}
+
+function mentionsProject(content, handles) {
+  const text = String(content || '');
+  for (const handle of handles) {
+    if (text.includes(`project: ${handle}`) || text.includes(`[MR_SCOPE project=${handle} `)) return true;
+  }
+  return false;
+}
+
+function projectHandles(project) {
+  if (!project) return new Set();
+  if (typeof project === 'string') return new Set([project]);
+  return new Set([project.handle, project.id, project.legacyHandle].filter(Boolean));
+}
+
+// Since 1.7.0 there is one vault per user and no project filtering at all:
+// every row the core vault returns is recalled, whatever wrote it (Codex,
+// Claude Code typed captures "[USER] ..." / "[ASSISTANT] ...", MCP saves,
+// ChatGPT or Claude connector saves, reflections, the pending buffer) and
+// whichever repository it came from. The only rows dropped are ones the user
+// suppressed locally with memory_forget.
+function filterMemories(memories, _project, config = {}) {
   const forgotten = new Set(config.forgottenHandles || []);
-  // Reflections (tier 2 and 3) are vault-level distilled prose without project
-  // envelopes. When the caller explicitly asked for reflection tiers, let those
-  // rows through the project filter instead of silently dropping every result.
-  const requestedReflectionTiers = Array.isArray(options.tiers) && options.tiers.some(tier => tier >= 2);
   return (Array.isArray(memories) ? memories : []).filter(memory => {
-    const parsed = parseEnvelope(memory.content);
+    const parsed = parseEnvelope(memory && memory.content);
     if (parsed && forgotten.has(parsed.handle)) return false;
-    if (scope === 'vault') return true;
-    if (requestedReflectionTiers && memory.tier != null && memory.tier >= 2) return true;
-    return parsed?.project === projectHandle;
+    if (memory && memory.id && forgotten.has(memory.id)) return false;
+    return true;
   });
 }
 
-function formatContext(memories, projectHandle, maxChars) {
+function formatContext(memories, project, maxChars) {
+  const own = projectHandles(project);
+  const projectHandle = typeof project === 'string' ? project : project && project.handle;
   const prefix = [
-    'MemoryRouter recalled the following project-scoped context from prior work.',
-    `Project handle: ${projectHandle}. Memory handles are stable references.`,
+    'MemoryRouter recalled the following context from your vault: one memory shared by every session, repository, and tool connected to it (Codex, Claude Code, the MemoryRouter MCP, ChatGPT, Claude).',
+    `Current repository handle: ${projectHandle}. Entries tagged "this repo" were saved from this repository; untagged entries may come from any session or tool. Memory handles are stable references.`,
     'Use this as recollection; current repository state and explicit user directions take precedence.',
   ].join('\n');
   let output = prefix;
   for (const memory of memories) {
     const parsed = parseEnvelope(memory.content);
-    const body = parsed ? parsed.body : String(memory.content || '');
-    const handle = parsed?.handle || memory.id || 'unhandled';
+    const body = displayBody(memory.content);
+    if (!body) continue;
+    const handle = (isSingleEnvelope(memory.content) && parsed?.handle) || memory.id || parsed?.handle || (memory.source === 'buffer' ? 'recent' : 'unhandled');
     const timestamp = memory.timestampHuman || (memory.timestamp ? new Date(memory.timestamp).toISOString() : 'unknown time');
     const tierTag = memory.tier != null && memory.tier !== 1 ? ` | tier ${memory.tier}` : '';
+    const repoTag = mentionsProject(memory.content, own) ? ' | this repo' : '';
     const importanceTag = memory.importance != null ? ` | importance ${memory.importance}` : '';
-    const chunk = `\n\n[${handle} | ${timestamp}${tierTag}${importanceTag}]\n${body.slice(0, 5000)}`;
-    if (output.length + chunk.length > maxChars) break;
+    const chunk = `\n\n[${handle} | ${timestamp}${repoTag}${tierTag}${importanceTag}]\n${body.slice(0, 5000)}`;
+    if (output.length + chunk.length > maxChars) continue;
     output += chunk;
   }
   return output === prefix ? '' : output;
 }
 
+function searchOnce(key, query, limit, config, options) {
+  return api.search(key, query, limit, {
+    apiBase: config.apiBase,
+    timeoutMs: options.timeoutMs || 5500,
+    retries: options.retries,
+    ...(options.tiers !== undefined ? { tiers: options.tiers } : {}),
+    ...(options.importance !== undefined ? { importance: options.importance } : {}),
+  });
+}
+
+function mergeMemories(lists) {
+  const seen = new Set();
+  const merged = [];
+  for (const list of lists) {
+    for (const memory of Array.isArray(list) ? list : []) {
+      const identity = memory && (memory.id || `${memory.source || ''}\0${memory.content || ''}`);
+      if (seen.has(identity)) continue;
+      seen.add(identity);
+      merged.push(memory);
+    }
+  }
+  return merged;
+}
+
+// One search against the user's whole vault (no session_id). The vault is the
+// same one the hosted MCP, the ChatGPT and Claude connectors, and Claude Code
+// use, so whatever any of them saved is recalled here.
 async function searchScoped(query, options = {}) {
   const config = options.config || loadConfig(options.env);
   const key = options.key || getApiKey(options.env, config);
@@ -106,34 +180,24 @@ async function searchScoped(query, options = {}) {
     recordAudit('search', { ok: false, reason: 'no-api-key' }, options.env);
     return { ok: false, reason: 'no-api-key', memories: [], context: '' };
   }
-  const project = options.project || resolveProject(options.cwd);
+  const project = options.project || resolveProject(options.cwd, { env: options.env, config });
   const limit = Math.max(1, Math.min(250, Number(options.limit || config.maxSearchResults || 12)));
-  const response = await api.search(
-    key,
-    `${normalizeContent(query)}\nMemoryRouter project handle ${project.handle}`,
-    limit,
-    {
-      apiBase: config.apiBase,
-      sessionId: options.sessionId,
-      timeoutMs: options.timeoutMs || 5500,
-      retries: options.retries,
-      ...(options.tiers !== undefined ? { tiers: options.tiers } : {}),
-      ...(options.importance !== undefined ? { importance: options.importance } : {}),
-    },
-  );
+  const text = normalizeContent(query);
+  const response = await searchOnce(key, text, limit, config, options);
   if (!response.ok) {
     recordAudit('search', { ok: false, status: response.status, project: project.handle }, options.env);
     return { ok: false, status: response.status, memories: [], context: '' };
   }
-  const memories = filterMemories(response.data?.memories, project.handle, config, { tiers: options.tiers });
-  recordAudit('search', { ok: true, project: project.handle, candidates: response.data?.memories?.length || 0, returned: memories.length }, options.env);
+  const candidates = mergeMemories([response.data?.memories]);
+  const memories = filterMemories(candidates, project, config);
+  recordAudit('search', { ok: true, project: project.handle, candidates: candidates.length, returned: memories.length }, options.env);
   return {
     ok: true,
     project,
     memories,
     reflection: response.data?.reflection || null,
     importState: response.data?.import || null,
-    context: formatContext(memories, project.handle, Number(config.contextChars || 12000)),
+    context: formatContext(memories, project, Number(config.contextChars || 12000)),
   };
 }
 
@@ -144,7 +208,7 @@ async function storeScoped(content, options = {}) {
     recordAudit('store', { ok: false, reason: 'no-api-key' }, options.env);
     return { ok: false, reason: 'no-api-key' };
   }
-  const project = options.project || resolveProject(options.cwd);
+  const project = options.project || resolveProject(options.cwd, { env: options.env, config });
   const normalized = normalizeContent(content);
   if (!normalized) return { ok: false, reason: 'empty-content' };
   const kind = options.kind || 'note';
@@ -172,8 +236,8 @@ async function storeScoped(content, options = {}) {
     content: normalized,
     tags: options.tags || [],
   });
-  const sessionId = options.sessionId || `mrcodex:${project.handle}:manual`;
-  const response = await api.ingest(key, [{ role: 'user', content: wrapped }], sessionId, {
+  // No session_id: the write lands in the user's one core vault.
+  const response = await api.ingest(key, [{ role: 'user', content: wrapped }], undefined, {
     apiBase: config.apiBase,
     timeoutMs: options.timeoutMs || 12000,
   });
@@ -210,8 +274,11 @@ module.exports = {
   stampBody,
   envelope,
   parseEnvelope,
+  displayBody,
+  projectHandles,
   filterMemories,
   formatContext,
+  mergeMemories,
   searchScoped,
   storeScoped,
   forgetLocally,

package/runtime/project.cjs

@@ -1,50 +1,198 @@
 'use strict';
 
+// Project identity for Codex hooks and the local MCP fallback.
+//
+// Since 1.7.0 MemoryRouter is one vault per user: every Codex session, every
+// Claude Code session, every repository, and every MemoryRouter surface (the
+// hosted MCP, ChatGPT, Claude) read and write the same core vault. The hooks
+// therefore send NO session_id (the API treats session_id as a hard vault
+// partition, so any session_id would wall memories off again).
+//
+// The repository identity below is still computed, byte-for-byte the same as
+// Claude Code (memoryrouter-claude lib/project.js): the same overrides, the
+// same git remote normalization, the same `ccp_` SHA-256 prefix. It is only
+// metadata now: it is stamped on Codex captures and used locally to label
+// which recalled memories came from the current repository.
+//
+// History: 1.1.0 to 1.6.1 sent `mrcodex:<proj>:<codex session uuid>` (one pile
+// per Codex session, so a new session recalled nothing), and memoryrouter-claude
+// up to 2.6.1 used the per-repo `ccp_` id as a partition (one pile per repo).
+// Both kinds of pile were merged into each user's core vault server-side when
+// 1.7.0 shipped, so nothing saved earlier is lost.
+//
+// Only the opaque hash leaves the machine; local paths and remotes stay local.
+// Keep this file self-contained: it is copied into the Codex runtime
+// directory and must not require anything outside runtime/.
+
+const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { execFileSync } = require('child_process');
 
-function git(cwd, args) {
+const PROJECT_CONFIG = '.memoryrouter.json';
+
+function runGit(args, cwd) {
   try {
-    return execFileSync('git', ['-C', cwd, ...args], {
+    return execFileSync('git', args, {
+      cwd,
       encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
       timeout: 2000,
+      stdio: ['ignore', 'pipe', 'ignore'],
     }).trim();
-  } catch { return ''; }
+  } catch {
+    return '';
+  }
 }
 
+// Back-compat helper used by older tests and callers: git -C <cwd> <args>.
+function git(cwd, args) {
+  return runGit(args, cwd);
+}
+
+function realpathSafe(value) {
+  const resolved = path.resolve(value || process.cwd());
+  try {
+    return fs.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+// Identical to memoryrouter-claude normalizeRemote(). Do not "improve" one
+// side without the other: any difference splits the shared project memory.
 function normalizeRemote(remote) {
   let value = String(remote || '').trim();
-  value = value.replace(/^([^@/]+)@([^:]+):/, 'ssh://$2/');
+  if (!value) return '';
+
+  // SCP-like git syntax: git@github.com:Org/Repo.git
+  const scp = value.match(/^(?:[^@/]+@)?([^:/]+):(.+)$/);
+  if (scp && !/^[a-z][a-z0-9+.-]*:\/\//i.test(value)) {
+    value = `ssh://${scp[1]}/${scp[2]}`;
+  }
+
   try {
     const url = new URL(value);
+    const host = url.hostname.toLowerCase();
+    const port = url.port && !((url.protocol === 'https:' && url.port === '443') || (url.protocol === 'ssh:' && url.port === '22'))
+      ? `:${url.port}`
+      : '';
+    const pathname = decodeURIComponent(url.pathname).replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '');
+    return host && pathname ? `${host}${port}/${pathname}`.toLowerCase() : '';
+  } catch {
+    return value
+      .replace(/^[^@/]+@/, '')
+      .replace(/^[a-z][a-z0-9+.-]*:\/\//i, '')
+      .replace(/[?#].*$/, '')
+      .replace(/^\/+|\/+$/g, '')
+      .replace(/\.git$/i, '')
+      .toLowerCase();
+  }
+}
+
+function readProjectConfig(root) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path.join(root, PROJECT_CONFIG), 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function hashIdentity(canonical) {
+  return crypto.createHash('sha256').update(canonical).digest('hex');
+}
+
+// Pre-1.7 Codex-only handle. Kept so envelopes written by older releases are
+// still recognised as belonging to this repository.
+function legacyHandle(root, rawRemote, commonDirRaw) {
+  let remote = String(rawRemote || '').trim();
+  remote = remote.replace(/^([^@/]+)@([^:]+):/, 'ssh://$2/');
+  try {
+    const url = new URL(remote);
     url.username = '';
     url.password = '';
-    value = `${url.protocol}//${url.host}${url.pathname}`;
+    remote = `${url.protocol}//${url.host}${url.pathname}`;
   } catch { /* local/file-like remote */ }
-  return value.replace(/\\/g, '/').replace(/\.git\/?$/i, '').replace(/\/+$/, '').toLowerCase();
-}
-
-function resolveProject(cwd = process.cwd()) {
-  const absoluteCwd = path.resolve(cwd);
-  const root = git(absoluteCwd, ['rev-parse', '--show-toplevel']) || absoluteCwd;
-  const remote = normalizeRemote(git(root, ['remote', 'get-url', 'origin']));
-  const commonDir = git(root, ['rev-parse', '--git-common-dir']);
+  remote = remote.replace(/\\/g, '/').replace(/\.git\/?$/i, '').replace(/\/+$/, '').toLowerCase();
   const canonical = remote
     ? `remote:${remote}`
-    : commonDir
-      ? `git:${path.resolve(root, commonDir)}`
+    : commonDirRaw
+      ? `git:${path.resolve(root, commonDirRaw)}`
       : `path:${root}`;
-  const digest = crypto.createHash('sha256')
-    .update(`memoryrouter-codex-project-v1\0${canonical}`)
-    .digest('hex');
+  const digest = crypto.createHash('sha256').update(`memoryrouter-codex-project-v1\0${canonical}`).digest('hex');
+  return `proj_${digest.slice(0, 20)}`;
+}
+
+function resolveProject(cwd = process.cwd(), options = {}) {
+  const env = options.env || process.env;
+  const config = options.config || {};
+  const requestedRoot = realpathSafe(cwd || process.cwd());
+  const gitRootRaw = runGit(['rev-parse', '--show-toplevel'], requestedRoot);
+  const root = realpathSafe(gitRootRaw || requestedRoot);
+  const projectConfig = readProjectConfig(root);
+  const ignored = fs.existsSync(path.join(root, '.memoryrouterignore')) || projectConfig.enabled === false;
+
+  const explicit = env.MEMORYROUTER_PROJECT_ID
+    || projectConfig.projectId
+    || projectConfig.project
+    || config.projectId
+    || config.project;
+
+  const originUrl = runGit(['config', '--get', 'remote.origin.url'], root);
+  const anyRemoteUrl = originUrl || runGit(['config', '--get-regexp', '^remote\\..*\\.url$'], root).split(/\s+/).pop();
+  const remote = normalizeRemote(anyRemoteUrl);
+
+  const commonDirRaw = gitRootRaw
+    ? runGit(['rev-parse', '--path-format=absolute', '--git-common-dir'], root)
+    : '';
+  const commonDir = commonDirRaw ? realpathSafe(commonDirRaw) : '';
+
+  let source;
+  let canonical;
+  if (explicit && String(explicit).trim()) {
+    source = 'explicit';
+    canonical = `explicit:${String(explicit).trim().toLowerCase()}`;
+  } else if (remote) {
+    source = 'git-remote';
+    canonical = `git:${remote}`;
+  } else if (commonDir) {
+    source = 'git-common-dir';
+    canonical = `git-local:${commonDir}`;
+  } else {
+    source = 'directory';
+    canonical = `dir:${root}`;
+  }
+
+  const id = `ccp_${hashIdentity(canonical).slice(0, 24)}`;
+
   return {
-    handle: `proj_${digest.slice(0, 20)}`,
+    handle: id,
+    id,
     root,
-    source: remote ? 'git-remote' : commonDir ? 'git-common-dir' : 'path',
-    portable: Boolean(remote),
+    source,
+    portable: source === 'git-remote' || source === 'explicit',
+    label: path.basename(root) || 'workspace',
+    ignored,
+    legacyHandle: legacyHandle(gitRootRaw || path.resolve(cwd || process.cwd()), originUrl, gitRootRaw ? runGit(['rev-parse', '--git-common-dir'], root) : ''),
   };
 }
 
-module.exports = { git, normalizeRemote, resolveProject };
+// The MemoryRouter session_id (vault partition) the hooks use. Always
+// undefined since 1.7.0: one vault per user, no per-session or per-repo walls.
+// Kept as a function so callers and tests have one place that states the rule.
+function sessionIdFor() {
+  return undefined;
+}
+
+module.exports = {
+  PROJECT_CONFIG,
+  git,
+  runGit,
+  realpathSafe,
+  normalizeRemote,
+  readProjectConfig,
+  hashIdentity,
+  legacyHandle,
+  resolveProject,
+  sessionIdFor,
+};

package/runtime/vault-binding.cjs

@@ -0,0 +1,51 @@
+'use strict';
+// One user = one vault. The vault a user selects when connecting MemoryRouter
+// over OAuth (the MCP login used by Claude Code, Codex, ChatGPT, Claude) must
+// be the same vault the automatic hooks write to with the Memory Key. The auth
+// server compares the two: GET /v1/vault-binding with the Memory Key as Bearer.
+// Kept self-contained (copied into the Codex runtime directory).
+// The response never contains a key, only opaque vault refs and names.
+
+const AUTH_BASE = 'https://auth.memoryrouter.ai';
+
+function authBase(env = process.env) {
+  return String(env.MEMORYROUTER_AUTH_BASE || AUTH_BASE).replace(/\/+$/, '');
+}
+
+async function checkVaultBinding(key, options = {}) {
+  const env = options.env || process.env;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs || 6000);
+  try {
+    const res = await fetch(`${authBase(env)}/v1/vault-binding`, {
+      headers: { Authorization: `Bearer ${key}`, Accept: 'application/json' },
+      signal: controller.signal,
+    });
+    let data = null;
+    try { data = await res.json(); } catch { /* not json */ }
+    if (!res.ok || !data || typeof data.status !== 'string') {
+      return { status: 'unknown', httpStatus: res.status, message: `vault check unavailable (HTTP ${res.status})` };
+    }
+    return data;
+  } catch (err) {
+    return { status: 'unknown', message: `vault check unavailable (${err && err.name === 'AbortError' ? 'timeout' : (err && err.message) || 'network error'})` };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function vaultLabel(binding) {
+  const vault = binding && binding.vault;
+  if (!vault) return 'this vault';
+  return vault.name ? `"${vault.name}" (${vault.ref})` : vault.ref;
+}
+
+class VaultMismatchError extends Error {
+  constructor(binding) {
+    super(`${binding.message || 'This Memory Key is not the vault you selected in OAuth.'}\n  Nothing was installed. Run init again with the Memory Key of the vault you selected (app.memoryrouter.ai), or reconnect MemoryRouter and select ${vaultLabel(binding)}.`);
+    this.name = 'VaultMismatchError';
+    this.binding = binding;
+  }
+}
+
+module.exports = { AUTH_BASE, authBase, checkVaultBinding, vaultLabel, VaultMismatchError };