memento-mcp 0.2.4 → 0.3.0

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`, configures Claude Code hooks, and sets up the MCP server — all in one command. Restart Claude Code to load the new config.
+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.
 
 ---
 
@@ -43,29 +43,55 @@ Save the `api_key` from the response — you'll need it next.
 
 ### Step 2: Configure your MCP client
 
-**Claude Code (project-level):** Create `.mcp.json` in your project root.
+**Claude Code** — `.mcp.json` in your project root (or `~/.claude.json` globally):
 
-**Claude Code (global):** Add to `~/.claude.json` under `"mcpServers"`.
+```json
+{
+  "mcpServers": {
+    "memento": {
+      "command": "npx",
+      "args": ["-y", "memento-mcp"]
+    }
+  }
+}
+```
+
+**OpenAI Codex** — `.codex/config.toml`:
+
+```toml
+[mcp_servers.memento]
+command = "npx"
+args = ["-y", "memento-mcp"]
+```
 
-**Claude Desktop:** Add to your `claude_desktop_config.json`.
+**Gemini CLI** — `.gemini/settings.json`:
 
 ```json
 {
   "mcpServers": {
     "memento": {
-      "command": "node",
-      "args": ["/home/you/memento-protocol/src/index.js"],
-      "env": {
-        "MEMENTO_API_KEY": "mp_live_your_key_here",
-        "MEMENTO_API_URL": "https://memento-api.myrakrusemark.workers.dev",
-        "MEMENTO_WORKSPACE": "my-project"
-      }
+      "command": "npx",
+      "args": ["-y", "memento-mcp"]
+    }
+  }
+}
+```
+
+**OpenCode** — `opencode.json`:
+
+```json
+{
+  "mcp": {
+    "memento": {
+      "type": "local",
+      "command": ["npx", "-y", "memento-mcp"],
+      "enabled": true
     }
   }
 }
 ```
 
-> **Tip:** Replace the path with the actual absolute path to `src/index.js` in your clone. Run `echo "$(pwd)/src/index.js"` from inside the repo to get it.
+Set credentials via `.memento.json` (created by `npx memento-mcp init`) or environment variables `MEMENTO_API_KEY`, `MEMENTO_API_URL`, `MEMENTO_WORKSPACE`.
 
 ### Step 3: Restart your client
 

package/package.json

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

package/scripts/memento-sessionstart-identity.sh

@@ -0,0 +1,162 @@
+#!/bin/bash
+# SessionStart hook (Memento) — inject identity crystal + active items at startup.
+# JSON output: hookSpecificOutput.additionalContext with identity, active work, and skip list.
+#
+# Three API calls (parallel where possible):
+#   1. GET /v1/identity — identity crystal
+#   2. GET /v1/working-memory/items?category=active_work&status=active — current tasks
+#   3. GET /v1/working-memory/items?category=skip_list&status=active — skip list
+
+set -o pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# --- Config from .memento.json (if present) ---
+CONFIG_JSON=$(python3 -c "
+import json, os
+d = os.getcwd()
+while True:
+    p = os.path.join(d, '.memento.json')
+    if os.path.isfile(p):
+        with open(p) as f:
+            print(f.read())
+        break
+    parent = os.path.dirname(d)
+    if parent == d:
+        break
+    d = parent
+" 2>/dev/null)
+
+if [ -n "$CONFIG_JSON" ]; then
+    HOOK_NAME="sessionstart-identity"
+    HOOK_ENABLED=$(echo "$CONFIG_JSON" | python3 -c "
+import json, sys
+cfg = json.load(sys.stdin)
+hook = cfg.get('hooks', {}).get('$HOOK_NAME', {})
+print('true' if hook.get('enabled', True) else 'false')
+" 2>/dev/null)
+
+    if [ "$HOOK_ENABLED" = "false" ]; then
+        exit 0
+    fi
+
+    # Dual gate: also check features.identity
+    IDENTITY_ENABLED=$(echo "$CONFIG_JSON" | python3 -c "
+import json, sys
+cfg = json.load(sys.stdin)
+print('true' if cfg.get('features', {}).get('identity', False) else 'false')
+" 2>/dev/null)
+
+    if [ "$IDENTITY_ENABLED" = "false" ]; then
+        exit 0
+    fi
+
+    MEMENTO_API_KEY="${MEMENTO_API_KEY:-$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('apiKey',''))" 2>/dev/null)}"
+    MEMENTO_API_URL="${MEMENTO_API_URL:-$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('apiUrl',''))" 2>/dev/null)}"
+    MEMENTO_WORKSPACE="${MEMENTO_WORKSPACE:-$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('workspace',''))" 2>/dev/null)}"
+fi
+# --- End config block ---
+
+# Consume stdin (SessionStart sends JSON we don't need)
+cat > /dev/null
+
+# Source credentials from .env (gitignored) — fallback if no .memento.json
+if [ -f "$SCRIPT_DIR/../.env" ]; then
+    set -a
+    source "$SCRIPT_DIR/../.env"
+    set +a
+fi
+
+MEMENTO_API="${MEMENTO_API_URL:-https://memento-api.myrakrusemark.workers.dev}"
+MEMENTO_KEY="${MEMENTO_API_KEY:?MEMENTO_API_KEY not set — check memento-protocol/.env or .memento.json}"
+MEMENTO_WS="${MEMENTO_WORKSPACE:-default}"
+
+AUTH_HEADER="Authorization: Bearer $MEMENTO_KEY"
+WS_HEADER="X-Memento-Workspace: $MEMENTO_WS"
+
+# Temp files for parallel curl results
+IDENTITY_TMP=$(mktemp)
+ACTIVE_TMP=$(mktemp)
+SKIP_TMP=$(mktemp)
+trap 'rm -f "$IDENTITY_TMP" "$ACTIVE_TMP" "$SKIP_TMP"' EXIT
+
+# Fetch all three endpoints in parallel
+curl -s --max-time 3 -H "$AUTH_HEADER" -H "$WS_HEADER" \
+    "$MEMENTO_API/v1/identity" > "$IDENTITY_TMP" 2>/dev/null &
+PID1=$!
+
+curl -s --max-time 3 -H "$AUTH_HEADER" -H "$WS_HEADER" \
+    "$MEMENTO_API/v1/working-memory/items?category=active_work&status=active" > "$ACTIVE_TMP" 2>/dev/null &
+PID2=$!
+
+curl -s --max-time 3 -H "$AUTH_HEADER" -H "$WS_HEADER" \
+    "$MEMENTO_API/v1/working-memory/items?category=skip_list&status=active" > "$SKIP_TMP" 2>/dev/null &
+PID3=$!
+
+wait $PID1 $PID2 $PID3 2>/dev/null
+
+# Build output from the three responses
+python3 -c "
+import json, sys
+
+sections = []
+
+# 1. Identity crystal — MCP envelope format: { content: [{ text: '...' }] }
+try:
+    with open(sys.argv[1]) as f:
+        identity_data = json.load(f)
+    crystal = identity_data.get('content', [{}])[0].get('text', '')
+    # Skip if empty or placeholder
+    if crystal and 'no identity crystal' not in crystal.lower() and 'placeholder' not in crystal.lower():
+        sections.append('# Identity Crystal\n\n' + crystal)
+except Exception:
+    pass
+
+# Format items using the same pattern as memento_item_list (index.js:831-838)
+def format_items(items):
+    lines = []
+    for item in items:
+        tags = item.get('tags', [])
+        tag_str = f' [{', '.join(tags)}]' if tags else ''
+        status = item.get('status', 'active')
+        status_str = f' ({status})' if status != 'active' else ''
+        next_action = item.get('next_action', '')
+        next_str = f'\n  Next: {next_action}' if next_action else ''
+        lines.append(f'**{item[\"id\"]}** {item[\"category\"]}: {item[\"title\"]}{status_str}{tag_str}{next_str}')
+    return '\n\n'.join(lines)
+
+# 2. Active work items — JSON format: { items: [...] }
+try:
+    with open(sys.argv[2]) as f:
+        active_data = json.load(f)
+    active_items = active_data.get('items', [])
+    if active_items:
+        sections.append('## Active Work\n\n' + format_items(active_items))
+except Exception:
+    pass
+
+# 3. Skip list items — same JSON format
+try:
+    with open(sys.argv[3]) as f:
+        skip_data = json.load(f)
+    skip_items = skip_data.get('items', [])
+    if skip_items:
+        sections.append('## Skip List\n\n' + format_items(skip_items))
+except Exception:
+    pass
+
+if not sections:
+    sys.exit(0)
+
+context = '\n\n'.join(sections)
+context += '\n\nREMINDER: If Memento MCP tools are not loaded, run: ToolSearch query=\"+memento\" max_results=20'
+
+print(json.dumps({
+    'hookSpecificOutput': {
+        'hookEventName': 'SessionStart',
+        'additionalContext': context
+    }
+}))
+" "$IDENTITY_TMP" "$ACTIVE_TMP" "$SKIP_TMP" 2>/dev/null
+
+exit 0

package/src/cli.js

@@ -96,6 +96,14 @@ function httpsPost(url, body) {
 // File writers
 // ---------------------------------------------------------------------------
 
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
 function writeJsonFile(filePath, data) {
   const dir = path.dirname(filePath);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -103,14 +111,7 @@ function writeJsonFile(filePath, data) {
 }
 
 function mergeJsonFile(filePath, data) {
-  let existing = {};
-  if (fs.existsSync(filePath)) {
-    try {
-      existing = JSON.parse(fs.readFileSync(filePath, "utf8"));
-    } catch {
-      // Corrupt file — overwrite
-    }
-  }
+  const existing = readJsonFile(filePath) || {};
   const merged = deepMerge(existing, data);
   writeJsonFile(filePath, merged);
 }
@@ -127,6 +128,106 @@ function appendToGitignore(cwd, line) {
   return true;
 }
 
+// ---------------------------------------------------------------------------
+// Agent registry — per-agent MCP config writers
+// ---------------------------------------------------------------------------
+
+const MCP_SERVER_ENTRY = {
+  command: "npx",
+  args: ["-y", "memento-mcp"],
+};
+
+function writeMcpJson(cwd) {
+  const filePath = path.join(cwd, ".mcp.json");
+  const existing = readJsonFile(filePath) || {};
+  deepMerge(existing, { mcpServers: { memento: MCP_SERVER_ENTRY } });
+  writeJsonFile(filePath, existing);
+  return ".mcp.json";
+}
+
+function writeCodexToml(cwd) {
+  const dir = path.join(cwd, ".codex");
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, "config.toml");
+
+  let content = "";
+  try {
+    content = fs.readFileSync(filePath, "utf8");
+  } catch {
+    /* file doesn't exist */
+  }
+
+  // Skip if memento section already exists
+  if (/\[mcp_servers\.memento\]/.test(content)) {
+    return ".codex/config.toml (already configured)";
+  }
+
+  const section = `\n[mcp_servers.memento]\ncommand = "npx"\nargs = ["-y", "memento-mcp"]\n`;
+  const separator = content && !content.endsWith("\n") ? "\n" : "";
+  fs.writeFileSync(filePath, content + separator + section);
+  return ".codex/config.toml";
+}
+
+function writeGeminiJson(cwd) {
+  const dir = path.join(cwd, ".gemini");
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, "settings.json");
+  const existing = readJsonFile(filePath) || {};
+  deepMerge(existing, { mcpServers: { memento: MCP_SERVER_ENTRY } });
+  writeJsonFile(filePath, existing);
+  return ".gemini/settings.json";
+}
+
+function writeOpencodeJson(cwd) {
+  const filePath = path.join(cwd, "opencode.json");
+  const existing = readJsonFile(filePath) || {};
+  deepMerge(existing, {
+    mcp: {
+      memento: {
+        type: "local",
+        command: ["npx", "-y", "memento-mcp"],
+        enabled: true,
+      },
+    },
+  });
+  writeJsonFile(filePath, existing);
+  return "opencode.json";
+}
+
+const AGENTS = {
+  "claude-code": {
+    name: "Claude Code",
+    detect: (cwd) => fs.existsSync(path.join(cwd, ".claude")),
+    configWriter: writeMcpJson,
+    hasHooks: true,
+    nextSteps: "Restart Claude Code to activate.",
+  },
+  codex: {
+    name: "OpenAI Codex",
+    detect: (cwd) => fs.existsSync(path.join(cwd, ".codex")),
+    configWriter: writeCodexToml,
+    hasHooks: false,
+    nextSteps: "Run `codex` in this directory — memento tools load automatically.",
+  },
+  gemini: {
+    name: "Gemini CLI",
+    detect: (cwd) => fs.existsSync(path.join(cwd, ".gemini")),
+    configWriter: writeGeminiJson,
+    hasHooks: false,
+    nextSteps: "Run `gemini` in this directory — memento tools load automatically.",
+  },
+  opencode: {
+    name: "OpenCode",
+    detect: (cwd) => fs.existsSync(path.join(cwd, "opencode.json")),
+    configWriter: writeOpencodeJson,
+    hasHooks: false,
+    nextSteps: "Run `opencode` in this directory — memento tools load automatically.",
+  },
+};
+
+// Exported for testing
+export { AGENTS, writeMcpJson, writeCodexToml, writeGeminiJson, writeOpencodeJson };
+
 // ---------------------------------------------------------------------------
 // CLI
 // ---------------------------------------------------------------------------
@@ -193,19 +294,77 @@ async function runInit() {
     false,
   );
 
-  // 4. Hooks
-  console.log("\nClaude Code hooks (automate recall + distillation):");
-  const enableUserPrompt = await askYesNo(
-    rl,
-    "  UserPromptSubmit — recall on every message?",
-    true
-  );
-  const enableStop = await askYesNo(rl, "  Stop — autonomous recall after responses?", true);
-  const enablePreCompact = await askYesNo(
-    rl,
-    "  PreCompact — distill memories before context compression?",
-    true
-  );
+  // 4. Agent detection + selection
+  const agentKeys = Object.keys(AGENTS);
+  const detected = agentKeys.filter((key) => AGENTS[key].detect(cwd));
+
+  console.log("\nDetected agents:");
+  const markers = {
+    "claude-code": ".claude/",
+    codex: ".codex/",
+    gemini: ".gemini/",
+    opencode: "opencode.json",
+  };
+  for (const key of agentKeys) {
+    const agent = AGENTS[key];
+    const isDetected = detected.includes(key);
+    const mark = isDetected ? "✓" : " ";
+    const hint = isDetected ? ` (${markers[key]} found)` : "";
+    console.log(`    ${mark} ${agent.name}${hint}`);
+  }
+
+  console.log("\n  Configure for which agents?");
+  agentKeys.forEach((key, i) => {
+    const mark = detected.includes(key) ? " ✓" : "";
+    console.log(`    ${i + 1}. ${AGENTS[key].name}${mark}`);
+  });
+
+  const defaultSelection =
+    detected.length > 0
+      ? detected.map((key) => agentKeys.indexOf(key) + 1).join(",")
+      : "1";
+  const selectionStr = await ask(rl, "\n  Enter numbers, comma-separated", defaultSelection);
+
+  const selectedIndices = selectionStr
+    .split(",")
+    .map((s) => parseInt(s.trim(), 10))
+    .filter((n) => n >= 1 && n <= agentKeys.length);
+  const selectedAgents = [...new Set(selectedIndices.map((i) => agentKeys[i - 1]))];
+
+  if (selectedAgents.length === 0) {
+    console.log("  No agents selected. Defaulting to Claude Code.");
+    selectedAgents.push("claude-code");
+  }
+
+  const hasClaude = selectedAgents.includes("claude-code");
+
+  // 5. Hooks — only if Claude Code selected
+  let enableUserPrompt = false;
+  let enableStop = false;
+  let enablePreCompact = false;
+  let enableSessionStart = false;
+
+  if (hasClaude) {
+    console.log("\nClaude Code hooks (automate recall + distillation):");
+    enableUserPrompt = await askYesNo(
+      rl,
+      "  UserPromptSubmit — recall on every message?",
+      true,
+    );
+    enableStop = await askYesNo(rl, "  Stop — autonomous recall after responses?", true);
+    enablePreCompact = await askYesNo(
+      rl,
+      "  PreCompact — distill memories before context compression?",
+      true,
+    );
+    if (enableIdentity) {
+      enableSessionStart = await askYesNo(
+        rl,
+        "  SessionStart — inject identity + active items at startup?",
+        true,
+      );
+    }
+  }
 
   rl.close();
 
@@ -213,6 +372,7 @@ async function runInit() {
   const config = {
     apiKey,
     workspace,
+    agents: selectedAgents,
     features: {
       images: enableImages,
       identity: enableIdentity,
@@ -221,20 +381,22 @@ async function runInit() {
       "userprompt-recall": { enabled: enableUserPrompt },
       "stop-recall": { enabled: enableStop },
       "precompact-distill": { enabled: enablePreCompact },
+      "sessionstart-identity": { enabled: enableSessionStart },
     },
   };
 
   const created = [];
 
-  // 5. Write .memento.json
+  // 6. Write .memento.json
   const configPath = path.join(cwd, ".memento.json");
   writeJsonFile(configPath, config);
   created.push(".memento.json");
 
-  // 6. Copy hook scripts into .memento/scripts/ for stable paths
-  //    (pointing into the npx cache would break on cache clear or update)
-  const anyHookEnabled = enableUserPrompt || enableStop || enablePreCompact;
-  if (anyHookEnabled) {
+  // 7. Copy hook scripts + write Claude Code settings — gated on hasClaude
+  const anyHookEnabled =
+    enableUserPrompt || enableStop || enablePreCompact || enableSessionStart;
+
+  if (hasClaude && anyHookEnabled) {
     const pkgScriptsDir = path.resolve(__dirname, "..", "scripts");
     const localScriptsDir = path.join(cwd, ".memento", "scripts");
     if (!fs.existsSync(localScriptsDir))
@@ -244,6 +406,7 @@ async function runInit() {
       enableUserPrompt && "memento-userprompt-recall.sh",
       enableStop && "memento-stop-recall.sh",
       enablePreCompact && "memento-precompact-distill.sh",
+      enableSessionStart && "memento-sessionstart-identity.sh",
     ].filter(Boolean);
 
     for (const name of scriptFiles) {
@@ -254,7 +417,7 @@ async function runInit() {
     }
     created.push(".memento/scripts/");
 
-    // 7. Write .claude/settings.local.json (hooks)
+    // 8. Write .claude/settings.local.json (hooks)
     const hooks = {};
     if (enableUserPrompt) {
       hooks.UserPromptSubmit = [
@@ -295,36 +458,51 @@ async function runInit() {
         },
       ];
     }
+    if (enableSessionStart) {
+      hooks.SessionStart = [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: path.join(
+                localScriptsDir,
+                "memento-sessionstart-identity.sh",
+              ),
+              timeout: 10000,
+            },
+          ],
+        },
+      ];
+    }
 
     const settingsPath = path.join(cwd, ".claude", "settings.local.json");
     mergeJsonFile(settingsPath, { hooks });
     created.push(".claude/settings.local.json");
   }
 
-  // 8. Write .mcp.json
-  const mcpPath = path.join(cwd, ".mcp.json");
-  mergeJsonFile(mcpPath, {
-    mcpServers: {
-      memento: {
-        command: "npx",
-        args: ["-y", "memento-mcp"],
-      },
-    },
-  });
-  created.push(".mcp.json");
+  // 9. Per-agent config files
+  for (const agentKey of selectedAgents) {
+    const agent = AGENTS[agentKey];
+    const result = agent.configWriter(cwd);
+    created.push(result);
+  }
 
-  // 9. Add .memento.json and .memento/scripts/ to .gitignore
+  // 10. Add .memento.json and .memento/scripts/ to .gitignore
   let gitignoreUpdated = false;
   if (appendToGitignore(cwd, ".memento.json")) gitignoreUpdated = true;
   if (appendToGitignore(cwd, ".memento/scripts/")) gitignoreUpdated = true;
   if (gitignoreUpdated) created.push(".gitignore (updated)");
 
-  // 10. Summary
+  // 11. Summary
   const labels = {
     ".memento.json": "workspace config + credentials",
     ".memento/scripts/": "hook scripts (recall + distillation)",
     ".claude/settings.local.json": "hooks registered with Claude Code",
-    ".mcp.json": "MCP server registered",
+    ".mcp.json": "MCP server registered (Claude Code)",
+    ".codex/config.toml": "MCP server registered (Codex)",
+    ".codex/config.toml (already configured)": "MCP server (Codex, skipped)",
+    ".gemini/settings.json": "MCP server registered (Gemini CLI)",
+    "opencode.json": "MCP server registered (OpenCode)",
     ".gitignore (updated)": "credentials excluded from git",
   };
   const colWidth = Math.max(...created.map((f) => f.length)) + 2;
@@ -334,14 +512,25 @@ async function runInit() {
     const label = labels[f] || "";
     console.log(`    ${f.padEnd(colWidth)}${label}`);
   }
-  console.log("\n  Restart Claude Code to activate.");
+
+  // Per-agent next steps
+  console.log("\n  Next steps:");
+  for (const agentKey of selectedAgents) {
+    const agent = AGENTS[agentKey];
+    console.log(`    · ${agent.name}: ${agent.nextSteps}`);
+  }
   console.log("  Your agent will wake up remembering.\n");
 
-  // 11. CLAUDE.md boilerplate
+  // 12. CLAUDE.md / AGENTS.md boilerplate
+  const hasNonClaude = selectedAgents.some((k) => k !== "claude-code");
+  const docTarget = hasNonClaude
+    ? "your CLAUDE.md, AGENTS.md, or equivalent"
+    : "your CLAUDE.md";
+
   console.log("─".repeat(60));
   console.log(`
