@topolo/cli 0.9.9 → 0.10.1

package/README.md

@@ -11,7 +11,7 @@ absent.
 - Stored access-token refresh; the `@topolo/mcp` server reads the same credential, so agents need no API-key plumbing.
 - Production credentials by default, with isolated profiles for approved self-hosted environments.
 - **Per-context credentials** — hold and switch between your personal space and multiple organizations with `topolo context`.
-- **One-command agent setup** — `topolo setup` wires the bundled compatible skill + MCP into Claude Code / Codex.
+- **One-command agent setup** — `topolo setup` detects and wires the bundled skill + MCP into Claude Code, Claude Desktop, Codex, Cursor, Grok Build, Gemini CLI, GitHub Copilot/VS Code, Windsurf, Cline, Goose, and Amazon Q Developer.
 - **End-to-end diagnostics** — `topolo doctor` proves authentication and the MCP protocol path.
 - Commands: `auth`, `whoami`, `context`, `setup`, `doctor`, `skills`, `apps`, `services`, `resources`, `workspaces`, credential-scoped `actions`, `oauth`, `integrations`, and generic `api` passthrough.
 
@@ -62,10 +62,11 @@ topolo context ls                          # personal + your orgs, and which is
 topolo context use <organization|personal> # switch (validated + a fresh token minted server-side)
 ```
 
-### Wire into Claude Code / Codex
+### Wire into agent hosts
 
 ```bash
-topolo setup             # copies the skill + registers the exact bundled MCP
+topolo setup             # detects installed local hosts and registers the exact bundled MCP
+topolo setup --all       # configure every supported local host
 topolo doctor            # verifies auth, handshake, tool discovery, and identity
 ```
 
@@ -78,9 +79,18 @@ topolo setup --name topolo-acme --context org:org_acme --env production
 topolo doctor --name topolo-acme
 ```
 
-This creates separately named Claude Code and Codex registrations using the
-same exact nested MCP executable. Reserved operator registrations cannot be
-created or removed by the public CLI.
+This creates native registrations for each detected host using the same exact
+bundled MCP executable. Use `--agent <host>` to target one host explicitly, or
+`--project <dir>` when a host should receive project-scoped MCP and skill files.
+Reserved operator registrations cannot be created or removed by the public CLI.
+
+Host ids accepted by `--agent` are `claude`, `claude-desktop`, `codex`,
+`cursor`, `grok`, `gemini`, `copilot`, `windsurf`, `cline`,
+`goose`, and `amazon-q`.
+
+The local installer does not edit JetBrains AI Assistant settings or web-only
+connectors because those are managed through their own UI or remote connector
+configuration. Use the generated native MCP entry as the import source there.
 
 ## Cross-org isolation
 

package/dist/index.js

@@ -9,7 +9,7 @@ import { platform as platform2 } from "os";
 import { createInterface } from "readline/promises";
 import { stdin as input } from "process";
 
-// ../../../../../TopoloWork2/.worktrees/cli-postinstall-message/packages/topolo-cli/node_modules/@topolo/sdk/dist/index.js
+// node_modules/.pnpm/@topolo+sdk@0.14.4/node_modules/@topolo/sdk/dist/index.js
 function applyAuthHeaders(headers, credential) {
   if (credential.kind === "api_key") {
     headers.set("X-Api-Key", credential.apiKey);
@@ -2948,7 +2948,7 @@ function createTopolo(options) {
   };
 }
 
-// ../../../../../TopoloWork2/.worktrees/cli-postinstall-message/packages/topolo-cli/node_modules/@topolo/sdk/dist/node/credential-store.js
+// node_modules/.pnpm/@topolo+sdk@0.14.4/node_modules/@topolo/sdk/dist/node/credential-store.js
 import { mkdir, readFile, writeFile, chmod, rm, stat } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir, platform } from "os";
@@ -5055,10 +5055,10 @@ function formatCheckResult(result) {
 
 // src/commands/skills.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir2, copyFile, readFile as readFile4, writeFile as writeFile2, rm as rm2, rename } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile5, rm as rm2 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join5, resolve } from "path";
+import { dirname as dirname4, join as join5, resolve } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createRequire } from "module";
 
@@ -5068,6 +5068,45 @@ import { existsSync as existsSync2 } from "fs";
 import { readFile as readFile3 } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { isAbsolute, join as join4 } from "path";
+var SUPPORTED_AGENT_IDS = [
+  "claude",
+  "claude-desktop",
+  "codex",
+  "cursor",
+  "grok",
+  "gemini",
+  "copilot",
+  "windsurf",
+  "cline",
+  "goose",
+  "amazon-q"
+];
+var AGENT_LABELS = {
+  claude: "Claude Code",
+  "claude-desktop": "Claude Desktop",
+  codex: "Codex",
+  cursor: "Cursor",
+  grok: "Grok Build",
+  gemini: "Gemini CLI",
+  copilot: "GitHub Copilot / VS Code",
+  windsurf: "Windsurf",
+  cline: "Cline",
+  goose: "Goose",
+  "amazon-q": "Amazon Q Developer"
+};
+var AGENT_NAME_FOR = {
+  claude: "claude-code",
+  "claude-desktop": "claude-desktop",
+  codex: "codex",
+  cursor: "cursor",
+  grok: "grok",
+  gemini: "gemini",
+  copilot: "github-copilot",
+  windsurf: "windsurf",
+  cline: "cline",
+  goose: "goose",
+  "amazon-q": "amazon-q"
+};
 var RESERVED_OPERATOR_REGISTRATION = ["topolo", "platform"].join("-");
 function isPublicRegistrationName(name) {
   return name === "topolo" || name.startsWith("topolo-") && name !== RESERVED_OPERATOR_REGISTRATION;
@@ -5083,28 +5122,162 @@ function stableNodeCommand() {
   });
   return selectStableNodeCommand(probe.status === 0 ? probe.stdout : void 0);
 }
