coding-friend-cli 1.36.4 → 1.38.0

package/README.md

@@ -1,6 +1,6 @@
 # coding-friend-cli
 
-CLI companion for the [coding-friend](https://github.com/dinhanhthi/coding-friend) plugin — a lean toolkit for disciplined engineering workflows with Claude Code.
+CLI companion for the [coding-friend](https://github.com/dinhanhthi/coding-friend) plugin — a lean toolkit for disciplined engineering workflows with Claude Code and Codex CLI.
 
 ## Plugin without the CLI?
 
@@ -17,13 +17,13 @@ Everything else (every skill, every agent, every hook except the three OPTIONAL
 - **`node` not found** — install Node.js 20+ from <https://nodejs.org> (the CLI declares `engines.node >= 20`; older versions will refuse to install).
 - **`EACCES` on global install** — set a user-writable global prefix: `npm config set prefix ~/.npm-global` and add `~/.npm-global/bin` to your `PATH`.
 - **`cf` not on PATH after install** — verify with `npm root -g` and ensure that directory's `bin/` is in your `PATH`.
-- **MCP server not appearing in Claude Code** — after install, run `cf mcp` to register the memory MCP, then restart Claude Code.
+- **MCP server not appearing in Claude Code** — after install, run `cf mcp` to register both Learn and Memory MCP at user scope, then restart Claude Code.
 
 ## Requirements
 
 - Node.js >= 20
 - npm (included with Node.js, but on some Linux distros you may need to install it separately)
-- The [coding-friend plugin](https://github.com/dinhanhthi/coding-friend) installed in Claude Code
+- The [coding-friend plugin](https://github.com/dinhanhthi/coding-friend) installed in Claude Code or Codex CLI
 
 ### Additional requirements for `cf memory init`
 
@@ -56,12 +56,14 @@ cf install --user       # Install at user scope (all projects)
 cf install --global     # Same as --user
 cf install --project    # Install at project scope (shared via git)
 cf install --local      # Install at local scope (this machine only)
+cf install --agent codex  # Register/install Coding Friend for Codex CLI
                         # 💡 Safe to run multiple times (idempotent).
 cf uninstall            # Uninstall plugin (interactive scope chooser)
 cf uninstall --user     # Uninstall from user scope (full cleanup)
 cf uninstall --global   # Same as --user
 cf uninstall --project  # Uninstall from project scope only
 cf uninstall --local    # Uninstall from local scope only
+cf uninstall --agent codex  # Disable Coding Friend in Codex CLI
                         # 💡 Interactive — asks for confirmation before acting.
 cf disable             # Disable plugin (interactive scope chooser)
 cf disable --user      # Disable at user scope (all projects)
@@ -75,6 +77,7 @@ cf enable --global     # Same as --user
 cf enable --project    # Enable at project scope
 cf enable --local      # Enable at local scope
 cf init              # Initialize workspace (interactive)
+cf init --agent codex  # Initialize workspace for Codex CLI
                      # 💡 You can run this anywhere, anytime.
 cf config            # Manage Coding Friend configuration (interactive menu)
                      # 💡 Edit docsDir, language, learn settings, and more.
@@ -89,6 +92,7 @@ cf permission              # Manage Claude Code permission rules (interactive)
 cf permission --all        # Apply all recommended permissions without prompts
 cf permission --user       # Save to user-level settings (~/.claude/settings.json)
 cf permission --project    # Save to project-level settings (.claude/settings.local.json)
+cf permission --agent codex --enable-auto-approve
 cf permission --all --user # Apply all recommended permissions to user settings
 cf statusline        # Setup coding-friend statusline
 cf update               # Update plugin + CLI + statusline
@@ -97,6 +101,7 @@ cf update               # Update plugin + CLI + statusline
 cf update --cli         # Update only the CLI (npm package)
 cf update --plugin      # Update only the Claude Code plugin
 cf update --statusline  # Update only the statusline
+cf update --agent codex # Update Codex marketplace/plugin cache
 cf update --project     # Update plugin at project scope
 cf update --local       # Update plugin at local scope
 cf dev on [path]     # Switch to local plugin source for development

package/dist/{chunk-GZT3YPAP.js → chunk-32UAW3NX.js}

@@ -8,7 +8,7 @@ import {
   claudeSettingsPath,
   installedPluginsPath,
   knownMarketplacesPath
-} from "./chunk-X2H7JJMR.js";
+} from "./chunk-PLSJW7QJ.js";
 
 // src/lib/plugin-state.ts
 var MARKETPLACE_NAME = "coding-friend-marketplace";

package/dist/chunk-5QCGEPQO.js

@@ -0,0 +1,238 @@
+import {
+  codexAgentsDir,
+  codexConfigTomlPath,
+  codexInstalledPluginsPath
+} from "./chunk-PLSJW7QJ.js";
+
+// src/lib/codex-config.ts
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname, join, resolve } from "path";
+var CODEX_MARKETPLACE_NAME = "coding-friend-marketplace";
+var CODEX_PLUGIN_NAME = "coding-friend";
+var CODEX_PLUGIN_ID = `${CODEX_PLUGIN_NAME}@${CODEX_MARKETPLACE_NAME}`;
+var CODEX_PLUGIN_TABLE = `plugins."${CODEX_PLUGIN_ID}"`;
+var CODEX_MEMORY_MCP_TABLE = "mcp_servers.coding-friend-memory";
+function readToml(filePath) {
+  try {
+    return readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+function writeToml(filePath, content) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, content.endsWith("\n") ? content : `${content}
+`);
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function tableHeader(tableName) {
+  return `[${tableName}]`;
+}
+function findTableRange(lines, header) {
+  const start = lines.findIndex((line) => line.trim() === header);
+  if (start === -1) return null;
+  let end = lines.length;
+  for (let index = start + 1; index < lines.length; index += 1) {
+    if (/^\s*\[[^\]]+\]\s*$/.test(lines[index])) {
+      end = index;
+      break;
+    }
+  }
+  return { start, end };
+}
+function replaceTable(content, tableName, body) {
+  const header = tableHeader(tableName);
+  const lines = content.split(/\n/);
+  const range = findTableRange(lines, header);
+  const nextBlock = [header, ...body];
+  if (range) {
+    lines.splice(range.start, range.end - range.start, ...nextBlock);
+    return `${lines.join("\n").replace(/\n*$/, "")}
+`;
+  }
+  const prefix = content.replace(/\n*$/, "");
+  return `${prefix}${prefix ? "\n\n" : ""}${nextBlock.join("\n")}
+`;
+}
+function upsertTableKey(content, tableName, key, valueLine) {
+  const header = tableHeader(tableName);
+  const lines = content.split(/\n/);
+  const range = findTableRange(lines, header);
+  if (!range) {
+    return replaceTable(content, tableName, [valueLine]);
+  }
+  const keyPattern = new RegExp(`^\\s*${key}\\s*=`);
+  let replaced = false;
+  for (let index = range.start + 1; index < range.end; index += 1) {
+    if (keyPattern.test(lines[index])) {
+      lines[index] = valueLine;
+      replaced = true;
+      break;
+    }
+  }
+  if (!replaced) {
+    lines.splice(range.end, 0, valueLine);
+  }
+  return `${lines.join("\n").replace(/\n*$/, "")}
+`;
+}
+function getTable(content, tableName) {
+  const lines = content.split(/\n/);
+  const range = findTableRange(lines, tableHeader(tableName));
+  if (!range) return [];
+  return lines.slice(range.start + 1, range.end);
+}
+function isCodexMarketplaceRegistered(configPath = codexConfigTomlPath()) {
+  return readToml(configPath).split(/\n/).some(
+    (line) => line.trim() === tableHeader(`marketplaces.${CODEX_MARKETPLACE_NAME}`)
+  );
+}
+function setCodexPluginEnabled(enabled, configPath = codexConfigTomlPath()) {
+  const content = readToml(configPath);
+  writeToml(
+    configPath,
+    upsertTableKey(
+      content,
+      CODEX_PLUGIN_TABLE,
+      "enabled",
+      `enabled = ${enabled ? "true" : "false"}`
+    )
+  );
+}
+function isCodexPluginDisabled(configPath = codexConfigTomlPath()) {
+  const table = getTable(readToml(configPath), CODEX_PLUGIN_TABLE);
+  return table.some((line) => /^\s*enabled\s*=\s*false\s*(?:#.*)?$/.test(line));
+}
+function removeTable(content, tableName) {
+  const lines = content.split(/\n/);
+  const range = findTableRange(lines, tableHeader(tableName));
+  if (!range) return content;
+  let start = range.start;
+  while (start > 0 && lines[start - 1].trim() === "") start -= 1;
+  lines.splice(start, range.end - start);
+  return `${lines.join("\n").replace(/\n*$/, "")}
+`;
+}
+function removeCodexMemoryMcpConfig(configPath = codexConfigTomlPath()) {
+  const content = readToml(configPath);
+  const next = removeTable(content, CODEX_MEMORY_MCP_TABLE);
+  if (next === content) return false;
+  writeToml(configPath, next);
+  return true;
+}
+function removeDeployedCodexAgents(targetDir = codexAgentsDir()) {
+  if (!existsSync(targetDir)) return 0;
+  let removed = 0;
+  for (const entry of readdirSync(targetDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !/^cf-.*\.toml$/.test(entry.name)) continue;
+    rmSync(join(targetDir, entry.name));
+    removed += 1;
+  }
+  return removed;
+}
+function writeCodexMemoryMcpConfig(memoryDir, configPath = codexConfigTomlPath()) {
+  const content = readToml(configPath);
+  writeToml(
+    configPath,
+    replaceTable(content, CODEX_MEMORY_MCP_TABLE, [
+      'command = "npx"',
+      `args = ["-y", "coding-friend-cli", "mcp-serve", ${tomlString(memoryDir)}]`
+    ])
+  );
+}
+function writeCodexAgentLimits(configPath = codexConfigTomlPath()) {
+  const content = readToml(configPath);
+  writeToml(
+    configPath,
+    upsertTableKey(content, "agents", "max_depth", "max_depth = 2")
+  );
+}
+function trustCodexProject(projectPath = process.cwd(), configPath = codexConfigTomlPath()) {
+  const tableName = `projects.${tomlString(projectPath)}`;
+  const content = readToml(configPath);
+  writeToml(
+    configPath,
+    upsertTableKey(
+      content,
+      tableName,
+      "trust_level",
+      'trust_level = "trusted"'
+    )
+  );
+}
+function generatedCodexAgentsDir(repoRoot = process.cwd()) {
+  return resolve(repoRoot, "plugin-codex", "agents");
+}
+function compareVersions(a, b) {
+  const left = a.split(".").map((part) => Number.parseInt(part, 10));
+  const right = b.split(".").map((part) => Number.parseInt(part, 10));
+  for (let index = 0; index < 3; index += 1) {
+    const diff = (left[index] || 0) - (right[index] || 0);
+    if (diff !== 0) return diff > 0 ? 1 : -1;
+  }
+  return 0;
+}
+function latestCodexInstalledPluginDir(pluginRoot = codexInstalledPluginsPath()) {
+  const directManifest = join(pluginRoot, ".codex-plugin", "plugin.json");
+  if (existsSync(directManifest)) return pluginRoot;
+  if (!existsSync(pluginRoot)) return null;
+  const versions = readdirSync(pluginRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter(
+    (version) => existsSync(join(pluginRoot, version, ".codex-plugin", "plugin.json"))
+  ).sort(compareVersions).reverse();
+  return versions[0] ? join(pluginRoot, versions[0]) : null;
+}
+function getCodexInstalledVersion(pluginRoot = codexInstalledPluginsPath()) {
+  const pluginDir = latestCodexInstalledPluginDir(pluginRoot);
+  if (!pluginDir) return null;
+  try {
+    const manifest = JSON.parse(
+      readFileSync(join(pluginDir, ".codex-plugin", "plugin.json"), "utf8")
+    );
+    return manifest.version ?? basename(pluginDir);
+  } catch {
+    return basename(pluginDir);
+  }
+}
+function findCodexAgentSourceDir(repoRoot = process.cwd()) {
+  const generated = generatedCodexAgentsDir(repoRoot);
+  if (existsSync(generated)) return generated;
+  const installedPluginDir = latestCodexInstalledPluginDir();
+  const installedAgents = installedPluginDir ? join(installedPluginDir, "agents") : null;
+  return installedAgents && existsSync(installedAgents) ? installedAgents : null;
+}
+function deployCodexAgents(sourceDir, targetDir = codexAgentsDir()) {
+  if (!existsSync(sourceDir)) return 0;
+  mkdirSync(targetDir, { recursive: true });
+  let copied = 0;
+  for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".toml")) continue;
+    copyFileSync(join(sourceDir, entry.name), join(targetDir, entry.name));
+    copied += 1;
+  }
+  return copied;
+}
+
+export {
+  CODEX_MARKETPLACE_NAME,
+  isCodexMarketplaceRegistered,
+  setCodexPluginEnabled,
+  isCodexPluginDisabled,
+  removeCodexMemoryMcpConfig,
+  removeDeployedCodexAgents,
+  writeCodexMemoryMcpConfig,
+  writeCodexAgentLimits,
+  trustCodexProject,
+  getCodexInstalledVersion,
+  findCodexAgentSourceDir,
+  deployCodexAgents
+};

package/dist/{chunk-YIXAQ4R2.js → chunk-6NXZKAOV.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-EVGXUDX4.js";
 import {
   resolvePath
-} from "./chunk-X2H7JJMR.js";
+} from "./chunk-PLSJW7QJ.js";
 import {
   log
 } from "./chunk-NREZK463.js";

package/dist/{chunk-XHP3EBR3.js → chunk-776ZY62N.js}

@@ -1,13 +1,23 @@
 import {
   ensureStatusline,
   getInstalledVersion
-} from "./chunk-XEKQW4RN.js";
+} from "./chunk-ETTZRJ55.js";
 import {
   ensureShellCompletion
 } from "./chunk-667NMPN4.js";
 import {
+  isMemoryMcpRegistered,
+  registerMemoryMcp,
+  removeMemoryMcpEntry
+} from "./chunk-BXSCYGWE.js";
+import {
+  CODEX_MARKETPLACE_NAME,
+  getCodexInstalledVersion
+} from "./chunk-5QCGEPQO.js";
+import {
+  resolveHostFlags,
   resolveScope
-} from "./chunk-IKLMHJH6.js";
+} from "./chunk-GIH6E7GJ.js";
 import {
   commandExists,
   run,
@@ -19,7 +29,7 @@ import {
 } from "./chunk-5UVDWG5L.js";
 import {
   claudeSettingsPath
-} from "./chunk-X2H7JJMR.js";
+} from "./chunk-PLSJW7QJ.js";
 import {
   log,
   printBanner
@@ -89,6 +99,11 @@ function getStatuslineVersion() {
   return match?.[1]?.replace(/^v/, "") ?? null;
 }
 async function updateCommand(opts) {
+  const { host } = resolveHostFlags(opts);
+  if (host === "codex") {
+    await updateCodexCommand(opts);
+    return;
+  }
   const updateAll = !opts.cli && !opts.plugin && !opts.statusline;
   const doCli = updateAll || !!opts.cli;
   const doPlugin = updateAll || !!opts.plugin;
@@ -249,9 +264,24 @@ async function updateCommand(opts) {
     }
   }
   if (doCli) {
-    const { refreshMemoryAfterUpdate } = await import("./memory-Y6GNALG3.js");
+    const { refreshMemoryAfterUpdate } = await import("./memory-DF7OUOTV.js");
     await refreshMemoryAfterUpdate();
   }
+  if (!isMemoryMcpRegistered()) {
+    registerMemoryMcp();
+  }
+  const migrationResult = removeMemoryMcpEntry();
+  if (migrationResult.removed) {
+    if (migrationResult.fileDeleted) {
+      log.success(
+        "Removed legacy project-scope coding-friend-memory from .mcp.json (file deleted \u2014 was empty)."
+      );
+    } else {
+      log.success(
+        "Removed legacy project-scope coding-friend-memory from .mcp.json"
+      );
+    }
+  }
   if (doStatusline) {
     const updatedVersion = ensureStatusline();
     if (updatedVersion) {
@@ -262,6 +292,84 @@ async function updateCommand(opts) {
   console.log();
   log.dim("Restart Claude Code (or start a new session) to see changes.");
 }
+async function updateCodexCommand(opts) {
+  const updateAll = !opts.cli && !opts.plugin && !opts.statusline;
+  const doCli = updateAll || !!opts.cli;
+  const doPlugin = updateAll || !!opts.plugin;
+  printBanner("\u2728 Coding Friend Codex Update \u2728");
+  console.log();
+  if (doPlugin) {
+    const beforeVersion = getCodexInstalledVersion();
+    console.log(
+      `  Plugin      ${beforeVersion ? beforeVersion : chalk.dim("not installed")}`
+    );
+    if (!commandExists("codex")) {
+      log.error("Codex CLI not found. Cannot update Codex plugin.");
+    } else {
+      log.step("Updating Codex marketplace...");
+      const result = runWithStderr("codex", [
+        "plugin",
+        "marketplace",
+        "upgrade",
+        CODEX_MARKETPLACE_NAME
+      ]);
+      if (result.exitCode !== 0) {
+        log.error(
+          `Codex marketplace upgrade failed. Try manually: codex plugin marketplace upgrade ${CODEX_MARKETPLACE_NAME}`
+        );
+        if (result.stderr) log.dim(`stderr: ${result.stderr}`);
+      } else {
+        const afterVersion = getCodexInstalledVersion();
+        if (afterVersion && afterVersion !== beforeVersion) {
+          log.success(
+            `Codex plugin updated to ${chalk.green(`v${afterVersion}`)}.`
+          );
+        } else if (afterVersion) {
+          log.success(
+            `Codex plugin is installed at ${chalk.green(`v${afterVersion}`)}.`
+          );
+        } else {
+          log.warn(
+            "Marketplace updated, but coding-friend is not installed yet. Open Codex and run /plugins to install it."
+          );
+        }
+      }
+    }
+  }
+  if (doCli) {
+    const cliVersion = getCliVersion();
+    const latestCliVersion = getLatestCliVersion();
+    if (!latestCliVersion) {
+      log.warn("Cannot check latest CLI version from npm.");
+    } else {
+      const cmp = semverCompare(cliVersion, latestCliVersion);
+      if (cmp < 0) {
+        log.step(
+          `CLI update available: ${chalk.yellow(`v${cliVersion}`)} \u2192 ${chalk.green(`v${latestCliVersion}`)}`
+        );
+        const result = run("npm", [
+          "install",
+          "-g",
+          "coding-friend-cli@latest"
+        ]);
+        if (result === null) {
+          log.error(
+            "CLI update failed. Try manually: npm install -g coding-friend-cli@latest"
+          );
+        } else {
+          log.success(`CLI updated to ${chalk.green(`v${latestCliVersion}`)}`);
+        }
+      }
+    }
+  }
+  if (opts.statusline) {
+    log.warn(
+      "Codex owns its TUI footer. Open Codex and run /statusline to configure it."
+    );
+  }
+  console.log();
+  log.dim("Restart Codex CLI (or start a new session) to see changes.");
+}
 
 export {
   semverCompare,

package/dist/{chunk-N4WZWRCI.js → chunk-BXSCYGWE.js}

@@ -1,6 +1,3 @@
-import {
-  resolveMemoryDir
-} from "./chunk-K4WSC62G.js";
 import {
   getLibPath
 } from "./chunk-RZRT7NGT.js";
@@ -9,7 +6,10 @@ import {
   askScope,
   formatScopeLabel,
   injectBackChoice
-} from "./chunk-IKLMHJH6.js";
+} from "./chunk-GIH6E7GJ.js";
+import {
+  runWithStderr
+} from "./chunk-EVGXUDX4.js";
 import {
   mergeJson,
   readJson,
@@ -19,15 +19,49 @@ import {
   claudeConfigDir,
   globalConfigPath,
   localConfigPath
-} from "./chunk-X2H7JJMR.js";
+} from "./chunk-PLSJW7QJ.js";
 import {
   log
 } from "./chunk-NREZK463.js";
 
+// src/lib/memory-mcp-register.ts
+var MCP_NAME = "coding-friend-memory";
+function registerMemoryMcp() {
+  const result = runWithStderr("claude", [
+    "mcp",
+    "add",
+    "--scope",
+    "user",
+    MCP_NAME,
+    "--",
+    "npx",
+    "-y",
+    "coding-friend-cli",
+    "mcp-serve"
+  ]);
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr ?? "";
+    if (stderr.includes("ENOENT") || stderr.includes("command not found")) {
+      log.warn(
+        `claude CLI not found \u2014 add MCP manually:
+  claude mcp add --scope user ${MCP_NAME} -- npx -y coding-friend-cli mcp-serve`
+      );
+    } else {
+      log.warn(`Could not register MCP: ${stderr || "unknown error"}`);
+    }
+    return false;
+  }
+  return true;
+}
+function isMemoryMcpRegistered() {
+  const result = runWithStderr("claude", ["mcp", "get", MCP_NAME]);
+  return result.exitCode === 0;
+}
+
 // src/lib/memory-prompts.ts
 import { confirm, input, select } from "@inquirer/prompts";
+import { rmSync } from "fs";
 import chalk from "chalk";
-import { homedir } from "os";
 import { join } from "path";
 function getMemoryFieldScope(field, globalCfg, localCfg) {
   const localSection = localCfg?.memory;
@@ -216,54 +250,66 @@ async function editMemoryEmbedding(globalCfg, localCfg) {
   if (ollamaUrl) embedding.ollamaUrl = ollamaUrl;
   writeMemoryField(scope, "embedding", embedding);
 }
-function writeMemoryMcpEntry(memoryDir) {
+function removeMemoryMcpEntry() {
   const mcpPath = join(process.cwd(), ".mcp.json");
-  const existing = readJson(mcpPath) ?? {};
-  const servers = existing.mcpServers ?? {};
-  writeJson(mcpPath, {
-    ...existing,
-    mcpServers: {
-      ...servers,
-      "coding-friend-memory": {
-        command: "npx",
-        args: ["-y", "coding-friend-cli", "mcp-serve", memoryDir]
-      }
-    }
-  });
-  log.success("Added coding-friend-memory to .mcp.json");
+  const existing = readJson(mcpPath);
+  if (existing == null) {
+    return { removed: false, fileDeleted: false };
+  }
+  const servers = existing.mcpServers;
+  if (servers == null || typeof servers !== "object" || Array.isArray(servers) || !("coding-friend-memory" in servers)) {
+    return { removed: false, fileDeleted: false };
+  }
+  delete servers["coding-friend-memory"];
+  if (Object.keys(servers).length === 0) {
+    delete existing.mcpServers;
+  }
+  if (Object.keys(existing).length === 0) {
+    rmSync(mcpPath, { force: true });
+    return { removed: true, fileDeleted: true };
+  }
+  writeJson(mcpPath, existing);
+  return { removed: true, fileDeleted: false };
 }
-function getMemoryMcpStatus() {
+function getMemoryMcpStatus(checkIsRegistered = isMemoryMcpRegistered) {
   const localMcpPath = join(process.cwd(), ".mcp.json");
   const localMcp = readJson(localMcpPath);
   const localServers = localMcp?.mcpServers;
+  const userScope = checkIsRegistered();
+  if (userScope) {
+    const hasShadow = localServers != null && "coding-friend-memory" in localServers;
+    return {
+      configured: true,
+      scope: hasShadow ? "local" : "user",
+      userScope: true
+    };
+  }
   if (localServers != null && "coding-friend-memory" in localServers) {
-    return { configured: true, scope: "local" };
+    return { configured: true, scope: "local", userScope: false };
   }
   const globalMcpPath = join(claudeConfigDir(), ".mcp.json");
   const globalMcp = readJson(globalMcpPath);
   const globalServers = globalMcp?.mcpServers;
   if (globalServers != null && "coding-friend-memory" in globalServers) {
-    return { configured: true, scope: "global" };
+    return { configured: true, scope: "global", userScope: false };
   }
-  return { configured: false, scope: null };
+  return { configured: false, scope: null, userScope: false };
 }
 async function editMemoryMcp() {
-  const status = getMemoryMcpStatus();
-  if (status.configured) {
-    const globalMcpDisplay = join(claudeConfigDir(), ".mcp.json").replace(
-      homedir(),
-      "~"
-    );
-    const label = status.scope === "local" ? chalk.green("configured") + chalk.dim(" (local .mcp.json)") : chalk.green("configured") + chalk.dim(` (global ${globalMcpDisplay})`) + " " + chalk.yellow("\u26A0 only works for one project");
-    log.info(`MCP: ${label}`);
+  if (isMemoryMcpRegistered()) {
+    log.info(`MCP: ${chalk.green("registered")} (user scope)`);
     const reconfigure = await confirm({
-      message: "Reconfigure Memory MCP in local .mcp.json?",
+      message: "Re-register Memory MCP (user scope)?",
       default: false
     });
     if (!reconfigure) return;
   }
-  const memoryDir = resolveMemoryDir();
-  writeMemoryMcpEntry(memoryDir);
+  const ok = registerMemoryMcp();
+  if (ok) {
+    log.success(
+      "Registered coding-friend-memory (user scope). Restart Claude Code to activate."
+    );
+  }
 }
 async function memoryConfigMenu(opts) {
   while (true) {
@@ -303,7 +349,7 @@ async function memoryConfigMenu(opts) {
     );
     const embeddingLabel = embeddingVal?.provider ? embeddingVal.model ? `${embeddingVal.model} (${embeddingVal.provider})` : embeddingVal.provider : "";
     const mcpStatus = getMemoryMcpStatus();
-    const mcpLabel = mcpStatus.configured ? mcpStatus.scope === "local" ? chalk.green("configured") + chalk.dim(" (.mcp.json)") : chalk.green("configured") + chalk.dim(" (global)") + " " + chalk.yellow("\u26A0") : chalk.dim("not configured");
+    const mcpLabel = mcpStatus.userScope ? mcpStatus.scope === "local" ? chalk.green("registered") + chalk.dim(" (user scope)") + " " + chalk.yellow("\u26A0 shadow") : chalk.green("registered") + chalk.dim(" (user scope)") : mcpStatus.configured ? mcpStatus.scope === "local" ? chalk.yellow("configured") + chalk.dim(" (.mcp.json)") : chalk.yellow("configured") + chalk.dim(" (global)") + " " + chalk.yellow("\u26A0") : chalk.dim("not registered");
     const choice = await select({
       message: "Memory settings:",
       choices: injectBackChoice(
@@ -354,7 +400,9 @@ async function memoryConfigMenu(opts) {
 }
 
 export {
-  writeMemoryMcpEntry,
+  registerMemoryMcp,
+  isMemoryMcpRegistered,
+  removeMemoryMcpEntry,
   getMemoryMcpStatus,
   memoryConfigMenu
 };