@bcmyguest/openmem 0.0.0-stage → 0.8.0

package/cli/coding-agent/file-io.mjs

@@ -0,0 +1,72 @@
+/**
+ * File helpers for the coding-agent installer: atomic rewrites of user config files
+ * (temp file in the same directory + rename), JSON read/write, and a silent logger.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+export const SILENT = Object.freeze({ info: () => {}, ok: () => {}, warn: () => {} });
+
+/**
+ * Replace `file` with `data` atomically. A symlinked file is written through to its target.
+ * Mode: `opts.mode` when given (also on an existing file), else the existing file's mode,
+ * else the process default (0666 minus umask).
+ * @param {string} file
+ * @param {string} data
+ * @param {{ mode?: number }} [opts]
+ */
+export function writeFileAtomic(file, data, opts = {}) {
+  let target = file;
+  try {
+    target = fs.realpathSync(file);
+  } catch {
+    // Missing file: write it where asked.
+  }
+  const dir = path.dirname(target);
+  fs.mkdirSync(dir, { recursive: true });
+  const existing = fs.statSync(target, { throwIfNoEntry: false });
+  const mode = opts.mode ?? (existing ? existing.mode & 0o7777 : undefined);
+  const tmp = path.join(dir, `.${path.basename(target)}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`);
+  try {
+    const fd = fs.openSync(tmp, "wx", mode ?? 0o666);
+    try {
+      fs.writeFileSync(fd, data);
+      if (mode !== undefined) fs.fchmodSync(fd, mode);
+      fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+    fs.renameSync(tmp, target);
+  } catch (err) {
+    fs.rmSync(tmp, { force: true });
+    throw err;
+  }
+}
+
+/** Parsed JSON of `file`, or `{}` when it is missing. Malformed JSON throws. */
+export function readJson(file) {
+  return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, "utf8")) : {};
+}
+
+/** @param {string} file @param {unknown} value @param {{ mode?: number }} [opts] */
+export function writeJson(file, value, opts = {}) {
+  writeFileAtomic(file, `${JSON.stringify(value, null, 2)}\n`, opts);
+}
+
+/**
+ * Set `KEY=value` lines in a dotenv file, replacing earlier lines for those keys and keeping
+ * every other line. The file keeps its mode; a missing file is created with `opts.mode`.
+ * @param {string} file
+ * @param {Record<string, string>} entries
+ * @param {{ mode?: number }} [opts]
+ */
+export function upsertEnvFile(file, entries, opts = {}) {
+  const keys = Object.keys(entries);
+  const exists = fs.existsSync(file);
+  const lines = exists ? fs.readFileSync(file, "utf8").split(/\r?\n/) : [];
+  const kept = lines.filter((line) => !keys.some((k) => line.startsWith(`${k}=`)));
+  while (kept.length && kept[kept.length - 1] === "") kept.pop();
+  const text = `${[...kept, ...keys.map((k) => `${k}=${entries[k]}`)].join("\n")}\n`;
+  writeFileAtomic(file, text, exists ? {} : opts);
+}

package/cli/coding-agent/hook-harnesses.mjs