-function agentSkillPath(agent, homeDir = homedir2()) {
-  return agent === "claude" ? join4(homeDir, ".claude", "skills", "topolo", "SKILL.md") : join4(homeDir, ".codex", "skills", "topolo", "SKILL.md");
-}
-async function readAgentRegistrations(agent, homeDir = homedir2()) {
-  return agent === "claude" ? readClaudeRegistrations(homeDir) : readCodexRegistrations(homeDir);
+function agentSkillPath(agent, homeDir = homedir2(), projectDir) {
+  switch (agent) {
+    case "claude":
+      return projectDir ? join4(projectDir, ".claude", "skills", "topolo", "SKILL.md") : join4(homeDir, ".claude", "skills", "topolo", "SKILL.md");
+    case "claude-desktop":
+      return join4(homeDir, ".claude", "skills", "topolo", "SKILL.md");
+    case "codex":
+      return join4(homeDir, ".codex", "skills", "topolo", "SKILL.md");
+    case "cursor":
+      return join4(projectDir ?? homeDir, ".cursor", "rules", "topolo.mdc");
+    case "grok":
+      return join4(projectDir ?? homeDir, ".grok", "skills", "topolo", "SKILL.md");
+    case "gemini":
+      return join4(projectDir ?? homeDir, ".gemini", "skills", "topolo", "SKILL.md");
+    case "copilot":
+      return projectDir ? join4(projectDir, ".github", "skills", "topolo", "SKILL.md") : join4(homeDir, ".copilot", "skills", "topolo", "SKILL.md");
+    case "windsurf":
+      return projectDir ? join4(projectDir, ".windsurf", "rules", "topolo.md") : void 0;
+    case "cline":
+      return join4(projectDir ?? homeDir, ".cline", "skills", "topolo", "SKILL.md");
+    case "goose":
+    case "amazon-q":
+      return void 0;
+  }
+}
+function agentConfigPaths(agent, homeDir = homedir2(), projectDir) {
+  switch (agent) {
+    case "claude":
+      return [{ path: join4(homeDir, ".claude.json"), format: "json", rootKey: "mcpServers" }];
+    case "claude-desktop":
+      return [{
+        path: claudeDesktopConfigPath(homeDir),
+        format: "json",
+        rootKey: "mcpServers"
+      }];
+    case "codex":
+      return [{ path: join4(homeDir, ".codex", "config.toml"), format: "toml" }];
+    case "cursor":
+      return [{
+        path: projectDir ? join4(projectDir, ".cursor", "mcp.json") : join4(homeDir, ".cursor", "mcp.json"),
+        format: "json",
+        rootKey: "mcpServers"
+      }];
+    case "grok":
+      return [{
+        path: projectDir ? join4(projectDir, ".grok", "config.toml") : join4(homeDir, ".grok", "config.toml"),
+        format: "toml"
+      }];
+    case "gemini":
+      return [{
+        path: projectDir ? join4(projectDir, ".gemini", "settings.json") : join4(homeDir, ".gemini", "settings.json"),
+        format: "json",
+        rootKey: "mcpServers"
+      }];
+    case "copilot":
+      return projectDir ? [
+        { path: join4(projectDir, ".mcp.json"), format: "json", rootKey: "mcpServers" },
+        { path: join4(projectDir, ".vscode", "mcp.json"), format: "json", rootKey: "servers" }
+      ] : [
+        {
+          path: join4(homeDir, ".copilot", "mcp-config.json"),
+          format: "json",
+          rootKey: "mcpServers"
+        },
+        { path: vscodeUserConfigPath(homeDir), format: "json", rootKey: "servers" }
+      ];
+    case "windsurf":
+      return [{
+        path: join4(homeDir, ".codeium", "windsurf", "mcp_config.json"),
+        format: "json",
+        rootKey: "mcpServers"
+      }];
+    case "cline":
+      return [{
+        path: projectDir ? join4(projectDir, ".cline", "mcp.json") : join4(homeDir, ".cline", "mcp.json"),
+        format: "json",
+        rootKey: "mcpServers"
+      }];
+    case "goose":
+      return [{ path: join4(homeDir, ".config", "goose", "config.yaml"), format: "yaml" }];
+    case "amazon-q":
+      if (projectDir) {
+        return [{ path: join4(projectDir, ".amazonq", "mcp.json"), format: "json", rootKey: "mcpServers" }];
+      }
+      return [{
+        path: existsSync2(join4(homeDir, ".aws", "amazonq", "mcp.json")) ? join4(homeDir, ".aws", "amazonq", "mcp.json") : join4(homeDir, ".aws", "amazonq", "default.json"),
+        format: "json",
+        rootKey: "mcpServers"
+      }];
+  }
+}
+function agentCliNames(agent) {
+  switch (agent) {
+    case "claude":
+      return ["claude"];
+    case "claude-desktop":
+      return [];
+    case "codex":
+      return ["codex"];
+    case "cursor":
+      return ["cursor"];
+    case "grok":
+      return ["grok"];
+    case "gemini":
+      return ["gemini"];
+    case "copilot":
+      return ["copilot"];
+    case "windsurf":
+      return ["windsurf"];
+    case "cline":
+      return ["cline"];
+    case "goose":
+      return ["goose"];
+    case "amazon-q":
+      return ["qchat", "q"];
+  }
+}
+function agentConfigExists(agent, homeDir = homedir2(), projectDir) {
+  return agentConfigPaths(agent, homeDir, projectDir).some((config) => existsSync2(config.path));
+}
+function claudeDesktopConfigPath(homeDir) {
+  if (process.platform === "darwin") return join4(homeDir, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (process.platform === "win32") return join4(process.env.APPDATA ?? join4(homeDir, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  return join4(process.env.XDG_CONFIG_HOME ?? join4(homeDir, ".config"), "Claude", "claude_desktop_config.json");
+}
+function vscodeUserConfigPath(homeDir) {
+  if (process.platform === "darwin") return join4(homeDir, "Library", "Application Support", "Code", "User", "mcp.json");
+  if (process.platform === "win32") return join4(process.env.APPDATA ?? join4(homeDir, "AppData", "Roaming"), "Code", "User", "mcp.json");
+  return join4(process.env.XDG_CONFIG_HOME ?? join4(homeDir, ".config"), "Code", "User", "mcp.json");
+}
+async function readAgentRegistrations(agent, homeDir = homedir2(), projectDir) {
+  const registrations = [];
+  for (const config of agentConfigPaths(agent, homeDir, projectDir)) {
+    if (!existsSync2(config.path)) continue;
+    if (config.format === "json") {
+      registrations.push(...await readJsonRegistrations(config.path, config.rootKey ?? "mcpServers", agent));
+    } else if (config.format === "toml") {
+      registrations.push(...await readTomlRegistrations(config.path, agent));
+    } else {
+      registrations.push(...await readGooseRegistrations(config.path));
+    }
+  }
+  return registrations.filter((registration, index, all) => all.findIndex((candidate) => candidate.name === registration.name) === index);
 }
-async function readClaudeRegistrations(homeDir) {
-  const path = join4(homeDir, ".claude.json");
-  if (!existsSync2(path)) return [];
+async function readJsonRegistrations(path, rootKey, agent) {
   let parsed;
   try {
     parsed = JSON.parse(await readFile3(path, "utf8"));
   } catch (error) {
-    throw new Error(`Cannot read malformed Claude configuration at ${path}: ${message(error)}`);
+    throw new Error("Cannot read malformed " + (agent === "claude" ? "Claude" : AGENT_LABELS[agent]) + " configuration at " + path + ": " + message(error));
   }
-  const servers = parsed.mcpServers;
+  const servers = parsed[rootKey];
   if (!servers || typeof servers !== "object" || Array.isArray(servers)) return [];
   return Object.entries(servers).filter(([name]) => isPublicRegistrationName(name)).flatMap(([name, value]) => normalizeRegistration(name, value));
 }
-async function readCodexRegistrations(homeDir) {
-  const path = join4(homeDir, ".codex", "config.toml");
-  if (!existsSync2(path)) return [];
+async function readTomlRegistrations(path, agent) {
   const registrations = /* @__PURE__ */ new Map();
   let section;
   let pending;
@@ -5112,11 +5285,11 @@ async function readCodexRegistrations(homeDir) {
     const line = stripTomlComment(rawLine).trim();
     if (pending) {
       if (line.startsWith("[")) {
-        throw new Error(`Cannot read unsupported MCP value in Codex configuration at ${path}.`);
+        throw new Error("Cannot read unsupported MCP value in " + AGENT_LABELS[agent] + " configuration at " + path + ".");
       }
-      pending.value = `${pending.value} ${line}`;
+      pending.value = pending.value + " " + line;
       if (isTomlValueComplete(pending.value)) {
-        applyCodexAssignment(path, section, pending, registrations);
+        applyTomlAssignment(path, agent, section, pending, registrations);
         pending = void 0;
       }
       continue;
@@ -5136,29 +5309,90 @@ async function readCodexRegistrations(homeDir) {
     if (!section || !isPublicRegistrationName(section.name) || !line || line.startsWith("#")) continue;
     const assignment = line.match(/^([A-Za-z0-9_]+)\s*=\s*(.+)$/);
     if (!assignment) continue;
-    if (!section.env && assignment[1] !== "command" && assignment[1] !== "args") continue;
+    if (!section.env && assignment[1] !== "command" && assignment[1] !== "args" && assignment[1] !== "env") continue;
     pending = { key: assignment[1], value: assignment[2] };
     if (isTomlValueComplete(pending.value)) {
-      applyCodexAssignment(path, section, pending, registrations);
+      applyTomlAssignment(path, agent, section, pending, registrations);
       pending = void 0;
     }
   }
-  if (pending) throw new Error(`Cannot read unsupported MCP value in Codex configuration at ${path}.`);
+  if (pending) throw new Error("Cannot read unsupported MCP value in " + AGENT_LABELS[agent] + " configuration at " + path + ".");
   return [...registrations.values()].filter((registration) => registration.command);
 }
-function applyCodexAssignment(path, section, assignment, registrations) {
+async function readGooseRegistrations(path) {
+  const text = await readFile3(path, "utf8");
+  const registrations = [];
+  const lines = text.split(/\r?\n/);
+  let inExtensions = false;
+  let inTopolo = false;
+  let current;
+  for (const rawLine of lines) {
+    if (/^extensions:\s*$/.test(rawLine)) {
+      inExtensions = true;
+      inTopolo = false;
+      continue;
+    }
+    if (inExtensions && /^\S/.test(rawLine) && rawLine.trim()) {
+      inExtensions = false;
+      inTopolo = false;
+      current = void 0;
+    }
+    if (!inExtensions) continue;
+    const extension = rawLine.match(/^  ([A-Za-z0-9_-]+):\s*$/);
+    if (extension) {
+      inTopolo = true;
+      current = isPublicRegistrationName(extension[1]) ? { name: extension[1], command: "", args: [], env: {} } : void 0;
+      continue;
+    }
+    if (inTopolo && /^\s{2}\S/.test(rawLine) && !/^\s{4}/.test(rawLine)) {
+      inTopolo = false;
+      if (current?.command) registrations.push(current);
+      current = void 0;
+    }
+    if (!inTopolo || !current) continue;
+    const command = rawLine.match(/^\s{4}cmd:\s*(.+)$/);
+    if (command) current.command = parseYamlScalar(command[1]);
+    const args = rawLine.match(/^\s{4}args:\s*\[(.*)\]\s*$/);
+    if (args) current.args = splitYamlArray(args[1]).map(parseYamlScalar);
+    const env = rawLine.match(/^\s{6}([A-Za-z0-9_]+):\s*(.+)$/);
+    if (env) current.env[env[1]] = parseYamlScalar(env[2]);
+  }
+  if (current?.command) registrations.push(current);
+  return registrations;
+}
+function parseYamlScalar(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1).replace(/''/g, "'");
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return trimmed.slice(1, -1);
+    }
+  }
+  return trimmed;
+}
+function splitYamlArray(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function applyTomlAssignment(path, agent, section, assignment, registrations) {
   const registration = registrations.get(section.name);
   let value;
   try {
     value = parseTomlValue(assignment.value);
   } catch {
-    throw new Error(`Cannot read unsupported MCP value in Codex configuration at ${path}.`);
+    throw new Error("Cannot read unsupported MCP value in " + AGENT_LABELS[agent] + " configuration at " + path + ".");
   }
   if (section.env && typeof value === "string") registration.env[assignment.key] = value;
   if (!section.env && assignment.key === "command" && typeof value === "string") registration.command = value;
   if (!section.env && assignment.key === "args" && Array.isArray(value) && value.every((item) => typeof item === "string")) {
     registration.args = value;
   }
+  if (!section.env && assignment.key === "env" && value && typeof value === "object" && !Array.isArray(value)) {
+    registration.env = Object.fromEntries(Object.entries(value).filter(
+      (entry) => typeof entry[1] === "string"
+    ));
+  }
 }
 function stripTomlComment(line) {
   let quote;
@@ -5185,6 +5419,7 @@ function isTomlValueComplete(value) {
   let quote;
   let escaped = false;
   let arrayDepth = 0;
+  let tableDepth = 0;
   for (let index = 0; index < value.length; index += 1) {
     const character = value[index];
     if (quote === '"') {
@@ -5201,8 +5436,10 @@ function isTomlValueComplete(value) {
     if (character === '"' || character === "'") quote = character;
     else if (character === "[") arrayDepth += 1;
     else if (character === "]") arrayDepth -= 1;
+    else if (character === "{") tableDepth += 1;
+    else if (character === "}") tableDepth -= 1;
   }
-  return !quote && arrayDepth === 0;
+  return !quote && arrayDepth === 0 && tableDepth === 0;
 }
 function parseTomlValue(rawValue) {
   const value = rawValue.trim();
@@ -5216,6 +5453,19 @@ function parseTomlValue(rawValue) {
     if (!body) return [];
     return splitTomlArray(body).map((item) => parseTomlValue(item));
   }
+  if (value.startsWith("{") && value.endsWith("}")) {
+    const body = value.slice(1, -1).trim();
+    if (!body) return {};
+    return Object.fromEntries(splitTomlArray(body).map((item) => {
+      const separator = item.indexOf("=");
+      if (separator < 1) throw new Error("Unsupported TOML inline table");
+      const key = item.slice(0, separator).trim();
+      return [
+        key.startsWith('"') && key.endsWith('"') ? parseTomlValue(key) : key,
+        parseTomlValue(item.slice(separator + 1))
+      ];
+    }));
+  }
   throw new Error("Unsupported TOML value");
 }
 function splitTomlArray(value) {
@@ -5224,6 +5474,7 @@ function splitTomlArray(value) {
   let quote;
   let escaped = false;
   let arrayDepth = 0;
+  let tableDepth = 0;
   for (let index = 0; index < value.length; index += 1) {
     const character = value[index];
     if (quote === '"') {
@@ -5240,7 +5491,9 @@ function splitTomlArray(value) {
     if (character === '"' || character === "'") quote = character;
     else if (character === "[") arrayDepth += 1;
     else if (character === "]") arrayDepth -= 1;
-    else if (character === "," && arrayDepth === 0) {
+    else if (character === "{") tableDepth += 1;
+    else if (character === "}") tableDepth -= 1;
+    else if (character === "," && arrayDepth === 0 && tableDepth === 0) {
       const item = value.slice(start, index).trim();
       if (item) items.push(item);
       start = index + 1;
@@ -5262,50 +5515,179 @@ function message(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/commands/skills.ts
-var AGENT_LABELS = { claude: "Claude Code", codex: "Codex" };
-var AGENT_NAME_FOR = { claude: "claude-code", codex: "codex" };
-function skillsSourceDir() {
-  const here = dirname3(fileURLToPath2(import.meta.url));
-  const distCandidate = resolve(here, "../skills");
-  const srcCandidate = resolve(here, "../../skills");
-  for (const candidate of [distCandidate, srcCandidate]) {
-    if (existsSync3(join5(candidate, "topolo", "SKILL.md"))) return candidate;
+// src/commands/agent-config.ts
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir2, readFile as readFile4, rename, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+async function installAgentSkill(agent, source, homeDir, projectDir) {
+  const path = agentSkillPath(agent, homeDir, projectDir);
+  if (!path) return { installed: false };
+  const contents = formatSkillForAgent(agent, source);
+  await atomicWrite(path, contents);
+  return { path, installed: true };
+}
+async function registerAgentConfig(agent, mcp, homeDir, registration, projectDir) {
+  for (const config of agentConfigPaths(agent, homeDir, projectDir)) {
+    if (config.format === "json") {
+      await registerJson(config, agent, mcp, registration);
+    } else if (config.format === "toml") {
+      await registerToml(config.path, agent, mcp, registration);
+    } else {
+      await registerGoose(config.path, mcp, registration);
+    }
   }
-  return distCandidate;
 }
-function resolveMcpCommand() {
-  const require2 = createRequire(import.meta.url);
-  return { command: stableNodeCommand(), args: [require2.resolve("@topolo/mcp/stdio")] };
+async function unregisterAgentConfig(agent, homeDir, name, projectDir) {
+  for (const config of agentConfigPaths(agent, homeDir, projectDir)) {
+    if (!existsSync3(config.path)) continue;
+    if (config.format === "json") {
+      await unregisterJson(config, agent, name);
+    } else if (config.format === "toml") {
+      const text = withoutMcpServerSections(await readFile4(config.path, "utf8"), name);
+      await atomicWrite(config.path, text ? text + "\n" : "");
+    } else {
+      await unregisterGoose(config.path, name);
+    }
+  }
 }
-function agentBinaryExists(bin) {
-  const probe = spawnSync2(process.platform === "win32" ? "where" : "which", [bin], {
-    stdio: "ignore"
-  });
-  return probe.status === 0;
+function registrationEnvironment(agent, registration) {
+  return {
+    TOPOLO_AGENT_NAME: AGENT_NAME_FOR[agent],
+    ...registration.context ? { TOPOLO_CONTEXT: registration.context, TOPOLO_ENV: registration.environment } : {}
+  };
 }
-function claudeSkillDir(projectDir, homeDir = homedir3()) {
-  const base = projectDir ? resolve(projectDir, ".claude") : join5(homeDir, ".claude");
-  return join5(base, "skills", "topolo");
+async function registerJson(config, agent, mcp, registration) {
+  let parsed = {};
+  if (existsSync3(config.path)) {
+    try {
+      parsed = JSON.parse(await readFile4(config.path, "utf8"));
+    } catch (error) {
+      throw new Error(
+        "Cannot update malformed " + (agent === "claude" ? "Claude" : AGENT_LABELS[agent]) + " configuration at " + config.path + ": " + (error instanceof Error ? error.message : String(error))
+      );
+    }
+  }
+  const rootKey = config.rootKey ?? "mcpServers";
+  const existingServers = parsed[rootKey];
+  if (existingServers !== void 0 && (!existingServers || typeof existingServers !== "object" || Array.isArray(existingServers))) {
+    throw new Error("Cannot update malformed " + AGENT_LABELS[agent] + " MCP configuration at " + config.path + ".");
+  }
+  const servers = existingServers ?? {};
+  const entry = {
+    command: mcp.command,
+    args: mcp.args,
+    env: registrationEnvironment(agent, registration)
+  };
+  if (agent === "claude" || agent === "claude-desktop" || rootKey === "servers") entry.type = "stdio";
+  servers[registration.name] = entry;
+  parsed[rootKey] = servers;
+  await atomicWrite(config.path, JSON.stringify(parsed, null, 2) + "\n");
 }
-function codexSkillDir(homeDir = homedir3()) {
-  return join5(homeDir, ".codex", "skills", "topolo");
+async function unregisterJson(config, agent, name) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile4(config.path, "utf8"));
+  } catch (error) {
+    throw new Error(
+      "Cannot update malformed " + AGENT_LABELS[agent] + " configuration at " + config.path + ": " + (error instanceof Error ? error.message : String(error))
+    );
+  }
+  const rootKey = config.rootKey ?? "mcpServers";
+  const existingServers = parsed[rootKey];
+  if (existingServers !== void 0 && (!existingServers || typeof existingServers !== "object" || Array.isArray(existingServers))) {
+    throw new Error("Cannot update malformed " + AGENT_LABELS[agent] + " MCP configuration at " + config.path + ".");
+  }
+  const servers = existingServers ?? {};
+  delete servers[name];
+  parsed[rootKey] = servers;
+  await atomicWrite(config.path, JSON.stringify(parsed, null, 2) + "\n");
+}
+async function registerToml(path, agent, mcp, registration) {
+  const existing = existsSync3(path) ? await readFile4(path, "utf8") : "";
+  const text = withoutMcpServerSections(existing, registration.name);
+  const args = mcp.args.length ? "\nargs = [" + mcp.args.map((item) => JSON.stringify(item)).join(", ") + "]" : "";
+  const environment = registrationEnvironment(agent, registration);
+  const environmentText = Object.entries(environment).map(([key, value]) => JSON.stringify(key) + " = " + JSON.stringify(value)).join(", ");
+  const block = agent === "grok" ? "\n\n[mcp_servers." + registration.name + "]\ncommand = " + JSON.stringify(mcp.command) + args + "\nenv = { " + environmentText + " }\n" : "\n\n[mcp_servers." + registration.name + "]\ncommand = " + JSON.stringify(mcp.command) + args + "\n\n[mcp_servers." + registration.name + ".env]\n" + Object.entries(environment).map(([key, value]) => key + " = " + JSON.stringify(value)).join("\n") + "\n";
+  await atomicWrite(path, text + block);
+}
+async function registerGoose(path, mcp, registration) {
+  const existing = existsSync3(path) ? await readFile4(path, "utf8") : "";
+  const withoutTopolo = removeGooseExtension(existing, registration.name);
+  const environment = registrationEnvironment("goose", registration);
+  const block = [
+    "  " + registration.name + ":",
+    "    name: Topolo",
+    "    cmd: " + yamlScalar(mcp.command),
+    "    args: [" + mcp.args.map(yamlScalar).join(", ") + "]",
+    "    enabled: true",
+    "    type: stdio",
+    "    timeout: 300",
+    "    envs:",
+    ...Object.entries(environment).map(([key, value]) => "      " + key + ": " + yamlScalar(value))
+  ].join("\n");
+  await atomicWrite(path, insertGooseExtension(withoutTopolo, block));
 }
-async function installSkillFile(sourceDir, targetDir) {
-  await mkdir2(targetDir, { recursive: true });
-  const target = join5(targetDir, "SKILL.md");
-  await copyFile(join5(sourceDir, "topolo", "SKILL.md"), target);
-  return target;
+async function unregisterGoose(path, name) {
+  const existing = await readFile4(path, "utf8");
+  await atomicWrite(path, removeGooseExtension(existing, name));
+}
+function removeGooseExtension(text, name) {
+  const lines = text.split(/\r?\n/);
+  const kept = [];
+  let inExtensions = false;
+  let skipping = false;
+  for (const line of lines) {
+    if (/^extensions:\s*$/.test(line)) {
+      inExtensions = true;
+      kept.push(line);
+      continue;
+    }
+    if (inExtensions && /^\S/.test(line) && line.trim()) inExtensions = false;
+    if (inExtensions && line.trim() === name + ":") {
+      skipping = true;
+      continue;
+    }
+    if (skipping && inExtensions && /^  \S/.test(line) && !/^\s{4}/.test(line)) skipping = false;
+    if (!skipping) kept.push(line);
+  }
+  return kept.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+function insertGooseExtension(text, block) {
+  if (!text.trim()) return "extensions:\n" + block + "\n";
+  const lines = text.split(/\r?\n/);
+  const extensionIndex = lines.findIndex((line) => /^extensions:\s*$/.test(line));
+  if (extensionIndex < 0) return text.trimEnd() + "\n\nextensions:\n" + block + "\n";
+  let end = lines.length;
+  for (let index = extensionIndex + 1; index < lines.length; index += 1) {
+    if (/^\S/.test(lines[index]) && lines[index].trim()) {
+      end = index;
+      break;
+    }
+  }
+  lines.splice(end, 0, block);
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+function yamlScalar(value) {
+  return "'" + value.replace(/'/g, "''") + "'";
+}
+function formatSkillForAgent(agent, source) {
+  if (agent !== "cursor" && agent !== "windsurf") return source;
+  const body = source.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
+  if (agent === "cursor") {
+    return "---\ndescription: Use Topolo MCP for Topolo platform operations.\nalwaysApply: false\n---\n\n" + body;
+  }
+  return "---\ntrigger: model_decision\ndescription: Use Topolo MCP for Topolo platform operations.\n---\n\n" + body;
 }
 async function atomicWrite(path, contents) {
   await mkdir2(dirname3(path), { recursive: true });
-  const temporaryPath = `${path}.topolo-${process.pid}.tmp`;
+  const temporaryPath = path + ".topolo-" + process.pid + ".tmp";
   await writeFile2(temporaryPath, contents, { encoding: "utf8", mode: 384 });
   await rename(temporaryPath, path);
 }
 function withoutMcpServerSections(text, name) {
-  const section = `[mcp_servers.${name}]`;
-  const environmentSection = `[mcp_servers.${name}.env]`;
+  const section = "[mcp_servers." + name + "]";
+  const environmentSection = "[mcp_servers." + name + ".env]";
   let skipping = false;
   return text.split(/\r?\n/).filter((line) => {
     const trimmed = line.trim();
@@ -5317,48 +5699,29 @@ function withoutMcpServerSections(text, name) {
     return !skipping;
   }).join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
 }
-async function registerClaudeViaConfig(mcp, homeDir, registration) {
-  const path = join5(homeDir, ".claude.json");
-  let config = {};
-  if (existsSync3(path)) {
-    try {
-      config = JSON.parse(await readFile4(path, "utf8"));
-    } catch (error) {
-      throw new Error(`Cannot update malformed Claude configuration at ${path}: ${error instanceof Error ? error.message : String(error)}`);
-    }
+
+// src/commands/skills.ts
+var AGENT_LABELS2 = AGENT_LABELS;
+function skillsSourceDir() {
+  const here = dirname4(fileURLToPath2(import.meta.url));
+  const distCandidate = resolve(here, "../skills");
+  const srcCandidate = resolve(here, "../../skills");
+  for (const candidate of [distCandidate, srcCandidate]) {
+    if (existsSync4(join5(candidate, "topolo", "SKILL.md"))) return candidate;
   }
-  const servers = config.mcpServers ?? {};
-  servers[registration.name] = {
-    type: "stdio",
-    command: mcp.command,
-    args: mcp.args,
-    env: registrationEnvironment(AGENT_NAME_FOR.claude, registration)
-  };
-  config.mcpServers = servers;
-  await atomicWrite(path, `${JSON.stringify(config, null, 2)}
-`);
+  return distCandidate;
 }
-async function registerCodexViaConfig(mcp, homeDir, registration) {
-  const path = join5(homeDir, ".codex", "config.toml");
-  let text = "";
-  if (existsSync3(path)) text = await readFile4(path, "utf8");
-  text = withoutMcpServerSections(text, registration.name);
-  const argsToml = mcp.args.length ? `
-args = [${mcp.args.map((a) => `"${a}"`).join(", ")}]` : "";
-  const block = `
-
-[mcp_servers.${registration.name}]
-command = ${JSON.stringify(mcp.command)}${argsToml}
-
-[mcp_servers.${registration.name}.env]
-` + Object.entries(registrationEnvironment(AGENT_NAME_FOR.codex, registration)).map(([key, value]) => `${key} = ${JSON.stringify(value)}`).join("\n") + "\n";
-  await atomicWrite(path, `${text}${block}`);
+function resolveMcpCommand() {
+  const require2 = createRequire(import.meta.url);
+  return { command: stableNodeCommand(), args: [require2.resolve("@topolo/mcp/stdio")] };
 }
-function registrationEnvironment(agentName, registration) {
-  return {
-    TOPOLO_AGENT_NAME: agentName,
-    ...registration.context ? { TOPOLO_CONTEXT: registration.context, TOPOLO_ENV: registration.environment } : {}
-  };
+function agentBinaryExists(agent) {
+  return agentCliNames(agent).some((bin) => {
+    const probe = spawnSync2(process.platform === "win32" ? "where" : "which", [bin], {
+      stdio: "ignore"
+    });
+    return probe.status === 0;
+  });
 }
 function resolveMcpRegistration(options) {
   const name = options.name?.trim() || "topolo";
@@ -5382,57 +5745,54 @@ function resolveMcpRegistration(options) {
   }
   return { name, ...context ? { context } : {}, environment };
 }
-async function unregisterFromConfig(agent, homeDir, name) {
-  if (agent === "claude") {
-    const path2 = join5(homeDir, ".claude.json");
-    if (!existsSync3(path2)) return;
-    const config = JSON.parse(await readFile4(path2, "utf8"));
-    const servers = config.mcpServers ?? {};
-    delete servers[name];
-    config.mcpServers = servers;
-    await atomicWrite(path2, `${JSON.stringify(config, null, 2)}
-`);
-    return;
-  }
-  const path = join5(homeDir, ".codex", "config.toml");
-  if (!existsSync3(path)) return;
-  const text = withoutMcpServerSections(await readFile4(path, "utf8"), name);
-  await atomicWrite(path, text ? `${text}
-` : "");
-}
 async function installForAgent(agent, sourceDir, mcp, opts) {
-  const skillDir = agent === "claude" ? claudeSkillDir(opts.projectDir, opts.homeDir) : codexSkillDir(opts.homeDir);
-  const skillPath = await installSkillFile(sourceDir, skillDir);
+  const source = await readFile5(join5(sourceDir, "topolo", "SKILL.md"), "utf8");
+  const skill = await installAgentSkill(agent, source, opts.homeDir, opts.projectDir);
   if (!opts.withMcp) {
-    return { agent, skillPath, skillInstalled: true, mcp: "skipped" };
+    return { agent, skillPath: skill.path, skillInstalled: skill.installed, mcp: "skipped" };
   }
   try {
-    if (agent === "claude") await registerClaudeViaConfig(mcp, opts.homeDir, opts.registration);
-    else await registerCodexViaConfig(mcp, opts.homeDir, opts.registration);
-    const installed = (await readAgentRegistrations(agent, opts.homeDir)).find((registration) => registration.name === opts.registration.name);
-    const expectedEnvironment = registrationEnvironment(AGENT_NAME_FOR[agent], opts.registration);
+    await registerAgentConfig(agent, mcp, opts.homeDir, opts.registration, opts.projectDir);
+    const installed = (await readAgentRegistrations(agent, opts.homeDir, opts.projectDir)).find((registration) => registration.name === opts.registration.name);
+    const expectedEnvironment = registrationEnvironment(agent, opts.registration);
     if (!installed || installed.command !== mcp.command || JSON.stringify(installed.args) !== JSON.stringify(mcp.args) || Object.entries(expectedEnvironment).some(([key, value]) => installed.env[key] !== value)) {
       throw new Error(`Host configuration did not retain the ${opts.registration.name} MCP registration.`);
     }
-    return { agent, skillPath, skillInstalled: true, mcp: "config-file" };
+    return { agent, skillPath: skill.path, skillInstalled: skill.installed, mcp: "config-file" };
   } catch (err) {
     return {
       agent,
-      skillPath,
-      skillInstalled: true,
+      skillPath: skill.path,
+      skillInstalled: skill.installed,
       mcp: "failed",
       detail: err instanceof Error ? err.message : String(err)
     };
   }
 }
 function resolveTargets(opts) {
-  if (opts.claude && !opts.codex) return ["claude"];
-  if (opts.codex && !opts.claude) return ["codex"];
-  return ["claude", "codex"];
+  const explicit = [
+    ...opts.agents ?? [],
+    ...opts.agent ?? [],
+    ...opts.claude ? ["claude"] : [],
+    ...opts.codex ? ["codex"] : []
+  ];
+  if (explicit.length) {
+    return [...new Set(explicit.map((value) => {
+      if (!SUPPORTED_AGENT_IDS.includes(value)) {
+        throw new Error('Unsupported agent host "' + value + '". Supported hosts: ' + SUPPORTED_AGENT_IDS.join(", ") + ".");
+      }
+      return value;
+    }))];
+  }
+  if (opts.all) return [...SUPPORTED_AGENT_IDS];
+  const homeDir = opts.homeDir ?? homedir3();
+  const detectBinaries = homeDir === homedir3();
+  const detected = SUPPORTED_AGENT_IDS.filter((agent) => agentConfigExists(agent, homeDir, opts.project) || detectBinaries && agentBinaryExists(agent));
+  return [.../* @__PURE__ */ new Set(["claude", "codex", ...detected])];
 }
 function registerSkillsCommand(program2) {
-  const skills = program2.command("skills").description("Install the Topolo agent skill + MCP server into Claude Code / Codex");
-  skills.command("install").description("Copy the skill file and register the topolo MCP server (credential-free)").option("--claude", "Target Claude Code only").option("--codex", "Target Codex only").option("--project <dir>", "Install the Claude skill into <dir>/.claude instead of ~/.claude").option("--agent-home <dir>", "Target an alternate agent home (managed installs and clean-room verification)").option("--name <name>", "Register a named pinned MCP, such as topolo-acme").option("--context <context>", "Pin the named MCP to an exact context returned by topolo context ls").option("--no-mcp", "Copy the skill file but do not register the MCP server").option("--json", "Output JSON", true).option("--no-json", "Output human-readable text").action(
+  const skills = program2.command("skills").description("Install the Topolo agent skill + MCP server into supported agent hosts");
+  skills.command("install").description("Copy the skill file and register the topolo MCP server (credential-free)").option("--claude", "Target Claude Code only").option("--codex", "Target Codex only").option("--agent <host...>", "Target one or more hosts by id (for example cursor gemini)").option("--all", "Configure every supported local host").option("--project <dir>", "Write project-scoped host files under <dir> where supported").option("--agent-home <dir>", "Target an alternate agent home (managed installs and clean-room verification)").option("--name <name>", "Register a named pinned MCP, such as topolo-acme").option("--context <context>", "Pin the named MCP to an exact context returned by topolo context ls").option("--no-mcp", "Copy the skill file but do not register the MCP server").option("--json", "Output JSON", true).option("--no-json", "Output human-readable text").action(
     async (opts) => {
       const mode = resolveOutputMode(opts.json);
       try {
@@ -5444,19 +5804,22 @@ function registerSkillsCommand(program2) {
       }
     }
   );
-  skills.command("status").description("List public Topolo skill and MCP registrations for each agent").option("--agent-home <dir>", "Inspect an alternate agent home").option("--name <name>", "Inspect one registration name").option("--json", "Output JSON", true).option("--no-json", "Output human-readable text").action(async (opts) => {
+  skills.command("status").description("List public Topolo skill and MCP registrations for each agent").option("--agent <host...>", "Inspect one or more hosts by id").option("--all", "Inspect every supported host").option("--project <dir>", "Inspect project-scoped host files under <dir>").option("--agent-home <dir>", "Inspect an alternate agent home").option("--name <name>", "Inspect one registration name").option("--json", "Output JSON", true).option("--no-json", "Output human-readable text").action(async (opts) => {
     const mode = resolveOutputMode(opts.json);
     try {
       const rows = await agentSurfaceStatus({
         homeDir: opts.agentHome ? resolve(opts.agentHome) : void 0,
-        name: opts.name
+        name: opts.name,
+        agent: opts.agent,
+        all: opts.all,
+        project: opts.project
       });
       emit({ agents: rows }, mode, () => formatStatus(rows));
     } catch (err) {
       fail(err, mode);
     }
   });
-  skills.command("uninstall").description("Remove the skill file and MCP registration for each agent").option("--claude", "Target Claude Code only").option("--codex", "Target Codex only").option("--agent-home <dir>", "Target an alternate agent home (managed installs and clean-room verification)").option("--name <name>", "Remove one registration (defaults to topolo)").option("--json", "Output JSON", true).option("--no-json", "Output human-readable text").action(async (opts) => {
+  skills.command("uninstall").description("Remove the skill file and MCP registration for each agent").option("--claude", "Target Claude Code only").option("--codex", "Target Codex only").option("--agent <host...>", "Target one or more hosts by id").option("--all", "Remove from every supported host").option("--project <dir>", "Remove project-scoped host files under <dir>").option("--agent-home <dir>", "Target an alternate agent home (managed installs and clean-room verification)").option("--name <name>", "Remove one registration (defaults to topolo)").option("--json", "Output JSON", true).option("--no-json", "Output human-readable text").action(async (opts) => {
     const mode = resolveOutputMode(opts.json);
     try {
       const removed = await uninstallAgentSurfaces({
@@ -5466,7 +5829,7 @@ function registerSkillsCommand(program2) {
       emit(
         { removed },
         mode,
-        () => removed.map((r) => `${AGENT_LABELS[r.agent]}: ${r.name} removed=${r.registrationRemoved}, skill removed=${r.skillRemoved}`).join("\n")
+        () => removed.map((r) => `${AGENT_LABELS2[r.agent]}: ${r.name} removed=${r.registrationRemoved}, skill removed=${r.skillRemoved}`).join("\n")
       );
     } catch (err) {
       fail(err, mode);
@@ -5475,14 +5838,14 @@ function registerSkillsCommand(program2) {
 }
 async function installAgentSurfaces(opts) {
   const sourceDir = skillsSourceDir();
-  if (!existsSync3(join5(sourceDir, "topolo", "SKILL.md"))) {
+  if (!existsSync4(join5(sourceDir, "topolo", "SKILL.md"))) {
     throw new Error("Bundled skill file not found. Reinstall the CLI: npm install -g @topolo/cli");
   }
   const mcp = resolveMcpCommand();
   const registration = resolveMcpRegistration(opts);
   const homeDir = opts.homeDir ?? homedir3();
   const results = [];
-  for (const agent of resolveTargets(opts)) {
+  for (const agent of resolveTargets({ ...opts, homeDir, project: opts.project })) {
     results.push(await installForAgent(agent, sourceDir, mcp, {
       withMcp: opts.mcp !== false,
       projectDir: opts.project,
@@ -5493,7 +5856,7 @@ async function installAgentSurfaces(opts) {
   return { results, mcp };
 }
 function registerSetupCommand(program2) {
-  program2.command("setup").description("Install the Topolo skill and deterministic local MCP server for supported agent hosts").option("--claude", "Target Claude Code only").option("--codex", "Target Codex only").option("--agent-home <dir>", "Target an alternate agent home (managed installs and clean-room verification)").option("--name <name>", "Register a named pinned MCP, such as topolo-acme").option("--context <context>", "Pin the named MCP to an exact context returned by topolo context ls").option("--json", "Output JSON", true).option("--no-json", "Output human-readable text").action(async (opts) => {
+  program2.command("setup").description("Install the Topolo skill and deterministic local MCP server for supported agent hosts").option("--claude", "Target Claude Code only").option("--codex", "Target Codex only").option("--agent <host...>", "Target one or more hosts by id").option("--all", "Configure every supported local host").option("--project <dir>", "Write project-scoped host files under <dir> where supported").option("--agent-home <dir>", "Target an alternate agent home (managed installs and clean-room verification)").option("--name <name>", "Register a named pinned MCP, such as topolo-acme").option("--context <context>", "Pin the named MCP to an exact context returned by topolo context ls").option("--json", "Output JSON", true).option("--no-json", "Output human-readable text").action(async (opts) => {
     const mode = resolveOutputMode(opts.json);
     try {
       const { results, mcp } = await installAgentSurfaces({ ...opts, homeDir: opts.agentHome });
@@ -5507,20 +5870,27 @@ function registerSetupCommand(program2) {
 function assertAgentSetupSucceeded(results) {
   const failed = results.filter((result) => result.mcp === "failed");
   if (failed.length) {
-    throw new Error(failed.map((result) => `${AGENT_LABELS[result.agent]}: ${result.detail ?? "MCP registration failed"}`).join("; "));
+    throw new Error(failed.map((result) => `${AGENT_LABELS2[result.agent]}: ${result.detail ?? "MCP registration failed"}`).join("; "));
   }
 }
 async function agentSurfaceStatus(options = {}) {
   const homeDir = options.homeDir ?? homedir3();
-  const sourceSkill = await readFile4(join5(skillsSourceDir(), "topolo", "SKILL.md"), "utf8");
-  return Promise.all(["claude", "codex"].map(async (agent) => {
-    const skillPath = agentSkillPath(agent, homeDir);
-    const installedSkill = existsSync3(skillPath) ? await readFile4(skillPath, "utf8") : void 0;
-    const registrations = (await readAgentRegistrations(agent, homeDir)).filter((registration) => !options.name || registration.name === options.name);
+  const sourceSkill = await readFile5(join5(skillsSourceDir(), "topolo", "SKILL.md"), "utf8");
+  const agents = resolveTargets({
+    agent: options.agent,
+    all: options.all,
+    homeDir,
+    project: options.project
+  });
+  return Promise.all(agents.map(async (agent) => {
+    const skillPath = agentSkillPath(agent, homeDir, options.project);
+    const installedSkill = skillPath && existsSync4(skillPath) ? await readFile5(skillPath, "utf8") : void 0;
+    const registrations = (await readAgentRegistrations(agent, homeDir, options.project)).filter((registration) => !options.name || registration.name === options.name);
     return {
       agent,
       skillInstalled: installedSkill !== void 0,
-      skillCurrent: installedSkill === sourceSkill,
+      skillCurrent: !skillPath || (agent === "cursor" || agent === "windsurf" ? Boolean(installedSkill?.includes("Topolo")) : installedSkill === sourceSkill),
+      skillSupported: Boolean(skillPath),
       skillPath,
       cliAvailable: agentBinaryExists(agent),
       registrations
@@ -5532,14 +5902,14 @@ async function uninstallAgentSurfaces(options) {
   const name = options.name?.trim() || "topolo";
   resolveMcpRegistration({ name, ...name === "topolo" ? {} : { context: "uninstall-validation" } });
   const removed = [];
-  for (const agent of resolveTargets(options)) {
-    const before = await readAgentRegistrations(agent, homeDir);
+  for (const agent of resolveTargets({ ...options, homeDir, project: options.project })) {
+    const before = await readAgentRegistrations(agent, homeDir, options.project);
     const registrationRemoved = before.some((entry) => entry.name === name);
-    await unregisterFromConfig(agent, homeDir, name);
-    const remaining = await readAgentRegistrations(agent, homeDir);
-    const skillPath = agentSkillPath(agent, homeDir);
-    const skillRemoved = remaining.length === 0 && existsSync3(skillPath);
-    if (skillRemoved) await rm2(dirname3(skillPath), { recursive: true, force: true });
+    await unregisterAgentConfig(agent, homeDir, name, options.project);
+    const remaining = await readAgentRegistrations(agent, homeDir, options.project);
+    const skillPath = agentSkillPath(agent, homeDir, options.project);
+    const skillRemoved = remaining.length === 0 && Boolean(skillPath && existsSync4(skillPath));
+    if (skillRemoved && skillPath) await rm2(dirname4(skillPath), { recursive: true, force: true });
     removed.push({ agent, name, registrationRemoved, skillRemoved });
   }
   return removed;
@@ -5548,8 +5918,8 @@ function formatInstall(results, mcp) {
   const lines = [];
   const mcpStr = [mcp.command, ...mcp.args].join(" ");
   for (const r of results) {
-    lines.push(`${AGENT_LABELS[r.agent]}:`);
-    lines.push(`  skill -> ${r.skillPath}`);
+    lines.push(`${AGENT_LABELS2[r.agent]}:`);
+    lines.push(r.skillPath ? `  skill -> ${r.skillPath}` : "  skill -> host-managed (MCP only)");
     if (r.mcp === "official-cli") lines.push(`  MCP registered via \`${r.agent} mcp add\` (${mcpStr})`);
     else if (r.mcp === "config-file") lines.push(`  MCP registered by editing the config file (${mcpStr})`);
     else if (r.mcp === "skipped") lines.push("  MCP registration skipped (--no-mcp)");
@@ -5563,7 +5933,7 @@ function formatInstall(results, mcp) {
 }
 function formatStatus(rows) {
   return rows.map(
-    (r) => `${AGENT_LABELS[r.agent]}: skill ${r.skillInstalled ? r.skillCurrent ? "current" : "stale" : "not installed"} (${r.skillPath}), ${r.agent} CLI ${r.cliAvailable ? "available" : "not found"}, MCP registrations: ${r.registrations.map((registration) => registration.name).join(", ") || "none"}`
+    (r) => `${AGENT_LABELS2[r.agent]}: skill ${!r.skillPath ? "host-managed" : r.skillInstalled ? r.skillCurrent ? "current" : "stale" : "not installed"} (${r.skillPath ?? "native host surface"}), ${r.agent} CLI ${r.cliAvailable ? "available" : "not found"}, MCP registrations: ${r.registrations.map((registration) => registration.name).join(", ") || "none"}`
   ).join("\n");
 }
 
@@ -5634,15 +6004,19 @@ async function resolveInstalledDoctorTarget(options) {
   const name = options.name?.trim() || "topolo";
   const homeDir = options.agentHome ? resolve2(options.agentHome) : homedir4();
   const expected = resolveMcpCommand();
-  const requestedAgents = options.claude && !options.codex ? ["claude"] : options.codex && !options.claude ? ["codex"] : ["claude", "codex"];
-  const rows = (await agentSurfaceStatus({ homeDir, name })).filter((row) => requestedAgents.includes(row.agent));
+  const requestedAgents = resolveTargets({
+    ...options,
+    homeDir,
+    project: options.project
+  });
+  const rows = (await agentSurfaceStatus({ homeDir, name, agent: requestedAgents, project: options.project })).filter((row) => requestedAgents.includes(row.agent));
   const preflightChecks = [];
   let selected = rows.flatMap((row) => row.registrations)[0];
   for (const row of rows) {
     preflightChecks.push({
       name: "skill",
-      ok: row.skillCurrent,
-      detail: `${row.agent}: ${row.skillCurrent ? "bundled skill is current" : row.skillInstalled ? "installed skill is stale" : "skill is missing"}`
+      ok: !row.skillPath || row.skillCurrent,
+      detail: `${row.agent}: ${!row.skillPath ? "host-managed skill surface" : row.skillCurrent ? "bundled skill is current" : row.skillInstalled ? "installed skill is stale" : "skill is missing"}`
     });
     const registration = row.registrations.find((entry) => entry.name === name);
     const exact = Boolean(
@@ -5669,7 +6043,7 @@ function definedEnvironment(environment) {
   return Object.fromEntries(Object.entries(environment).filter((entry) => entry[1] !== void 0));
 }
 function registerDoctorCommand(program2) {
-  program2.command("doctor").description("Verify installed agent surfaces, exact credential, and MCP protocol end to end").option("--name <name>", "Verify one installed MCP registration (defaults to topolo)").option("--context <context>", "Verify one exact personal or organization context").option("--environment <env>", "Override the context environment").option("--claude", "Verify Claude Code only").option("--codex", "Verify Codex only").option("--agent-home <dir>", "Inspect an alternate agent home").option("--json", "Output JSON", true).option("--no-json", "Output human-readable text").action(async (opts) => {
+  program2.command("doctor").description("Verify installed agent surfaces, exact credential, and MCP protocol end to end").option("--name <name>", "Verify one installed MCP registration (defaults to topolo)").option("--context <context>", "Verify one exact personal or organization context").option("--environment <env>", "Override the context environment").option("--claude", "Verify Claude Code only").option("--codex", "Verify Codex only").option("--agent <host...>", "Verify one or more hosts by id").option("--all", "Verify every supported local host").option("--project <dir>", "Inspect project-scoped host files under <dir>").option("--agent-home <dir>", "Inspect an alternate agent home").option("--json", "Output JSON", true).option("--no-json", "Output human-readable text").action(async (opts) => {
     const mode = resolveOutputMode(opts.json);
     try {
       const target = await resolveInstalledDoctorTarget(opts);
@@ -5713,8 +6087,15 @@ async function fetchMe(credential, serviceUrls) {
   const user = data.user ?? {};
   const rawMemberships = user.organizationMemberships || data.organizations || [];
   const memberships = rawMemberships.filter((m) => m && m.id);
-  const activeType = user.orgId ? "organization" : "personal";
-  return { memberships, activeType, activeOrgId: user.orgId || void 0 };
+  const availableContexts = Array.isArray(user.availableContexts) ? user.availableContexts : [];
+  const activeType = user.activeContextType === "personal" ? "personal" : "organization";
+  const activeOrgId = activeType === "organization" ? user.activeContextId || void 0 : void 0;
+  return {
+    memberships,
+    activeType,
+    activeOrgId,
+    personalAvailable: availableContexts.some((candidate) => candidate?.type === "personal")
+  };
 }
 function credentialFromTokens(tokens) {
   const accessToken = tokens.accessToken || tokens.access_token;
@@ -5758,7 +6139,7 @@ function hasSameAccessToken(left, right) {
   return leftCredential?.kind === "access_token" && rightCredential?.kind === "access_token" && leftCredential.accessToken === rightCredential.accessToken;
 }
 function identityMatchesContext(me, context) {
-  if (context.contextType === "personal") return me.activeType === "personal";
+  if (context.contextType === "personal") return me.personalAvailable && me.activeType === "personal";
   return me.activeType === "organization" && me.activeOrgId === context.organizationId;
 }
 function registerContextCommand(program2) {
@@ -5773,6 +6154,7 @@ function registerContextCommand(program2) {
       const activeKey = profile.activeContext;
       const rows = /* @__PURE__ */ new Map();
       for (const [key, ctx] of Object.entries(stored)) {
+        if (ctx.contextType === "personal") continue;
         rows.set(key, {
           key,
           type: ctx.contextType,
@@ -5798,15 +6180,22 @@ function registerContextCommand(program2) {
           if (!contextCredential) return;
           const identity = key === activeKey && activeIdentity ? activeIdentity : await fetchMe(contextCredential, serviceUrls);
           if (!identityMatchesContext(identity, ctx)) return;
-          const row = rows.get(key);
-          if (row) rows.set(key, { ...row, signedIn: true, available: true });
+          const row = rows.get(key) ?? {
+            key,
+            type: ctx.contextType,
+            label: labelFor(ctx),
+            signedIn: false,
+            available: false,
+            active: key === activeKey
+          };
+          rows.set(key, { ...row, signedIn: true, available: true });
         } catch {
         }
       }));
       if (activeIdentity) {
         try {
           const personalKey = contextKey("personal");
-          if (!rows.has(personalKey)) {
+          if (activeIdentity.personalAvailable && !rows.has(personalKey)) {
             rows.set(personalKey, {
               key: personalKey,
               type: "personal",
@@ -5815,7 +6204,7 @@ function registerContextCommand(program2) {
               available: true,
               active: personalKey === activeKey
             });
-          } else {
+          } else if (activeIdentity.personalAvailable) {
             const row = rows.get(personalKey);
             rows.set(personalKey, { ...row, available: true });
           }
@@ -5891,8 +6280,9 @@ function registerContextCommand(program2) {
         );
         if (!match) {
           const names = me.memberships.map((m) => m.slug || m.name || m.id);
+          const available = [me.personalAvailable ? "personal" : "", ...names].filter(Boolean);
           throw new Error(
-            `You are not a member of "${target}". Available: personal${names.length ? ", " + names.join(", ") : ""}.`
+            `You are not a member of "${target}". Available: ${available.join(", ") || "none"}.`
           );
         }
         resolved = {
@@ -5918,6 +6308,12 @@ function registerContextCommand(program2) {
         }
       }
       if (!newCredential) {
+        if (resolved.contextType === "personal") {
+          const identity = await fetchMe(cred, serviceUrls);
+          if (!identity.personalAvailable) {
+            throw new Error("Personal context is not available for this account.");
+          }
+        }
         try {
           newCredential = await exchangeForContext(cred, serviceUrls, {
             type: resolved.contextType,

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@topolo/cli",
-  "version": "0.9.9",
-  "topoloPublishedVersion": "0.9.9",
+  "packageManager": "pnpm@10.17.1",
+  "version": "0.10.1",
+  "topoloPublishedVersion": "0.10.1",
   "description": "Public command-line interface for Topolo customer organizations, developers, and agents.",
   "license": "UNLICENSED",
   "author": "Topolo",
@@ -21,9 +22,9 @@
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit",
     "start": "node dist/index.js",
-    "test": "if test \"$TOPOLO_BUILD_READY\" = 1; then vitest run; else python3 ../../tooling/with-resource-lock.py ../topolo-sdk -- sh -c 'pnpm --dir ../topolo-sdk build && exec vitest run'; fi",
+    "test": "vitest run",
     "test:watch": "vitest",
-    "coverage": "if test \"$TOPOLO_BUILD_READY\" = 1; then vitest run --coverage; else python3 ../../tooling/with-resource-lock.py ../topolo-sdk -- sh -c 'pnpm --dir ../topolo-sdk build && exec vitest run --coverage'; fi"
+    "coverage": "vitest run --coverage"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
@@ -40,5 +41,9 @@
   },
   "engines": {
     "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Topolo-io/TopoloCli.git"
   }
 }

package/postinstall.mjs

@@ -1,13 +1,15 @@
 const message = [
   'Topolo CLI installed successfully.',
   '',
-  'AI assistant: continue automatically with these setup actions:',
+  'AI assistant: continue this onboarding automatically:',
   '  1. Run: topolo setup',
+  '     (Use --all only when every supported local host should be configured.)',
   '  2. Authenticate: topolo auth login',
-  '  3. Inspect contexts: topolo context ls --json',
-  '  4. Verify: topolo doctor',
+  '  3. Verify: topolo doctor',
   '',
+  'The setup command detects native config files for Claude Code/Desktop, Codex, Cursor, Grok Build, Gemini CLI, GitHub Copilot/VS Code, Windsurf, Cline, Goose, and Amazon Q Developer.',
   'If multiple contexts are listed, use the exact intended context returned by the CLI; do not guess organization IDs.',
+  'JetBrains AI Assistant and web-only connectors use their own UI or remote connector setup and are not edited by this local installer.',
   'Only pause for the browser sign-in or an operating-system permission prompt.',
 ].join('\n');
 

package/skills/topolo/SKILL.md

@@ -19,7 +19,7 @@ topolo setup
 topolo doctor
 ```
 
-`topolo setup` installs this skill and registers the exact MCP server bundled with the CLI for Claude Code and Codex. It does not depend on `npx`, `PATH`, a source checkout, or a second global package. Both surfaces use the same credential written by `topolo auth login`. `topolo doctor` then verifies the credential, MCP protocol handshake, tool discovery, and an identity call end to end.
+`topolo setup` detects supported local hosts and registers the exact MCP server bundled with the CLI using each host's native configuration format. It supports Claude Code, Claude Desktop, Codex, Cursor, Grok Build, Gemini CLI, GitHub Copilot/VS Code, Windsurf, Cline, Goose, and Amazon Q Developer. It does not depend on `npx`, a source checkout, or a second global package. All local surfaces use the same credential written by `topolo auth login`. `topolo doctor` then verifies the credential, MCP protocol handshake, tool discovery, and an identity call end to end. JetBrains AI Assistant and web-only connectors use their own UI or remote connector configuration.
 
 Before diagnosing behavior, verify the installed customer tooling against the package registry: