autorouter-mcp 0.2.0 → 0.2.2

package/dist/cli.js

@@ -7496,6 +7496,10 @@ var DEFAULT_CONFIG = {
   exclude: [],
   alwaysExpose: [],
   confirm: [],
+  promptMode: "commands",
+  activation: "lazy",
+  autoAdopt: true,
+  allowAddServer: true,
   selector: {
     mode: "auto",
     candidates: 30,
@@ -8910,6 +8914,23 @@ function substitutePluginRoot(value, root) {
 }
 
 // src/config/resolve.ts
+function harnessSources(name, cwd) {
+  const home = homeDir();
+  switch (name) {
+    case "claude":
+      return [join7(home, ".claude.json"), join7(cwd, ".mcp.json")];
+    case "cursor":
+      return [join7(home, ".cursor", "mcp.json"), join7(cwd, ".cursor", "mcp.json")];
+    case "vscode":
+      return [join7(home, ".vscode", "mcp.json"), join7(cwd, ".vscode", "mcp.json")];
+    case "codex":
+      return [join7(home, ".codex", "config.toml"), join7(cwd, ".codex", "config.toml")];
+    case "plugins":
+      return [join7(home, ".claude", "plugins", "installed_plugins.json")];
+    default:
+      return [];
+  }
+}
 function configCandidates(cwd) {
   const explicit = process.env.AUTOROUTER_CONFIG;
   return [
@@ -8945,6 +8966,7 @@ async function resolveConfig(cwd = process.cwd()) {
   };
   applyEnvOverrides(config);
   const imported = [];
+  const sources = [];
   const loaders = {
     claude: () => loadClaude(cwd),
     cursor: () => loadCursor(cwd),
@@ -8956,6 +8978,7 @@ async function resolveConfig(cwd = process.cwd()) {
     const load = loaders[name];
     if (!load)
       continue;
+    sources.push(...harnessSources(name, cwd));
     try {
       imported.push(...await load());
     } catch {}
@@ -8965,7 +8988,7 @@ async function resolveConfig(cwd = process.cwd()) {
     if (entry)
       imported.push(entry);
   }
-  return { config, servers: dedupeServers(imported), configPath, cwd };
+  return { config, servers: dedupeServers(imported), configPath, cwd, sources };
 }
 function applyEnvOverrides(config) {
   const env = process.env;
@@ -8982,6 +9005,16 @@ function applyEnvOverrides(config) {
   }
   if (env.AUTOROUTER_SELECTOR_BASE_URL)
     config.selector.baseUrl = env.AUTOROUTER_SELECTOR_BASE_URL;
+  if (env.AUTOROUTER_PROMPT_MODE) {
+    config.promptMode = env.AUTOROUTER_PROMPT_MODE;
+  }
+  if (env.AUTOROUTER_ACTIVATION) {
+    config.activation = env.AUTOROUTER_ACTIVATION;
+  }
+  if (env.AUTOROUTER_AUTO_ADOPT)
+    config.autoAdopt = env.AUTOROUTER_AUTO_ADOPT !== "0";
+  if (env.AUTOROUTER_ALLOW_ADD_SERVER)
+    config.allowAddServer = env.AUTOROUTER_ALLOW_ADD_SERVER !== "0";
   if (env.AUTOROUTER_EMBEDDINGS_PROVIDER) {
     config.embeddings.provider = env.AUTOROUTER_EMBEDDINGS_PROVIDER;
   }
@@ -19211,7 +19244,7 @@ async function buildCatalog(resolved) {
   const { config: config2, servers, cwd, configPath } = resolved;
   const capabilities = [];
   const errors3 = {};
-  const sourceFiles = configPath ? [configPath] : [];
+  const sourceFiles = [...configPath ? [configPath] : [], ...resolved.sources];
   sourceFiles.push(...servers.filter((s) => s.transport === "http").map((s) => `${AUTH}${authPath(s.name)}`));
   const skills = await collectSkills(config2.skillPaths, cwd, {
     includePlugins: config2.import.includes("plugins")
@@ -20201,6 +20234,10 @@ class ConnectionPool {
   names() {
     return [...this.byName.keys()];
   }
+  setEntries(entries) {
+    this.reset();
+    this.byName = new Map(entries.map((e) => [e.name, e]));
+  }
   async get(serverName) {
     const existing = this.clients.get(serverName);
     if (existing) {
@@ -20302,15 +20339,15 @@ class CapabilityError extends Error {
 }
 
 class Router {
-  resolved;
   pool;
-  guard;
   catalog;
   index;
+  resolved;
+  guard;
   refreshing = null;
   constructor(resolved, catalog, index, pool, guard) {
-    this.resolved = resolved;
     this.pool = pool;
+    this.resolved = resolved;
     this.guard = guard;
     this.catalog = catalog;
     this.index = index;
@@ -20329,13 +20366,16 @@ class Router {
       return;
     this.refreshing = (async () => {
       try {
-        const catalog = await buildCatalog(this.resolved);
+        const resolved = await resolveConfig(this.resolved.cwd);
+        const catalog = await buildCatalog(resolved);
         await saveCatalog(catalog);
-        const index = new HybridIndex(catalog.capabilities, this.resolved.config);
+        const index = new HybridIndex(catalog.capabilities, resolved.config);
         await index.warmEmbeddings();
+        this.resolved = resolved;
+        this.guard = new Guard(resolved.config);
         this.catalog = catalog;
         this.index = index;
-        this.pool.reset();
+        this.pool.setEntries(resolved.servers);
       } catch {} finally {
         this.refreshing = null;
       }
@@ -21152,9 +21192,27 @@ function oneLine(text, max) {
 
 // src/server/prompts.ts
 var INSTRUCTION_KINDS = new Set(["skill", "command", "agent"]);
+var KINDS_BY_MODE = {
+  all: INSTRUCTION_KINDS,
+  commands: new Set(["command", "agent"]),
+  none: new Set
+};
 var FIND_PROMPT = "find";
-var DESCRIPTION_CHARS = 180;
-function promptList(capabilities) {
+var DESCRIPTION_CHARS = 120;
+function* published(capabilities, mode) {
+  const kinds = KINDS_BY_MODE[mode] ?? KINDS_BY_MODE.commands;
+  if (!kinds.size)
+    return;
+  const seen = new Set([FIND_PROMPT]);
+  for (const cap of capabilities) {
+    if (!kinds.has(cap.kind))
+      continue;
+    const name = uniquePromptName(cap, seen);
+    seen.add(name);
+    yield [name, cap];
+  }
+}
+function promptList(capabilities, mode = "commands") {
   const prompts = [
     {
       name: FIND_PROMPT,
@@ -21162,12 +21220,7 @@ function promptList(capabilities) {
       arguments: [{ name: "query", description: "What you are trying to accomplish.", required: true }]
     }
   ];
-  const seen = new Set([FIND_PROMPT]);
-  for (const cap of capabilities) {
-    if (!INSTRUCTION_KINDS.has(cap.kind))
-      continue;
-    const name = uniquePromptName(cap, seen);
-    seen.add(name);
+  for (const [name, cap] of published(capabilities, mode)) {
     prompts.push({
       name,
       description: clamp(cap.description || `${cap.kind} ${cap.name}`, DESCRIPTION_CHARS),
@@ -21197,13 +21250,8 @@ function uniquePromptName(cap, taken) {
   }
   return base;
 }
-function capabilityForPrompt(capabilities, name) {
-  const seen = new Set([FIND_PROMPT]);
-  for (const cap of capabilities) {
-    if (!INSTRUCTION_KINDS.has(cap.kind))
-      continue;
-    const promptName2 = uniquePromptName(cap, seen);
-    seen.add(promptName2);
+function capabilityForPrompt(capabilities, name, mode = "commands") {
+  for (const [promptName2, cap] of published(capabilities, mode)) {
     if (promptName2 === name)
       return cap;
   }
@@ -21230,187 +21278,725 @@ function mentionsArguments(body) {
   return /\$ARGUMENTS\b|\$\d\b/.test(body);
 }
 
-// src/server/index.ts
-var NAME = "autorouter";
-var VERSION = "0.1.0";
-var INSTRUCTIONS = `This server is a capability router. Instead of loading every
-available tool into your context, it exposes a search interface over all of them.
+// src/cli/adopt.ts
+import { join as join16 } from "node:path";
 
-Workflow:
-1. find_capabilities({ query }) — describe what you are trying to do in plain
-   language. Matching tools come back with their full input schema, and on
-   hosts that support it are added to your tool list immediately, so you can
-   call them directly like any other tool.
-2. call_capability({ id, arguments }) — the fallback path, and the only one on
-   hosts that do not refresh their tool list. Use it whenever a tool named in a
-   search result is not yet callable directly; the result is identical.
-3. describe_capability({ id }) — full detail on demand: the schema for a tool
-   that was not inlined, or the complete instruction text for a skill. Reading a
-   skill's instructions is how a skill runs.
-
-Search before concluding that something is impossible: the catalog covers many
-servers, skills and plugin commands that are not visible in your tool list.`;
-async function serve(opts = {}) {
-  const router = await Router.create({ cwd: opts.cwd });
-  const server = new Server({ name: NAME, version: VERSION }, {
-    capabilities: {
-      tools: { listChanged: true },
-      prompts: { listChanged: true }
-    },
-    instructions: INSTRUCTIONS
-  });
-  let profile = null;
-  const activated = new Map;
-  server.oninitialized = () => {
-    profile = profileClient(server.getClientVersion(), server.getClientCapabilities());
-    log(`client: ${profile.name} ${profile.version} — ${profile.rationale}`);
-  };
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    refreshAndAnnounce();
-    const tools = routerTools(router, profile);
-    for (const [name, cap] of activated)
-      tools.push(promotedTool(name, cap));
-    return { tools };
-  });
-  server.setRequestHandler(ListPromptsRequestSchema, async () => {
-    refreshAndAnnounce();
-    return { prompts: promptList(router.catalog.capabilities) };
-  });
-  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    const { name, arguments: args = {} } = request.params;
-    if (await router.isStale())
-      await router.refresh();
-    return await handleGetPrompt(router, name, args);
-  });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args = {} } = request.params;
-    try {
-      switch (name) {
-        case "find_capabilities":
-          if (await router.isStale())
-            await router.refresh();
-          return await handleFind(router, server, profile, activated, args);
-        case "describe_capability":
-          return await handleDescribe(router, args);
-        case "call_capability":
-          return await handleCall(router, args);
-        case "activate_capabilities":
-          return await handleActivate(router, server, activated, args);
-        case "deactivate_capabilities":
-          return await handleDeactivate(server, activated, args);
-        default: {
-          const cap = activated.get(name);
-          if (cap)
-            return await invoke(router, cap, args, true);
-          return errorResult(`Unknown tool: ${name}. Use find_capabilities to search.`);
-        }
-      }
-    } catch (err) {
-      return errorResult(err instanceof Error ? err.message : String(err));
-    }
-  });
-  async function refreshAndAnnounce() {
-    const before = router.summary();
-    await router.refresh();
-    if (router.summary() === before)
-      return;
-    log(`catalog changed — ${router.summary()}`);
-    server.sendToolListChanged?.();
-    server.sendPromptListChanged?.();
+// src/config/write.ts
+import { join as join14 } from "node:path";
+function routerConfigPath(existingPath) {
+  return existingPath ?? join14(homeDir(), ".config", "autorouter", "config.json");
+}
+async function read(path) {
+  if (!await exists(path))
+    return {};
+  try {
+    return JSON.parse(stripJsonComments(await readText(path) ?? "{}"));
+  } catch {
+    throw new Error(`${path} is not valid JSON — fix it before writing to it.`);
   }
-  const transport = new StdioServerTransport;
-  await server.connect(transport);
-  log(`ready — ${router.summary()}`);
-  await new Promise((resolve2) => {
-    let done = false;
-    const finish = () => {
-      if (done)
-        return;
-      done = true;
-      router.close().catch(() => {});
-      resolve2();
-    };
-    server.onclose = finish;
-    transport.onclose = finish;
-    process.on("SIGINT", finish);
-    process.on("SIGTERM", finish);
-    process.stdin.on("end", finish);
-  });
 }
-function routerTools(router, profile) {
-  const tools = [
-    {
-      name: "find_capabilities",
-      description: `Search every available tool, skill, prompt and command by what you are trying to do, and get back only the ones that fit. Catalog: ${router.summary()}. Use this whenever a task might need a capability you cannot already see — searching is cheap and the catalog is much larger than your tool list.`,
-      inputSchema: {
-        type: "object",
-        properties: {
-          query: {
-            type: "string",
-            description: "What you are trying to accomplish, in plain language. Describe the goal, not a guessed tool name."
-          },
-          kind: {
-            type: "string",
-            enum: ["tool", "skill", "prompt", "resource", "command", "agent"],
-            description: "Optional: restrict results to one kind of capability."
-          },
-          server: { type: "string", description: "Optional: restrict to one provider." },
-          limit: { type: "number", description: "Max results (default 8)." }
-        },
-        required: ["query"]
-      }
-    },
-    {
-      name: "describe_capability",
-      description: "Get full detail for one capability id from find_capabilities: the complete input schema for a tool, or the full instruction text for a skill or command.",
-      inputSchema: {
-        type: "object",
-        properties: { id: { type: "string", description: "Capability id, e.g. mcp:supabase/execute_sql" } },
-        required: ["id"]
-      }
-    },
-    {
-      name: "call_capability",
-      description: "Run a capability by id and return its result. Works for tools, prompts and resources; skills and commands are executed by following the text from describe_capability instead.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          id: { type: "string", description: "Capability id to invoke." },
-          arguments: { type: "object", description: "Arguments matching the capability's input schema." },
-          confirm: {
-            type: "boolean",
-            description: "Set true to proceed with a capability that requires explicit confirmation."
-          }
-        },
-        required: ["id"]
-      }
+async function upsertServers(servers, opts) {
+  const path = routerConfigPath(opts.configPath);
+  await ensureDir(join14(path, ".."));
+  const config2 = await read(path);
+  config2.servers = opts.overwrite ? { ...config2.servers, ...servers } : { ...servers, ...config2.servers };
+  await writeText(path, `${JSON.stringify(config2, null, 2)}
+`);
+  return path;
+}
+async function removeServer(name, configPath) {
+  const path = routerConfigPath(configPath);
+  const config2 = await read(path);
+  if (!config2.servers || !(name in config2.servers))
+    return { removed: false, path };
+  delete config2.servers[name];
+  await writeText(path, `${JSON.stringify(config2, null, 2)}
+`);
+  return { removed: true, path };
+}
+
+// src/cli/adoptExtras.ts
+import { join as join15 } from "node:path";
+function settingsPath() {
+  return join15(homeDir(), ".claude", "settings.json");
+}
+async function planExtras(opts) {
+  const file = settingsPath();
+  const settings = await readSettings(file) ?? {};
+  const plan = { file, skills: [], plugins: [], skipped: [] };
+  const keepSkills = new Set(opts.keepSkills);
+  const keepPlugins = new Set(opts.keepPlugins);
+  const plugins = await listInstalledPlugins();
+  const pluginByName = new Map(plugins.map((p) => [p.name, p]));
+  const disabledPluginNames = new Set;
+  const untouched = new Set;
+  for (const plugin of plugins) {
+    if (keepPlugins.has(plugin.name) || keepPlugins.has(plugin.key)) {
+      untouched.add(plugin.name);
+      continue;
     }
-  ];
-  if (profile?.supportsListChanged) {
-    tools.push({
-      name: "activate_capabilities",
-      description: "Promote capabilities to real, first-class tools in your tool list so you can call them directly with full schema validation. Use after find_capabilities when you expect to call something several times.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          ids: { type: "array", items: { type: "string" }, description: "Capability ids to promote." }
-        },
-        required: ["ids"]
-      }
-    }, {
-      name: "deactivate_capabilities",
-      description: "Remove previously activated capabilities from your tool list to reclaim context.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          ids: { type: "array", items: { type: "string" }, description: "Ids to remove; omit to remove all." }
-        }
-      }
+    if (settings.enabledPlugins?.[plugin.key] === false) {
+      plan.skipped.push(`plugin ${plugin.name} (already disabled)`);
+      disabledPluginNames.add(plugin.name);
+      continue;
+    }
+    const servers = await pluginServerNames(plugin.root);
+    const broken = servers.map((s) => opts.unreachable?.has(`${plugin.name}:${s}`) ? `${plugin.name}:${s}` : opts.unreachable?.has(s) ? s : null).filter((s) => s !== null);
+    if (broken.length) {
+      plan.skipped.push(`plugin ${plugin.name} (the router cannot reach ${broken.join(", ")} — run: ${broken.map((s) => `autorouter login ${s}`).join("; ")})`);
+      untouched.add(plugin.name);
+      continue;
+    }
+    const unrouted = servers.filter((s) => !opts.routedServers.has(s) && !opts.routedServers.has(`${plugin.name}:${s}`));
+    if (unrouted.length) {
+      plan.skipped.push(`plugin ${plugin.name} (${unrouted.length > 1 ? `its servers ${unrouted.join(", ")} are` : `its server ${unrouted[0]} is`} not routed yet — adopt ${unrouted.length > 1 ? "them" : "it"} first)`);
+      continue;
+    }
+    plan.plugins.push({
+      id: plugin.key,
+      name: plugin.name,
+      reason: servers.length ? `${servers.length} server(s) already routed` : "skills only"
     });
+    disabledPluginNames.add(plugin.name);
   }
-  return tools;
+  const { capabilities } = await collectSkills(opts.skillPaths, opts.cwd, { includePlugins: true });
+  for (const cap of capabilities) {
+    if (cap.server && (disabledPluginNames.has(cap.server) || untouched.has(cap.server)))
+      continue;
+    if (keepSkills.has(cap.name))
+      continue;
+    const current = settings.skillOverrides?.[cap.name];
+    if (current === "off" || current === "user-invocable-only") {
+      plan.skipped.push(`skill ${cap.name} (already ${current})`);
+      continue;
+    }
+    plan.skills.push({ name: cap.name, mode: opts.mode, from: cap.server ?? null });
+  }
+  return plan;
 }
-function promotedTool(name, cap) {
+async function applyExtras(plan) {
+  const settings = await readSettings(plan.file) ?? {};
+  settings.skillOverrides = { ...settings.skillOverrides };
+  settings.enabledPlugins = { ...settings.enabledPlugins };
+  for (const s of plan.skills)
+    settings.skillOverrides[s.name] = s.mode;
+  for (const p of plan.plugins)
+    settings.enabledPlugins[p.id] = false;
+  await writeText(plan.file, `${JSON.stringify(settings, null, 2)}
+`);
+}
+async function readSettings(file) {
+  if (!await exists(file))
+    return null;
+  const text = await readText(file);
+  if (!text?.trim())
+    return null;
+  try {
+    return JSON.parse(stripJsonComments(text));
+  } catch {
+    return null;
+  }
+}
+async function pluginServerNames(root) {
+  const manifestText = await readText(join15(root, ".claude-plugin", "plugin.json"));
+  if (!manifestText)
+    return [];
+  let manifest;
+  try {
+    manifest = JSON.parse(stripJsonComments(manifestText));
+  } catch {
+    return [];
+  }
+  if (!manifest.mcpServers)
+    return [];
+  if (typeof manifest.mcpServers !== "string")
+    return Object.keys(manifest.mcpServers);
+  const rel = manifest.mcpServers.replace(/^\.\//, "");
+  const text = await readText(join15(root, rel));
+  if (!text)
+    return [];
+  try {
+    const loaded = JSON.parse(stripJsonComments(text));
+    return Object.keys(loaded.mcpServers ?? loaded ?? {});
+  } catch {
+    return [];
+  }
+}
+
+// src/cli/adopt.ts
+async function runAdopt(opts) {
+  const resolved = await resolveConfig(opts.cwd);
+  const keep = new Set([
+    "autorouter",
+    ...opts.keep,
+    ...serversBehind(resolved.config.alwaysExpose)
+  ]);
+  const plans = [];
+  const adopted = {};
+  const backup = {};
+  const docs = new Map;
+  const apply = (site, entries) => {
+    for (const [name, spec] of Object.entries(entries)) {
+      if (keep.has(name)) {
+        site.kept.push(name);
+        continue;
+      }
+      site.moved.push(name);
+      adopted[name] ??= spec;
+      delete entries[name];
+    }
+  };
+  if (opts.harness === "codex") {
+    const file = join16(homeDir(), ".codex", "config.toml");
+    const text = await readText(file);
+    if (text) {
+      let config2;
+      try {
+        config2 = parse(text);
+      } catch {
+        config2 = null;
+      }
+      if (config2) {
+        const plan = { harness: "codex", file, section: "mcp_servers", moved: [], kept: [] };
+        backup[file] = text;
+        docs.set(file, config2);
+        apply(plan, config2.mcp_servers ?? {});
+        plans.push(plan);
+      }
+    }
+  } else {
+    for (const site of jsonSites(opts.harness, opts.cwd)) {
+      if (!docs.has(site.file)) {
+        const text = await readText(site.file);
+        if (!text)
+          continue;
+        try {
+          docs.set(site.file, JSON.parse(stripJsonComments(text)));
+        } catch {
+          continue;
+        }
+        backup[site.file] = text;
+      }
+      const config2 = docs.get(site.file);
+      const container = site.path.reduce((acc, k) => acc?.[k], config2);
+      if (!container || typeof container !== "object")
+        continue;
+      const plan = {
+        harness: opts.harness,
+        file: site.file,
+        section: site.section,
+        moved: [],
+        kept: []
+      };
+      apply(plan, container);
+      plans.push(plan);
+    }
+  }
+  const routedServers = new Set([
+    ...resolved.servers.map((s) => s.name),
+    ...resolved.servers.flatMap((s) => s.name.includes(":") ? [s.name.split(":").pop()] : []),
+    ...Object.keys(adopted)
+  ]);
+  const extras = opts.extras && opts.harness === "claude" ? await planExtras({
+    cwd: opts.cwd,
+    skillPaths: resolved.config.skillPaths,
+    keepSkills: opts.keepSkills ?? [],
+    keepPlugins: opts.keepPlugins ?? [],
+    mode: opts.skillMode ?? "user-invocable-only",
+    routedServers,
+    unreachable: opts.unreachable
+  }) : null;
+  const extrasCount = (extras?.skills.length ?? 0) + (extras?.plugins.length ?? 0);
+  const movedCount = plans.reduce((n, p) => n + p.moved.length, 0);
+  if (!movedCount && !extrasCount) {
+    return {
+      plans,
+      extras,
+      backup: null,
+      notes: ["Nothing to adopt — no downstream servers, skills or plugins are loaded directly by this harness."]
+    };
+  }
+  if (opts.dryRun)
+    return { plans, extras, backup: null, notes: ["Dry run — no files were changed."] };
+  if (extrasCount) {
+    const text = await readText(settingsPath());
+    if (text !== null)
+      backup[settingsPath()] = text;
+  }
+  const backupPath = join16(backupDir(), `${opts.harness}-${stamp()}.json`);
+  await ensureDir(join16(backupPath, ".."));
+  await writeText(backupPath, `${JSON.stringify({ harness: opts.harness, files: backup }, null, 2)}
+`);
+  const touched = new Set(plans.filter((p) => p.moved.length).map((p) => p.file));
+  for (const file of touched) {
+    const config2 = docs.get(file);
+    await writeText(file, file.endsWith(".toml") ? stringify(config2) : `${JSON.stringify(config2, null, 2)}
+`);
+  }
+  if (movedCount)
+    await upsertServers(adopted, { configPath: resolved.configPath });
+  if (extras && extrasCount)
+    await applyExtras(extras);
+  const notes = [];
+  if (movedCount)
+    notes.push(`Moved ${movedCount} server(s) into the router's config.`);
+  if (extras?.skills.length) {
+    notes.push(`Hid ${extras.skills.length} skill(s) from the model` + (extras.skills[0]?.mode === "user-invocable-only" ? " — /name still works for you." : "."));
+  }
+  if (extras?.plugins.length)
+    notes.push(`Disabled ${extras.plugins.length} plugin(s).`);
+  notes.push(`Backup at ${backupPath}`);
+  notes.push("Restart the harness — its tool list should now show only the router.");
+  return { plans, extras, backup: backupPath, notes };
+}
+var HARNESSES = ["claude", "codex", "cursor", "vscode"];
+async function runAutoAdopt(cwd) {
+  const resolved = await resolveConfig(cwd);
+  if (resolved.config.autoAdopt === false)
+    return [];
+  const notes = [];
+  for (const harness of HARNESSES) {
+    if (!resolved.config.import.includes(harness))
+      continue;
+    try {
+      const result = await runAdopt({ harness, cwd, keep: [], dryRun: false, extras: false });
+      const moved = result.plans.flatMap((p) => p.moved);
+      if (moved.length)
+        notes.push(`adopted ${moved.join(", ")} from ${harness}`);
+    } catch {}
+  }
+  return notes;
+}
+function backupDir() {
+  return join16(homeDir(), ".autorouter", "adopted");
+}
+function stamp() {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+async function runRestore(harness) {
+  const dir = backupDir();
+  const { readdir: readdir2 } = await import("node:fs/promises");
+  let files;
+  try {
+    files = (await readdir2(dir)).filter((f) => f.startsWith(`${harness}-`)).sort();
+  } catch {
+    return [`No adoption backups found for ${harness}.`];
+  }
+  const latest = files.at(-1);
+  if (!latest)
+    return [`No adoption backups found for ${harness}.`];
+  const payload = JSON.parse(await readText(join16(dir, latest)));
+  const notes = [];
+  for (const [file, text] of Object.entries(payload.files)) {
+    await writeText(file, text);
+    notes.push(`Restored ${file}`);
+  }
+  notes.push(`From ${join16(dir, latest)}. The router's own config still lists these servers; that is harmless (duplicates are deduped) but you can remove them.`);
+  return notes;
+}
+function jsonSites(harness, cwd) {
+  switch (harness) {
+    case "claude":
+      return [
+        { file: join16(homeDir(), ".claude.json"), section: "mcpServers", path: ["mcpServers"] },
+        {
+          file: join16(homeDir(), ".claude.json"),
+          section: `projects[${cwd}].mcpServers`,
+          path: ["projects", cwd, "mcpServers"]
+        },
+        { file: join16(cwd, ".mcp.json"), section: "mcpServers", path: ["mcpServers"] }
+      ];
+    case "cursor":
+      return [
+        { file: join16(homeDir(), ".cursor", "mcp.json"), section: "mcpServers", path: ["mcpServers"] },
+        { file: join16(cwd, ".cursor", "mcp.json"), section: "mcpServers", path: ["mcpServers"] }
+      ];
+    case "vscode":
+      return [
+        { file: join16(homeDir(), ".vscode", "mcp.json"), section: "servers", path: ["servers"] },
+        { file: join16(cwd, ".vscode", "mcp.json"), section: "servers", path: ["servers"] }
+      ];
+    default:
+      return [];
+  }
+}
+function serversBehind(patterns) {
+  const out = [];
+  for (const p of patterns) {
+    const m = /^(?:mcp:)?([^:/.*]+)[/.]/.exec(p);
+    if (m?.[1])
+      out.push(m[1]);
+  }
+  return out;
+}
+
+// src/cli/add.ts
+function parseAddSpec(spec) {
+  if (spec.json) {
+    let parsed;
+    try {
+      parsed = JSON.parse(spec.json);
+    } catch (err) {
+      throw new Error(`--json is not valid JSON: ${err instanceof Error ? err.message : err}`);
+    }
+    const servers = parsed?.mcpServers ?? parsed?.servers;
+    if (servers && typeof servers === "object") {
+      const entries = Object.entries(servers);
+      if (entries.length !== 1 && !spec.name) {
+        throw new Error(`--json holds ${entries.length} servers; name the one you want: autorouter add <name> --json '…'`);
+      }
+      const picked = spec.name ? entries.find(([n]) => n === spec.name) : entries[0];
+      if (!picked)
+        throw new Error(`--json has no server named "${spec.name}".`);
+      return { name: spec.name ?? picked[0], raw: picked[1] };
+    }
+    if (!spec.name)
+      throw new Error("A name is required: autorouter add <name> --json '…'");
+    return { name: spec.name, raw: parsed };
+  }
+  if (!spec.name)
+    throw new Error("A name is required: autorouter add <name> --url … | --command …");
+  if (!spec.url && !spec.command) {
+    throw new Error(`Nothing to register: pass --url, --command, or -- <command> <args…>`);
+  }
+  return {
+    name: spec.name,
+    raw: {
+      ...spec.url ? { url: spec.url, headers: spec.headers } : {},
+      ...spec.command ? { command: spec.command, args: spec.args ?? [] } : {},
+      ...spec.env ? { env: spec.env } : {}
+    }
+  };
+}
+function describeSpec(raw) {
+  return raw.url ? raw.url : `${raw.command} ${(raw.args ?? []).join(" ")}`.trim();
+}
+async function runAdd(spec, cwd = process.cwd()) {
+  const { name, raw } = parseAddSpec(spec);
+  const target = describeSpec(raw);
+  const entry = normalizeServer(name, raw, "config");
+  if (!entry) {
+    return { ok: false, name, target, message: `Could not read a server out of that: ${target || "(empty)"}` };
+  }
+  if (isSelfReference(entry)) {
+    return {
+      ok: false,
+      name,
+      target,
+      message: `"${target}" launches autorouter itself. Registering the router with the router would recurse forever.`
+    };
+  }
+  const resolved = await resolveConfig(cwd);
+  const path = await upsertServers({ [name]: raw }, {
+    configPath: resolved.configPath,
+    overwrite: true
+  });
+  let client;
+  let capabilities;
+  let failure;
+  try {
+    client = await connect(entry);
+    capabilities = (await enumerateServer(entry, client)).length;
+  } catch (err) {
+    failure = authHint(name, err);
+  } finally {
+    try {
+      await client?.close();
+    } catch {}
+  }
+  if (failure) {
+    return {
+      ok: false,
+      name,
+      target,
+      path,
+      message: `Registered ${name} in ${path}, but it did not answer: ${failure}`
+    };
+  }
+  const router = await Router.create({ cwd, force: true });
+  await router.close();
+  return {
+    ok: true,
+    name,
+    target,
+    path,
+    capabilities,
+    message: `Added ${name} → ${target}
+  ${capabilities} capabilities, registered in ${path}`
+  };
+}
+async function runRemove(name, cwd = process.cwd()) {
+  const resolved = await resolveConfig(cwd);
+  const { removed, path } = await removeServer(name, resolved.configPath);
+  if (!removed)
+    return `No server named "${name}" in ${path}.`;
+  const stillImported = (await resolveConfig(cwd)).servers.some((s) => s.name === name);
+  return stillImported ? `Removed ${name} from ${path}, but a harness still registers it — it will keep appearing. ` + `Add "${name}/*" to "exclude" to hide it entirely.` : `Removed ${name} from ${path}.`;
+}
+
+// src/server/index.ts
+var NAME = "autorouter";
+var VERSION = "0.1.0";
+var INSTRUCTIONS = `This server is a capability router. Instead of loading every
+available tool into your context, it exposes a search interface over all of them.
+
+1. find_capabilities({ query }) — say what you are trying to do, in plain
+   language. Top tool hits come back with their input schema attached.
+2. call_capability({ id, arguments }) — run any hit by its id. A tool you call
+   more than once is promoted into your tool list automatically.
+3. describe_capability({ id }) — the full schema for a hit whose schema was
+   abbreviated, or a skill's instruction text. Reading those instructions is how
+   a skill runs.
+
+Search before concluding something is impossible: the catalog is much larger
+than your tool list.`;
+async function serve(opts = {}) {
+  const router = await Router.create({ cwd: opts.cwd });
+  const server = new Server({ name: NAME, version: VERSION }, {
+    capabilities: {
+      tools: { listChanged: true },
+      prompts: { listChanged: true }
+    },
+    instructions: INSTRUCTIONS
+  });
+  let profile = null;
+  const activated = new Map;
+  const { promptMode, activation, allowAddServer } = router.resolved.config;
+  let pendingNotes = [];
+  const canPromote = () => Boolean(profile?.supportsListChanged) && activation !== "off";
+  const promoteOnUse = async (cap) => {
+    if (activation !== "lazy" || !canPromote())
+      return null;
+    if (cap.kind !== "tool" || !cap.inputSchema)
+      return null;
+    const [name] = await promote(server, activated, [cap]);
+    return name ?? null;
+  };
+  server.oninitialized = () => {
+    profile = profileClient(server.getClientVersion(), server.getClientCapabilities());
+    log(`client: ${profile.name} ${profile.version} — ${profile.rationale}`);
+  };
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    refreshAndAnnounce();
+    const tools = routerTools(router, profile, activation, allowAddServer);
+    for (const [name, cap] of activated)
+      tools.push(promotedTool(name, cap));
+    return { tools };
+  });
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    refreshAndAnnounce();
+    return { prompts: promptList(router.catalog.capabilities, promptMode) };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args = {} } = request.params;
+    if (await router.isStale())
+      await router.refresh();
+    return await handleGetPrompt(router, name, args, promptMode);
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args = {} } = request.params;
+    try {
+      switch (name) {
+        case "find_capabilities":
+          if (await router.isStale())
+            await refreshAndAnnounce();
+          return await handleFind(router, server, profile, activated, activation, args, drainNotes());
+        case "describe_capability":
+          return await handleDescribe(router, args);
+        case "call_capability":
+          return await handleCall(router, promoteOnUse, args);
+        case "activate_capabilities":
+          return await handleActivate(router, server, activated, args);
+        case "deactivate_capabilities":
+          return await handleDeactivate(server, activated, args);
+        case "add_server":
+          return await handleAddServer(router, server, args);
+        default: {
+          const cap = activated.get(name);
+          if (cap)
+            return await invoke(router, cap, args, true);
+          return errorResult(`Unknown tool: ${name}. Use find_capabilities to search.`);
+        }
+      }
+    } catch (err) {
+      return errorResult(err instanceof Error ? err.message : String(err));
+    }
+  });
+  let adopting = false;
+  async function maybeAutoAdopt() {
+    if (adopting)
+      return;
+    adopting = true;
+    try {
+      const adopted = await runAutoAdopt(router.resolved.cwd);
+      for (const note of adopted) {
+        log(note);
+        pendingNotes.push(`${note} — restart the harness to reclaim its context.`);
+      }
+      if (adopted.length)
+        await router.refresh({ force: true });
+    } catch {} finally {
+      adopting = false;
+    }
+  }
+  async function refreshAndAnnounce() {
+    const before = router.summary();
+    const wasStale = await router.isStale();
+    await router.refresh();
+    if (wasStale)
+      await maybeAutoAdopt();
+    if (router.summary() === before)
+      return;
+    log(`catalog changed — ${router.summary()}`);
+    server.sendToolListChanged?.();
+    server.sendPromptListChanged?.();
+  }
+  function drainNotes() {
+    const notes = pendingNotes;
+    pendingNotes = [];
+    return notes;
+  }
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  log(`ready — ${router.summary()}`);
+  await new Promise((resolve2) => {
+    let done = false;
+    const finish = () => {
+      if (done)
+        return;
+      done = true;
+      router.close().catch(() => {});
+      resolve2();
+    };
+    server.onclose = finish;
+    transport.onclose = finish;
+    process.on("SIGINT", finish);
+    process.on("SIGTERM", finish);
+    process.stdin.on("end", finish);
+  });
+}
+function routerTools(router, profile, activation, allowAddServer) {
+  const tools = [
+    {
+      name: "find_capabilities",
+      description: `Search every available tool, skill, prompt and command by what you are trying to do, and get back only the ones that fit. Catalog: ${router.summary()}. Use this whenever a task might need a capability you cannot already see — searching is cheap and the catalog is much larger than your tool list.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "What you are trying to accomplish, in plain language. Describe the goal, not a guessed tool name."
+          },
+          kind: {
+            type: "string",
+            enum: ["tool", "skill", "prompt", "resource", "command", "agent"],
+            description: "Optional: restrict results to one kind of capability."
+          },
+          server: { type: "string", description: "Optional: restrict to one provider." },
+          limit: { type: "number", description: "Max results (default 8)." }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "describe_capability",
+      description: "Get full detail for one capability id from find_capabilities: the complete input schema for a tool, or the full instruction text for a skill or command.",
+      inputSchema: {
+        type: "object",
+        properties: { id: { type: "string", description: "Capability id, e.g. mcp:supabase/execute_sql" } },
+        required: ["id"]
+      }
+    },
+    {
+      name: "call_capability",
+      description: "Run a capability by id and return its result. Works for tools, prompts and resources; skills and commands are executed by following the text from describe_capability instead.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Capability id to invoke." },
+          arguments: { type: "object", description: "Arguments matching the capability's input schema." },
+          confirm: {
+            type: "boolean",
+            description: "Set true to proceed with a capability that requires explicit confirmation."
+          }
+        },
+        required: ["id"]
+      }
+    }
+  ];
+  if (profile?.supportsListChanged && activation !== "off") {
+    tools.push({
+      name: "activate_capabilities",
+      description: "Promote capabilities to real, first-class tools in your tool list so you can call them directly with full schema validation. Use after find_capabilities when you expect to call something several times.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ids: { type: "array", items: { type: "string" }, description: "Capability ids to promote." }
+        },
+        required: ["ids"]
+      }
+    }, {
+      name: "deactivate_capabilities",
+      description: "Remove previously activated capabilities from your tool list to reclaim context.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ids: { type: "array", items: { type: "string" }, description: "Ids to remove; omit to remove all." }
+        }
+      }
+    });
+  }
+  if (allowAddServer) {
+    tools.push({
+      name: "add_server",
+      description: 'Register a new MCP server behind the router, instead of running `claude mcp add`. Pass url or command+args, or json for a pasted {"mcpServers":{…}} snippet. Rejected without confirm: true.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          url: { type: "string" },
+          command: { type: "string" },
+          args: { type: "array", items: { type: "string" } },
+          env: { type: "object" },
+          headers: { type: "object" },
+          json: { type: "string" },
+          confirm: { type: "boolean" }
+        },
+        required: ["name"]
+      }
+    });
+  }
+  return tools;
+}
+async function handleAddServer(router, server, args) {
+  let target;
+  let name;
+  try {
+    const parsed = parseAddSpec(args);
+    name = parsed.name;
+    target = describeSpec(parsed.raw);
+  } catch (err) {
+    return errorResult(err instanceof Error ? err.message : String(err));
+  }
+  if (args.confirm !== true) {
+    return textResult([
+      `Confirmation required before registering "${name}".`,
+      `This machine will ${args.url || target.startsWith("http") ? "connect to" : "execute"}: ${target}`,
+      "",
+      "Show the user that line. If it is what they asked for, call add_server again with confirm: true."
+    ].join(`
+`));
+  }
+  const result = await runAdd(args, router.resolved.cwd);
+  if (!result.ok)
+    return errorResult(result.message);
+  await router.refresh({ force: true });
+  server.sendToolListChanged?.();
+  server.sendPromptListChanged?.();
+  return textResult(`${result.message}
+Search for them with find_capabilities.`);
+}
+function promotedTool(name, cap) {
   return {
     name,
     description: clamp(cap.description || `${cap.kind} ${cap.name}`, PROMOTED_DESC_CHARS),
@@ -21421,7 +22007,7 @@ var PROMOTED_DESC_CHARS = 320;
 function promotedCost(name, cap) {
   return tokensOf(promotedTool(name, cap));
 }
-async function handleGetPrompt(router, name, args) {
+async function handleGetPrompt(router, name, args, mode) {
   if (name === FIND_PROMPT) {
     const query = (args.query ?? "").trim();
     if (!query)
@@ -21440,7 +22026,7 @@ async function handleGetPrompt(router, name, args) {
       ]
     };
   }
-  const cap = capabilityForPrompt(router.catalog.capabilities, name);
+  const cap = capabilityForPrompt(router.catalog.capabilities, name, mode);
   if (!cap)
     throw new Error(`Unknown prompt: ${name}`);
   const found = await router.describe(cap.id);
@@ -21451,7 +22037,7 @@ async function handleGetPrompt(router, name, args) {
 }
 var AUTO_ACTIVATE_LIMIT = 5;
 var ACTIVE_TOKEN_BUDGET = 3000;
-async function handleFind(router, server, profile, activated, args) {
+async function handleFind(router, server, profile, activated, activation, args, notes = []) {
   const query = (args.query ?? "").trim();
   if (!query)
     return errorResult("query is required");
@@ -21462,587 +22048,301 @@ async function handleFind(router, server, profile, activated, args) {
     harness: profile?.name,
     server_handle: server
   });
-  const promoted = profile?.supportsListChanged ? await promote(server, activated, result.hits.map((h) => h.capability)) : [];
-  const text = renderRouteResult(query, result, { inlineSchemas: promoted.length === 0 });
+  const promoted = activation === "eager" && profile?.supportsListChanged ? await promote(server, activated, result.hits.map((h) => h.capability)) : [];
+  const body = renderRouteResult(query, result, { inlineSchemas: promoted.length === 0 });
+  const text = notes.length ? `${notes.map((n) => `[autorouter] ${n}`).join(`
+`)}
+
+${body}` : body;
   if (!promoted.length)
     return textResult(text);
-  return textResult(`${text}
-
-Now callable directly as: ${promoted.join(", ")}.
-` + "If they are not yet in your tool list, use call_capability with the ids above — the result is identical.");
-}
-async function promote(server, activated, caps) {
-  const names = [];
-  let changed = false;
-  for (const cap of caps) {
-    if (cap.kind !== "tool" || !cap.inputSchema)
-      continue;
-    if (names.length >= AUTO_ACTIVATE_LIMIT)
-      break;
-    const name = exposedName(cap);
-    names.push(name);
-    if (activated.get(name)?.id !== cap.id)
-      changed = true;
-    activated.delete(name);
-    activated.set(name, cap);
-  }
-  if (evictToBudget(activated, names))
-    changed = true;
-  if (changed)
-    await server.sendToolListChanged();
-  return names;
-}
-function evictToBudget(activated, keep) {
-  let total = 0;
-  for (const [name, cap] of activated)
-    total += promotedCost(name, cap);
-  if (total <= ACTIVE_TOKEN_BUDGET)
-    return false;
-  const protectedNames = new Set(keep);
-  let changed = false;
-  for (const [name, cap] of activated) {
-    if (total <= ACTIVE_TOKEN_BUDGET)
-      break;
-    if (protectedNames.has(name))
-      continue;
-    total -= promotedCost(name, cap);
-    activated.delete(name);
-    changed = true;
-  }
-  return changed;
-}
-async function handleDescribe(router, args) {
-  if (!args.id)
-    return errorResult("id is required");
-  const found = await router.describe(args.id);
-  if (!found) {
-    return errorResult(`No capability with id "${args.id}". Use find_capabilities to search.`);
-  }
-  return textResult(renderCapability(found.capability, found.body));
-}
-async function handleCall(router, args) {
-  if (!args.id)
-    return errorResult("id is required");
-  const cap = router.get(args.id);
-  if (!cap)
-    return errorResult(`No capability with id "${args.id}".`);
-  return invoke(router, cap, args.arguments ?? {}, args.confirm === true);
-}
-async function invoke(router, cap, args, confirmed) {
-  try {
-    const out = await router.call(cap.id, args, { confirmed });
-    if (out.capability.kind === "skill" || out.capability.kind === "command" || out.capability.kind === "agent") {
-      return { content: out.content, isError: false };
-    }
-    return {
-      content: [{ type: "text", text: `[${out.source}]` }, ...out.content],
-      isError: out.isError,
-      ...out.structuredContent ? { structuredContent: out.structuredContent } : {}
-    };
-  } catch (err) {
-    return errorResult(err instanceof Error ? err.message : String(err));
-  }
-}
-async function handleActivate(router, server, activated, args) {
-  const ids = args.ids ?? [];
-  if (!ids.length)
-    return errorResult("ids is required");
-  const added = [];
-  const missing = [];
-  for (const id of ids) {
-    const cap = router.get(id);
-    if (!cap || cap.kind !== "tool") {
-      missing.push(id);
-      continue;
-    }
-    const toolName = exposedName(cap);
-    activated.set(toolName, cap);
-    added.push(toolName);
-  }
-  if (added.length)
-    await server.sendToolListChanged();
-  const lines = [
-    added.length ? `Activated as tools: ${added.join(", ")}` : "Nothing activated.",
-    missing.length ? `Not activatable (unknown, or not a tool): ${missing.join(", ")}` : "",
-    added.length ? "If these do not appear in your tool list yet, call them through call_capability instead — the result is identical." : ""
-  ].filter(Boolean);
-  return textResult(lines.join(`
-`));
-}
-async function handleDeactivate(server, activated, args) {
-  const before = activated.size;
-  if (!args.ids?.length)
-    activated.clear();
-  else {
-    for (const id of args.ids) {
-      for (const [name, cap] of activated) {
-        if (cap.id === id || name === id)
-          activated.delete(name);
-      }
-    }
-  }
-  if (activated.size !== before)
-    await server.sendToolListChanged();
-  return textResult(`Active tools: ${activated.size} (was ${before}).`);
-}
-function exposedName(cap) {
-  const parsed = parseCapabilityId(cap.id);
-  const raw = parsed.server ? `${parsed.server}__${cap.name}` : cap.name;
-  return raw.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
-}
-function textResult(text) {
-  return { content: [{ type: "text", text }] };
-}
-function errorResult(text) {
-  return { content: [{ type: "text", text }], isError: true };
-}
-function log(message) {
-  process.stderr.write(`[autorouter] ${message}
-`);
-}
-
-// src/cli/init.ts
-import { join as join14 } from "node:path";
-import { createInterface } from "node:readline/promises";
-var HARNESS_LABEL = {
-  claude: "Claude Code",
-  codex: "Codex CLI",
-  cursor: "Cursor",
-  vscode: "VS Code / Copilot"
-};
-async function runInit(opts) {
-  const notes = [];
-  const env = {};
-  const suggested = await suggestModel(opts.harness);
-  const model = opts.yes ? suggested : await promptModel(opts.harness, suggested);
-  if (model) {
-    env.AUTOROUTER_SELECTOR_MODEL = model;
-    notes.push(`Selector model: ${model}`);
-  } else {
-    notes.push("No selector model set — the router will use MCP sampling if the host offers it, otherwise raw index ranking.");
-  }
-  switch (opts.harness) {
-    case "claude":
-      notes.push(await writeJsonServer(join14(homeDir(), ".claude.json"), "mcpServers", opts, env));
-      break;
-    case "cursor":
-      notes.push(await writeJsonServer(join14(homeDir(), ".cursor", "mcp.json"), "mcpServers", opts, env));
-      break;
-    case "vscode":
-      notes.push(await writeJsonServer(join14(homeDir(), ".vscode", "mcp.json"), "servers", opts, env));
-      break;
-    case "codex":
-      notes.push(await writeCodexServer(opts, env));
-      break;
-  }
-  notes.push(await writePrimer(opts.harness));
-  return notes;
-}
-async function writeJsonServer(path, key, opts, env) {
-  await ensureDir(join14(path, ".."));
-  const existing = await readText(path) ?? "{}";
-  let config2;
-  try {
-    config2 = JSON.parse(existing);
-  } catch {
-    return `Could not parse ${path}; add the server manually.`;
-  }
-  config2[key] ??= {};
-  config2[key].autorouter = {
-    command: opts.command,
-    args: opts.args,
-    ...Object.keys(env).length ? { env } : {}
-  };
-  await writeText(path, `${JSON.stringify(config2, null, 2)}
-`);
-  return `Registered autorouter in ${path}`;
-}
-async function writeCodexServer(opts, env) {
-  const path = join14(homeDir(), ".codex", "config.toml");
-  await ensureDir(join14(path, ".."));
-  const text = await readText(path) ?? "";
-  let config2;
-  try {
-    config2 = text ? parse(text) : {};
-  } catch {
-    return `Could not parse ${path}; add [mcp_servers.autorouter] manually.`;
-  }
-  config2.mcp_servers ??= {};
-  config2.mcp_servers.autorouter = {
-    command: opts.command,
-    args: opts.args,
-    startup_timeout_sec: 60,
-    ...Object.keys(env).length ? { env } : {}
-  };
-  await writeText(path, stringify(config2));
-  return `Registered autorouter in ${path}`;
-}
-async function writePrimer(harness) {
-  const targets = {
-    claude: join14(homeDir(), ".claude", "CLAUDE.md"),
-    codex: join14(homeDir(), ".codex", "AGENTS.md"),
-    cursor: join14(process.cwd(), ".cursor", "rules", "autorouter.mdc"),
-    vscode: join14(process.cwd(), ".github", "copilot-instructions.md")
-  };
-  const path = targets[harness];
-  await ensureDir(join14(path, ".."));
-  const current = await readText(path) ?? "";
-  if (current.includes("<!-- autorouter -->"))
-    return `Primer already present in ${path}`;
-  const section = harness === "cursor" ? `---
-description: Capability router
-alwaysApply: true
----
-
-${PRIMER}` : PRIMER;
-  await writeText(path, current ? `${current.trimEnd()}
-
-${section}
-` : `${section}
-`);
-  return `Added router primer to ${path}`;
-}
-var PRIMER = `<!-- autorouter -->
-## Capability router
-
-Most tools, skills and commands on this machine are not in your tool list. They
-are behind \`find_capabilities\`.
-
-Before deciding a task cannot be done, or reaching for a manual workaround, call
-\`find_capabilities({ query: "<what you are trying to do>" })\`. It searches every
-configured MCP server, skill and plugin command and returns only what fits.
-Then \`describe_capability\` for the schema, and \`call_capability\` to run it.
-<!-- /autorouter -->`;
-async function promptModel(harness, suggested) {
-  if (!process.stdin.isTTY)
-    return suggested;
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    console.log(`
-The router uses a small model to pick which capabilities fit a request.
-` + `It should be the cheapest model available in ${HARNESS_LABEL[harness]}.`);
-    const answer = (await rl.question(suggested ? `Selector model [${suggested}] (enter to accept, "none" to skip): ` : "Selector model (blank to skip): ")).trim();
-    if (answer.toLowerCase() === "none")
-      return null;
-    return answer || suggested;
-  } finally {
-    rl.close();
-  }
-}
-
-// src/cli/adopt.ts
-import { join as join16 } from "node:path";
+  return textResult(`${text}
 
-// src/cli/adoptExtras.ts
-import { join as join15 } from "node:path";
-function settingsPath() {
-  return join15(homeDir(), ".claude", "settings.json");
+Now callable directly as: ${promoted.join(", ")}.
+` + "If they are not yet in your tool list, use call_capability with the ids above — the result is identical.");
 }
-async function planExtras(opts) {
-  const file = settingsPath();
-  const settings = await readSettings(file) ?? {};
-  const plan = { file, skills: [], plugins: [], skipped: [] };
-  const keepSkills = new Set(opts.keepSkills);
-  const keepPlugins = new Set(opts.keepPlugins);
-  const plugins = await listInstalledPlugins();
-  const pluginByName = new Map(plugins.map((p) => [p.name, p]));
-  const disabledPluginNames = new Set;
-  const untouched = new Set;
-  for (const plugin of plugins) {
-    if (keepPlugins.has(plugin.name) || keepPlugins.has(plugin.key)) {
-      untouched.add(plugin.name);
-      continue;
-    }
-    if (settings.enabledPlugins?.[plugin.key] === false) {
-      plan.skipped.push(`plugin ${plugin.name} (already disabled)`);
-      disabledPluginNames.add(plugin.name);
-      continue;
-    }
-    const servers = await pluginServerNames(plugin.root);
-    const broken = servers.map((s) => opts.unreachable?.has(`${plugin.name}:${s}`) ? `${plugin.name}:${s}` : opts.unreachable?.has(s) ? s : null).filter((s) => s !== null);
-    if (broken.length) {
-      plan.skipped.push(`plugin ${plugin.name} (the router cannot reach ${broken.join(", ")} — run: ${broken.map((s) => `autorouter login ${s}`).join("; ")})`);
-      untouched.add(plugin.name);
-      continue;
-    }
-    const unrouted = servers.filter((s) => !opts.routedServers.has(s) && !opts.routedServers.has(`${plugin.name}:${s}`));
-    if (unrouted.length) {
-      plan.skipped.push(`plugin ${plugin.name} (${unrouted.length > 1 ? `its servers ${unrouted.join(", ")} are` : `its server ${unrouted[0]} is`} not routed yet — adopt ${unrouted.length > 1 ? "them" : "it"} first)`);
-      continue;
-    }
-    plan.plugins.push({
-      id: plugin.key,
-      name: plugin.name,
-      reason: servers.length ? `${servers.length} server(s) already routed` : "skills only"
-    });
-    disabledPluginNames.add(plugin.name);
-  }
-  const { capabilities } = await collectSkills(opts.skillPaths, opts.cwd, { includePlugins: true });
-  for (const cap of capabilities) {
-    if (cap.server && (disabledPluginNames.has(cap.server) || untouched.has(cap.server)))
-      continue;
-    if (keepSkills.has(cap.name))
-      continue;
-    const current = settings.skillOverrides?.[cap.name];
-    if (current === "off" || current === "user-invocable-only") {
-      plan.skipped.push(`skill ${cap.name} (already ${current})`);
+async function promote(server, activated, caps) {
+  const names = [];
+  let changed = false;
+  for (const cap of caps) {
+    if (cap.kind !== "tool" || !cap.inputSchema)
       continue;
-    }
-    plan.skills.push({ name: cap.name, mode: opts.mode, from: cap.server ?? null });
+    if (names.length >= AUTO_ACTIVATE_LIMIT)
+      break;
+    const name = exposedName(cap);
+    names.push(name);
+    if (activated.get(name)?.id !== cap.id)
+      changed = true;
+    activated.delete(name);
+    activated.set(name, cap);
   }
-  return plan;
-}
-async function applyExtras(plan) {
-  const settings = await readSettings(plan.file) ?? {};
-  settings.skillOverrides = { ...settings.skillOverrides };
-  settings.enabledPlugins = { ...settings.enabledPlugins };
-  for (const s of plan.skills)
-    settings.skillOverrides[s.name] = s.mode;
-  for (const p of plan.plugins)
-    settings.enabledPlugins[p.id] = false;
-  await writeText(plan.file, `${JSON.stringify(settings, null, 2)}
-`);
+  if (evictToBudget(activated, names))
+    changed = true;
+  if (changed)
+    await server.sendToolListChanged();
+  return names;
 }
-async function readSettings(file) {
-  if (!await exists(file))
-    return null;
-  const text = await readText(file);
-  if (!text?.trim())
-    return null;
-  try {
-    return JSON.parse(stripJsonComments(text));
-  } catch {
-    return null;
+function evictToBudget(activated, keep) {
+  let total = 0;
+  for (const [name, cap] of activated)
+    total += promotedCost(name, cap);
+  if (total <= ACTIVE_TOKEN_BUDGET)
+    return false;
+  const protectedNames = new Set(keep);
+  let changed = false;
+  for (const [name, cap] of activated) {
+    if (total <= ACTIVE_TOKEN_BUDGET)
+      break;
+    if (protectedNames.has(name))
+      continue;
+    total -= promotedCost(name, cap);
+    activated.delete(name);
+    changed = true;
   }
+  return changed;
 }
-async function pluginServerNames(root) {
-  const manifestText = await readText(join15(root, ".claude-plugin", "plugin.json"));
-  if (!manifestText)
-    return [];
-  let manifest;
-  try {
-    manifest = JSON.parse(stripJsonComments(manifestText));
-  } catch {
-    return [];
-  }
-  if (!manifest.mcpServers)
-    return [];
-  if (typeof manifest.mcpServers !== "string")
-    return Object.keys(manifest.mcpServers);
-  const rel = manifest.mcpServers.replace(/^\.\//, "");
-  const text = await readText(join15(root, rel));
-  if (!text)
-    return [];
-  try {
-    const loaded = JSON.parse(stripJsonComments(text));
-    return Object.keys(loaded.mcpServers ?? loaded ?? {});
-  } catch {
-    return [];
+async function handleDescribe(router, args) {
+  if (!args.id)
+    return errorResult("id is required");
+  const found = await router.describe(args.id);
+  if (!found) {
+    return errorResult(`No capability with id "${args.id}". Use find_capabilities to search.`);
   }
+  return textResult(renderCapability(found.capability, found.body));
 }
-
-// src/cli/adopt.ts
-async function runAdopt(opts) {
-  const resolved = await resolveConfig(opts.cwd);
-  const keep = new Set([
-    "autorouter",
-    ...opts.keep,
-    ...serversBehind(resolved.config.alwaysExpose)
-  ]);
-  const plans = [];
-  const adopted = {};
-  const backup = {};
-  const docs = new Map;
-  const apply = (site, entries) => {
-    for (const [name, spec] of Object.entries(entries)) {
-      if (keep.has(name)) {
-        site.kept.push(name);
-        continue;
-      }
-      site.moved.push(name);
-      adopted[name] ??= spec;
-      delete entries[name];
-    }
+async function handleCall(router, promoteOnUse, args) {
+  if (!args.id)
+    return errorResult("id is required");
+  const cap = router.get(args.id);
+  if (!cap)
+    return errorResult(`No capability with id "${args.id}".`);
+  const out = await invoke(router, cap, args.arguments ?? {}, args.confirm === true);
+  if (out.isError)
+    return out;
+  const name = await promoteOnUse(cap);
+  if (!name)
+    return out;
+  return {
+    ...out,
+    content: [
+      ...out.content,
+      {
+        type: "text",
+        text: `(now in your tool list as ${name} — call it directly next time)`
+      }
+    ]
   };
-  if (opts.harness === "codex") {
-    const file = join16(homeDir(), ".codex", "config.toml");
-    const text = await readText(file);
-    if (text) {
-      let config2;
-      try {
-        config2 = parse(text);
-      } catch {
-        config2 = null;
-      }
-      if (config2) {
-        const plan = { harness: "codex", file, section: "mcp_servers", moved: [], kept: [] };
-        backup[file] = text;
-        docs.set(file, config2);
-        apply(plan, config2.mcp_servers ?? {});
-        plans.push(plan);
-      }
-    }
-  } else {
-    for (const site of jsonSites(opts.harness, opts.cwd)) {
-      if (!docs.has(site.file)) {
-        const text = await readText(site.file);
-        if (!text)
-          continue;
-        try {
-          docs.set(site.file, JSON.parse(stripJsonComments(text)));
-        } catch {
-          continue;
-        }
-        backup[site.file] = text;
-      }
-      const config2 = docs.get(site.file);
-      const container = site.path.reduce((acc, k) => acc?.[k], config2);
-      if (!container || typeof container !== "object")
-        continue;
-      const plan = {
-        harness: opts.harness,
-        file: site.file,
-        section: site.section,
-        moved: [],
-        kept: []
-      };
-      apply(plan, container);
-      plans.push(plan);
+}
+async function invoke(router, cap, args, confirmed) {
+  try {
+    const out = await router.call(cap.id, args, { confirmed });
+    if (out.capability.kind === "skill" || out.capability.kind === "command" || out.capability.kind === "agent") {
+      return { content: out.content, isError: false };
     }
-  }
-  const routedServers = new Set([
-    ...resolved.servers.map((s) => s.name),
-    ...resolved.servers.flatMap((s) => s.name.includes(":") ? [s.name.split(":").pop()] : []),
-    ...Object.keys(adopted)
-  ]);
-  const extras = opts.extras && opts.harness === "claude" ? await planExtras({
-    cwd: opts.cwd,
-    skillPaths: resolved.config.skillPaths,
-    keepSkills: opts.keepSkills ?? [],
-    keepPlugins: opts.keepPlugins ?? [],
-    mode: opts.skillMode ?? "user-invocable-only",
-    routedServers,
-    unreachable: opts.unreachable
-  }) : null;
-  const extrasCount = (extras?.skills.length ?? 0) + (extras?.plugins.length ?? 0);
-  const movedCount = plans.reduce((n, p) => n + p.moved.length, 0);
-  if (!movedCount && !extrasCount) {
     return {
-      plans,
-      extras,
-      backup: null,
-      notes: ["Nothing to adopt — no downstream servers, skills or plugins are loaded directly by this harness."]
+      content: [{ type: "text", text: `[${out.source}]` }, ...out.content],
+      isError: out.isError,
+      ...out.structuredContent ? { structuredContent: out.structuredContent } : {}
     };
+  } catch (err) {
+    return errorResult(err instanceof Error ? err.message : String(err));
   }
-  if (opts.dryRun)
-    return { plans, extras, backup: null, notes: ["Dry run — no files were changed."] };
-  if (extrasCount) {
-    const text = await readText(settingsPath());
-    if (text !== null)
-      backup[settingsPath()] = text;
-  }
-  const backupPath = join16(backupDir(), `${opts.harness}-${stamp()}.json`);
-  await ensureDir(join16(backupPath, ".."));
-  await writeText(backupPath, `${JSON.stringify({ harness: opts.harness, files: backup }, null, 2)}
-`);
-  const touched = new Set(plans.filter((p) => p.moved.length).map((p) => p.file));
-  for (const file of touched) {
-    const config2 = docs.get(file);
-    await writeText(file, file.endsWith(".toml") ? stringify(config2) : `${JSON.stringify(config2, null, 2)}
-`);
+}
+async function handleActivate(router, server, activated, args) {
+  const ids = args.ids ?? [];
+  if (!ids.length)
+    return errorResult("ids is required");
+  const added = [];
+  const missing = [];
+  for (const id of ids) {
+    const cap = router.get(id);
+    if (!cap || cap.kind !== "tool") {
+      missing.push(id);
+      continue;
+    }
+    const toolName = exposedName(cap);
+    activated.set(toolName, cap);
+    added.push(toolName);
   }
-  if (movedCount)
-    await mergeIntoRouterConfig(adopted, resolved.configPath);
-  if (extras && extrasCount)
-    await applyExtras(extras);
-  const notes = [];
-  if (movedCount)
-    notes.push(`Moved ${movedCount} server(s) into the router's config.`);
-  if (extras?.skills.length) {
-    notes.push(`Hid ${extras.skills.length} skill(s) from the model` + (extras.skills[0]?.mode === "user-invocable-only" ? " — /name still works for you." : "."));
+  if (added.length)
+    await server.sendToolListChanged();
+  const lines = [
+    added.length ? `Activated as tools: ${added.join(", ")}` : "Nothing activated.",
+    missing.length ? `Not activatable (unknown, or not a tool): ${missing.join(", ")}` : "",
+    added.length ? "If these do not appear in your tool list yet, call them through call_capability instead — the result is identical." : ""
+  ].filter(Boolean);
+  return textResult(lines.join(`
+`));
+}
+async function handleDeactivate(server, activated, args) {
+  const before = activated.size;
+  if (!args.ids?.length)
+    activated.clear();
+  else {
+    for (const id of args.ids) {
+      for (const [name, cap] of activated) {
+        if (cap.id === id || name === id)
+          activated.delete(name);
+      }
+    }
   }
-  if (extras?.plugins.length)
-    notes.push(`Disabled ${extras.plugins.length} plugin(s).`);
-  notes.push(`Backup at ${backupPath}`);
-  notes.push("Restart the harness — its tool list should now show only the router.");
-  return { plans, extras, backup: backupPath, notes };
+  if (activated.size !== before)
+    await server.sendToolListChanged();
+  return textResult(`Active tools: ${activated.size} (was ${before}).`);
 }
-function backupDir() {
-  return join16(homeDir(), ".autorouter", "adopted");
+function exposedName(cap) {
+  const parsed = parseCapabilityId(cap.id);
+  const raw = parsed.server ? `${parsed.server}__${cap.name}` : cap.name;
+  return raw.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
-function stamp() {
-  return new Date().toISOString().replace(/[:.]/g, "-");
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
 }
-async function runRestore(harness) {
-  const dir = backupDir();
-  const { readdir: readdir2 } = await import("node:fs/promises");
-  let files;
-  try {
-    files = (await readdir2(dir)).filter((f) => f.startsWith(`${harness}-`)).sort();
-  } catch {
-    return [`No adoption backups found for ${harness}.`];
-  }
-  const latest = files.at(-1);
-  if (!latest)
-    return [`No adoption backups found for ${harness}.`];
-  const payload = JSON.parse(await readText(join16(dir, latest)));
+function errorResult(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function log(message) {
+  process.stderr.write(`[autorouter] ${message}
+`);
+}
+
+// src/cli/init.ts
+import { join as join17 } from "node:path";
+import { createInterface } from "node:readline/promises";
+var HARNESS_LABEL = {
+  claude: "Claude Code",
+  codex: "Codex CLI",
+  cursor: "Cursor",
+  vscode: "VS Code / Copilot"
+};
+async function runInit(opts) {
   const notes = [];
-  for (const [file, text] of Object.entries(payload.files)) {
-    await writeText(file, text);
-    notes.push(`Restored ${file}`);
+  const env = {};
+  const suggested = await suggestModel(opts.harness);
+  const model = opts.yes ? suggested : await promptModel(opts.harness, suggested);
+  if (model) {
+    env.AUTOROUTER_SELECTOR_MODEL = model;
+    notes.push(`Selector model: ${model}`);
+  } else {
+    notes.push("No selector model set — the router will use MCP sampling if the host offers it, otherwise raw index ranking.");
   }
-  notes.push(`From ${join16(dir, latest)}. The router's own config still lists these servers; that is harmless (duplicates are deduped) but you can remove them.`);
-  return notes;
-}
-function jsonSites(harness, cwd) {
-  switch (harness) {
+  switch (opts.harness) {
     case "claude":
-      return [
-        { file: join16(homeDir(), ".claude.json"), section: "mcpServers", path: ["mcpServers"] },
-        {
-          file: join16(homeDir(), ".claude.json"),
-          section: `projects[${cwd}].mcpServers`,
-          path: ["projects", cwd, "mcpServers"]
-        },
-        { file: join16(cwd, ".mcp.json"), section: "mcpServers", path: ["mcpServers"] }
-      ];
+      notes.push(await writeJsonServer(join17(homeDir(), ".claude.json"), "mcpServers", opts, env));
+      break;
     case "cursor":
-      return [
-        { file: join16(homeDir(), ".cursor", "mcp.json"), section: "mcpServers", path: ["mcpServers"] },
-        { file: join16(cwd, ".cursor", "mcp.json"), section: "mcpServers", path: ["mcpServers"] }
-      ];
+      notes.push(await writeJsonServer(join17(homeDir(), ".cursor", "mcp.json"), "mcpServers", opts, env));
+      break;
     case "vscode":
-      return [
-        { file: join16(homeDir(), ".vscode", "mcp.json"), section: "servers", path: ["servers"] },
-        { file: join16(cwd, ".vscode", "mcp.json"), section: "servers", path: ["servers"] }
-      ];
-    default:
-      return [];
+      notes.push(await writeJsonServer(join17(homeDir(), ".vscode", "mcp.json"), "servers", opts, env));
+      break;
+    case "codex":
+      notes.push(await writeCodexServer(opts, env));
+      break;
   }
+  notes.push(await writePrimer(opts.harness));
+  return notes;
 }
-function serversBehind(patterns) {
-  const out = [];
-  for (const p of patterns) {
-    const m = /^(?:mcp:)?([^:/.*]+)[/.]/.exec(p);
-    if (m?.[1])
-      out.push(m[1]);
+async function writeJsonServer(path, key, opts, env) {
+  await ensureDir(join17(path, ".."));
+  const existing = await readText(path) ?? "{}";
+  let config2;
+  try {
+    config2 = JSON.parse(existing);
+  } catch {
+    return `Could not parse ${path}; add the server manually.`;
   }
-  return out;
+  config2[key] ??= {};
+  config2[key].autorouter = {
+    command: opts.command,
+    args: opts.args,
+    ...Object.keys(env).length ? { env } : {}
+  };
+  await writeText(path, `${JSON.stringify(config2, null, 2)}
+`);
+  return `Registered autorouter in ${path}`;
 }
-async function mergeIntoRouterConfig(servers, existingPath) {
-  const path = existingPath ?? join16(homeDir(), ".config", "autorouter", "config.json");
-  await ensureDir(join16(path, ".."));
-  let config2 = {};
-  if (await exists(path)) {
-    try {
-      config2 = JSON.parse(stripJsonComments(await readText(path) ?? "{}"));
-    } catch {
-      config2 = {};
-    }
+async function writeCodexServer(opts, env) {
+  const path = join17(homeDir(), ".codex", "config.toml");
+  await ensureDir(join17(path, ".."));
+  const text = await readText(path) ?? "";
+  let config2;
+  try {
+    config2 = text ? parse(text) : {};
+  } catch {
+    return `Could not parse ${path}; add [mcp_servers.autorouter] manually.`;
   }
-  config2.servers = { ...servers, ...config2.servers };
-  await writeText(path, `${JSON.stringify(config2, null, 2)}
+  config2.mcp_servers ??= {};
+  config2.mcp_servers.autorouter = {
+    command: opts.command,
+    args: opts.args,
+    startup_timeout_sec: 60,
+    ...Object.keys(env).length ? { env } : {}
+  };
+  await writeText(path, stringify(config2));
+  return `Registered autorouter in ${path}`;
+}
+async function writePrimer(harness) {
+  const targets = {
+    claude: join17(homeDir(), ".claude", "CLAUDE.md"),
+    codex: join17(homeDir(), ".codex", "AGENTS.md"),
+    cursor: join17(process.cwd(), ".cursor", "rules", "autorouter.mdc"),
+    vscode: join17(process.cwd(), ".github", "copilot-instructions.md")
+  };
+  const path = targets[harness];
+  await ensureDir(join17(path, ".."));
+  const current = await readText(path) ?? "";
+  const section = harness === "cursor" ? `---
+description: Capability router
+alwaysApply: true
+---
+
+${PRIMER}` : PRIMER;
+  const existing = /<!-- autorouter -->[\s\S]*?<!-- \/autorouter -->/.exec(current);
+  if (existing) {
+    if (existing[0] === PRIMER)
+      return `Primer already current in ${path}`;
+    await writeText(path, current.replace(existing[0], PRIMER));
+    return `Updated router primer in ${path}`;
+  }
+  await writeText(path, current ? `${current.trimEnd()}
+
+${section}
+` : `${section}
 `);
+  return `Added router primer to ${path}`;
+}
+var PRIMER = `<!-- autorouter -->
+## Capability router
+
+Most tools, skills and commands on this machine are not in your tool list. They
+are behind \`find_capabilities\`.
+
+Before deciding a task cannot be done, or reaching for a manual workaround, call
+\`find_capabilities({ query: "<what you are trying to do>" })\`. It searches every
+configured MCP server, skill and plugin command and returns only what fits.
+Then \`describe_capability\` for the schema, and \`call_capability\` to run it.
+
+To install a new MCP server, use the router's \`add_server\` tool, or run
+\`autorouter add <name> --url <url>\` / \`autorouter add <name> -- <command>\`.
+Do not run \`claude mcp add\` — that loads the server's whole tool list into
+context, which is what the router is here to avoid.
+<!-- /autorouter -->`;
+async function promptModel(harness, suggested) {
+  if (!process.stdin.isTTY)
+    return suggested;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    console.log(`
+The router uses a small model to pick which capabilities fit a request.
+` + `It should be the cheapest model available in ${HARNESS_LABEL[harness]}.`);
+    const answer = (await rl.question(suggested ? `Selector model [${suggested}] (enter to accept, "none" to skip): ` : "Selector model (blank to skip): ")).trim();
+    if (answer.toLowerCase() === "none")
+      return null;
+    return answer || suggested;
+  } finally {
+    rl.close();
+  }
 }
 
 // src/cli/doctor.ts
@@ -22099,7 +22399,7 @@ async function runDoctor(cwd) {
   lines.push("");
   const stillDirect = new Map;
   const stillLoaded = new Map;
-  for (const harness of ["claude", "codex", "cursor", "vscode"]) {
+  for (const harness of HARNESSES2) {
     try {
       const { plans, extras } = await runAdopt({ harness, cwd, keep: [], dryRun: true, extras: true });
       const names = plans.flatMap((p) => p.moved);
@@ -22113,18 +22413,29 @@ async function runDoctor(cwd) {
       }
     } catch {}
   }
-  const directNames = new Set([...stillDirect.values()].flat());
-  const directTokens = catalog.capabilities.filter((c) => c.server && directNames.has(c.server)).reduce((sum, c) => sum + c.approxTokens, 0);
-  const loadedSkills = new Set([...stillLoaded.values()].flatMap((x) => x.skills));
-  const skillTokens = catalog.capabilities.filter((c) => c.kind === "skill" && loadedSkills.has(c.name)).reduce((sum, c) => sum + c.approxTokens, 0);
+  const unrealized = (harness) => {
+    const servers = new Set(stillDirect.get(harness) ?? []);
+    const skills = new Set(stillLoaded.get(harness)?.skills ?? []);
+    return catalog.capabilities.filter((c) => c.server && servers.has(c.server) || c.kind === "skill" && skills.has(c.name)).reduce((sum, c) => sum + c.approxTokens, 0);
+  };
   const full = catalog.capabilities.reduce((sum, c) => sum + c.approxTokens, 0);
-  const routerSurface = 700 + tokensOf(promptList(catalog.capabilities));
+  const routerSurface = 700 + tokensOf(promptList(catalog.capabilities, cfg.promptMode));
   lines.push("## Context cost");
   lines.push(`  exposing everything: ~${full.toLocaleString()} tokens`);
-  lines.push(`  router surface:      ~${routerSurface} tokens`);
-  lines.push(`  still loaded direct: ~${(directTokens + skillTokens).toLocaleString()} tokens` + (skillTokens ? ` (${directTokens.toLocaleString()} servers + ${skillTokens.toLocaleString()} skills)` : ""));
-  const saved = full - routerSurface - directTokens - skillTokens;
-  lines.push(saved > 0 ? `  actually saved:      ~${saved.toLocaleString()} tokens per request (${Math.round(saved / full * 100)}%)` : "  actually saved:      nothing yet");
+  lines.push(`  router surface:      ~${routerSurface.toLocaleString()} tokens`);
+  lines.push(`  best case:           ~${(full - routerSurface).toLocaleString()} tokens saved (${Math.round((full - routerSurface) / full * 100)}%)`);
+  lines.push("", "  per harness (a session only ever runs in one):");
+  for (const harness of HARNESSES2) {
+    if (!stillDirect.has(harness) && !stillLoaded.has(harness))
+      continue;
+    const direct = unrealized(harness);
+    const saved = full - routerSurface - direct;
+    lines.push(`    ${harness.padEnd(7)} still loaded ~${direct.toLocaleString()}` + (saved > 0 ? ` → saves ~${saved.toLocaleString()} (${Math.round(saved / full * 100)}%)` : " → saves nothing yet"));
+  }
+  const adopted = HARNESSES2.filter((h) => !stillDirect.has(h) && !stillLoaded.has(h));
+  if (adopted.length) {
+    lines.push(`    ${adopted.join(", ")}: fully adopted → saves ~${(full - routerSurface).toLocaleString()} (${Math.round((full - routerSurface) / full * 100)}%)`);
+  }
   if (stillDirect.size || stillLoaded.size) {
     lines.push("", "## Not yet adopted");
     lines.push("  These are loaded by a harness directly, so they are injected on every");
@@ -22148,6 +22459,7 @@ async function runDoctor(cwd) {
   return lines.join(`
 `);
 }
+var HARNESSES2 = ["claude", "codex", "cursor", "vscode"];
 function truncate2(s, max) {
   return s.length > max ? `${s.slice(0, max - 1)}…` : s;
 }
@@ -22400,7 +22712,7 @@ function summarizeScopes(scope, limit = 6) {
 }
 
 // src/cli.ts
-var VERSION2 = "0.2.0";
+var VERSION2 = "0.2.2";
 var USAGE = `autorouter — one search tool instead of every tool
 
   autorouter serve                     Run as an MCP server over stdio (default)
@@ -22413,6 +22725,10 @@ var USAGE = `autorouter — one search tool instead of every tool
   autorouter login [server]            Authorize an OAuth server (opens a browser);
                                        with no argument, lists what needs one
   autorouter logout <server>           Forget a stored grant
+  autorouter add <name> --url URL      Register a server with the router directly
+  autorouter add <name> -- <cmd> ...   Same, for a stdio server
+  autorouter add --json '<snippet>'    Same, from a pasted mcpServers block
+  autorouter remove <name>             Unregister one
   autorouter init --target <harness>   Register with claude|codex|cursor|vscode
   autorouter adopt --target <harness>  Move that harness's other MCP servers —
                                        and, on Claude Code, its skills and
@@ -22423,6 +22739,9 @@ var USAGE = `autorouter — one search tool instead of every tool
 
 Options
   --raw          search: skip the selector model, show index ranking
+  --url URL      add: an http server
+  --command C    add: a stdio server (or put the command after a bare --)
+  --json SNIPPET add: a pasted {"mcpServers": {...}} block or a bare entry
   --kind K       restrict to tool|skill|prompt|resource|command|agent
   --server S     restrict to one provider
   --limit N      max results
@@ -22442,13 +22761,17 @@ Options
   --scopes S     login: request exactly these scopes (comma or space separated)
   --list-scopes  login: show what the server offers, authorize nothing
 
+\`add\` registers behind the router, so a new server never enters your context.
+Servers added to a harness the normal way (\`claude mcp add\`) are moved behind
+it automatically; set "autoAdopt": false to keep that manual.
+
 Servers like Datadog and Supabase hold no credentials in their config — the
 working token is an OAuth grant the harness keeps privately. The router obtains
 its own grant instead of borrowing one, so \`autorouter login <server>\` is a
 one-time step before those can be adopted.
 `;
 async function main(argv) {
-  const { command, positionals, flags } = parseArgs(argv);
+  const { command, positionals, flags, rest } = parseArgs(argv);
   switch (command) {
     case undefined:
     case "serve":
@@ -22480,6 +22803,11 @@ async function main(argv) {
       return await cmdLogin(positionals[0], flags);
     case "logout":
       return await cmdLogout(positionals[0]);
+    case "add":
+      return await cmdAdd(positionals[0], flags, rest);
+    case "remove":
+    case "rm":
+      return await cmdRemove(positionals[0]);
     case "adopt":
       return await cmdAdopt(flags);
     case "restore": {
@@ -22509,6 +22837,33 @@ ${USAGE}`);
       return 1;
   }
 }
+async function cmdAdd(name, flags, rest) {
+  try {
+    const result = await runAdd({
+      name,
+      url: flags.url,
+      command: flags.command ?? rest[0],
+      args: flags.command ? undefined : rest.slice(1),
+      json: flags.json
+    });
+    console.log(result.message);
+    if (!result.ok && result.path) {
+      console.log("Fix it and re-run, or `autorouter remove` it.");
+    }
+    return result.ok ? 0 : 1;
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+async function cmdRemove(name) {
+  if (!name) {
+    console.error("Usage: autorouter remove <name>");
+    return 1;
+  }
+  console.log(await runRemove(name));
+  return 0;
+}
 async function cmdLogin(server, flags) {
   if (!server) {
     const resolved = await resolveConfig(process.cwd());
@@ -22828,24 +23183,20 @@ function parseArgs(argv) {
   const positionals = [];
   const flags = {};
   let command;
+  let rest = [];
   for (let i = 0;i < argv.length; i++) {
     const arg = argv[i];
+    if (arg === "--") {
+      rest = argv.slice(i + 1);
+      break;
+    }
     if (arg.startsWith("--")) {
       const [name, inline] = splitOnce(arg.slice(2), "=");
       if (!command && (name === "help" || name === "version")) {
         command = `--${name}`;
         continue;
       }
-      const boolean5 = [
-        "raw",
-        "json",
-        "yes",
-        "dry-run",
-        "force",
-        "servers-only",
-        "read-only",
-        "list-scopes"
-      ].includes(name);
+      const boolean5 = ["raw", "json", "yes", "dry-run", "force", "servers-only", "read-only", "list-scopes"].includes(name) && !(name === "json" && command === "add");
       if (boolean5) {
         flags[name] = true;
       } else if (inline !== undefined) {
@@ -22860,7 +23211,7 @@ function parseArgs(argv) {
     else
       positionals.push(arg);
   }
-  return { command, positionals, flags };
+  return { command, positionals, flags, rest };
 }
 function splitOnce(s, sep) {
   const i = s.indexOf(sep);