memoryrouter-codex 1.0.0

package/runtime/config.cjs

@@ -0,0 +1,166 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { API_BASE, DEFAULT_CONTEXT_CHARS, DEFAULT_SEARCH_RESULTS, RUNTIME_SCHEMA_VERSION } = require('./constants.cjs');
+
+function codexHome(env = process.env) {
+  return path.resolve(env.CODEX_HOME || path.join(os.homedir(), '.codex'));
+}
+
+function dataHome(env = process.env) {
+  return path.resolve(env.MEMORYROUTER_CODEX_HOME || path.join(os.homedir(), '.memoryrouter', 'codex'));
+}
+
+function configPath(env = process.env) {
+  return path.join(dataHome(env), 'config.json');
+}
+
+function ensurePrivateDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(dir, 0o700); } catch { /* Windows/best effort */ }
+}
+
+function atomicWriteJson(file, value, mode = 0o600) {
+  ensurePrivateDir(path.dirname(file));
+  const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode });
+  try { fs.chmodSync(tmp, mode); } catch { /* best effort */ }
+  fs.renameSync(tmp, file);
+  try { fs.chmodSync(file, mode); } catch { /* best effort */ }
+}
+
+function defaultConfig() {
+  return {
+    version: RUNTIME_SCHEMA_VERSION,
+    apiBase: API_BASE,
+    contextChars: DEFAULT_CONTEXT_CHARS,
+    maxSearchResults: DEFAULT_SEARCH_RESULTS,
+    retrievalScope: 'project',
+    forgottenHandles: [],
+  };
+}
+
+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 : {}) };
+}
+
+function saveConfig(config, env = process.env) {
+  const safe = { ...defaultConfig(), ...config, version: RUNTIME_SCHEMA_VERSION };
+  atomicWriteJson(configPath(env), safe, 0o600);
+  return safe;
+}
+
+function getApiKey(env = process.env, config = loadConfig(env)) {
+  return env.MEMORYROUTER_API_KEY || config.apiKey || null;
+}
+
+function safeId(value) {
+  return crypto.createHash('sha256').update(String(value || 'unknown')).digest('hex').slice(0, 32);
+}
+
+function stateDir(env = process.env) {
+  const dir = path.join(dataHome(env), 'state');
+  ensurePrivateDir(dir);
+  return dir;
+}
+
+function sessionStatePath(sessionId, env = process.env) {
+  return path.join(stateDir(env), `${safeId(sessionId)}.json`);
+}
+
+function tracePath(sessionId, turnId, env = process.env) {
+  return path.join(stateDir(env), `${safeId(sessionId)}-${safeId(turnId)}.trace.jsonl`);
+}
+
+function loadSessionState(sessionId, env = process.env) {
+  try {
+    const value = JSON.parse(fs.readFileSync(sessionStatePath(sessionId, env), 'utf8'));
+    return value && typeof value === 'object' ? value : {};
+  } catch { return {}; }
+}
+
+function saveSessionState(sessionId, state, env = process.env) {
+  atomicWriteJson(sessionStatePath(sessionId, env), state, 0o600);
+}
+
+function pruneState(env = process.env, maxAgeMs = 30 * 24 * 60 * 60 * 1000) {
+  const dir = stateDir(env);
+  const cutoff = Date.now() - maxAgeMs;
+  let removed = 0;
+  for (const name of fs.readdirSync(dir)) {
+    if (!name.endsWith('.json') && !name.endsWith('.jsonl')) continue;
+    const file = path.join(dir, name);
+    try {
+      if (fs.statSync(file).mtimeMs < cutoff) { fs.rmSync(file, { force: true }); removed += 1; }
+    } catch { /* raced with another hook */ }
+  }
+  return removed;
+}
+
+function auditPath(env = process.env) {
+  return path.join(dataHome(env), 'audit.jsonl');
+}
+
+function recordAudit(event, details = {}, env = process.env) {
+  try {
+    const file = auditPath(env);
+    ensurePrivateDir(path.dirname(file));
+    try {
+      if (fs.statSync(file).size > 5 * 1024 * 1024) fs.renameSync(file, `${file}.1`);
+    } catch { /* new file */ }
+    const safe = { at: new Date().toISOString(), event, ...details };
+    delete safe.apiKey;
+    delete safe.key;
+    delete safe.content;
+    fs.appendFileSync(file, `${JSON.stringify(safe)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'a' });
+  } catch { /* audit logging cannot block memory or Codex */ }
+}
+
+function healthPath(env = process.env) {
+  return path.join(dataHome(env), 'health.json');
+}
+
+function recordHealth(event, details = {}, env = process.env) {
+  let health = {};
+  try { health = JSON.parse(fs.readFileSync(healthPath(env), 'utf8')); } catch { /* empty */ }
+  health[event] = { at: new Date().toISOString(), ...details };
+  try { atomicWriteJson(healthPath(env), health, 0o600); } catch { /* observability never blocks */ }
+}
+
+function forgetHandle(handle, env = process.env) {
+  const cfg = loadConfig(env);
+  const set = new Set(Array.isArray(cfg.forgottenHandles) ? cfg.forgottenHandles : []);
+  set.add(handle);
+  cfg.forgottenHandles = [...set].slice(-1000);
+  saveConfig(cfg, env);
+}
+
+module.exports = {
+  codexHome,
+  dataHome,
+  configPath,
+  ensurePrivateDir,
+  atomicWriteJson,
+  defaultConfig,
+  loadConfig,
+  saveConfig,
+  getApiKey,
+  safeId,
+  stateDir,
+  sessionStatePath,
+  tracePath,
+  loadSessionState,
+  saveSessionState,
+  pruneState,
+  auditPath,
+  recordAudit,
+  healthPath,
+  recordHealth,
+  forgetHandle,
+};

package/runtime/constants.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+const INTEGRATION_VERSION = '1.0.0';
+const RUNTIME_SCHEMA_VERSION = 1;
+const API_BASE = 'https://api.memoryrouter.ai';
+const MCP_ENDPOINT = 'https://mcp.memoryrouter.ai/mcp';
+const DEFAULT_CONTEXT_CHARS = 12000;
+const DEFAULT_SEARCH_RESULTS = 12;
+const MAX_TRACE_RECORD_CHARS = 8000;
+const MAX_TRACE_TOTAL_CHARS = 60000;
+const ENVELOPE_HEADER = '[MemoryRouter Codex Memory v1]';
+
+module.exports = {
+  INTEGRATION_VERSION,
+  RUNTIME_SCHEMA_VERSION,
+  API_BASE,
+  MCP_ENDPOINT,
+  DEFAULT_CONTEXT_CHARS,
+  DEFAULT_SEARCH_RESULTS,
+  MAX_TRACE_RECORD_CHARS,
+  MAX_TRACE_TOTAL_CHARS,
+  ENVELOPE_HEADER,
+};

package/runtime/hook.cjs

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const { loadConfig, getApiKey, loadSessionState, saveSessionState, tracePath, pruneState, recordHealth } = require('./config.cjs');
+const { resolveProject } = require('./project.cjs');
+const { searchScoped, storeScoped, memoryHandle } = require('./memory.cjs');
+const { MAX_TRACE_RECORD_CHARS, MAX_TRACE_TOTAL_CHARS } = require('./constants.cjs');
+
+function debug(...values) {
+  if (process.env.MEMORYROUTER_DEBUG) console.error('[memoryrouter-codex]', ...values);
+}
+
+function readStdin(timeoutMs = 1500) {
+  return new Promise(resolve => {
+    let value = '';
+    const timer = setTimeout(() => resolve(value), timeoutMs);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => { value += chunk; });
+    process.stdin.on('end', () => { clearTimeout(timer); resolve(value); });
+    process.stdin.on('error', () => { clearTimeout(timer); resolve(value); });
+  });
+}
+
+function truncate(value, limit = MAX_TRACE_RECORD_CHARS) {
+  let text;
+  try { text = typeof value === 'string' ? value : JSON.stringify(value); } catch { text = String(value); }
+  if (text.length <= limit) return text;
+  return `${text.slice(0, limit)}\n[truncated by memoryrouter-codex]`;
+}
+
+function emitContext(eventName, context) {
+  if (!context) return false;
+  process.stdout.write(JSON.stringify({
+    continue: true,
+    hookSpecificOutput: { hookEventName: eventName, additionalContext: context },
+  }));
+  return true;
+}
+
+function appendTrace(input, env = process.env) {
+  if (!input.session_id || !input.turn_id) return;
+  const record = {
+    at: new Date().toISOString(),
+    turn_id: input.turn_id,
+    tool_name: input.tool_name,
+    tool_use_id: input.tool_use_id,
+    input: truncate(input.tool_input),
+    response: truncate(input.tool_response),
+  };
+  const file = tracePath(input.session_id, input.turn_id, env);
+  fs.appendFileSync(file, `${JSON.stringify(record)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'a' });
+}
+
+function readTrace(sessionId, turnId, env = process.env) {
+  const file = tracePath(sessionId, turnId, env);
+  let text;
+  try { text = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  const records = [];
+  let total = 0;
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const record = JSON.parse(line);
+      const size = JSON.stringify(record).length;
+      if (total + size > MAX_TRACE_TOTAL_CHARS) break;
+      records.push(record);
+      total += size;
+    } catch { /* tolerate partial concurrent append */ }
+  }
+  return records;
+}
+
+function removeTrace(sessionId, turnId, env = process.env) {
+  try { fs.unlinkSync(tracePath(sessionId, turnId, env)); } catch { /* absent */ }
+}
+
+function turnContent(input, state, records, partial = false) {
+  const prompt = state.prompts?.[input.turn_id] || state.lastPrompt || '';
+  const parts = [
+    partial ? 'Codex work checkpoint before compaction/session end.' : 'Completed Codex turn.',
+    prompt ? `User request:\n${truncate(prompt, 40000)}` : null,
+  ];
+  if (records.length) {
+    parts.push(`Tool activity (${records.length} calls):`);
+    for (const record of records) {
+      parts.push([
+        `- ${record.tool_name || 'tool'} (${record.tool_use_id || 'unknown'})`,
+        `  input: ${record.input}`,
+        `  result: ${record.response}`,
+      ].join('\n'));
+    }
+  }
+  if (input.last_assistant_message) parts.push(`Final assistant response:\n${truncate(input.last_assistant_message, 60000)}`);
+  return parts.filter(Boolean).join('\n\n');
+}
+
+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);
+
+  const result = await searchScoped(prompt, {
+    ...context,
+    sessionId: `mrcodex:${context.project.handle}:${input.session_id}`,
+    timeoutMs: 5500,
+  });
+  recordHealth('inject', {
+    ok: result.ok,
+    project: context.project.handle,
+    memories: result.memories?.length || 0,
+    status: result.status,
+  }, context.env);
+  emitContext('UserPromptSubmit', result.context);
+}
+
+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 },
+  );
+  recordHealth('session-start', {
+    ok: result.ok,
+    source: input.source,
+    project: context.project.handle,
+    memories: result.memories?.length || 0,
+  }, context.env);
+  emitContext('SessionStart', result.context);
+}
+
+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]) {
+    return { ok: true, skipped: 'deduplicated', handle: state.capturedTurns[turnId] };
+  }
+  const records = readTrace(sessionId, turnId, context.env);
+  if (!input.last_assistant_message && records.length === 0) return { ok: true, skipped: 'empty' };
+  const content = turnContent({ ...input, turn_id: turnId }, state, records, partial);
+  const kind = partial ? 'checkpoint' : 'turn';
+  const handle = memoryHandle(context.project.handle, kind, content);
+  if ((state.capturedHandles || []).includes(handle)) return { ok: true, skipped: 'deduplicated', handle };
+  const result = await storeScoped(content, {
+    ...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));
+    }
+    if (!partial && state.prompts) delete state.prompts[turnId];
+    state.lastCaptureAt = new Date().toISOString();
+    saveSessionState(sessionId, state, context.env);
+    if (!partial) removeTrace(sessionId, turnId, context.env);
+  }
+  recordHealth(partial ? 'flush' : 'capture', {
+    ok: result.ok,
+    status: result.status,
+    project: context.project.handle,
+    handle,
+    toolCalls: records.length,
+  }, context.env);
+  return result;
+}
+
+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;
+}
+
+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());
+  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;
+  }
+  switch (kind) {
+    case 'inject': return handleInject(input, context);
+    case 'session-start': return handleSessionStart(input, context);
+    case 'trace': appendTrace(input, env); return;
+    case 'capture': return captureTurn(input, context, false);
+    case 'capture-subagent': return captureSubagent(input, context);
+    case 'flush': return captureTurn(input, context, true);
+    default: throw new Error(`Unknown hook kind: ${kind}`);
+  }
+}
+
+async function main() {
+  const kind = process.argv[2];
+  const wallClock = setTimeout(() => process.exit(0), kind === 'trace' ? 2500 : kind === 'inject' ? 7500 : 18000);
+  wallClock.unref();
+  let input = {};
+  try { input = JSON.parse((await readStdin()) || '{}'); } catch { debug('invalid hook JSON'); }
+  try { await run(kind, input); } catch (error) { debug(error?.stack || error); }
+  if (kind === 'capture' || kind === 'capture-subagent') process.stdout.write(JSON.stringify({ continue: true }));
+  process.exitCode = 0;
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  readStdin,
+  truncate,
+  emitContext,
+  appendTrace,
+  readTrace,
+  removeTrace,
+  turnContent,
+  handleInject,
+  handleSessionStart,
+  captureTurn,
+  captureSubagent,
+  run,
+  main,
+};