@@ -0,0 +1,88 @@
+/** Hook event names and stdout shapes per coding-agent host. */
+
+export const SHIM_MARKER = "coding-agent/hook-runner.mjs";
+
+export const SHIM_HARNESSES = {
+  "claude-code": {
+    configStyle: "nested",
+    settingsPath: (home) => `${home}/.claude/settings.json`,
+    rootKey: "hooks",
+    events: {
+      sessionStart: { hook: "SessionStart", timeout: 30 },
+      prompt: { hook: "UserPromptSubmit", timeout: 30 },
+      stop: { hook: "Stop", timeout: 60 },
+    },
+    parse: {
+      sessionStart: (ev) => ({ cwd: ev.cwd, sessionId: ev.session_id }),
+      prompt: (ev) => ({ cwd: ev.cwd, sessionId: ev.session_id, prompt: ev.prompt }),
+      stop: (ev) => ({ cwd: ev.cwd, sessionId: ev.session_id, transcriptPath: ev.transcript_path }),
+    },
+    emit: {
+      sessionStart: (ctx) => ({
+        hookSpecificOutput: { hookEventName: "SessionStart", ...(ctx ? { additionalContext: ctx } : {}) },
+      }),
+      prompt: (ctx) => ({
+        hookSpecificOutput: { hookEventName: "UserPromptSubmit", ...(ctx ? { additionalContext: ctx } : {}) },
+      }),
+      stop: () => ({}),
+    },
+  },
+  codex: {
+    configStyle: "nested",
+    settingsPath: (home) => `${home}/.codex/hooks.json`,
+    rootKey: "hooks",
+    events: {
+      sessionStart: { hook: "SessionStart", timeout: 30 },
+      prompt: { hook: "UserPromptSubmit", timeout: 30 },
+      stop: { hook: "Stop", timeout: 60 },
+    },
+    parse: {
+      sessionStart: (ev) => ({ cwd: ev.cwd, sessionId: ev.session_id }),
+      prompt: (ev) => ({ cwd: ev.cwd, sessionId: ev.session_id, prompt: ev.prompt ?? ev.user_prompt }),
+      stop: (ev) => ({ cwd: ev.cwd, sessionId: ev.session_id, transcriptPath: ev.transcript_path }),
+    },
+    emit: {
+      sessionStart: (ctx) => ({
+        hookSpecificOutput: { hookEventName: "SessionStart", ...(ctx ? { additionalContext: ctx } : {}) },
+      }),
+      prompt: (ctx) => ({
+        hookSpecificOutput: { hookEventName: "UserPromptSubmit", ...(ctx ? { additionalContext: ctx } : {}) },
+      }),
+      stop: () => ({}),
+    },
+  },
+  "cursor-cli": {
+    configStyle: "flat",
+    settingsPath: (home) => `${home}/.cursor/hooks.json`,
+    // Cursor reads `{ "version": 1, "hooks": { <event>: [{ command }] } }`.
+    rootKey: "hooks",
+    events: {
+      sessionStart: { hook: "sessionStart", timeout: 30 },
+      prompt: { hook: "beforeSubmitPrompt", timeout: 30 },
+      stop: { hook: "stop", timeout: 30 },
+    },
+    parse: {
+      sessionStart: (ev) => ({
+        cwd: ev.cwd ?? ev.workspace_root ?? ev.workspace_roots?.[0],
+        sessionId: ev.conversation_id ?? ev.session_id,
+      }),
+      prompt: (ev) => ({
+        cwd: ev.cwd ?? ev.workspace_root ?? ev.workspace_roots?.[0],
+        sessionId: ev.conversation_id ?? ev.session_id,
+        prompt: ev.prompt ?? ev.user_prompt,
+      }),
+      stop: (ev) => ({
+        cwd: ev.cwd ?? ev.workspace_root ?? ev.workspace_roots?.[0],
+        sessionId: ev.conversation_id ?? ev.session_id,
+        transcriptPath: ev.transcript_path,
+      }),
+    },
+    emit: {
+      sessionStart: (ctx) => (ctx ? { additional_context: ctx } : {}),
+      prompt: (ctx) => ({ continue: true, ...(ctx ? { additional_context: ctx } : {}) }),
+      stop: () => ({}),
+    },
+  },
+};
+
+export const SHIM_AGENT_IDS = Object.freeze(Object.keys(SHIM_HARNESSES));

