memento-mcp 0.3.4 → 0.3.6

package/README.md

@@ -10,7 +10,7 @@ AI agents have anterograde amnesia — every session starts blank. The Memento P
 npx memento-mcp init
 ```
 
-This creates `.memento.json`, detects your agent (Claude Code, Codex, Gemini CLI, OpenCode), writes the correct MCP config, and sets up hooks (Claude Code only) — all in one command.
+This creates `.memento.json`, detects your agent (Claude Code, Codex, Gemini CLI, OpenCode), writes the correct MCP config, and registers hooks — all in one command.
 
 ---
 
@@ -154,13 +154,29 @@ Full guide: **[The Protocol](https://hifathom.com/memento/docs/protocol)** on hi
 
 ## Hooks
 
-Hooks automate memory at session boundaries — recall on every message, distillation before context loss. Three production-ready scripts are included in `scripts/`:
+Hooks automate memory at session boundaries — recall on every message, distillation before context loss, identity injection at session start. Five production-ready scripts are included in `scripts/`:
 
-| Script | Event | What it does |
-|--------|-------|-------------|
-| `memento-userprompt-recall.sh` | UserPromptSubmit | Recalls memories relevant to the user's message |
-| `memento-stop-recall.sh` | Stop | Recalls memories from the assistant's own output (autonomous work) |
-| `memento-precompact-distill.sh` | PreCompact | Extracts memories from the conversation before context compression |
+| Script | What it does |
+|--------|-------------|
+| `memento-sessionstart-identity.sh` | Injects identity crystal + version check at session start |
+| `memento-userprompt-recall.sh` | Recalls memories relevant to the user's message |
+| `memento-stop-recall.sh` | Recalls memories from the assistant's own output (autonomous work) |
+| `memento-precompact-distill.sh` | Extracts memories from the conversation before context compression |
+| `memento-codex-notify.sh` | Stores post-turn summaries from Codex CLI as memory observations |
+
+### Agent hook support
+
+`npx memento-mcp init` auto-detects your agent and registers the appropriate hooks. Not all agents support the same hook events — here's what gets wired up:
+
+| Hook | Claude Code | Gemini CLI | Codex CLI |
+|------|:-----------:|:----------:|:---------:|
+| Session start / identity | `SessionStart` | `SessionStart` | — |
+| Recall on user message | `UserPromptSubmit` | `BeforeAgent` | — |
+| Recall on assistant output | `Stop` | `SessionEnd` | — |
+| Pre-compaction distillation | `PreCompact` | `PreCompress` | — |
+| Post-turn memory storage | — | — | `notify` |
+
+**OpenCode** uses a TypeScript plugin system — MCP tools work, but hooks require a different integration pattern.
 
 See **[scripts/README.md](scripts/README.md)** for setup, configuration, and how to write your own hooks.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memento-mcp",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "mcpName": "io.github.myrakrusemark/memento-protocol",
   "description": "The Memento Protocol — persistent memory for AI agents",
   "type": "module",

package/scripts/README.md

@@ -1,18 +1,56 @@
 # Memento Protocol — Hook Scripts
 
-Automation hooks for [Claude Code](https://docs.anthropic.com/en/docs/claude-code) that connect the Memento API to session lifecycle events. These scripts make memory automatic — recall on every message, distillation before context loss.
+Automation hooks that connect the Memento API to agent lifecycle events. These scripts make memory automatic — recall on every message, distillation before context loss, identity injection at session start.
 
-## Naming convention
+## Supported agents
 
-Hook scripts follow the pattern `[system]-[hook]-[verb].sh`:
+Memento hooks work with three CLI agents. Each has a different hook system, but the same scripts power all of them.
 
-| Script | Event | What it does |
-|--------|-------|-------------|
-| `memento-userprompt-recall.sh` | UserPromptSubmit | Recall memories relevant to the user's message |
-| `memento-stop-recall.sh` | Stop | Recall memories relevant to the assistant's own output |
-| `memento-precompact-distill.sh` | PreCompact | Extract memories from the conversation before context compression |
+| Hook | Claude Code | Gemini CLI | Codex CLI |
+|------|:-----------:|:----------:|:---------:|
+| Session start / identity | `SessionStart` | `SessionStart` | — |
+| Recall on user message | `UserPromptSubmit` | `BeforeAgent` | — |
+| Recall on assistant output | `Stop` | `SessionEnd` | — |
+| Pre-compaction distillation | `PreCompact` | `PreCompress` | — |
+| Post-turn memory storage | — | — | `notify` |
 
-## Set up hooks
+**OpenCode** uses a TypeScript plugin system — MCP tools work, but hooks require a different integration pattern.
+
+**Claude Code** and **Gemini CLI** have near-identical hook architectures — JSON on stdin, JSON on stdout. The same shell scripts work for both; only the event names differ.
+
+**Codex CLI** has a single `notify` mechanism — fire-and-forget, JSON as `argv[1]`, no context injection. Useful for post-turn memory storage only.
+
+## Scripts
+
+| Script | What it does |
+|--------|-------------|
+| `memento-sessionstart-identity.sh` | Injects identity crystal + version check at session start |
+| `memento-userprompt-recall.sh` | Recalls memories relevant to the user's message |
+| `memento-stop-recall.sh` | Recalls memories from the assistant's own output |
+| `memento-precompact-distill.sh` | Extracts memories from the conversation before context compression |
+| `memento-codex-notify.sh` | Stores post-turn summaries from Codex CLI as memory observations |
+
+## Automatic setup
+
+The recommended way to set up hooks:
+
+```bash
+npx memento-mcp init
+```
+
+This detects your agent, registers hooks in the correct config file, and copies scripts to `.memento/scripts/`. No manual configuration needed.
+
+To update hooks in an existing project:
+
+```bash
+npx memento-mcp update
+```
+
+---
+
+## Manual setup
+
+If you prefer to configure hooks yourself:
 
 ### 1. Create a `.env` file
 
@@ -36,18 +74,29 @@ The `.env` file is gitignored. All scripts source it automatically.
 chmod +x scripts/*.sh
 ```
 
