pennyrouter 0.2.9 → 0.2.11

package/src/launch.test.js

@@ -1,153 +1,170 @@
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-import {
-  buildPennyInvocation,
-  claudeLaunchSettingsPath,
-  claudeUserSkillPath,
-  codexLaunchProfilePath,
-  configurePennyHarness,
-  fileMode,
-  installPennyRuntime,
-  loadPennyConfig,
-  pennyConfigPath,
-  pennyRuntimeDir,
-  pennyShimPath,
-  removePennyHarness,
-  removePennyRuntime,
-  renderCodexLaunchProfile,
-} from "./launch.js";
-
-const ENV_KEYS = [
-  "HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME", "CODEX_HOME", "PATH", "SHELL",
-];
-
-async function main() {
-  if (!(["darwin", "linux"].includes(process.platform))) {
-    console.log("launch.test.js: skipped on unsupported platform");
-    return;
-  }
-
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pr-launch-test-"));
-  const previous = Object.fromEntries(ENV_KEYS.map((key) => [key, process.env[key]]));
-  const home = path.join(root, "home");
-  fs.mkdirSync(path.join(home, ".claude"), { recursive: true });
-  fs.mkdirSync(path.join(home, ".codex"), { recursive: true });
-  const nativeClaude = `${JSON.stringify({
-    permissions: { allow: ["Read"] },
-    statusLine: { type: "command", command: "native-status" },
-  }, null, 2)}\n`;
-  const nativeCodex = 'model = "native-model"\n';
-  fs.writeFileSync(path.join(home, ".claude", "settings.json"), nativeClaude);
-  fs.writeFileSync(path.join(home, ".codex", "config.toml"), nativeCodex);
-  fs.writeFileSync(path.join(home, ".zshrc"), "# user setting\n");
-
-  Object.assign(process.env, {
-    HOME: home,
-    XDG_CONFIG_HOME: path.join(home, ".config"),
-    XDG_DATA_HOME: path.join(home, ".local", "share"),
-    XDG_STATE_HOME: path.join(home, ".local", "state"),
-    CODEX_HOME: path.join(home, ".codex"),
-    PATH: "/usr/bin:/bin",
-    SHELL: "/bin/zsh",
-  });
-
-  try {
-    const first = await installPennyRuntime();
-    const staleSkill = path.join(pennyRuntimeDir(), "claude-plugin", "skills", "penny", "SKILL.md");
-    fs.mkdirSync(path.dirname(staleSkill), { recursive: true });
-    fs.writeFileSync(staleSkill, "stale plugin file");
-    const second = await installPennyRuntime();
-    assert.equal(first.supported, true);
-    assert.equal(first.changed, true);
-    assert.equal(second.changed, false);
-    assert.equal(await fileMode(pennyShimPath()), 0o755);
-    assert.ok(fs.existsSync(path.join(pennyRuntimeDir(), "bin", "penny.js")));
-    assert.ok(!fs.existsSync(staleSkill), "runtime upgrade removes stale plugin files");
-    const rc = fs.readFileSync(path.join(home, ".zshrc"), "utf8");
-    assert.equal((rc.match(/>>> pennyrouter PATH >>>/g) || []).length, 1);
-
-    await configurePennyHarness("claude-code", {
-      apiKey: "pr-super-secret",
-      gatewayBaseUrl: "https://gateway.example/",
-      subscriptionAuth: true,
-      models: { haiku: "Haiku 4.5 (PennyRouter)", sonnet: "Sonnet 5 (PennyRouter)", opus: "Opus 5 (PennyRouter)" },
-    });
-    await configurePennyHarness("codex", {
-      apiKey: "pr-super-secret",
-      gatewayBaseUrl: "https://gateway.example/",
-      subscriptionAuth: true,
-    });
-
-    assert.equal(fs.readFileSync(path.join(home, ".claude", "settings.json"), "utf8"), nativeClaude);
-    assert.equal(fs.readFileSync(path.join(home, ".codex", "config.toml"), "utf8"), nativeCodex);
-    assert.equal(await fileMode(pennyConfigPath()), 0o600);
-    assert.equal(await fileMode(claudeLaunchSettingsPath()), 0o600);
-    assert.equal(await fileMode(codexLaunchProfilePath()), 0o600);
-
-    const config = await loadPennyConfig();
-    assert.equal(config.api_key, "pr-super-secret");
-    const codexProfile = fs.readFileSync(codexLaunchProfilePath(), "utf8");
-    assert.ok(codexProfile.includes('env_http_headers = { "x-pennyrouter-key" = "PENNYROUTER_API_KEY" }'));
-    assert.ok(!codexProfile.includes("pr-super-secret"));
-    assert.ok(!rc.includes("pr-super-secret"));
-
-    const claude = buildPennyInvocation("claude", ["--resume", "abc"], config);
-    assert.equal(claude.command, "claude");
-    assert.deepEqual(claude.args.slice(-2), ["--resume", "abc"]);
-    assert.ok(!claude.args.includes("--plugin-dir"));
-    assert.equal(claude.env.ANTHROPIC_AUTH_TOKEN, "pr-super-secret");
-    assert.equal(claude.env.ANTHROPIC_BASE_URL, "https://gateway.example/");
-    assert.equal(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "Opus 5 (PennyRouter)");
-
-    const codex = buildPennyInvocation("codex", ["resume", "--last"], config);
-    assert.deepEqual(codex.args, ["--profile", "pennyrouter", "resume", "--last"]);
-    assert.equal(codex.env.PENNYROUTER_API_KEY, "pr-super-secret");
-    assert.throws(() => buildPennyInvocation("claude", ["--settings=x"], config), /manages --settings/);
-    assert.throws(() => buildPennyInvocation("codex", ["-p", "other"], config), /manages --profile/);
-
-    const command = fs.readFileSync(claudeUserSkillPath(), "utf8");
-    assert.ok(command.includes("@penny $ARGUMENTS"));
-    assert.ok(command.includes("name: penny"));
-
-    await removePennyHarness("claude-code");
-    assert.ok(!fs.existsSync(claudeUserSkillPath()));
-    fs.mkdirSync(path.dirname(claudeUserSkillPath()), { recursive: true });
-    fs.writeFileSync(claudeUserSkillPath(), "user-owned command\n");
-    await assert.rejects(configurePennyHarness("claude-code", {
-      apiKey: "pr-super-secret",
-      gatewayBaseUrl: "https://gateway.example/",
-      models: {},
-    }), /not managed by PennyRouter/);
-    assert.equal(fs.readFileSync(claudeUserSkillPath(), "utf8"), "user-owned command\n");
-    assert.ok(fs.existsSync(codexLaunchProfilePath()));
-    assert.ok(fs.existsSync(pennyShimPath()));
-    await removePennyHarness("codex");
-    await removePennyRuntime();
-    assert.ok(!fs.existsSync(pennyShimPath()));
-    assert.ok(!fs.existsSync(pennyRuntimeDir()));
-    assert.ok(!fs.existsSync(pennyConfigPath()));
-    assert.equal(fs.readFileSync(path.join(home, ".zshrc"), "utf8"), "# user setting\n");
-
-    const paid = renderCodexLaunchProfile({
-      gatewayBaseUrl: "https://gateway.example/", subscriptionAuth: false,
-    });
-    assert.ok(paid.includes('env_key = "PENNYROUTER_API_KEY"'));
-    assert.ok(!paid.includes("requires_openai_auth"));
-  } finally {
-    for (const key of ENV_KEYS) {
-      if (previous[key] === undefined) delete process.env[key];
-      else process.env[key] = previous[key];
-    }
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-
-  console.log("launch.test.js: all checks passed");
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  buildPennyInvocation,
+  claudeLaunchSettingsPath,
+  claudeUserSkillPath,
+  codexLaunchProfilePath,
+  configurePennyHarness,
+  fileMode,
+  installPennyRuntime,
+  loadPennyConfig,
+  pennyConfigPath,
+  pennyRuntimeDir,
+  pennyShimPath,
+  removePennyHarness,
+  removePennyRuntime,
+  renderCodexLaunchProfile,
+} from "./launch.js";
+import { claudeCodeHarness } from "./harnesses/claude-code.js";
+
+const ENV_KEYS = [
+  "HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME", "CODEX_HOME", "PATH", "SHELL",
+];
+
+async function main() {
+  if (!(["darwin", "linux"].includes(process.platform))) {
+    console.log("launch.test.js: skipped on unsupported platform");
+    return;
+  }
+
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pr-launch-test-"));
+  const previous = Object.fromEntries(ENV_KEYS.map((key) => [key, process.env[key]]));
+  const home = path.join(root, "home");
+  fs.mkdirSync(path.join(home, ".claude"), { recursive: true });
+  fs.mkdirSync(path.join(home, ".codex"), { recursive: true });
+  const nativeClaude = `${JSON.stringify({
+    permissions: { allow: ["Read"] },
+    statusLine: { type: "command", command: "native-status" },
+  }, null, 2)}\n`;
+  const nativeCodex = 'model = "native-model"\n';
+  fs.writeFileSync(path.join(home, ".claude", "settings.json"), nativeClaude);
+  fs.writeFileSync(path.join(home, ".codex", "config.toml"), nativeCodex);
+  fs.writeFileSync(path.join(home, ".zshrc"), "# user setting\n");
+
+  Object.assign(process.env, {
+    HOME: home,
+    XDG_CONFIG_HOME: path.join(home, ".config"),
+    XDG_DATA_HOME: path.join(home, ".local", "share"),
+    XDG_STATE_HOME: path.join(home, ".local", "state"),
+    CODEX_HOME: path.join(home, ".codex"),
+    PATH: "/usr/bin:/bin",
+    SHELL: "/bin/zsh",
+  });
+
+  try {
+    const first = await installPennyRuntime();
+    const staleSkill = path.join(pennyRuntimeDir(), "claude-plugin", "skills", "penny", "SKILL.md");
+    fs.mkdirSync(path.dirname(staleSkill), { recursive: true });
+    fs.writeFileSync(staleSkill, "stale plugin file");
+    const second = await installPennyRuntime();
+    assert.equal(first.supported, true);
+    assert.equal(first.changed, true);
+    assert.equal(second.changed, false);
+    assert.equal(await fileMode(pennyShimPath()), 0o755);
+    assert.ok(fs.existsSync(path.join(pennyRuntimeDir(), "bin", "penny.js")));
+    assert.ok(!fs.existsSync(staleSkill), "runtime upgrade removes stale plugin files");
+    const rc = fs.readFileSync(path.join(home, ".zshrc"), "utf8");
+    assert.equal((rc.match(/>>> pennyrouter PATH >>>/g) || []).length, 1);
+
+    await configurePennyHarness("claude-code", {
+      apiKey: "pr-super-secret",
+      gatewayBaseUrl: "https://gateway.example/",
+      subscriptionAuth: true,
+      // Simulate an existing install. `penny claude` must fix this at launch,
+      // without requiring a separate reinstall before its context limits are right.
+      models: { haiku: "Haiku 4.5 (PennyRouter)", sonnet: "Sonnet 5 (PennyRouter)", opus: "Opus 5 (PennyRouter)" },
+    });
+    await configurePennyHarness("codex", {
+      apiKey: "pr-super-secret",
+      gatewayBaseUrl: "https://gateway.example/",
+      subscriptionAuth: true,
+    });
+
+    assert.equal(fs.readFileSync(path.join(home, ".claude", "settings.json"), "utf8"), nativeClaude);
+    assert.equal(fs.readFileSync(path.join(home, ".codex", "config.toml"), "utf8"), nativeCodex);
+    assert.equal(await fileMode(pennyConfigPath()), 0o600);
+    assert.equal(await fileMode(claudeLaunchSettingsPath()), 0o600);
+    assert.equal(await fileMode(codexLaunchProfilePath()), 0o600);
+
+    const config = await loadPennyConfig();
+    assert.equal(config.api_key, "pr-super-secret");
+    const codexProfile = fs.readFileSync(codexLaunchProfilePath(), "utf8");
+    assert.ok(codexProfile.includes('env_http_headers = { "x-pennyrouter-key" = "PENNYROUTER_API_KEY" }'));
+    assert.ok(!codexProfile.includes("pr-super-secret"));
+    assert.ok(!rc.includes("pr-super-secret"));
+
+    const claude = buildPennyInvocation("claude", ["--resume", "abc"], config);
+    assert.equal(claude.command, "claude");
+    assert.deepEqual(claude.args.slice(-2), ["--resume", "abc"]);
+    assert.ok(!claude.args.includes("--plugin-dir"));
+    assert.equal(claude.env.ANTHROPIC_AUTH_TOKEN, "pr-super-secret");
+    assert.equal(claude.env.ANTHROPIC_BASE_URL, "https://gateway.example/");
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "claude-opus-5");
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, "claude-haiku-4-5-20251001");
+    assert.equal(claude.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS, undefined);
+
+    const codex = buildPennyInvocation("codex", ["resume", "--last"], config);
+    assert.deepEqual(codex.args, ["--profile", "pennyrouter", "resume", "--last"]);
+    assert.equal(codex.env.PENNYROUTER_API_KEY, "pr-super-secret");
+    assert.throws(() => buildPennyInvocation("claude", ["--settings=x"], config), /manages --settings/);
+    assert.throws(() => buildPennyInvocation("codex", ["-p", "other"], config), /manages --profile/);
+
+    const command = fs.readFileSync(claudeUserSkillPath(), "utf8");
+    assert.ok(command.includes("@penny $ARGUMENTS"));
+    assert.ok(command.includes("name: penny"));
+
+    // Persistent direct-Claude installs use the same native ids and must not
+    // leave the former global 1M override behind.
+    await claudeCodeHarness.install({
+      apiKey: "pr-super-secret",
+      gatewayBaseUrl: "https://gateway.example/",
+      plan: { configPath: path.join(home, ".claude", "settings.json") },
+    });
+    const persistedClaude = JSON.parse(fs.readFileSync(path.join(home, ".claude", "settings.json"), "utf8"));
+    assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, "claude-haiku-4-5-20251001");
+    assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_SONNET_MODEL, "claude-sonnet-5");
+    assert.equal("CLAUDE_CODE_MAX_CONTEXT_TOKENS" in persistedClaude.env, false);
+
+    await removePennyHarness("claude-code");
+    assert.ok(!fs.existsSync(claudeUserSkillPath()));
+    fs.mkdirSync(path.dirname(claudeUserSkillPath()), { recursive: true });
+    fs.writeFileSync(claudeUserSkillPath(), "user-owned command\n");
+    await assert.rejects(configurePennyHarness("claude-code", {
+      apiKey: "pr-super-secret",
+      gatewayBaseUrl: "https://gateway.example/",
+      models: {},
+    }), /not managed by PennyRouter/);
+    assert.equal(fs.readFileSync(claudeUserSkillPath(), "utf8"), "user-owned command\n");
+    assert.ok(fs.existsSync(codexLaunchProfilePath()));
+    assert.ok(fs.existsSync(pennyShimPath()));
+    await removePennyHarness("codex");
+    await removePennyRuntime();
+    assert.ok(!fs.existsSync(pennyShimPath()));
+    assert.ok(!fs.existsSync(pennyRuntimeDir()));
+    assert.ok(!fs.existsSync(pennyConfigPath()));
+    assert.equal(fs.readFileSync(path.join(home, ".zshrc"), "utf8"), "# user setting\n");
+
+    const paid = renderCodexLaunchProfile({
+      gatewayBaseUrl: "https://gateway.example/", subscriptionAuth: false,
+    });
+    assert.ok(paid.includes('env_key = "PENNYROUTER_API_KEY"'));
+    assert.ok(!paid.includes("requires_openai_auth"));
+  } finally {
+    for (const key of ENV_KEYS) {
+      if (previous[key] === undefined) delete process.env[key];
+      else process.env[key] = previous[key];
+    }
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+
+  console.log("launch.test.js: all checks passed");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/mcp-register.js

@@ -0,0 +1,193 @@
+/* Register the Threads MCP server with the harnesses that can run it.
+
+   Without this, `pennyrouter install` gives a user routing and nothing else: the MCP server
+   exists as a command they would have to discover and register by hand, which almost nobody
+   does. Registration is what makes thread_read/thread_resume simply be there.
+
+   Two harnesses, two config files, neither of them the one the installer already manages:
+
+     Claude Code  ~/.claude.json          -> mcpServers.pennyrouter   (JSON)
+     Codex        ~/.codex/config.toml    -> [mcp_servers.pennyrouter] (TOML)
+
+   NOTE the file for Claude Code. Its MCP registry is `~/.claude.json`, NOT the
+   `~/.claude/settings.json` that harnesses/claude-code.js writes — different file, different
+   shape. Writing the entry into settings.json looks right and does nothing.
+
+   The command is `npx -y pennyrouter mcp`, deliberately unpinned. An absolute path to the
+   current bin breaks the moment the user switches node versions or reinstalls, and the server
+   then silently stops appearing rather than failing loudly. A pinned version would freeze the
+   session writers, which is wrong for a feature whose whole risk is that Claude Code and Codex
+   change their undocumented formats — the writers need to be updatable. */
+
+import { atomicWrite, backupFile, exists, expandHome, readJsonFile } from "./state.js";
+import { readFile } from "node:fs/promises";
+
+export const SERVER_NAME = "pennyrouter";
+const CLAUDE_REGISTRY = "~/.claude.json";
+const CODEX_CONFIG = "~/.codex/config.toml";
+
+const MANAGED_START = "# --- PennyRouter managed MCP server ---";
+const MANAGED_END = "# --- end PennyRouter managed MCP server ---";
+
+/** What we register. Shared by both harnesses so the two configs cannot drift apart. */
+export function serverEntry() {
+  return { command: "npx", args: ["-y", "pennyrouter", "mcp"] };
+}
+
+/** True when an entry is one of ours, so re-installing updates rather than duplicating and
+    uninstalling never removes a server the user registered themselves. */
+export function isManagedEntry(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  const args = Array.isArray(entry.args) ? entry.args.join(" ") : "";
+  return /\bpennyrouter\b/.test(`${entry.command || ""} ${args}`);
+}
+
+// -- Claude Code ----------------------------------------------------------
+
+export function applyClaudeRegistry(config, { remove = false } = {}) {
+  const next = { ...(config || {}) };
+  const servers = { ...(next.mcpServers || {}) };
+
+  if (remove) {
+    // Only remove what we wrote. A user who pointed the name at their own build keeps it.
+    if (isManagedEntry(servers[SERVER_NAME])) delete servers[SERVER_NAME];
+  } else {
+    const existing = servers[SERVER_NAME];
+    if (existing && !isManagedEntry(existing)) {
+      throw new Error(
+        `Claude Code already has an MCP server named "${SERVER_NAME}" that PennyRouter did not ` +
+          "write. Rename it before installing so your configuration is not overwritten.",
+      );
+    }
+    servers[SERVER_NAME] = serverEntry();
+  }
+
+  if (Object.keys(servers).length) next.mcpServers = servers;
+  else delete next.mcpServers;
+  return next;
+}
+
+async function writeClaude({ remove }) {
+  if (!(await exists(CLAUDE_REGISTRY))) {
+    // Claude Code writes this on first run. Creating it ourselves risks clobbering a shape we
+    // do not own, so skip rather than guess.
+    return { changed: false, reason: "Claude Code config not found" };
+  }
+  const current = (await readJsonFile(CLAUDE_REGISTRY, null)) || {};
+  const next = applyClaudeRegistry(current, { remove });
+  if (JSON.stringify(next) === JSON.stringify(current)) return { changed: false };
+
+  await backupFile(CLAUDE_REGISTRY, "mcp");
+  await atomicWrite(CLAUDE_REGISTRY, `${JSON.stringify(next, null, 2)}\n`);
+  return { changed: true, path: expandHome(CLAUDE_REGISTRY) };
+}
+
+// -- Codex ----------------------------------------------------------------
+
+export function renderCodexMcp(text, { remove = false } = {}) {
+  const clean = removeManagedCodexMcp(text).trimEnd();
+  if (remove) return clean ? `${clean}\n` : "";
+
+  const pattern = new RegExp(`^\\s*\\[mcp_servers\\.${SERVER_NAME}\\]\\s*$`, "m");
+  if (pattern.test(clean)) {
+    throw new Error(
+      `Codex already defines [mcp_servers.${SERVER_NAME}] outside PennyRouter's managed block. ` +
+        "Rename that server before installing so PennyRouter does not overwrite it.",
+    );
+  }
+
+  const entry = serverEntry();
+  const block = [
+    MANAGED_START,
+    `[mcp_servers.${SERVER_NAME}]`,
+    `command = "${entry.command}"`,
+    `args = [${entry.args.map((a) => `"${a}"`).join(", ")}]`,
+    MANAGED_END,
+  ].join("\n");
+
+  // Appended rather than spliced at the first table: a TOML table header captures every key
+  // that follows it, so inserting this block above existing tables would silently reparent
+  // their keys into ours.
+  return `${clean ? `${clean}\n\n` : ""}${block}\n`;
+}
+
+export function removeManagedCodexMcp(text) {
+  return String(text || "").replace(
+    new RegExp(
+      `${escapeRegex(MANAGED_START)}[\\s\\S]*?${escapeRegex(MANAGED_END)}\\n?`,
+      "g",
+    ),
+    "",
+  );
+}
+
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+async function writeCodex({ remove }) {
+  if (!(await exists(CODEX_CONFIG))) return { changed: false, reason: "Codex config not found" };
+  const current = await readFile(expandHome(CODEX_CONFIG), "utf8").catch(() => "");
+  const next = renderCodexMcp(current, { remove });
+  if (next === current) return { changed: false };
+
+  await backupFile(CODEX_CONFIG, "mcp");
+  await atomicWrite(CODEX_CONFIG, next);
+  return { changed: true, path: expandHome(CODEX_CONFIG) };
+}
+
+// -- entry points ---------------------------------------------------------
+
+const WRITERS = { "claude-code": writeClaude, codex: writeCodex };
+
+/** Whether each harness currently has our server registered, and whether it could. */
+export async function mcpStatus(harnessIds = Object.keys(WRITERS)) {
+  const out = [];
+  for (const id of harnessIds) {
+    if (id === "claude-code") {
+      const present = await exists(CLAUDE_REGISTRY);
+      const config = present ? (await readJsonFile(CLAUDE_REGISTRY, null)) || {} : {};
+      out.push({
+        harness: id,
+        configFound: present,
+        registered: isManagedEntry((config.mcpServers || {})[SERVER_NAME]),
+        conflict: Boolean(
+          (config.mcpServers || {})[SERVER_NAME] &&
+            !isManagedEntry((config.mcpServers || {})[SERVER_NAME]),
+        ),
+      });
+    } else if (id === "codex") {
+      const present = await exists(CODEX_CONFIG);
+      const text = present ? await readFile(expandHome(CODEX_CONFIG), "utf8").catch(() => "") : "";
+      const managed = text.includes(MANAGED_START);
+      out.push({
+        harness: id,
+        configFound: present,
+        registered: managed,
+        conflict:
+          !managed && new RegExp(`^\\s*\\[mcp_servers\\.${SERVER_NAME}\\]`, "m").test(text),
+      });
+    }
+  }
+  return out;
+}
+
+/**
+ * Register (or with `remove`, unregister) the MCP server for `harnessIds`.
+ * Returns one result per harness; a harness whose config is absent is skipped, not an error.
+ */
+export async function registerMcp(harnessIds, { remove = false } = {}) {
+  const results = [];
+  for (const id of harnessIds) {
+    const writer = WRITERS[id];
+    if (!writer) continue;
+    try {
+      results.push({ harness: id, ...(await writer({ remove })) });
+    } catch (error) {
+      // A conflict must not fail the whole install: routing is the primary job and is already
+      // done by this point. Report it and let the user resolve the name.
+      results.push({ harness: id, changed: false, error: error?.message || String(error) });
+    }
+  }
+  return results;
+}