memoryrouter-codex 1.0.0 → 1.1.0

package/README.md

@@ -2,15 +2,17 @@
 
 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.
+
 ## What this integration does
 
 | Layer | Behavior |
 | --- | --- |
 | `UserPromptSubmit` hook | Searches MemoryRouter before every prompt and injects bounded, project-scoped context as developer context. |
-| `PostToolUse` + `Stop` hooks | Captures the user request, stable hook-provided tool inputs/results, and final answer after each completed turn. |
+| `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 work before compaction and recalls context before Codex continues after compaction. |
-| `SessionEnd` | Best-effort final checkpoint within Codex's three-second SessionEnd budget. |
+| `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. |
 | `AGENTS.md` | Tells Codex when to recall/store and how MemoryRouter coexists with native Memories. |
@@ -37,7 +39,7 @@ 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.0.0 init --scope user --auth oauth --api-key-stdin
+  npx -y memoryrouter-codex@1.1.0 init --scope user --auth oauth --api-key-stdin
 
 codex mcp login memoryrouter
 memoryrouter-codex doctor --scope user
@@ -59,7 +61,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.0.0 init --scope project --auth oauth --api-key-stdin
+  npx -y memoryrouter-codex@1.1.0 init --scope project --auth oauth --api-key-stdin
 codex mcp login memoryrouter
 ```
 
@@ -69,7 +71,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.0.0 init --scope user --auth api-key --api-key-stdin
+  npx -y memoryrouter-codex@1.1.0 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:
@@ -126,6 +128,10 @@ Automatic memories use an envelope containing project handle, stable memory hand
 
 Set `retrievalScope` to `"vault"` in the private config only if you intentionally want unscoped automatic recall.
 
+## Historical import boundary
+
+The Codex package captures future work after installation. It does not ship a deterministic importer for ChatGPT exports or prior Codex conversations. A local Codex workflow can inspect an extracted export and curate selected facts, but that is experimental guided curation, not checkpointed/resumable/reconciled archive ingestion. Remote MCP OAuth connection by itself never imports history.
+
 ## Handles, deduplication, retries, and forgetting
 
 - Handles (`mrh_...`) are content-derived from project, kind, and normalized content.
@@ -142,7 +148,7 @@ Set `retrievalScope` to `"vault"` in the private config only if you intentionall
 - Hook `additionalContextLimit`: approximately 3,500 tokens, so Codex can spill unexpectedly large context safely instead of consuming the whole model window.
 - Candidate search default: 12 before strict project filtering.
 - All hook entrypoints exit zero on missing credentials, malformed input, API errors, and timeouts. Memory never blocks Codex work.
-- Hook status is recorded without secrets in `~/.memoryrouter/codex/health.json`. Search/store/forget outcomes (metadata only, never memory content or keys) append to a rotating 5 MiB local `~/.memoryrouter/codex/audit.jsonl`. `memory_status` exposes both locations. This is a host-local integration audit, not a server-wide team access log. Session/trace state older than 30 days is pruned at session start.
+- Hook status is recorded without secrets in `~/.memoryrouter/codex/health.json`. Search/store/forget outcomes (metadata only, never memory content or keys) append to a rotating 5 MiB local `~/.memoryrouter/codex/audit.jsonl`. `memory_status` exposes both locations. This is a host-local integration audit, not a server-wide team access log. Session state and any legacy pre-1.1 trace files older than 30 days are pruned at session start. Version 1.1 creates no tool trace files.
 - Set `MEMORYROUTER_DEBUG=1` for hook errors on stderr. Debug is off by default.
 
 ## Codex native Memories coexistence
@@ -172,7 +178,7 @@ Live verification with official `@openai/codex` **0.146.0** established:
 5. Codex generates an authorization URL with PKCE S256, `memories:read memories:write`, the exact RFC 8707 resource, and a loopback callback.
 6. The browser consent/token step was deliberately not completed by the package test because it is account-specific. Therefore `doctor` verifies discovery compatibility but never reports an OAuth session as logged in without user consent. Use `codex mcp login memoryrouter` and `/mcp verbose` to complete/verify it.
 
-The remote server currently negotiates legacy MCP `2025-11-25`. Codex 0.146 remains dual-era and initializes it successfully today. MemoryRouter's MCP server still needs its separate `2026-07-28` protocol modernization; this client integration does not hide that server limitation.
+The production server supports modern stateless MCP `2026-07-28` and still accepts `2025-11-25`, `2025-06-18`, and `2025-03-26` for handshake-era clients. Codex 0.146 initializes the compatibility path successfully. Do not infer Codex support from protocol negotiation alone; verify OAuth login, `/mcp verbose`, and the actual tool inventory.
 
 ## Doctor
 
@@ -189,15 +195,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.0.0 init --scope user
+npx -y memoryrouter-codex@1.1.0 init --scope user
 ```
 
 Uninstall:
 
 ```bash
-npx -y memoryrouter-codex@1.0.0 uninstall --scope user
+npx -y memoryrouter-codex@1.1.0 uninstall --scope user
 # or
-npx -y memoryrouter-codex@1.0.0 uninstall --scope project --project-dir /repo
+npx -y memoryrouter-codex@1.1.0 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.
@@ -205,8 +211,8 @@ Uninstall deliberately retains `~/.memoryrouter/codex/` because another project
 ## Honest limitations
 
 - Hooks are the deterministic automatic path. Remote MCP alone remains model-invoked, not guaranteed every turn.
-- The transcript file path supplied to hooks is documented as unstable, so this integration does **not** parse Codex transcript JSONL. It captures only stable hook fields: prompt, tool input/result, and final assistant message.
-- Hosted tools such as web search do not currently emit `PostToolUse`; their detailed output is not automatically captured unless reflected in the final response.
+- The transcript file path supplied to hooks is documented as unstable, so this integration does **not** parse Codex transcript JSONL. Version 1.1 captures only the stable user prompt and `last_assistant_message`.
+- 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.

package/RESEARCH.md

@@ -17,7 +17,7 @@ Verified 2026-07-31. This is engineering evidence, not public marketing copy.
 ## Platform findings used in the architecture
 
 - Current Codex supports command hooks for `SessionStart`, `SessionEnd`, `PreToolUse`, `PostToolUse`, `PreCompact`, `PostCompact`, `UserPromptSubmit`, `SubagentStart`, `SubagentStop`, and `Stop`.
-- Hook transcript paths are explicitly documented as unstable. The integration therefore uses stable event fields and an append-only local tool trace rather than parsing transcript JSONL.
+- Hook transcript paths are explicitly documented as unstable. Version 1.0 used stable event fields plus an append-only local `PostToolUse` trace. Version 1.1 removes that trace and its hook entirely: completed-turn storage is composed only from the `UserPromptSubmit` prompt and Stop's stable `last_assistant_message`.
 - Hooks are enabled by default and project hooks require trust. `features.codex_hooks` is only a deprecated alias; the current canonical key is `features.hooks`.
 - Remote MCP OAuth no longer needs `experimental_use_rmcp_client` in current Codex. That key is absent from the current configuration reference.
 - The local CLI, desktop Codex host, and IDE extension share Codex config. ChatGPT web uses hosted plugin tools and does not inherit local config.
@@ -54,4 +54,8 @@ npm run typecheck
 npm pack --dry-run
 ```
 
-The integration suite covers config migration/backup, foreign-config preservation, corrupt config fail-closed behavior, idempotent upgrades, uninstall, project/worktree identity, project-vs-vault filtering, native-memory config coexistence, OAuth/local fallback configuration, read retries, write deduplication, hook fail-open behavior, full stable-field turn capture, context budgets, local suppression, and MCP tool annotations.
+The integration suite covers config migration/backup, foreign-config preservation, corrupt config fail-closed behavior, idempotent upgrades, uninstall, project/worktree identity, project-vs-vault filtering, native-memory config coexistence, OAuth/local fallback configuration, read retries, write deduplication, hook fail-open behavior, prompt/final-only turn and checkpoint capture, explicit exclusion of tool payloads, context budgets, local suppression, and MCP tool annotations.
+
+## Version 1.1 capture decision
+
+`PostToolUse` is not registered by the installer in 1.1. The runtime no longer defines or reads trace files, and health records no longer count tool calls. Normal Stop capture requires `last_assistant_message`; PreCompact and SessionEnd may preserve the cached user prompt when no final response is available. `SubagentStop` remains separate and stores only its stable final outcome plus non-payload agent identifiers.

package/lib/hooks.cjs

@@ -52,7 +52,6 @@ function managedGroups(runtimeDir, scope) {
   return {
     SessionStart: [{ matcher: 'startup|resume|clear|compact', hooks: [handler('session-start', 8, 'Recalling MemoryRouter context', 3500)] }],
     UserPromptSubmit: [{ hooks: [handler('inject', 8, 'Searching project memory', 3500)] }],
-    PostToolUse: [{ hooks: [handler('trace', 3)] }],
     Stop: [{ hooks: [handler('capture', 18, 'Saving durable project memory')] }],
     SubagentStop: [{ hooks: [handler('capture-subagent', 15, 'Saving durable subagent outcome')] }],
     PreCompact: [{ matcher: 'manual|auto', hooks: [handler('flush', 18, 'Saving memory before compaction')] }],

package/lib/installer.cjs

@@ -11,7 +11,7 @@ const {
   installToml, uninstallToml, installAgents, uninstallAgents, readText, replaceBlock,
   hasUnmanagedMemoryRouterTable, TOML_START, TOML_END, AGENTS_START, AGENTS_END,
 } = require('./managed.cjs');
-const { installHooks, uninstallHooks, isOwnedHook, parseHooks } = require('./hooks.cjs');
+const { installHooks, uninstallHooks, isOwnedHook, managedGroups, parseHooks } = require('./hooks.cjs');
 
 function resolveLayout(options = {}) {
   const env = options.env || process.env;
@@ -176,7 +176,8 @@ async function doctor(options = {}) {
   let hooks = null;
   try { hooks = hooksText ? JSON.parse(hooksText) : null; } catch { /* handled */ }
   const owned = hooks ? Object.values(hooks.hooks || {}).flat().flatMap(group => group.hooks || []).filter(isOwnedHook) : [];
-  addCheck(checks, 'hooks', owned.length >= 7 ? 'pass' : 'error', owned.length ? `${owned.length} managed lifecycle hooks found.` : 'Managed lifecycle hooks are missing or hooks.json is invalid.');
+  const expectedOwned = Object.values(managedGroups(layout.runtimeDir, layout.scope)).flat().flatMap(group => group.hooks || []).length;
+  addCheck(checks, 'hooks', owned.length === expectedOwned ? 'pass' : 'error', owned.length ? `${owned.length} of ${expectedOwned} managed lifecycle hooks found.` : 'Managed lifecycle hooks are missing or hooks.json is invalid.');
   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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoryrouter-codex",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Automatic, project-scoped MemoryRouter memory for OpenAI Codex",
   "license": "MIT",
   "type": "commonjs",

package/runtime/config.cjs

@@ -74,10 +74,6 @@ 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'));
@@ -154,7 +150,6 @@ module.exports = {
   safeId,
   stateDir,
   sessionStatePath,
-  tracePath,
   loadSessionState,
   saveSessionState,
   pruneState,

package/runtime/constants.cjs

@@ -1,13 +1,11 @@
 'use strict';
 
-const INTEGRATION_VERSION = '1.0.0';
+const INTEGRATION_VERSION = '1.1.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 = {
@@ -17,7 +15,5 @@ module.exports = {
   MCP_ENDPOINT,
   DEFAULT_CONTEXT_CHARS,
   DEFAULT_SEARCH_RESULTS,
-  MAX_TRACE_RECORD_CHARS,
-  MAX_TRACE_TOTAL_CHARS,
   ENVELOPE_HEADER,
 };

package/runtime/hook.cjs

@@ -1,11 +1,9 @@
 #!/usr/bin/env node
 'use strict';
 
-const fs = require('fs');
-const { loadConfig, getApiKey, loadSessionState, saveSessionState, tracePath, pruneState, recordHealth } = require('./config.cjs');
+const { loadConfig, getApiKey, loadSessionState, saveSessionState, 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);
@@ -22,7 +20,7 @@ function readStdin(timeoutMs = 1500) {
   });
 }
 
-function truncate(value, limit = MAX_TRACE_RECORD_CHARS) {
+function truncate(value, limit = 8000) {
   let text;
   try { text = typeof value === 'string' ? value : JSON.stringify(value); } catch { text = String(value); }
   if (text.length <= limit) return text;
@@ -38,61 +36,16 @@ function emitContext(eventName, 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) {
+function turnContent(input, state) {
   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');
+  return [
+    prompt ? `User request:
+${truncate(prompt, 40000)}` : null,
+    input.last_assistant_message
+      ? `Final assistant response:
+${truncate(input.last_assistant_message, 60000)}`
+      : null,
+  ].filter(Boolean).join('\n\n');
 }
 
 async function handleInject(input, context) {
@@ -142,9 +95,10 @@ async function captureTurn(input, context, partial = false) {
   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 prompt = state.prompts?.[turnId] || state.lastPrompt || '';
+  if (!partial && !input.last_assistant_message) return { ok: true, skipped: 'empty' };
+  if (partial && !prompt && !input.last_assistant_message) return { ok: true, skipped: 'empty' };
+  const content = turnContent({ ...input, turn_id: turnId }, state);
   const kind = partial ? 'checkpoint' : 'turn';
   const handle = memoryHandle(context.project.handle, kind, content);
   if ((state.capturedHandles || []).includes(handle)) return { ok: true, skipped: 'deduplicated', handle };
@@ -166,14 +120,14 @@ async function captureTurn(input, context, partial = false) {
     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,
+    hasPrompt: Boolean(prompt),
+    hasFinalResponse: Boolean(input.last_assistant_message),
   }, context.env);
   return result;
 }
@@ -222,7 +176,6 @@ async function run(kind, input, options = {}) {
   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);
@@ -232,7 +185,7 @@ async function run(kind, input, options = {}) {
 
 async function main() {
   const kind = process.argv[2];
-  const wallClock = setTimeout(() => process.exit(0), kind === 'trace' ? 2500 : kind === 'inject' ? 7500 : 18000);
+  const wallClock = setTimeout(() => process.exit(0), kind === 'inject' ? 7500 : 18000);
   wallClock.unref();
   let input = {};
   try { input = JSON.parse((await readStdin()) || '{}'); } catch { debug('invalid hook JSON'); }
@@ -247,9 +200,6 @@ module.exports = {
   readStdin,
   truncate,
   emitContext,
-  appendTrace,
-  readTrace,
-  removeTrace,
   turnContent,
   handleInject,
   handleSessionStart,