package/runtime/mcp-stdio.cjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+'use strict';
+
+const readline = require('readline');
+const fs = require('fs');
+const { loadConfig, getApiKey, configPath, auditPath, recordAudit, healthPath } = require('./config.cjs');
+const { resolveProject } = require('./project.cjs');
+const { searchScoped, storeScoped, forgetLocally } = require('./memory.cjs');
+const api = require('./api.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 TOOLS = [
+  {
+    name: 'memory_search',
+    description: 'Search durable MemoryRouter memories. Defaults to the current git project and filters other projects out.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Semantic search query.' },
+        limit: { type: 'integer', minimum: 1, maximum: 50, description: 'Candidate results before project filtering.' },
+      },
+      required: ['query'],
+    },
+    annotations: { title: 'Search MemoryRouter', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+  },
+  {
+    name: 'memory_store',
+    description: 'Store a concise durable project memory. Returns a stable content-derived handle and deduplicates exact repeats.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string' },
+        kind: { type: 'string', enum: ['decision', 'preference', 'fact', 'incident', 'note'] },
+        tags: { type: 'array', items: { type: 'string' }, maxItems: 20 },
+      },
+      required: ['content'],
+    },
+    annotations: { title: 'Store MemoryRouter memory', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+  },
+  {
+    name: 'memory_status',
+    description: 'Show MemoryRouter authentication, project identity, vault statistics, and recent hook health without exposing secrets.',
+    inputSchema: { type: 'object', properties: {} },
+    annotations: { title: 'MemoryRouter status', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+  },
+  {
+    name: 'memory_forget',
+    description: 'Suppress one memory handle from this machine, or clear the entire server vault only with an exact confirmation phrase. Handle suppression is not server deletion.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        handle: { type: 'string', description: 'mrh_... handle to suppress locally.' },
+        clear_vault_confirmation: { type: 'string', description: 'Exact phrase CLEAR MY ENTIRE MEMORYROUTER VAULT to irreversibly clear every memory in the vault.' },
+      },
+    },
+    annotations: { title: 'Forget MemoryRouter memory', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+  },
+];
+
+function textResult(text, isError = false) {
+  return { content: [{ type: 'text', text: String(text) }], ...(isError ? { isError: true } : {}) };
+}
+
+async function callTool(name, args = {}, options = {}) {
+  const env = options.env || process.env;
+  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);
+  if (!key) return textResult('MemoryRouter API key is not configured. Run `memoryrouter-codex init` or set MEMORYROUTER_API_KEY.', true);
+
+  if (name === 'memory_search') {
+    if (!args.query) return textResult('query is required', true);
+    const result = await searchScoped(args.query, { env, config, key, cwd, project, limit: args.limit });
+    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}.`);
+    return textResult(result.context);
+  }
+  if (name === 'memory_store') {
+    if (!args.content) return textResult('content is required', true);
+    const result = await storeScoped(args.content, {
+      env, config, key, cwd, project, kind: args.kind || 'note', tags: args.tags || [],
+    });
+    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}`);
+  }
+  if (name === 'memory_status') {
+    const response = await api.stats(key, { apiBase: config.apiBase, timeoutMs: 8000, retries: 1 });
+    let health = null;
+    try { health = JSON.parse(fs.readFileSync(healthPath(env), 'utf8')); } catch { /* optional */ }
+    return textResult(JSON.stringify({
+      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',
+      configFile: configPath(env),
+      localAuditFile: auditPath(env),
+      retrievalScope: config.retrievalScope,
+      vault: response.ok ? response.data : null,
+      recentHooks: health,
+    }, null, 2));
+  }
+  if (name === 'memory_forget') {
+    if (args.clear_vault_confirmation === 'CLEAR MY ENTIRE MEMORYROUTER VAULT') {
+      const response = await api.clearVault(key, { apiBase: config.apiBase, timeoutMs: 15000 });
+      recordAudit('clear-vault', { ok: response.ok, status: response.status, project: project.handle }, env);
+      return response.ok
+        ? textResult('The entire MemoryRouter vault was cleared. This cannot be undone.')
+        : textResult(`Vault clear failed (HTTP ${response.status}).`, true);
+    }
+    if (!args.handle) return textResult('Provide a memory handle, or the exact full-vault confirmation phrase.', true);
+    const result = forgetLocally(args.handle, { env });
+    return result.ok ? textResult(result.message) : textResult('Invalid memory handle.', true);
+  }
+  return textResult(`Unknown tool: ${name}`, true);
+}
+
+async function dispatch(message) {
+  const { id, method, params = {} } = message;
+  if (method === 'initialize') return {
+    jsonrpc: '2.0', id,
+    result: {
+      protocolVersion: params.protocolVersion || '2025-11-25',
+      capabilities: { tools: {} },
+      serverInfo: { name: 'MemoryRouter Codex local fallback', version: INTEGRATION_VERSION },
+      instructions: SERVER_INSTRUCTIONS,
+    },
+  };
+  if (method === 'tools/list') return { jsonrpc: '2.0', id, result: { tools: TOOLS } };
+  if (method === 'tools/call') return { jsonrpc: '2.0', id, result: await callTool(params.name, params.arguments || {}) };
+  if (method === 'ping') return { jsonrpc: '2.0', id, result: {} };
+  if (id === undefined || id === null) return null;
+  return { jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${method}` } };
+}
+
+async function main() {
+  const input = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+  for await (const line of input) {
+    if (!line.trim()) continue;
+    let message;
+    try { message = JSON.parse(line); } catch {
+      process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } })}\n`);
+      continue;
+    }
+    try {
+      const response = await dispatch(message);
+      if (response) process.stdout.write(`${JSON.stringify(response)}\n`);
+    } catch (error) {
+      if (message.id !== undefined) process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, error: { code: -32603, message: error?.message || 'Internal error' } })}\n`);
+    }
+  }
+}
+
+if (require.main === module) main();
+
+module.exports = { SERVER_INSTRUCTIONS, TOOLS, textResult, callTool, dispatch, main };