-### 3. Register hooks in Claude Code
+### 3. Register hooks
+
+#### Claude Code
 
-Add to `.claude/settings.json` (project-level) or `~/.claude/settings.json` (global):
+Add to `.claude/settings.local.json` (project-level) or `~/.claude/settings.json` (global):
 
 ```json
 {
   "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [{
+          "type": "command",
+          "command": "bash .memento/scripts/memento-sessionstart-identity.sh",
+          "timeout": 10000
+        }]
+      }
+    ],
     "UserPromptSubmit": [
       {
         "hooks": [{
           "type": "command",
-          "command": "/path/to/memento-protocol/scripts/memento-userprompt-recall.sh",
+          "command": "bash .memento/scripts/memento-userprompt-recall.sh",
           "timeout": 5000
         }]
       }
@@ -56,7 +105,7 @@ Add to `.claude/settings.json` (project-level) or `~/.claude/settings.json` (glo
       {
         "hooks": [{
           "type": "command",
-          "command": "/path/to/memento-protocol/scripts/memento-stop-recall.sh",
+          "command": "bash .memento/scripts/memento-stop-recall.sh",
           "timeout": 5000
         }]
       }
@@ -65,7 +114,54 @@ Add to `.claude/settings.json` (project-level) or `~/.claude/settings.json` (glo
       {
         "hooks": [{
           "type": "command",
-          "command": "/path/to/memento-protocol/scripts/memento-precompact-distill.sh",
+          "command": "bash .memento/scripts/memento-precompact-distill.sh",
+          "timeout": 30000
+        }]
+      }
+    ]
+  }
+}
+```
+
+#### Gemini CLI
+
+Add to `.gemini/settings.json`:
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [{
+          "type": "command",
+          "command": "bash .memento/scripts/memento-sessionstart-identity.sh",
+          "timeout": 10000
+        }]
+      }
+    ],
+    "BeforeAgent": [
+      {
+        "hooks": [{
+          "type": "command",
+          "command": "bash .memento/scripts/memento-userprompt-recall.sh",
+          "timeout": 5000
+        }]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [{
+          "type": "command",
+          "command": "bash .memento/scripts/memento-stop-recall.sh",
+          "timeout": 5000
+        }]
+      }
+    ],
+    "PreCompress": [
+      {
+        "hooks": [{
+          "type": "command",
+          "command": "bash .memento/scripts/memento-precompact-distill.sh",
           "timeout": 30000
         }]
       }
@@ -74,13 +170,29 @@ Add to `.claude/settings.json` (project-level) or `~/.claude/settings.json` (glo
 }
 ```
 
-Replace `/path/to/memento-protocol` with the actual absolute path to your clone.
+#### Codex CLI
+
+Add to `.codex/config.toml`:
+
+```toml
+notify = ["bash", ".memento/scripts/memento-codex-notify.sh"]
+```
+
+Codex `notify` fires on `agent-turn-complete` — the script receives JSON as `argv[1]` (not stdin) and stores a memory observation from the assistant's response. Fire-and-forget only — no context injection.
 
 ---
 
 ## Script details
 
-### `memento-userprompt-recall.sh` — UserPromptSubmit
+### `memento-sessionstart-identity.sh` — SessionStart
+
+Fires when a session begins. Injects the identity crystal into model context and checks whether a newer version of memento-mcp is available.
+
+- **Timeout:** 10 seconds
+- **Model sees:** Identity crystal text + update notice (if newer version available)
+- **Version check:** Compares `.memento/version` against npm registry (2s timeout, silent on failure)
+
+### `memento-userprompt-recall.sh` — UserPromptSubmit / BeforeAgent
 
 Fires before every agent response. Sends the user's message to `/v1/context`, which returns relevant memories and skip list warnings.
 
@@ -91,7 +203,7 @@ Fires before every agent response. Sends the user's message to `/v1/context`, wh
 
 **Output format:** JSON with `systemMessage` (user display) + `hookSpecificOutput.additionalContext` (model context).
 
-### `memento-stop-recall.sh` — Stop
+### `memento-stop-recall.sh` — Stop / SessionEnd
 
 Fires after every assistant response. Uses the assistant's own output as the recall query — so memories surface during autonomous work, not just on user messages.
 
@@ -105,9 +217,9 @@ Fires after every assistant response. Uses the assistant's own output as the rec
 
 **Why this matters:** Without the Stop hook, memories only surface when a human sends a message. For autonomous agents that work independently — running ping routines, doing research, monitoring news — their own memories never get recalled. The Stop hook closes that gap.
 
-### `memento-precompact-distill.sh` — PreCompact
+### `memento-precompact-distill.sh` — PreCompact / PreCompress
 
-Fires before Claude Code compresses the conversation. Parses the full JSONL transcript and extracts novel facts, decisions, and observations as stored memories. Supports two extraction backends:
+Fires before the agent compresses the conversation. Parses the full JSONL transcript and extracts novel facts, decisions, and observations as stored memories. Supports two extraction backends:
 
 - **`"llama"` (default)** — sends transcript to `/v1/distill`, which runs Llama 3.1 8B via Cloudflare Workers AI. Free.
 - **`"claude-code"`** — runs `claude -p` locally for better extraction quality, then pushes to `/v1/memories/ingest`. Uses API credits.
@@ -135,19 +247,33 @@ Configure the model in `.memento.json`:
 
 **Why this matters:** Context compaction destroys information. Without distillation, anything discussed but not explicitly saved is lost. This hook captures what's novel — deduplicating against existing memories — so nothing important vanishes.
 
+### `memento-codex-notify.sh` — Codex notify
+
+Receives JSON as `argv[1]` on `agent-turn-complete` events. Extracts the assistant's response and stores it as a memory observation — best-effort, fire-and-forget.
+
+- **Event filter:** Only handles `agent-turn-complete` (other event types exit silently)
+- **Minimum threshold:** Messages under 50 characters are skipped
+- **Truncation:** Stores first 500 characters of the assistant's response
+- **Tags:** `codex`, `turn-summary`, `auto-capture`
+- **Config:** Reads `.memento.json` for API key, URL, and workspace
+
+**Why this matters:** Codex CLI can't inject context back into the model, so recall hooks don't apply. But post-turn storage still captures what the agent learned — available for recall in future sessions via any agent.
+
 ---
 
 ## Hook output formats
 
-Claude Code hooks can output data in several formats. These scripts use two:
+Claude Code and Gemini CLI hooks output data in the same JSON formats:
 
 | Format | Where it appears | Used by |
 |--------|-----------------|---------|
 | `systemMessage` | User's terminal | All scripts |
-| `hookSpecificOutput.additionalContext` | Model context (system-reminder) | UserPromptSubmit recall |
-| `decision: "block"` with `reason` | Model context (next instruction) | Stop recall |
+| `hookSpecificOutput.additionalContext` | Model context (system-reminder) | UserPromptSubmit / BeforeAgent recall |
+| `decision: "block"` with `reason` | Model context (next instruction) | Stop / SessionEnd recall |
 
-The `additionalContext` approach only works for UserPromptSubmit, PreToolUse, and PostToolUse events. For Stop hooks, the `decision: "block"` pattern is the only mechanism that injects content into model context.
+The `additionalContext` approach works for UserPromptSubmit/BeforeAgent, PreToolUse, and PostToolUse events. For Stop/SessionEnd hooks, the `decision: "block"` pattern is the only mechanism that injects content into model context.
+
+Codex `notify` has no output mechanism — it's fire-and-forget.
 
 ---
 
@@ -165,8 +291,13 @@ The `additionalContext` approach only works for UserPromptSubmit, PreToolUse, an
 
 Follow the naming convention: `[system]-[hook]-[verb].sh`. Your script receives JSON on stdin with event-specific fields:
 
-- **UserPromptSubmit:** `{ "prompt": "user's message" }`
-- **Stop:** `{ "last_assistant_message": "...", "stop_hook_active": false }`
-- **PreCompact:** `{ "transcript_path": "~/.claude/projects/.../conversation.jsonl" }`
+**Claude Code / Gemini CLI** (JSON on stdin):
+- **SessionStart:** `{ "session_id": "..." }`
+- **UserPromptSubmit / BeforeAgent:** `{ "prompt": "user's message" }`
+- **Stop / SessionEnd:** `{ "last_assistant_message": "...", "stop_hook_active": false }`
+- **PreCompact / PreCompress:** `{ "transcript_path": "~/.claude/projects/.../conversation.jsonl" }`
+
+**Codex CLI** (JSON as `argv[1]`):
+- **agent-turn-complete:** `{ "type": "agent-turn-complete", "last-assistant-message": "...", "input-messages": [...] }`
 
 Source `.env` for credentials, call the Memento API, and output JSON to stdout. Exit 0 for no-op (nothing to report).

package/scripts/memento-codex-notify.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+# Codex CLI notify hook — post-turn memory storage to Memento.
+# Receives JSON payload as argv[1] on agent-turn-complete events.
+#
+# Extracts the assistant's response and stores it as a Memento observation.
+# Best-effort — failures are silent. This is fire-and-forget.
+
+set -o pipefail
+
+PAYLOAD="$1"
+[ -z "$PAYLOAD" ] && exit 0
+
+# Only handle agent-turn-complete events
+EVENT_TYPE=$(echo "$PAYLOAD" | python3 -c "import json,sys; print(json.load(sys.stdin).get('type',''))" 2>/dev/null)
+[ "$EVENT_TYPE" != "agent-turn-complete" ] && exit 0
+
+# Find .memento.json by walking up
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+CONFIG_JSON=""
+_d="$(pwd)"
+while true; do
+    if [ -f "$_d/.memento.json" ]; then
+        CONFIG_JSON=$(cat "$_d/.memento.json" 2>/dev/null)
+        break
+    fi
+    _p="$(dirname "$_d")"
+    [ "$_p" = "$_d" ] && break
+    _d="$_p"
+done
+
+[ -z "$CONFIG_JSON" ] && exit 0
+
+# Extract config
+MEMENTO_API_KEY=$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('apiKey',''))" 2>/dev/null)
+MEMENTO_API_URL=$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('apiUrl',''))" 2>/dev/null)
+MEMENTO_WORKSPACE=$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('workspace',''))" 2>/dev/null)
+
+MEMENTO_API="${MEMENTO_API_URL:-https://memento-api.myrakrusemark.workers.dev}"
+[ -z "$MEMENTO_API_KEY" ] && exit 0
+
+# Extract turn content and store to Memento API
+python3 -c "
+import json, sys, urllib.request
+
+payload = json.loads(sys.argv[1])
+api_url = sys.argv[2]
+api_key = sys.argv[3]
+workspace = sys.argv[4]
+
+assistant_msg = payload.get('last-assistant-message', '')
+
+# Only store if there's meaningful content
+if not assistant_msg or len(assistant_msg) < 50:
+    sys.exit(0)
+
+# Truncate for storage
+summary = assistant_msg[:500]
+if len(assistant_msg) > 500:
+    summary += '...'
+
+data = json.dumps({
+    'content': summary,
+    'type': 'observation',
+    'tags': ['codex', 'turn-summary', 'auto-capture']
+}).encode()
+
+req = urllib.request.Request(
+    f'{api_url}/v1/memories',
+    data=data,
+    headers={
+        'Authorization': f'Bearer {api_key}',
+        'Content-Type': 'application/json',
+        'X-Memento-Workspace': workspace
+    }
+)
+urllib.request.urlopen(req, timeout=3)
+" "$PAYLOAD" "$MEMENTO_API" "$MEMENTO_API_KEY" "$MEMENTO_WORKSPACE" 2>/dev/null || true
+
+exit 0

package/src/cli.js

@@ -119,7 +119,7 @@ before compaction. Trust the hooks. Focus on writing good memories.`;
 // ---------------------------------------------------------------------------
 
 const HEADLESS_CMDS = {
-  "claude-code": (prompt) => ["claude", "-p", prompt],
+  "claude-code": (prompt) => ["claude", "-p", "--dangerously-skip-permissions", prompt],
   "codex":       (prompt) => ["codex", "exec", prompt],
   "gemini":      (prompt) => ["gemini", prompt],
   "opencode":    (prompt) => ["opencode", "run", prompt],
@@ -196,10 +196,23 @@ function writeJsonFile(filePath, data) {
   fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 
-function mergeJsonFile(filePath, data) {
-  const existing = readJsonFile(filePath) || {};
-  const merged = deepMerge(existing, data);
-  writeJsonFile(filePath, merged);
+/**
+ * Idempotently register a hook in a settings object.
+ * Works for both Claude Code and Gemini CLI (same JSON structure).
+ * Returns true if a new hook was added, false if already present.
+ */
+function ensureHook(settings, eventName, command, timeout) {
+  const existing = settings.hooks?.[eventName] || [];
+  const alreadyRegistered = existing.some((entry) =>
+    entry.hooks?.some((h) => h.command === command)
+  );
+  if (alreadyRegistered) return false;
+  if (!settings.hooks) settings.hooks = {};
+  settings.hooks[eventName] = [
+    ...existing,
+    { hooks: [{ type: "command", command, timeout }] },
+  ];
+  return true;
 }
 
 function appendToGitignore(cwd, line) {
@@ -452,13 +465,16 @@ async function runInit(flags = {}) {
 
   const hasClaude = selectedAgents.includes("claude-code");
 
-  // 5. Hooks — only if Claude Code selected
+  // 5. Hooks — if any hook-supporting agent is selected (Claude Code, Gemini CLI)
+  const hasGemini = selectedAgents.includes("gemini");
+  const hasHookAgent = hasClaude || hasGemini;
+
   let enableUserPrompt = false;
   let enableStop = false;
   let enablePreCompact = false;
   let enableSessionStart = false;
 
-  if (hasClaude) {
+  if (hasHookAgent) {
     if (nonInteractive) {
       // All hooks on by default in non-interactive mode
       enableUserPrompt = true;
@@ -466,10 +482,10 @@ async function runInit(flags = {}) {
       enablePreCompact = true;
       enableSessionStart = false; // identity not enabled in -y mode
     } else {
-      console.log("\nClaude Code hooks (automate recall + distillation):");
+      console.log("\nAgent hooks (automate recall + distillation):");
       enableUserPrompt = await askYesNo(
         rl,
-        "  UserPromptSubmit — recall on every message?",
+        "  Prompt recall — recall on every message?",
         true,
       );
       enableStop = await askYesNo(rl, "  Stop — autonomous recall after responses?", true);
@@ -514,11 +530,12 @@ async function runInit(flags = {}) {
   writeJsonFile(configPath, config);
   created.push(".memento.json");
 
-  // 7. Copy hook scripts + write Claude Code settings — gated on hasClaude
+  // 7. Copy hook scripts — gated on any hook-supporting agent
+  const hasCodex = selectedAgents.includes("codex");
   const anyHookEnabled =
     enableUserPrompt || enableStop || enablePreCompact || enableSessionStart;
 
-  if (hasClaude && anyHookEnabled) {
+  if (hasHookAgent && anyHookEnabled) {
     const pkgScriptsDir = path.resolve(__dirname, "..", "scripts");
     const localScriptsDir = path.join(cwd, ".memento", "scripts");
     if (!fs.existsSync(localScriptsDir))
@@ -532,8 +549,12 @@ async function runInit(flags = {}) {
       enableSessionStart && "memento-sessionstart-identity.sh",
     ].filter(Boolean);
 
+    // Also copy Codex notify script if Codex is selected
+    if (hasCodex) scriptFiles.push("memento-codex-notify.sh");
+
     for (const name of scriptFiles) {
       const src = path.join(pkgScriptsDir, name);
+      if (!fs.existsSync(src)) continue; // skip if script doesn't exist yet
       const dest = path.join(localScriptsDir, name);
       fs.copyFileSync(src, dest);
       fs.chmodSync(dest, 0o755);
@@ -546,67 +567,65 @@ async function runInit(flags = {}) {
     const versionPath = path.join(cwd, ".memento", "version");
     fs.writeFileSync(versionPath, pkgVersion + "\n");
 
-    // 8. Write .claude/settings.local.json (hooks)
-    const hooks = {};
-    if (enableUserPrompt) {
-      hooks.UserPromptSubmit = [
-        {
-          hooks: [
-            {
-              type: "command",
-              command: path.join(localScriptsDir, "memento-userprompt-recall.sh"),
-              timeout: 5000,
-            },
-          ],
-        },
-      ];
+    // Hook script commands (absolute paths)
+    const recallCmd = path.join(localScriptsDir, "memento-userprompt-recall.sh");
+    const stopCmd = path.join(localScriptsDir, "memento-stop-recall.sh");
+    const precompactCmd = path.join(localScriptsDir, "memento-precompact-distill.sh");
+    const sessionStartCmd = path.join(localScriptsDir, "memento-sessionstart-identity.sh");
+
+    // 8a. Claude Code hooks — .claude/settings.local.json
+    if (hasClaude) {
+      const settingsPath = path.join(cwd, ".claude", "settings.local.json");
+      const settings = readJsonFile(settingsPath) || {};
+      let changed = false;
+      if (enableUserPrompt) changed = ensureHook(settings, "UserPromptSubmit", recallCmd, 5000) || changed;
+      if (enableStop) changed = ensureHook(settings, "Stop", stopCmd, 5000) || changed;
+      if (enablePreCompact) changed = ensureHook(settings, "PreCompact", precompactCmd, 30000) || changed;
+      if (enableSessionStart) changed = ensureHook(settings, "SessionStart", sessionStartCmd, 10000) || changed;
+      if (changed) {
+        writeJsonFile(settingsPath, settings);
+        created.push(".claude/settings.local.json");
+      }
     }
-    if (enableStop) {
-      hooks.Stop = [
-        {
-          hooks: [
-            {
-              type: "command",
-              command: path.join(localScriptsDir, "memento-stop-recall.sh"),
-              timeout: 5000,
-            },
-          ],
-        },
-      ];
+
+    // 8b. Gemini CLI hooks — .gemini/settings.json
+    if (hasGemini) {
+      const settingsPath = path.join(cwd, ".gemini", "settings.json");
+      const settings = readJsonFile(settingsPath) || {};
+      let changed = false;
+      if (enableUserPrompt) changed = ensureHook(settings, "BeforeAgent", recallCmd, 5000) || changed;
+      if (enableStop) changed = ensureHook(settings, "SessionEnd", stopCmd, 5000) || changed;
+      if (enablePreCompact) changed = ensureHook(settings, "PreCompress", precompactCmd, 30000) || changed;
+      if (enableSessionStart) changed = ensureHook(settings, "SessionStart", sessionStartCmd, 10000) || changed;
+      if (changed) {
+        writeJsonFile(settingsPath, settings);
+        created.push(".gemini/settings.json (hooks)");
+      }
     }
-    if (enablePreCompact) {
-      hooks.PreCompact = [
-        {
-          hooks: [
-            {
-              type: "command",
-              command: path.join(localScriptsDir, "memento-precompact-distill.sh"),
-              timeout: 30000,
-            },
-          ],
-        },
-      ];
+  }
+
+  // 8c. Codex CLI notify — .codex/config.toml (fire-and-forget, post-turn memory storage)
+  if (hasCodex) {
+    const pkgScriptsDir = path.resolve(__dirname, "..", "scripts");
+    const localScriptsDir = path.join(cwd, ".memento", "scripts");
+    // Ensure the notify script is copied (may not have been copied above if no hook agent)
+    const notifySrc = path.join(pkgScriptsDir, "memento-codex-notify.sh");
+    const notifyDest = path.join(localScriptsDir, "memento-codex-notify.sh");
+    if (fs.existsSync(notifySrc) && !fs.existsSync(notifyDest)) {
+      fs.mkdirSync(localScriptsDir, { recursive: true });
+      fs.copyFileSync(notifySrc, notifyDest);
+      fs.chmodSync(notifyDest, 0o755);
     }
-    if (enableSessionStart) {
-      hooks.SessionStart = [
-        {
-          hooks: [
-            {
-              type: "command",
-              command: path.join(
-                localScriptsDir,
-                "memento-sessionstart-identity.sh",
-              ),
-              timeout: 10000,
-            },
-          ],
-        },
-      ];
+    const notifyScript = notifyDest;
+    const codexTomlPath = path.join(cwd, ".codex", "config.toml");
+    let tomlContent = "";
+    try { tomlContent = fs.readFileSync(codexTomlPath, "utf-8"); } catch { /* doesn't exist yet */ }
+    if (!tomlContent.includes("notify")) {
+      const notifyLine = `\nnotify = ["bash", "${notifyScript}"]\n`;
+      const separator = tomlContent && !tomlContent.endsWith("\n") ? "\n" : "";
+      fs.writeFileSync(codexTomlPath, tomlContent + separator + notifyLine);
+      created.push(".codex/config.toml (notify)");
     }
-
-    const settingsPath = path.join(cwd, ".claude", "settings.local.json");
-    mergeJsonFile(settingsPath, { hooks });
-    created.push(".claude/settings.local.json");
   }
 
   // 9. Per-agent config files
@@ -674,12 +693,13 @@ async function runInit(flags = {}) {
     // Interactive: ask with explicit command shown
     if (cmdParts) {
       const [cmd, ...args] = cmdParts;
-      const displayCmd = `${cmd} ${args[0]}${args.length > 1 ? " ..." : ""}`;
+      const flagArgs = args.slice(0, -1).join(" ");
+      const displayCmd = `${cmd} ${flagArgs} <prompt>`;
       const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
       console.log("─".repeat(60));
       const integrate = await askYesNo(
         rl2,
-        `\n  Auto-integrate instructions into your project?\n  This will run: ${displayCmd}\n\n  Proceed?`,
+        `\n  Auto-integrate instructions into your project?\n  This will run: ${displayCmd}\n\n  ⚠  This uses --dangerously-skip-permissions so the agent can\n  write to CLAUDE.md without prompting. If you prefer, decline\n  and we'll print the instructions for you to add manually.\n\n  Proceed?`,
         true,
       );
       rl2.close();
@@ -746,28 +766,51 @@ async function runUpdate() {
   const versionPath = path.join(cwd, ".memento", "version");
   fs.writeFileSync(versionPath, pkgVersion + "\n");
 
-  // Ensure SessionStart hook is registered for Claude Code workspaces
-  // Detect by .claude/ dir (older configs may not have agents field)
+  // Ensure SessionStart hook is registered for agents that support hooks
+  // Detect by config agents field or directory presence (older configs may lack agents)
   const config = readJsonFile(configPath) || {};
-  const hasClaude = (config.agents || []).includes("claude-code")
+  const agents = config.agents || [];
+  const sessionStartCmd = path.join(localScriptsDir, "memento-sessionstart-identity.sh");
+  const registeredHooks = [];
+
+  // Claude Code
+  const hasClaude = agents.includes("claude-code")
     || fs.existsSync(path.join(cwd, ".claude"));
-  let hooksUpdated = false;
   if (hasClaude) {
     const settingsPath = path.join(cwd, ".claude", "settings.local.json");
-    const claudeSettings = readJsonFile(settingsPath) || {};
-    const sessionStartCmd = path.join(localScriptsDir, "memento-sessionstart-identity.sh");
-    const existingHooks = claudeSettings.hooks?.["SessionStart"] || [];
-    const hasSessionStart = existingHooks.some((entry) =>
-      entry.hooks?.some((h) => h.command === sessionStartCmd)
-    );
-    if (!hasSessionStart) {
-      claudeSettings.hooks = claudeSettings.hooks || {};
-      claudeSettings.hooks["SessionStart"] = [
-        ...existingHooks,
-        { hooks: [{ type: "command", command: sessionStartCmd, timeout: 10000 }] },
-      ];
-      writeJsonFile(settingsPath, claudeSettings);
-      hooksUpdated = true;
+    const settings = readJsonFile(settingsPath) || {};
+    if (ensureHook(settings, "SessionStart", sessionStartCmd, 10000)) {
+      writeJsonFile(settingsPath, settings);
+      registeredHooks.push("Claude Code → .claude/settings.local.json");
+    }
+  }
+
+  // Gemini CLI
+  const hasGemini = agents.includes("gemini")
+    || fs.existsSync(path.join(cwd, ".gemini"));
+  if (hasGemini) {
+    const settingsPath = path.join(cwd, ".gemini", "settings.json");
+    const settings = readJsonFile(settingsPath) || {};
+    if (ensureHook(settings, "SessionStart", sessionStartCmd, 10000)) {
+      writeJsonFile(settingsPath, settings);
+      registeredHooks.push("Gemini CLI → .gemini/settings.json");
+    }
+  }
+
+  // Codex CLI — ensure notify is configured
+  const hasCodex = agents.includes("codex")
+    || fs.existsSync(path.join(cwd, ".codex"));
+  if (hasCodex) {
+    const notifyScript = path.join(localScriptsDir, "memento-codex-notify.sh");
+    const codexTomlPath = path.join(cwd, ".codex", "config.toml");
+    let tomlContent = "";
+    try { tomlContent = fs.readFileSync(codexTomlPath, "utf-8"); } catch { /* doesn't exist yet */ }
+    if (!tomlContent.includes("notify") && fs.existsSync(notifyScript)) {
+      const notifyLine = `\nnotify = ["bash", "${notifyScript}"]\n`;
+      const separator = tomlContent && !tomlContent.endsWith("\n") ? "\n" : "";
+      fs.mkdirSync(path.dirname(codexTomlPath), { recursive: true });
+      fs.writeFileSync(codexTomlPath, tomlContent + separator + notifyLine);
+      registeredHooks.push("Codex CLI → .codex/config.toml (notify)");
     }
   }
 
@@ -776,9 +819,11 @@ async function runUpdate() {
   for (const name of updated) {
     console.log(`    ${name}`);
   }
-  if (hooksUpdated) {
+  if (registeredHooks.length > 0) {
     console.log("\n  Registered hooks:");
-    console.log("    SessionStart → memento-sessionstart-identity.sh (identity + version check)");
+    for (const hook of registeredHooks) {
+      console.log(`    ${hook}`);
+    }
   }
   console.log(`\n  Version written to .memento/version`);
   console.log("  Restart your agent session to pick up changes.\n");