-  One more step: paste the following into your CLAUDE.md,
-  or hand it to Claude and ask it to add it. This teaches
+  One more step: paste the following into ${docTarget},
+  or hand it to your agent and ask it to add it. This teaches
   your agent the memory discipline Memento expects.
 
   ── paste below this line ──────────────────────────────
@@ -368,32 +557,39 @@ before compaction. Trust the hooks. Focus on writing good memories.
 }
 
 // ---------------------------------------------------------------------------
-// Entrypoint
+// Entrypoint — only run when this module is the entry point (not imported)
 // ---------------------------------------------------------------------------
 
-const args = process.argv.slice(2);
+const isMain =
+  process.argv[1] &&
+  (process.argv[1].endsWith("/cli.js") || process.argv[1].endsWith("memento-mcp"));
 
-if (args[0] === "init") {
-  runInit().catch((err) => {
-    console.error(err);
-    process.exit(1);
-  });
-} else if (args.length === 0) {
-  // No args — start the MCP server (this is what .mcp.json invokes)
-  // Must call main() explicitly because the isMainModule guard in index.js
-  // checks process.argv[1] which still points to cli.js, not index.js.
-  const { main } = await import("./index.js");
-  await main();
-} else {
-  console.log(`
+if (isMain) {
+  const args = process.argv.slice(2);
+
+  if (args[0] === "init") {
+    runInit().catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+  } else if (args.length === 0) {
+    // No args — start the MCP server (this is what .mcp.json invokes)
+    // Must call main() explicitly because the isMainModule guard in index.js
+    // checks process.argv[1] which still points to cli.js, not index.js.
+    const { main } = await import("./index.js");
+    await main();
+  } else {
+    console.log(`
   Memento Protocol CLI
 
   Usage:
     npx memento-mcp init    Set up Memento in the current project
     npx memento-mcp         Start the MCP server (used by .mcp.json)
 
-  This creates .memento.json, configures Claude Code hooks,
-  and sets up the MCP server — all in one command.
+  This creates .memento.json, configures your agent's MCP client,
+  and sets up hooks (Claude Code) — all in one command.
+  Supports Claude Code, Codex, Gemini CLI, and OpenCode.
 `);
-  process.exit(1);
+    process.exit(1);
+  }
 }

package/src/config.js

@@ -14,11 +14,13 @@ import path from "node:path";
 export const DEFAULTS = {
   apiUrl: "https://memento-api.myrakrusemark.workers.dev",
   workspace: "default",
+  agents: [],
   features: { images: false, identity: false },
   hooks: {
     "userprompt-recall": { enabled: true, limit: 5, maxLength: 200 },
     "stop-recall": { enabled: true, limit: 5, maxLength: 200 },
     "precompact-distill": { enabled: true },
+    "sessionstart-identity": { enabled: true },
   },
 };
 
@@ -68,5 +70,7 @@ export function resolveConfig(startDir = process.cwd()) {
     hooks[key] = { ...defaults, ...(fileConfig.hooks?.[key] || {}) };
   }
 
-  return { apiKey, apiUrl, workspace, features, hooks };
+  const agents = fileConfig.agents || DEFAULTS.agents;
+
+  return { apiKey, apiUrl, workspace, agents, features, hooks };
 }