package/cli/coding-agent/hook-runner.mjs

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+/**
+ * Session hook entry: node hook-runner.mjs <harness> <sessionStart|prompt|stop>
+ * stdin: host hook JSON. Uses unified memory facade (active MEMORY_PROVIDER).
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { bankFromCwd } from "./bank-from-cwd.mjs";
+import { accessAllowed, readAccessConfig } from "./access-policy.mjs";
+import { providerSupports } from "./capabilities.mjs";
+import { isSmartCompactPrompt, registerSession, writeForceFlag } from "./context-store.mjs";
+import { SHIM_HARNESSES } from "./hook-harnesses.mjs";
+import { hookRecallBlock, sessionRecall, sessionRetain } from "./session-facade.mjs";
+import { resolveMcpContext } from "../mcp/context.mjs";
+import { resolveStackRoot } from "../stack.mjs";
+
+const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+function resolveAccess(cwd, config, home = process.env.HOME || os.homedir()) {
+  if (!accessAllowed(cwd, config)) return { allowed: false };
+  return { allowed: true, bank: bankFromCwd(cwd, { home, mapPathToBank: config.mapPathToBank }) };
+}
+
+async function readStdinJson() {
+  const chunks = [];
+  for await (const c of process.stdin) chunks.push(c);
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  return JSON.parse(raw);
+}
+
+const TRANSCRIPT_TAIL_BYTES = 256 * 1024;
+const TRANSCRIPT_MAX_CHARS = 12000;
+
+/** Short SessionStart banner; names knowledge tools only when the provider has them. */
+export function sessionBanner(provider, bank) {
+  const tools = ["memory_recall", "memory_add"];
+  if (providerSupports(provider, "knowledge_pages")) tools.push("memory_pages_search");
+  if (providerSupports(provider, "initiatives")) tools.push("memory_capture_initiative");
+  return [
+    `[openmem] Memory provider ${provider}, bank ${bank}.`,
+    `Tools: ${tools.join(", ")}. Pass bank "${bank}" for this project.`,
+  ].join("\n");
+}
+
+function blockText(content, acceptedTypes) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((part) => part && acceptedTypes.includes(part.type) && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("");
+}
+
+function safeAction(label, input) {
+  let parsed = input;
+  if (typeof input === "string") {
+    try { parsed = JSON.parse(input); } catch { /* retain only valid structured arguments */ }
+  }
+  const summary = parsed && typeof parsed === "object" ? JSON.stringify(parsed) : "";
+  return `[action: ${label}${summary ? ` ${summary.slice(0, 800)}` : ""}]`;
+}
+
+function parseTranscriptRecord(harnessId, record) {
+  if (!record || typeof record !== "object") return [];
+  const out = [];
+  if (harnessId === "codex") {
+    // Best-effort adapter for observed rollout response_item rows. Codex says
+    // transcript_path is provided for convenience, but its transcript schema is unstable.
+    const payload = record.type === "response_item" ? record.payload : null;
+    if (!payload || typeof payload !== "object") return out;
+    if (payload.type === "message" && ["user", "assistant"].includes(payload.role)) {
+      const accepted = payload.role === "user" ? ["input_text"] : ["output_text"];
+      const text = blockText(payload.content, accepted);
+      if (text.trim()) out.push(`${payload.role}: ${text.trim()}`);
+    } else if (payload.type === "function_call" || payload.type === "custom_tool_call") {
+      const label = payload.name || payload.type;
+      out.push(safeAction(label, payload.arguments ?? payload.input));
+    }
+    return out;
+  }
+  if (harnessId === "claude-code") {
+    // Claude transcript message rows use user/assistant roles. Keep only ordinary
+    // text and explicit tool-use blocks; thinking and tool-result blocks are omitted.
+    const message = record.message;
+    if (!["user", "assistant"].includes(message?.role)) return out;
+    const text = blockText(message.content, ["text"]);
+    if (text.trim()) out.push(`${message.role}: ${text.trim()}`);
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if (part?.type === "tool_use") out.push(safeAction(part.name || "tool", part.input));
+      }
+    }
+    return out;
+  }
+  if (harnessId === "cursor-cli") {
+    // Observed Cursor agent-transcripts rows have a top-level role and a
+    // message.content array. This adapter is based on the local schema shape;
+    // live Hook transcript_path linkage remains unverified.
+    const role = record.role;
+    const message = record.message;
+    if (!["user", "assistant"].includes(role) || !Array.isArray(message?.content)) return out;
+    const text = blockText(message.content, ["text"]);
+    if (text.trim()) out.push(`${role}: ${text.trim()}`);
+    if (role === "assistant") {
+      for (const part of message.content) {
+        if (part?.type === "tool_use") out.push(safeAction(part.name || "tool", part.input));
+      }
+    }
+    return out;
+  }
+  return out;
+}
+
+function cursorFile(home) {
+  return path.join(home, ".config", "personal-memory", "transcript-cursors.json");
+}
+
+function loadTranscriptCursors(home) {
+  try {
+    const value = JSON.parse(fs.readFileSync(cursorFile(home), "utf8"));
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  } catch { return {}; }
+}
+
+function saveTranscriptCursors(home, cursors) {
+  const file = cursorFile(home);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, JSON.stringify(cursors), { mode: 0o600 });
+  fs.renameSync(temporary, file);
+}
+
+function readNewTranscript(harnessId, transcriptPath, home, sessionId) {
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) return null;
+  try {
+    const stat = fs.statSync(transcriptPath);
+    if (!stat.isFile()) return null;
+    const key = `${harnessId}:${sessionId || path.resolve(transcriptPath)}`;
+    const cursors = loadTranscriptCursors(home);
+    const saved = cursors[key];
+    const oldPosition = Number.isSafeInteger(saved) ? saved
+      : Number.isSafeInteger(saved?.position) ? saved.position : 0;
+    const position = oldPosition <= stat.size ? oldPosition : 0;
+    let validPosition = position;
+    if (position && typeof saved === "object" && saved.anchor) {
+      const anchorLength = Math.min(256, position);
+      const anchorBuffer = Buffer.alloc(anchorLength);
+      const anchorFd = fs.openSync(transcriptPath, "r");
+      try { fs.readSync(anchorFd, anchorBuffer, 0, anchorLength, position - anchorLength); }
+      finally { fs.closeSync(anchorFd); }
+      if (anchorBuffer.toString("base64") !== saved.anchor) validPosition = 0;
+    }
+    const start = Math.max(validPosition, stat.size - TRANSCRIPT_TAIL_BYTES);
+    const length = stat.size - start;
+    const fd = fs.openSync(transcriptPath, "r");
+    const buffer = Buffer.alloc(length);
+    try { fs.readSync(fd, buffer, 0, length, start); } finally { fs.closeSync(fd); }
+    const text = buffer.toString("utf8");
+    const completeText = text.endsWith("\n") ? text : text.slice(0, text.lastIndexOf("\n") + 1);
+    const completeLines = completeText.split("\n");
+    if (completeLines.at(-1) === "") completeLines.pop();
+    if (harnessId === "cursor-cli") {
+      // Do not create a cursor for unknown or unverified row shapes. A single
+      // structurally recognized message row enables the bounded adapter.
+      const recognized = completeLines.some((line) => {
+        try {
+          const record = JSON.parse(line);
+          return ["user", "assistant"].includes(record?.role) && Array.isArray(record?.message?.content);
+        } catch { return false; }
+      });
+      if (!recognized) return null;
+    }
+    const extracted = [];
+    for (const line of completeLines) {
+      if (!line.trim()) continue;
+      try { extracted.push(...parseTranscriptRecord(harnessId, JSON.parse(line))); } catch { /* ignore malformed rows */ }
+    }
+    const content = extracted.join("\n").slice(-TRANSCRIPT_MAX_CHARS).trim();
+    // A bounded tail can begin mid-row. If it contains no newline, do not
+    // checkpoint that interior offset; retry from the last known boundary.
+    const nextPosition = completeText.length
+      ? start + Buffer.byteLength(completeText)
+      : validPosition;
+    const anchorLength = Math.min(256, nextPosition);
+    const anchorBuffer = Buffer.alloc(anchorLength);
+    const anchorFd = fs.openSync(transcriptPath, "r");
+    try {
+      if (anchorLength) fs.readSync(anchorFd, anchorBuffer, 0, anchorLength, nextPosition - anchorLength);
+    } finally { fs.closeSync(anchorFd); }
+    return {
+      key, cursors, position: { position: nextPosition, anchor: anchorBuffer.toString("base64") }, content,
+    };
+  } catch { return null; }
+}
+
+export async function runHook(harnessId, phase, { home, env, repoRoot, ev, fetchFn = fetch }) {
+  const spec = SHIM_HARNESSES[harnessId];
+  if (!spec) throw new Error(`unknown harness ${harnessId}`);
+  const parsed = spec.parse[phase](ev);
+  const smartCompact = phase === "prompt" && isSmartCompactPrompt(parsed.prompt);
+  if (smartCompact) {
+    // Context trimming is independent of memory access; the flag never fails the hook.
+    try { writeForceFlag({ home, env, sessionId: parsed.sessionId }); } catch { /* best effort */ }
+  }
+  const config = readAccessConfig(home);
+  const access = config ? resolveAccess(parsed.cwd, config, home) : { allowed: false };
+  if (!access.allowed) return spec.emit[phase](undefined);
+  const bank = access.bank;
+  let runtimeConfig = {};
+  try {
+    runtimeConfig = JSON.parse(fs.readFileSync(path.join(repoRoot, "agent-runtime.json"), "utf8"));
+  } catch {
+    // Checkout and direct test calls use ordinary stack resolution.
+  }
+  const runtimeEnv = { ...env, PM_STACK_ROOT: env.PM_STACK_ROOT || runtimeConfig.stackRoot };
+  const stack = resolveStackRoot({ pkgRoot: repoRoot, env: runtimeEnv, home });
+  const ctx = resolveMcpContext({ home, stackRoot: stack.root, repoRoot, env: runtimeEnv });
+  let context = "";
+
+  if (phase === "sessionStart") {
+    try {
+      registerSession({ home, env, sessionId: parsed.sessionId, agent: harnessId, cwd: parsed.cwd, bank });
+    } catch { /* Registration is optional for the proxy; never fail SessionStart. */ }
+    const recalled = await sessionRecall(
+      ctx,
+      { query: "What should I know about this project and recent decisions?", bank, limit: 8,
+        budget: "low", maxTokens: 1200 },
+      fetchFn,
+    );
+    const banner = sessionBanner(ctx.provider, bank);
+    const block = hookRecallBlock(recalled);
+    context = block ? `${banner}\n\n${block}` : banner;
+  } else if (phase === "prompt") {
+    const q = String(parsed.prompt || "").trim();
+    if (q && !smartCompact) {
+      context = hookRecallBlock(await sessionRecall(ctx, { query: q, bank, limit: 8 }, fetchFn));
+    }
+  } else if (phase === "stop") {
+    const transcript = readNewTranscript(harnessId, parsed.transcriptPath, home, parsed.sessionId);
+    if (transcript) {
+      if (transcript.content) {
+        await sessionRetain(
+          ctx,
+          {
+            bank,
+            content: `Session turn (${harnessId} ${parsed.sessionId || "unknown"}):\n${transcript.content}`,
+          },
+          fetchFn,
+        );
+      }
+      transcript.cursors[transcript.key] = transcript.position;
+      saveTranscriptCursors(home, transcript.cursors);
+    }
+    return spec.emit.stop();
+  }
+
+  return spec.emit[phase](context?.trim() || undefined);
+}
+
+async function main() {
+  const [harnessId, phase] = process.argv.slice(2);
+  if (!harnessId || !phase || !SHIM_HARNESSES[harnessId]?.parse[phase]) {
+    console.error("usage: hook-runner.mjs <claude-code|codex|cursor-cli> <sessionStart|prompt|stop>");
+    process.exit(2);
+  }
+  try {
+    const ev = await readStdinJson();
+    const out = await runHook(harnessId, phase, {
+      home: process.env.HOME || os.homedir(),
+      env: process.env,
+      repoRoot: PKG_ROOT,
+      ev,
+    });
+    if (out && Object.keys(out).length) process.stdout.write(`${JSON.stringify(out)}\n`);
+  } catch (err) {
+    console.error(`openmem hook: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+}
+
+const self = fileURLToPath(import.meta.url);
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(self)) main();

package/cli/coding-agent/install-access.mjs

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import path from "node:path";
+import TOML from "@iarna/toml";
+import { readJson, writeFileAtomic, writeJson } from "./file-io.mjs";
+import { mergeOpencodeConfig, opencodeConfigPath } from "./opencode-config.mjs";
+import { removeSpans, tomlSpansUnder, tomlStatements } from "./toml-edit.mjs";
+
+const SKILL_TARGETS = {
+  "claude-code": ".claude/skills/openmem",
+  codex: ".agents/skills/openmem",
+  "cursor-cli": ".cursor/skills/openmem",
+  opencode: ".config/opencode/skills/openmem",
+};
+
+/** Set `[table] key = true` unless the file sets it (to any value) already. */
+function enableTomlFlag(text, table, key) {
+  const statements = tomlStatements(text);
+  if (statements.some((s) => s.kind === "kv" && s.path.length === 2 && s.path[0] === table && s.path[1] === key)) return text;
+  const at = statements.findIndex((s) => s.kind === "table" && s.path.length === 1 && s.path[0] === table);
+  if (at < 0) return `${text}${text && !text.endsWith("\n") ? "\n" : ""}[${table}]\n${key} = true\n`;
+  let end = statements[at].end;
+  for (let k = at + 1; k < statements.length && statements[k].kind === "kv"; k++) end = statements[k].end;
+  const head = text.slice(0, end);
+  return `${head}${head.endsWith("\n") ? "" : "\n"}${key} = true\n${text.slice(end)}`;
+}
+
+/** Add top-level `key = value` (before the first table) unless the file sets `key` already. */
+function setTomlDefault(text, key, value) {
+  const statements = tomlStatements(text);
+  if (statements.some((s) => s.kind === "kv" && s.path.length === 1 && s.path[0] === key)) return text;
+  const firstTable = statements.findIndex((s) => s.kind !== "kv");
+  const at = firstTable < 0 ? text.length : statements[firstTable].start;
+  const head = text.slice(0, at);
+  return `${head}${head && !head.endsWith("\n") ? "\n" : ""}${key} = ${JSON.stringify(value)}\n${text.slice(at)}`;
+}
+
+/**
+ * Codex config with hooks enabled, the workspace-write sandbox with network allowed (Codex defaults to a
+ * read-only sandbox without network, so curl and package installs fail) and exactly one current
+ * `[mcp_servers.openmem]`; throws on a TOML it cannot edit.
+ */
+function updateCodexToml(text, scriptPath, stackRoot) {
+  text = setTomlDefault(text, "sandbox_mode", "workspace-write");
+  text = enableTomlFlag(text, "features", "hooks");
+  text = enableTomlFlag(text, "sandbox_workspace_write", "network_access");
+  const section = [
+    "[mcp_servers.openmem]",
+    'command = "node"',
+    `args = [${JSON.stringify(scriptPath)}]`,
+    "[mcp_servers.openmem.env]",
+    `PM_STACK_ROOT = ${JSON.stringify(stackRoot)}`,
+  ].join("\n");
+  // Drop current openmem blocks and the pre-rebrand personal-memory name.
+  const spans = ["openmem", "personal-memory"].flatMap((name) => tomlSpansUnder(text, ["mcp_servers", name]));
+  const retained = removeSpans(text, spans).trimEnd();
+  const out = `${retained ? `${retained}\n\n` : ""}${section}\n`;
+  TOML.parse(out);
+  return out;
+}
+
+/** Install one shared skill and the unified MCP in each selected agent's global config. */
+export function installAgentAccess({ home, runtimeRoot, stackRoot, agents, dry = false, h }) {
+  const scriptPath = path.join(runtimeRoot, "cli", "openmem-mcp.mjs");
+  const skillSource = path.join(runtimeRoot, ".agents", "skills", "openmem", "SKILL.md");
+  for (const agent of agents) {
+    const skillRel = SKILL_TARGETS[agent];
+    if (!skillRel) continue;
+    const skillPath = path.join(home, skillRel, "SKILL.md");
+    if (dry) h?.info(`[dry-run] install ${agent} openmem skill → ${skillPath}`);
+    else {
+      fs.mkdirSync(path.dirname(skillPath), { recursive: true });
+      fs.copyFileSync(skillSource, skillPath);
+      h?.ok(`${agent} skill → ${skillPath}`);
+    }
+    if (agent === "cursor-cli") continue; // install-mcp owns ~/.cursor/mcp.json
+    if (agent === "codex") {
+      const file = path.join(home, ".codex", "config.toml");
+      if (dry) h?.info(`[dry-run] merge openmem MCP into ${file}`);
+      else {
+        const current = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+        let next;
+        try {
+          next = updateCodexToml(current, scriptPath, stackRoot);
+        } catch (err) {
+          h?.warn(`codex: left ${file} unchanged; add [mcp_servers.openmem] by hand (${err.message})`);
+          continue;
+        }
+        writeFileAtomic(file, next);
+        h?.ok(`codex MCP → ${file}`);
+      }
+      continue;
+    }
+    const file = agent === "claude-code" ? path.join(home, ".claude.json") : opencodeConfigPath(home);
+    if (dry) {
+      h?.info(`[dry-run] merge openmem MCP into ${file}`);
+      continue;
+    }
+    if (agent === "claude-code") {
+      const config = readJson(file);
+      const servers = { ...(config.mcpServers || {}) };
+      delete servers["personal-memory"];
+      servers.openmem = {
+        type: "stdio", command: "node", args: [scriptPath], env: { PM_STACK_ROOT: stackRoot },
+      };
+      config.mcpServers = servers;
+      writeJson(file, config);
+    } else {
+      mergeOpencodeConfig(home, "mcp", (existing) => {
+        const next = { ...existing, openmem: {
+          type: "local", command: ["node", scriptPath], enabled: true,
+          environment: { PM_STACK_ROOT: stackRoot },
+        } };
+        delete next["personal-memory"];
+        return next;
+      });
+    }
+    h?.ok(`${agent} MCP → ${file}`);
+  }
+}