memoryrouter-codex 1.6.1 → 1.8.0

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.8.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

@@ -64,8 +64,16 @@ function maybeAppendNudge(context, reflection, sessionId, hookContext, importSta
   return context;
 }
 
+// The prompt that started THIS turn. Never another turn's prompt: falling back
+// to "the last prompt seen" could pair a response with the wrong question.
+function promptForTurn(state, turnId) {
+  if (state.prompts?.[turnId]) return state.prompts[turnId];
+  if (turnId && state.lastTurnId === turnId) return state.lastPrompt || '';
+  return '';
+}
+
 function turnContent(input, state) {
-  const prompt = state.prompts?.[input.turn_id] || state.lastPrompt || '';
+  const prompt = promptForTurn(state, input.turn_id);
   return [
     prompt ? `User request:
 ${truncate(prompt, 40000)}` : null,
@@ -79,15 +87,18 @@ ${truncate(input.last_assistant_message, 60000)}`
 async function handleInject(input, context) {
   const prompt = typeof input.prompt === 'string' ? input.prompt.trim() : '';
   if (!prompt) return;
-  const state = loadSessionState(input.session_id, context.env);
-  state.prompts = { ...(state.prompts || {}), [input.turn_id]: prompt.slice(0, 100000) };
-  state.lastPrompt = prompt.slice(0, 100000);
-  state.lastTurnId = input.turn_id;
-  saveSessionState(input.session_id, state, context.env);
+  // A thread-spawned subagent's "prompt" is the parent agent's instruction (an
+  // intermediate step). Recall for it, but never record it for capture.
+  if (!input.agent_id) {
+    const state = loadSessionState(input.session_id, context.env);
+    state.prompts = { ...(state.prompts || {}), [input.turn_id]: prompt.slice(0, 100000) };
+    state.lastPrompt = prompt.slice(0, 100000);
+    state.lastTurnId = input.turn_id;
+    saveSessionState(input.session_id, state, context.env);
+  }
 
   const result = await searchScoped(prompt, {
     ...context,
-    sessionId: `mrcodex:${context.project.handle}:${input.session_id}`,
     timeoutMs: 5500,
   });
   recordHealth('inject', {
@@ -103,12 +114,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,
@@ -119,18 +137,27 @@ async function handleSessionStart(input, context) {
   emitContext('SessionStart', maybeAppendNudge(result.context, result.reflection, input.session_id, context, result.importState));
 }
 
+// Stop (partial=false): save the user's prompt + the final assistant response.
+// SessionEnd / PreCompact (partial=true): only if the last turn never reached
+// Stop (interrupted), save that turn's user prompt so it is not lost. A turn
+// that was already saved is never saved again.
 async function captureTurn(input, context, partial = false) {
   const sessionId = input.session_id;
   const turnId = input.turn_id || loadSessionState(sessionId, context.env).lastTurnId;
   if (!sessionId || !turnId) return { ok: false, reason: 'missing-turn' };
   if (!partial && input.stop_hook_active) return { ok: true, skipped: 'stop-hook-active' };
   const state = loadSessionState(sessionId, context.env);
-  if (!partial && state.capturedTurns?.[turnId]) {
+  if (state.capturedTurns?.[turnId]) {
     return { ok: true, skipped: 'deduplicated', handle: state.capturedTurns[turnId] };
   }
-  const prompt = state.prompts?.[turnId] || state.lastPrompt || '';
+  if (partial && state.checkpointedTurns?.[turnId]) {
+    return { ok: true, skipped: 'deduplicated', handle: state.checkpointedTurns[turnId] };
+  }
+  const prompt = promptForTurn(state, turnId);
   if (!partial && !input.last_assistant_message) return { ok: true, skipped: 'empty' };
-  if (partial && !prompt && !input.last_assistant_message) return { ok: true, skipped: 'empty' };
+  if (partial && !prompt) return { ok: true, skipped: 'empty' };
+  // PreCompact/SessionEnd carry no final response; never invent one.
+  if (partial) input = { ...input, last_assistant_message: undefined };
   const content = turnContent({ ...input, turn_id: turnId }, state);
   const kind = partial ? 'checkpoint' : 'turn';
   const handle = memoryHandle(context.project.handle, kind, content);
@@ -139,16 +166,18 @@ 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],
   });
   if (result.ok && result.stored) {
     state.capturedHandles = [...(state.capturedHandles || []), handle].slice(-500);
-    if (!partial) state.capturedTurns = { ...(state.capturedTurns || {}), [turnId]: handle };
-    if (Object.keys(state.capturedTurns || {}).length > 500) {
-      state.capturedTurns = Object.fromEntries(Object.entries(state.capturedTurns).slice(-500));
+    // A checkpoint (prompt of an unfinished turn) never blocks that turn's
+    // full save if it does finish later.
+    const ledger = partial ? 'checkpointedTurns' : 'capturedTurns';
+    state[ledger] = { ...(state[ledger] || {}), [turnId]: handle };
+    if (Object.keys(state[ledger] || {}).length > 500) {
+      state[ledger] = Object.fromEntries(Object.entries(state[ledger]).slice(-500));
     }
     if (!partial && state.prompts) delete state.prompts[turnId];
     state.lastCaptureAt = new Date().toISOString();
@@ -165,47 +194,33 @@ async function captureTurn(input, context, partial = false) {
   return result;
 }
 
+// Subagent output is intermediate work, not the user's conversation. Saving it
+// broke the "user message + final response only" rule, so 1.8.0 no longer
+// installs a SubagentStop hook and this handler is a no-op for installs that
+// still have one until `init` is re-run.
 async function captureSubagent(input, context) {
-  if (!input.last_assistant_message || !input.session_id) return { ok: true, skipped: 'empty' };
-  const state = loadSessionState(input.session_id, context.env);
-  const captureKey = `subagent:${input.agent_id || 'unknown'}:${input.turn_id || 'unknown'}`;
-  if (state.capturedTurns?.[captureKey]) return { ok: true, skipped: 'deduplicated', handle: state.capturedTurns[captureKey] };
-  const content = [
-    'Completed Codex subagent outcome.',
-    `Subagent type: ${input.agent_type || 'unknown'}`,
-    `Subagent id: ${input.agent_id || 'unknown'}`,
-    `Outcome:\n${truncate(input.last_assistant_message, 60000)}`,
-  ].join('\n\n');
-  const handle = memoryHandle(context.project.handle, 'subagent', content);
-  const result = await storeScoped(content, {
-    ...context,
-    kind: 'subagent',
-    handle,
-    sessionId: `mrcodex:${context.project.handle}:${input.session_id}`,
-    skipRemoteDedupe: true,
-    timeoutMs: 12000,
-    tags: ['codex', 'subagent', input.agent_type || 'unknown'],
-  });
-  if (result.ok && result.stored) {
-    state.capturedHandles = [...(state.capturedHandles || []), handle].slice(-500);
-    state.capturedTurns = { ...(state.capturedTurns || {}), [captureKey]: handle };
-    if (Object.keys(state.capturedTurns).length > 500) state.capturedTurns = Object.fromEntries(Object.entries(state.capturedTurns).slice(-500));
-    saveSessionState(input.session_id, state, context.env);
-  }
-  recordHealth('capture-subagent', { ok: result.ok, status: result.status, project: context.project.handle, handle }, context.env);
-  return result;
+  recordHealth('capture-subagent', { ok: true, skipped: 'subagent-not-captured', project: context.project.handle }, context.env);
+  return { ok: true, skipped: 'subagent-not-captured' };
 }
 
+
 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,