agents-united 1.4.0 → 1.5.0

package/dist/cli.js

@@ -4,8 +4,8 @@
 import { cac } from "cac";
 import pc from "picocolors";
 import { intro, outro, spinner, note, select, multiselect, confirm, text } from "@clack/prompts";
-import fs11 from "fs-extra";
-import path13 from "path";
+import fs12 from "fs-extra";
+import path14 from "path";
 
 // src/core/registry.ts
 import path from "path";
@@ -453,13 +453,13 @@ ${bodyStr}
     return yaml.stringify(manifest);
   }
   /**
-   * Render the coordinator rule file (.cline/rules/agents-united-<bundle>.md).
+   * Render the coordinator rule file (.agents/plugins/<bundle>/rules/agents-united-<bundle>.md).
    * @param excludeAddons optional addon names to omit from the "Recommended Addon
    *   Policy" list (used to stop advertising bundles already installed).
    */
   static renderCoordinatorRule(bundle, scope, excludeAddons = []) {
     const marker = `<!-- managed-by: agents-united | profile: cline | bundle: ${bundle.name} | do not edit -->`;
-    const manifestRelPath = scope === "global" ? `~/.cline/agents-united/teams/${bundle.name}.yaml` : `.cline/agents-united/teams/${bundle.name}.yaml`;
+    const manifestRelPath = scope === "global" ? `~/.agents/plugins/${bundle.name}/agents-united/teams/${bundle.name}.yaml` : `.agents/plugins/${bundle.name}/agents-united/teams/${bundle.name}.yaml`;
     const coordinatorFile = bundle.orchestrator || `${bundle.name}.md`;
     const coordinatorName = coordinatorFile.replace(/\.md$/, "");
     const coordinatorCanonical = `agents/${coordinatorFile}`;
@@ -496,7 +496,26 @@ ${addonSection}
    */
   static async planCompoundProjection(bundle, scope, resolved, registryDir, excludeAddons = []) {
     const artifacts = [];
-    const baseDir = scope === "global" ? ".cline" : ".cline";
+    const baseDir = `.agents/plugins/${bundle.name}`;
+    const pluginManifest = {
+      name: `agents-united-${bundle.name}`,
+      version: "1.0.0",
+      description: bundle.description || "",
+      cline: {
+        plugins: [
+          {
+            capabilities: ["skills", "tools", "workflows"],
+            skills: ["./skills"]
+          }
+        ]
+      }
+    };
+    artifacts.push({
+      kind: "plugin-manifest",
+      relPath: `${baseDir}/package.json`.replace(/\\/g, "/"),
+      content: JSON.stringify(pluginManifest, null, 2),
+      managedMarker: false
+    });
     for (const agentFile of resolved.agents) {
       const canonicalRel = `agents/${agentFile}`;
       const srcPath = path4.join(registryDir, "agents", agentFile);
@@ -593,7 +612,10 @@ var ANTIGRAVITY_ONLY_KEYS = [
   "commandExecutionPolicy",
   "mainAgent",
   "subagent",
-  "hooks"
+  "hooks",
+  "inheritCustomizations",
+  "rules",
+  "effort"
 ];
 var FRONTMATTER_REGEX = /^---\r?\n([\s\S]+?)\r?\n---/;
 var HostProjector = class _HostProjector {
@@ -873,6 +895,19 @@ var InstallEngine = class _InstallEngine {
       asset.projectedTo.push(normProj);
     }
   }
+  removeProjectedTo(lockfile, canonicalRelPath, projectedRelPath) {
+    const normProj = this.toPosix(projectedRelPath);
+    const posixKey = canonicalRelPath.replace(/\\/g, "/");
+    const sysKey = canonicalRelPath.replace(/\//g, path5.sep);
+    const targetKey = lockfile.files[posixKey] ? posixKey : lockfile.files[sysKey] ? sysKey : canonicalRelPath;
+    const asset = lockfile.files[targetKey];
+    if (asset && asset.projectedTo) {
+      asset.projectedTo = asset.projectedTo.filter((p) => p !== normProj);
+      if (asset.projectedTo.length === 0) {
+        delete asset.projectedTo;
+      }
+    }
+  }
   async removeEmptyProjectionDirs(workspaceRoot, projPath) {
     let dir = path5.dirname(path5.join(workspaceRoot, projPath));
     while (dir !== workspaceRoot && dir.startsWith(workspaceRoot)) {
@@ -960,6 +995,40 @@ var InstallEngine = class _InstallEngine {
           (bundleDef.skills || []).forEach((s) => declared.add(`skills/${s}/SKILL.md`));
           (bundleDef.workflows || []).forEach((w) => declared.add(`workflows/${w}`));
           const artifacts = await ClineProjector.planCompoundProjection(bundleDef, scope, resolved, registryDir);
+          const newPaths = new Set(artifacts.map((a) => a.relPath));
+          if (lockfile.projections) {
+            for (const [projRelPath, proj] of Object.entries(lockfile.projections)) {
+              if (proj.host === "cline" && !newPaths.has(projRelPath) && proj.owners.includes(bundleDef.name)) {
+                proj.owners = proj.owners.filter((o) => o !== bundleDef.name);
+                if (proj.owners.length === 0) {
+                  const absProjection = path5.join(root, projRelPath);
+                  if (await fs3.pathExists(absProjection)) {
+                    await fs3.remove(absProjection);
+                    await this.removeEmptyProjectionDirs(root, projRelPath);
+                  }
+                  delete lockfile.projections[projRelPath];
+                }
+                if (proj.canonical) {
+                  this.removeProjectedTo(lockfile, proj.canonical, projRelPath);
+                }
+              }
+            }
+          }
+          if (lockfile.files) {
+            for (const [canonKey, fileMeta] of Object.entries(lockfile.files)) {
+              if (fileMeta.projectedTo) {
+                const staleClinePaths = fileMeta.projectedTo.filter((p) => p.startsWith(".cline/"));
+                for (const stalePath of staleClinePaths) {
+                  const absPath = path5.join(root, stalePath);
+                  if (await fs3.pathExists(absPath)) {
+                    await fs3.remove(absPath);
+                    await this.removeEmptyProjectionDirs(root, stalePath);
+                  }
+                  this.removeProjectedTo(lockfile, canonKey, stalePath);
+                }
+              }
+            }
+          }
           for (const artifact of artifacts) {
             const dest = path5.join(root, artifact.relPath);
             if (await fs3.pathExists(dest) && !options.force) {
@@ -989,7 +1058,7 @@ var InstallEngine = class _InstallEngine {
             lockfile.projections = lockfile.projections || {};
             const existingProj = lockfile.projections[artifact.relPath];
             const bundleName = bundleDef.name;
-            const declares = artifact.kind === "rule" || artifact.kind === "team-manifest" || (artifact.canonical ? declared.has(artifact.canonical) : false);
+            const declares = artifact.kind === "rule" || artifact.kind === "team-manifest" || artifact.kind === "plugin-manifest" || (artifact.canonical ? declared.has(artifact.canonical) : false);
             const priorOwners = existingProj?.owners ?? [];
             const owners = declares ? Array.from(/* @__PURE__ */ new Set([...priorOwners, bundleName])) : priorOwners;
             lockfile.projections[artifact.relPath] = {
@@ -2256,7 +2325,7 @@ var ClineLauncher = class _ClineLauncher {
       throw new Error(`Bundle '${bundleName}' is not installed in ${scope} scope.`);
     }
     const hasClineFanout = (lockfile.fanout || []).includes("cline");
-    const manifestRel = `.cline/agents-united/teams/${bundleName}.yaml`;
+    const manifestRel = `.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml`;
     const manifestPath = path11.join(workspace, manifestRel);
     if (!hasClineFanout || !await fs9.pathExists(manifestPath)) {
       throw new Error(
@@ -2300,16 +2369,18 @@ var ClineLauncher = class _ClineLauncher {
       teamName = customTeamName;
     }
     const strategy = report.namedTeams ? "named-team" : "adaptive-session";
-    const manifestRel = scope === "global" ? `~/.cline/agents-united/teams/${bundleName}.yaml` : `.cline/agents-united/teams/${bundleName}.yaml`;
+    const manifestRel = scope === "global" ? `~/.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml` : `.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml`;
     const coordinatorFile = (orchestrator || "orchestrator-engineering.md").replace(/\.md$/, "");
     const coordinatorCanonical = `.agents/agents/${coordinatorFile}.md`;
     const addonPolicyText = allowAddons ? "Addon auto-installation is pre-authorized for this session." : `Before installing any recommended addon, explain the requirement to the user and request explicit confirmation to run: agents add <addon> -t cline ${scope === "global" ? "-g " : ""}-y.`;
+    const pluginInstallText = `Before proceeding, ensure you have installed this bundle's plugin by running: cline plugin install .agents/plugins/${bundleName}`;
     const taskText = prompt && prompt.trim().length > 0 ? `User task: ${prompt.trim()}` : "Please introduce your coordinator role to the user and ask for their first task.";
     const bootstrapPrompt = [
       `You are coordinating the "${bundleName}" team in Agents United.`,
       `Read the Team Manifest at "${manifestRel}" and your coordinator role definition at "${coordinatorCanonical}" before acting.`,
       `Use specialist roles only when necessary.`,
       addonPolicyText,
+      pluginInstallText,
       taskText
     ].join("\n\n");
     const argv = [...command.prefixArgs];
@@ -2356,151 +2427,416 @@ var ClineLauncher = class _ClineLauncher {
 };
 
 // src/core/prerequisites.ts
+import path13 from "path";
+import os5 from "os";
+import fs11 from "fs-extra";
+
+// src/core/mcp-locations.ts
 import path12 from "path";
 import os4 from "os";
 import fs10 from "fs-extra";
-var PrerequisiteChecker = class _PrerequisiteChecker {
+var McpLocationRegistry = class _McpLocationRegistry {
   /**
-   * Discovers whether an MCP server is configured across supported host runtimes
-   * (Antigravity/Gemini, Cursor, Cline, Claude Code, etc.)
+   * Declarative catalog of known MCP configuration files across AI tools, CLIs, extensions, and workspaces.
    */
-  static async isMcpConfigured(mcpName, cwd = process.cwd()) {
-    const normName = mcpName.trim().toLowerCase();
-    const homeDir = os4.homedir();
-    const localCursor = [
-      path12.join(cwd, ".cursor", "mcp.json"),
-      path12.join(cwd, "cursor.mcp.json")
-    ];
-    for (const cand of localCursor) {
-      if (await fs10.pathExists(cand)) {
-        try {
-          const config = await fs10.readJson(cand);
-          const servers = config?.mcpServers || config?.servers || config;
-          if (servers && (servers[normName] || servers[mcpName])) {
-            return { configured: true, host: "cursor", location: cand };
-          }
-        } catch {
-        }
-      }
-    }
-    const localCline = [
-      path12.join(cwd, "cline_mcp_settings.json"),
-      path12.join(cwd, ".cline", "mcp.json")
-    ];
-    for (const cand of localCline) {
-      if (await fs10.pathExists(cand)) {
-        try {
-          const config = await fs10.readJson(cand);
-          const servers = config?.mcpServers || config?.servers || config;
-          if (servers && (servers[normName] || servers[mcpName])) {
-            return { configured: true, host: "cline", location: cand };
-          }
-        } catch {
-        }
-      }
+  static LOCATIONS = [
+    // --- Google Antigravity & Gemini ---
+    {
+      id: "antigravity-global",
+      host: "gemini",
+      category: "cli",
+      label: "Google Antigravity & Gemini Global Config",
+      resolvePath: (_, home) => path12.join(home, ".gemini", "config", "mcp_config.json"),
+      isPrimary: true
+    },
+    {
+      id: "antigravity-system",
+      host: "gemini",
+      category: "desktop",
+      label: "Google Antigravity System Config",
+      resolvePath: (_, home) => path12.join(home, ".gemini", "antigravity", "mcp_config.json")
+    },
+    {
+      id: "antigravity-workspace",
+      host: "gemini",
+      category: "workspace",
+      label: "Google Antigravity Local Workspace Config",
+      resolvePath: (cwd) => path12.join(cwd, ".gemini", "config", "mcp_config.json")
+    },
+    {
+      id: "gemini-appdata",
+      host: "gemini",
+      category: "cli",
+      label: "Google Gemini AppData Config",
+      resolvePath: (_, __, appData) => path12.join(appData, "gemini", "config", "mcp_config.json")
+    },
+    // --- Cline CLI & VS Code Extension ---
+    {
+      id: "cline-cli-settings",
+      host: "cline",
+      category: "cli",
+      label: "Cline CLI MCP Settings",
+      resolvePath: (_, home) => path12.join(home, ".cline", "data", "settings", "cline_mcp_settings.json"),
+      isPrimary: true
+    },
+    {
+      id: "cline-extension-settings",
+      host: "cline",
+      category: "extension",
+      label: "Cline VS Code Extension Global Settings",
+      resolvePath: (_, __, appData) => path12.join(appData, "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-insiders-extension-settings",
+      host: "cline",
+      category: "extension",
+      label: "Cline VS Code Insiders Extension Settings",
+      resolvePath: (_, __, appData) => path12.join(appData, "Code - Insiders", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-legacy-settings",
+      host: "cline",
+      category: "cli",
+      label: "Cline Home Legacy Settings",
+      resolvePath: (_, home) => path12.join(home, ".cline", "settings", "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-home-flat",
+      host: "cline",
+      category: "cli",
+      label: "Cline Home Flat Settings",
+      resolvePath: (_, home) => path12.join(home, "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-workspace-flat",
+      host: "cline",
+      category: "workspace",
+      label: "Cline Workspace Settings",
+      resolvePath: (cwd) => path12.join(cwd, "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-workspace-dot",
+      host: "cline",
+      category: "workspace",
+      label: "Cline Workspace .cline/mcp.json",
+      resolvePath: (cwd) => path12.join(cwd, ".cline", "mcp.json")
+    },
+    // --- Roo Code Extension ---
+    {
+      id: "roo-code-extension-settings",
+      host: "cline",
+      category: "extension",
+      label: "Roo Code VS Code Extension Settings",
+      resolvePath: (_, __, appData) => path12.join(appData, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json")
+    },
+    // --- Cursor IDE / CLI ---
+    {
+      id: "cursor-workspace",
+      host: "cursor",
+      category: "workspace",
+      label: "Cursor Workspace Config",
+      resolvePath: (cwd) => path12.join(cwd, ".cursor", "mcp.json"),
+      isPrimary: true
+    },
+    {
+      id: "cursor-global",
+      host: "cursor",
+      category: "desktop",
+      label: "Cursor Global User Config",
+      resolvePath: (_, home) => path12.join(home, ".cursor", "mcp.json")
+    },
+    // --- Claude Code CLI & Claude Desktop ---
+    {
+      id: "claude-workspace-dot",
+      host: "claude",
+      category: "workspace",
+      label: "Claude Code Workspace Config",
+      resolvePath: (cwd) => path12.join(cwd, ".claude", "mcp.json"),
+      isPrimary: true
+    },
+    {
+      id: "claude-workspace-flat",
+      host: "claude",
+      category: "workspace",
+      label: "Claude Workspace claude.json",
+      resolvePath: (cwd) => path12.join(cwd, "claude.json")
+    },
+    {
+      id: "claude-global-dot",
+      host: "claude",
+      category: "cli",
+      label: "Claude Code Global Config",
+      resolvePath: (_, home) => path12.join(home, ".claude", "mcp.json")
+    },
+    {
+      id: "claude-global-flat",
+      host: "claude",
+      category: "cli",
+      label: "Claude Code Global claude.json",
+      resolvePath: (_, home) => path12.join(home, "claude.json")
+    },
+    {
+      id: "claude-desktop-global",
+      host: "claude",
+      category: "desktop",
+      label: "Claude Desktop Global Config",
+      resolvePath: (_, __, appData) => path12.join(appData, "Claude", "claude_desktop_config.json")
+    },
+    // --- Windsurf IDE ---
+    {
+      id: "windsurf-global",
+      host: "windsurf",
+      category: "desktop",
+      label: "Windsurf Global Config",
+      resolvePath: (_, home) => path12.join(home, ".codeium", "windsurf", "mcp_config.json"),
+      isPrimary: true
+    },
+    {
+      id: "windsurf-appdata",
+      host: "windsurf",
+      category: "desktop",
+      label: "Windsurf AppData Config",
+      resolvePath: (_, __, appData) => path12.join(appData, "Windsurf", "mcp_config.json")
+    },
+    // --- OpenCode & Codex ---
+    {
+      id: "opencode-workspace",
+      host: "opencode",
+      category: "workspace",
+      label: "OpenCode Workspace Config",
+      resolvePath: (cwd) => path12.join(cwd, ".opencode", "mcp.json"),
+      isPrimary: true
+    },
+    {
+      id: "opencode-global",
+      host: "opencode",
+      category: "cli",
+      label: "OpenCode Global Config",
+      resolvePath: (_, home) => path12.join(home, ".config", "opencode", "mcp.json")
     }
-    const localClaude = [
-      path12.join(cwd, "claude.json"),
-      path12.join(cwd, ".claude", "mcp.json")
-    ];
-    for (const cand of localClaude) {
-      if (await fs10.pathExists(cand)) {
+  ];
+  /**
+   * Discovers all MCP configuration files across the filesystem, inspecting existence and parsing server definitions.
+   */
+  static async discoverAll(cwd = process.cwd()) {
+    const homeDir = os4.homedir();
+    const appData = process.env.APPDATA || (process.platform === "darwin" ? path12.join(homeDir, "Library", "Application Support") : path12.join(homeDir, ".config"));
+    const results = [];
+    const seenPaths = /* @__PURE__ */ new Set();
+    for (const desc of _McpLocationRegistry.LOCATIONS) {
+      const resolved = path12.normalize(desc.resolvePath(cwd, homeDir, appData));
+      const key = resolved.toLowerCase();
+      if (seenPaths.has(key)) continue;
+      seenPaths.add(key);
+      const exists = await fs10.pathExists(resolved);
+      let serverCount = 0;
+      let servers;
+      if (exists) {
         try {
-          const config = await fs10.readJson(cand);
-          const servers = config?.mcpServers || config?.servers || config;
-          if (servers && (servers[normName] || servers[mcpName])) {
-            return { configured: true, host: "claude", location: cand };
+          const config = await fs10.readJson(resolved);
+          const rawServers = config?.mcpServers || config?.servers || config;
+          if (rawServers && typeof rawServers === "object") {
+            servers = rawServers;
+            serverCount = Object.keys(rawServers).length;
           }
         } catch {
         }
       }
+      results.push({
+        id: desc.id,
+        host: desc.host,
+        category: desc.category,
+        label: desc.label,
+        path: resolved,
+        exists,
+        serverCount,
+        servers,
+        isPrimary: desc.isPrimary
+      });
     }
-    const localGemini = [
-      path12.join(cwd, ".gemini", "antigravity", "mcp", normName),
-      path12.join(cwd, ".gemini", "antigravity", "mcp")
-    ];
-    for (const cand of localGemini) {
-      if (await fs10.pathExists(cand)) {
-        if (cand.endsWith(normName)) {
-          return { configured: true, host: "gemini", location: cand };
-        }
-        const entries = await fs10.readdir(cand).catch(() => []);
-        if (entries.some((e) => e.toLowerCase() === normName || e.toLowerCase().startsWith(`${normName}.`))) {
-          return { configured: true, host: "gemini", location: cand };
-        }
-      }
+    return results;
+  }
+  /**
+   * Returns discovered locations filtered for specific host(s).
+   */
+  static async discoverForHosts(hosts, cwd = process.cwd()) {
+    const all = await _McpLocationRegistry.discoverAll(cwd);
+    const hostSet = new Set(hosts.map((h) => h === "agents" ? "gemini" : h));
+    return all.filter((loc) => hostSet.has(loc.host));
+  }
+  /**
+   * Resolves the primary target write path for a given host runtime.
+   */
+  static getPrimaryWritePath(host, cwd = process.cwd()) {
+    const homeDir = os4.homedir();
+    const appData = process.env.APPDATA || (process.platform === "darwin" ? path12.join(homeDir, "Library", "Application Support") : path12.join(homeDir, ".config"));
+    const targetHost = host === "agents" ? "gemini" : host;
+    const desc = _McpLocationRegistry.LOCATIONS.find((l) => l.host === targetHost && l.isPrimary);
+    if (desc) {
+      return path12.normalize(desc.resolvePath(cwd, homeDir, appData));
     }
-    const globalGemini = [
-      path12.join(homeDir, ".gemini", "antigravity", "mcp", normName),
-      path12.join(homeDir, ".gemini", "antigravity", "mcp")
-    ];
-    for (const cand of globalGemini) {
-      if (await fs10.pathExists(cand)) {
-        if (cand.endsWith(normName)) {
-          return { configured: true, host: "gemini", location: cand };
-        }
-        const entries = await fs10.readdir(cand).catch(() => []);
-        if (entries.some((e) => e.toLowerCase() === normName || e.toLowerCase().startsWith(`${normName}.`))) {
-          return { configured: true, host: "gemini", location: cand };
-        }
+    return path12.normalize(path12.join(cwd, ".cursor", "mcp.json"));
+  }
+};
+
+// src/core/prerequisites.ts
+var PrerequisiteChecker = class _PrerequisiteChecker {
+  /**
+   * Discovers all candidate and existing MCP configuration files across AI hosts
+   */
+  static async discoverHostConfigFiles(cwd = process.cwd()) {
+    const discovered = await McpLocationRegistry.discoverAll(cwd);
+    return discovered.map((d) => ({
+      host: d.host,
+      label: d.label,
+      path: d.path,
+      exists: d.exists,
+      serverCount: d.serverCount
+    }));
+  }
+  /**
+   * Helper that checks if a configured MCP server key or its configuration payload matches the target MCP name
+   */
+  static matchesMcpServer(targetMcpName, serverKey, serverConfig = {}) {
+    const targetNorm = targetMcpName.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const keyNorm = serverKey.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (keyNorm === targetNorm) return true;
+    if (keyNorm.includes(targetNorm)) return true;
+    if (targetNorm.includes(keyNorm)) return true;
+    const strippedKey = keyNorm.replace(/^githubcom/g, "").replace(/^mcp/g, "").replace(/mcp$/g, "").replace(/^server/g, "").replace(/server$/g, "");
+    if (strippedKey === targetNorm || strippedKey.length > 2 && targetNorm.includes(strippedKey) || targetNorm.length > 2 && strippedKey.includes(targetNorm)) {
+      return true;
+    }
+    const cmd = String(serverConfig?.command || "").toLowerCase();
+    const args = Array.isArray(serverConfig?.args) ? serverConfig.args.map((a) => String(a).toLowerCase()).join(" ") : "";
+    const fullExec = `${cmd} ${args}`;
+    if (targetMcpName === "github") {
+      if (fullExec.includes("github") || fullExec.includes("ghcr.io/github")) return true;
+    }
+    if (targetMcpName === "playwright") {
+      if (fullExec.includes("playwright")) return true;
+    }
+    if (targetMcpName === "markitdown") {
+      if (fullExec.includes("markitdown")) return true;
+    }
+    if (targetMcpName === "chrome-devtools-mcp" || targetMcpName === "chrome-devtools") {
+      if (fullExec.includes("chrome-devtools")) return true;
+    }
+    if (targetMcpName === "stitch") {
+      if (fullExec.includes("stitch") || fullExec.includes("stitch.googleapis.com")) return true;
+    }
+    if (targetMcpName === "figma") {
+      if (fullExec.includes("figma")) return true;
+    }
+    if (targetMcpName === "firecrawl") {
+      if (fullExec.includes("firecrawl")) return true;
+    }
+    if (targetMcpName === "context7") {
+      if (fullExec.includes("context7")) return true;
+    }
+    if (targetMcpName === "supabase") {
+      if (fullExec.includes("supabase")) return true;
+    }
+    const url = String(serverConfig?.url || serverConfig?.serverUrl || "").toLowerCase();
+    if (url.includes(targetNorm)) return true;
+    if (targetMcpName === "stitch" && url.includes("stitch.googleapis.com")) return true;
+    if (targetMcpName === "context7" && url.includes("context7.com")) return true;
+    if (targetMcpName === "firecrawl" && url.includes("firecrawl.dev")) return true;
+    if (targetMcpName === "supabase" && url.includes("supabase.com")) return true;
+    return false;
+  }
+  /**
+   * Discovers whether an MCP server is configured across supported host runtimes
+   * (Antigravity/Gemini, Cursor, Cline, Claude Code, etc.)
+   */
+  static async isMcpConfigured(mcpName, cwd = process.cwd()) {
+    const discovered = await McpLocationRegistry.discoverAll(cwd);
+    const foundInConfigs = [];
+    const missingInConfigs = [];
+    for (const file of discovered) {
+      if (!file.exists) {
+        missingInConfigs.push({
+          id: file.id,
+          host: file.host,
+          label: file.label,
+          path: file.path
+        });
+        continue;
       }
-    }
-    const globalCursor = [path12.join(homeDir, ".cursor", "mcp.json")];
-    for (const cand of globalCursor) {
-      if (await fs10.pathExists(cand)) {
-        try {
-          const config = await fs10.readJson(cand);
-          const servers = config?.mcpServers || config?.servers || config;
-          if (servers && (servers[normName] || servers[mcpName])) {
-            return { configured: true, host: "cursor", location: cand };
+      let matched = false;
+      if (file.servers && typeof file.servers === "object") {
+        for (const [key, serverDef] of Object.entries(file.servers)) {
+          if (_PrerequisiteChecker.matchesMcpServer(mcpName, key, serverDef)) {
+            const isDisabled = serverDef?.disabled === true;
+            foundInConfigs.push({
+              id: file.id,
+              host: file.host,
+              label: file.label,
+              path: file.path,
+              disabled: isDisabled,
+              serverKey: key
+            });
+            matched = true;
+            break;
           }
-        } catch {
         }
       }
-    }
-    const globalCline = [path12.join(homeDir, "cline_mcp_settings.json")];
-    for (const cand of globalCline) {
-      if (await fs10.pathExists(cand)) {
-        try {
-          const config = await fs10.readJson(cand);
-          const servers = config?.mcpServers || config?.servers || config;
-          if (servers && (servers[normName] || servers[mcpName])) {
-            return { configured: true, host: "cline", location: cand };
-          }
-        } catch {
-        }
+      if (!matched) {
+        missingInConfigs.push({
+          id: file.id,
+          host: file.host,
+          label: file.label,
+          path: file.path
+        });
       }
     }
-    const globalClaude = [
-      path12.join(homeDir, "claude.json"),
-      path12.join(homeDir, ".claude", "mcp.json")
+    const homeDir = os5.homedir();
+    const dirCandidates = [
+      path13.join(cwd, ".gemini", "antigravity", "mcp"),
+      path13.join(homeDir, ".gemini", "antigravity", "mcp")
     ];
-    for (const cand of globalClaude) {
-      if (await fs10.pathExists(cand)) {
-        try {
-          const config = await fs10.readJson(cand);
-          const servers = config?.mcpServers || config?.servers || config;
-          if (servers && (servers[normName] || servers[mcpName])) {
-            return { configured: true, host: "claude", location: cand };
+    for (const dir of dirCandidates) {
+      if (await fs11.pathExists(dir)) {
+        const entries = await fs11.readdir(dir).catch(() => []);
+        for (const entry of entries) {
+          if (_PrerequisiteChecker.matchesMcpServer(mcpName, entry, {})) {
+            foundInConfigs.push({
+              id: "antigravity-dir",
+              host: "gemini",
+              label: "Google Antigravity MCP Directory",
+              path: path13.join(dir, entry),
+              disabled: false,
+              serverKey: entry
+            });
+            break;
           }
-        } catch {
         }
       }
     }
-    return { configured: false };
+    const isConfigured = foundInConfigs.length > 0;
+    const firstFound = foundInConfigs[0];
+    return {
+      configured: isConfigured,
+      host: firstFound?.host,
+      location: firstFound?.path,
+      disabled: firstFound?.disabled,
+      serverKey: firstFound?.serverKey,
+      foundInConfigs,
+      missingInConfigs
+    };
   }
   /**
    * Checks if an npm package is installed in node_modules or declared in package.json
    */
   static async isPackageInstalled(pkgName, cwd = process.cwd()) {
-    const modulePath = path12.join(cwd, "node_modules", ...pkgName.split("/"));
-    if (await fs10.pathExists(modulePath)) {
+    const modulePath = path13.join(cwd, "node_modules", ...pkgName.split("/"));
+    if (await fs11.pathExists(modulePath)) {
       return { installed: true, location: modulePath };
     }
-    const pkgJsonPath = path12.join(cwd, "package.json");
-    if (await fs10.pathExists(pkgJsonPath)) {
+    const pkgJsonPath = path13.join(cwd, "package.json");
+    if (await fs11.pathExists(pkgJsonPath)) {
       try {
-        const pkg = await fs10.readJson(pkgJsonPath);
+        const pkg = await fs11.readJson(pkgJsonPath);
         const deps = {
           ...pkg.dependencies,
           ...pkg.devDependencies,
@@ -2523,20 +2859,20 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
       return { set: true, source: "process.env" };
     }
     const envFiles = [
-      path12.join(cwd, ".env.local"),
-      path12.join(cwd, ".env")
+      path13.join(cwd, ".env.local"),
+      path13.join(cwd, ".env")
     ];
     for (const envFile of envFiles) {
-      if (await fs10.pathExists(envFile)) {
+      if (await fs11.pathExists(envFile)) {
         try {
-          const content = await fs10.readFile(envFile, "utf8");
+          const content = await fs11.readFile(envFile, "utf8");
           const lines = content.split("\n");
           for (const line of lines) {
             const trimmed = line.trim();
             if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
             const [k, ...v] = trimmed.split("=");
             if (k.trim() === varName && v.join("=").trim() !== "") {
-              return { set: true, source: path12.basename(envFile) };
+              return { set: true, source: path13.basename(envFile) };
             }
           }
         } catch {
@@ -2546,25 +2882,60 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
     return { set: false };
   }
   /**
-   * Evaluates all prerequisites declared on a bundle
+   * Evaluates all prerequisites declared on a bundle, supporting target host scoping and multi-host partial breakdowns
    */
   async evaluate(bundle, options = {}) {
     const cwd = options.cwd || process.cwd();
     const env = options.env || process.env;
     const tier = bundle.tier || "domain";
     const prereqs = bundle.prerequisites || {};
+    const targetHosts = options.targetHosts || ["agents"];
+    const targetHostKeys = new Set(targetHosts.map((h) => h === "agents" ? "gemini" : h));
     const items = [];
     if (prereqs.requiredMcps && prereqs.requiredMcps.length > 0) {
       for (const mcp of prereqs.requiredMcps) {
         const check = await _PrerequisiteChecker.isMcpConfigured(mcp.name, cwd);
+        const relevantFound = check.foundInConfigs.filter((c) => targetHostKeys.has(c.host));
+        const hostCleanNames = {
+          gemini: "Google Antigravity",
+          agents: "Google Antigravity",
+          cline: "Cline",
+          cursor: "Cursor",
+          claude: "Claude Code",
+          opencode: "OpenCode",
+          windsurf: "Windsurf"
+        };
+        const detectedHostLabels = Array.from(new Set(relevantFound.map((c) => hostCleanNames[c.host] || c.host)));
+        const detectedHostKeys = new Set(relevantFound.map((c) => c.host));
+        const missingHostKeys = Array.from(targetHostKeys).filter((h) => !detectedHostKeys.has(h));
+        const missingHostLabels = missingHostKeys.map((h) => hostCleanNames[h] || h);
+        let satisfied = false;
+        let status = "missing";
+        let details = "Not found in host MCP configuration";
+        if (relevantFound.length > 0 && missingHostKeys.length === 0) {
+          satisfied = true;
+          status = "ok";
+          details = `Configured in ${detectedHostLabels.join(", ")}`;
+        } else if (relevantFound.length > 0 && missingHostKeys.length > 0) {
+          satisfied = false;
+          status = "partial";
+          details = `Detected in ${detectedHostLabels.join(", ")}; Missing in ${missingHostLabels.join(", ")}`;
+        } else if (check.foundInConfigs.length > 0 && relevantFound.length === 0) {
+          const otherLabels = Array.from(new Set(check.foundInConfigs.map((c) => hostCleanNames[c.host] || c.host)));
+          satisfied = false;
+          status = "partial";
+          details = `Detected in ${otherLabels.join(", ")}; Missing in target (${Array.from(targetHostKeys).map((h) => hostCleanNames[h] || h).join(", ")})`;
+        }
         items.push({
           type: "mcp",
           name: mcp.name,
           purpose: mcp.purpose,
-          satisfied: check.configured,
-          status: check.configured ? "ok" : "missing",
-          details: check.configured ? `Configured in ${check.host || "host"}` : "Not found in host MCP configuration",
-          optionalForBrainstorming: mcp.optionalForBrainstorming ?? true
+          satisfied,
+          status,
+          details,
+          optionalForBrainstorming: mcp.optionalForBrainstorming ?? true,
+          detectedInHosts: detectedHostLabels,
+          missingInHosts: missingHostLabels
         });
       }
     }
@@ -2607,6 +2978,175 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
       modes: bundle.modes
     };
   }
+  /**
+   * Returns canonical command and environment definitions for known MCP servers
+   */
+  static getMcpDefinition(mcpName, mode = "operational", envVars = {}) {
+    const norm = mcpName.trim().toLowerCase();
+    switch (norm) {
+      case "github":
+        return {
+          command: "npx",
+          args: ["-y", "@modelcontextprotocol/server-github"],
+          ...mode === "operational" && (envVars.GITHUB_PERSONAL_ACCESS_TOKEN || process.env.GITHUB_PERSONAL_ACCESS_TOKEN) ? { env: { GITHUB_PERSONAL_ACCESS_TOKEN: envVars.GITHUB_PERSONAL_ACCESS_TOKEN || process.env.GITHUB_PERSONAL_ACCESS_TOKEN || "" } } : {}
+        };
+      case "firecrawl":
+        return {
+          command: "npx",
+          args: ["-y", "firecrawl-mcp"],
+          ...mode === "operational" && (envVars.FIRECRAWL_API_KEY || process.env.FIRECRAWL_API_KEY) ? { env: { FIRECRAWL_API_KEY: envVars.FIRECRAWL_API_KEY || process.env.FIRECRAWL_API_KEY || "" } } : mode === "limited-operational" && envVars.FIRECRAWL_API_URL ? { env: { FIRECRAWL_API_URL: envVars.FIRECRAWL_API_URL } } : {}
+        };
+      case "context7":
+        return {
+          command: "npx",
+          args: ["-y", "@upstash/context7-mcp"],
+          ...mode === "operational" && envVars.UPSTASH_REDIS_REST_URL && envVars.UPSTASH_REDIS_REST_TOKEN ? { env: { UPSTASH_REDIS_REST_URL: envVars.UPSTASH_REDIS_REST_URL, UPSTASH_REDIS_REST_TOKEN: envVars.UPSTASH_REDIS_REST_TOKEN } } : {}
+        };
+      case "playwright":
+        return {
+          command: "npx",
+          args: ["-y", "@executeautomation/playwright-mcp-server"]
+        };
+      case "markitdown":
+        return {
+          command: "uvx",
+          args: ["markitdown-mcp"]
+        };
+      case "chrome-devtools-mcp":
+      case "chrome-devtools":
+        return {
+          command: "npx",
+          args: ["-y", "chrome-devtools-mcp"]
+        };
+      case "stitch":
+        return {
+          command: "npx",
+          args: ["-y", "mcp-remote", "https://stitch.googleapis.com/mcp"],
+          ...mode === "operational" && (envVars.STITCH_API_KEY || process.env.STITCH_API_KEY) ? { env: { STITCH_API_KEY: envVars.STITCH_API_KEY || process.env.STITCH_API_KEY || "" } } : {}
+        };
+      case "figma":
+        return {
+          command: "npx",
+          args: ["-y", "ai-figma-mcp"],
+          ...mode === "operational" && (envVars.FIGMA_ACCESS_TOKEN || process.env.FIGMA_ACCESS_TOKEN) ? { env: { FIGMA_ACCESS_TOKEN: envVars.FIGMA_ACCESS_TOKEN || process.env.FIGMA_ACCESS_TOKEN || "" } } : {}
+        };
+      default:
+        return {
+          command: "npx",
+          args: ["-y", norm]
+        };
+    }
+  }
+  /**
+   * Generates client-specific MCP configuration objects for Cursor, Cline, Claude, or Antigravity
+   */
+  static generateClientConfig(client, mcpNames, mode = "operational", envVars = {}) {
+    const servers = {};
+    for (const name of mcpNames) {
+      const def = _PrerequisiteChecker.getMcpDefinition(name, mode, envVars);
+      if (client === "cline") {
+        servers[name] = {
+          ...def,
+          disabled: false,
+          autoApprove: []
+        };
+      } else {
+        servers[name] = def;
+      }
+    }
+    return { mcpServers: servers };
+  }
+  /**
+   * Attempts to automatically provision a missing MCP server using the native CLI.
+   */
+  static async provisionMcpServer(mcpName, options = {}) {
+    try {
+      const { execSync } = await import("child_process");
+      const cmd = `npx @antigravity/cli mcp add ${mcpName} --type stdio`;
+      const output = execSync(cmd, {
+        cwd: options.cwd || process.cwd(),
+        env: options.env || process.env,
+        encoding: "utf8"
+      });
+      return { success: true, output };
+    } catch (err) {
+      return { success: false, output: err.message || String(err) };
+    }
+  }
+  /**
+   * Automatically configures missing MCP servers into a specific MCP JSON configuration file,
+   * activating disabled servers and appending missing definitions.
+   */
+  static async autoConfigureConfigFile(targetFilePath, mcpNames, mode = "operational", envVars = {}) {
+    await fs11.ensureDir(path13.dirname(targetFilePath));
+    let existingConfig = {};
+    if (await fs11.pathExists(targetFilePath)) {
+      try {
+        existingConfig = await fs11.readJson(targetFilePath);
+      } catch {
+        existingConfig = {};
+      }
+    }
+    const isServersProp = Boolean(existingConfig.servers && !existingConfig.mcpServers);
+    const existingServers = (isServersProp ? existingConfig.servers : existingConfig.mcpServers) || {};
+    const addedServers = [];
+    const enabledServers = [];
+    for (const mcp of mcpNames) {
+      let foundKey = null;
+      for (const [key, serverDef] of Object.entries(existingServers)) {
+        if (_PrerequisiteChecker.matchesMcpServer(mcp, key, serverDef)) {
+          foundKey = key;
+          if (serverDef?.disabled === true) {
+            existingServers[key].disabled = false;
+            enabledServers.push(key);
+          }
+          break;
+        }
+      }
+      if (!foundKey) {
+        const def = _PrerequisiteChecker.getMcpDefinition(mcp, mode, envVars);
+        existingServers[mcp] = def;
+        addedServers.push(mcp);
+      }
+    }
+    if (isServersProp) {
+      existingConfig.servers = existingServers;
+    } else {
+      existingConfig.mcpServers = existingServers;
+    }
+    await fs11.writeJson(targetFilePath, existingConfig, { spaces: 2 });
+    return {
+      success: true,
+      targetFile: targetFilePath,
+      addedServers,
+      enabledServers
+    };
+  }
+  /**
+   * Automatically configures missing MCP servers into a specific AI host's configuration file.
+   */
+  static async autoConfigureHost(host, mcpNames, cwd = process.cwd(), mode = "operational", envVars = {}) {
+    const targetFile = McpLocationRegistry.getPrimaryWritePath(host, cwd);
+    const res = await _PrerequisiteChecker.autoConfigureConfigFile(targetFile, mcpNames, mode, envVars);
+    return {
+      configured: res.success,
+      targetFile: res.targetFile,
+      addedServers: [...res.addedServers, ...res.enabledServers]
+    };
+  }
+  /**
+   * Automatically installs missing NPM packages into the workspace.
+   */
+  static async autoInstallPackages(packages, cwd = process.cwd()) {
+    try {
+      const { execSync } = await import("child_process");
+      const cmd = `npm install -D ${packages.join(" ")}`;
+      const output = execSync(cmd, { cwd, encoding: "utf8" });
+      return { success: true, output };
+    } catch (err) {
+      return { success: false, output: err.message || String(err) };
+    }
+  }
 };
 
 // src/cli.ts
@@ -2619,7 +3159,7 @@ var updater = new UpdateEngine(registry, scanner, installer);
 function detectWorkspaceHosts(cwd = process.cwd()) {
   const detected = [];
   for (const host of Object.values(HOST_REGISTRY)) {
-    const found = host.detectionMarkers.some((marker) => fs11.pathExistsSync(path13.join(cwd, marker)));
+    const found = host.detectionMarkers.some((marker) => fs12.pathExistsSync(path14.join(cwd, marker)));
     if (found) detected.push(host.id);
   }
   return detected;
@@ -3082,71 +3622,40 @@ To bypass this gate and install draft assets anyway, pass: --allow-under-constru
   let executionMode = options.mode || "operational";
   if (targetBundleDef && (targetBundleDef.prerequisites || targetBundleDef.tier === "organization")) {
     const checker = new PrerequisiteChecker();
-    const prereqEval = await checker.evaluate(targetBundleDef);
+    const prereqEval = await checker.evaluate(targetBundleDef, { cwd: process.cwd(), targetHosts: hosts });
     if (prereqEval.hasPrerequisites) {
       const checkLines = [];
       for (const item of prereqEval.items) {
         const typeLabel = item.type === "mcp" ? "MCP" : item.type === "env" ? "Env" : "Pkg";
-        const icon = item.satisfied ? pc.green("\u2713") : pc.red("\u2717");
+        let icon = pc.green("\u2713");
+        let statusText = pc.green("Detected");
+        if (!item.satisfied) {
+          if (item.status === "partial") {
+            icon = pc.yellow("~");
+            statusText = pc.yellow("Partial");
+          } else {
+            icon = pc.red("\u2717");
+            statusText = pc.red("Missing");
+          }
+        }
         const details = pc.dim(`(${item.details || ""})`);
-        checkLines.push(`  ${icon} [${typeLabel}] ${pc.bold(item.name)}: ${item.satisfied ? pc.green("Detected") : pc.red("Missing")} ${details}`);
+        checkLines.push(`  ${icon} [${typeLabel}] ${pc.bold(item.name)}: ${statusText} ${details}`);
       }
       note(
         checkLines.join("\n"),
         `Prerequisite Evaluation: ${targetBundleDef.name} (${targetBundleDef.tier === "organization" ? "Organization Bundle" : "Prerequisites Required"})`
       );
-      if (!prereqEval.allSatisfied) {
-        if (isInteractive) {
-          const gateChoice = await select({
-            message: pc.yellow(`Prerequisites not fully satisfied for "${targetBundleDef.name}". How would you like to proceed?`),
-            options: [
-              {
-                value: "abort",
-                label: "\u{1F6D1} Abort and configure missing prerequisites (Recommended)",
-                hint: "exit and configure MCP servers, packages, or environment variables"
-              },
-              {
-                value: "brainstorming",
-                label: "\u{1F4A1} Install in Brainstorming Mode (Advisory & Spec generation only)",
-                hint: "runs in idea/planning mode without requiring live MCP tool connections"
-              },
-              {
-                value: "force",
-                label: "\u26A0\uFE0F  Force install in Operational Mode anyway",
-                hint: "proceed despite missing prerequisites (may fail during runtime calls)"
-              }
-            ]
-          });
-          if (gateChoice === "abort" || typeof gateChoice !== "string") {
-            outro(pc.yellow("Installation aborted. Please configure required MCPs and environment variables, then retry."));
-            return;
-          }
-          if (gateChoice === "brainstorming") {
-            executionMode = "brainstorming";
-            note(pc.cyan('Switched execution mode to "brainstorming" (idea/spec fallback mode).'), "Mode Selected");
-          } else if (gateChoice === "force") {
-            executionMode = "operational";
-            note(pc.yellow('Proceeding in "operational" mode with missing prerequisites.'), "Warning");
-          }
-        } else {
-          if (options.mode === "brainstorming") {
-            executionMode = "brainstorming";
-          } else if (options.force || options.allowMissingPrereqs) {
-            executionMode = "operational";
-          } else {
-            const missingList = prereqEval.items.filter((i) => !i.satisfied).map((i) => `${i.type}:${i.name}`).join(", ");
-            outro(
-              pc.red(
-                `Error: Prerequisites not satisfied for "${targetBundleDef.name}".
-Missing items: ${missingList}
-
-To install in fallback mode: agents add ${identifier} --mode brainstorming
-To bypass prerequisite gate: agents add ${identifier} --allow-missing-prereqs`
-              )
-            );
-            process.exit(1);
-          }
-        }
+      if (prereqEval.allSatisfied) {
+        executionMode = options.mode || "operational";
+        note(pc.green("All prerequisites are satisfied! Running in Fully Operational Mode."), "Prerequisites Ready");
+      } else {
+        executionMode = options.mode || "limited-operational";
+        note(
+          pc.cyan(
+            "\u26A1 Adaptive Tooling: Limited Operational / Brainstorming Mode ready.\nYour Lead Orchestrator will automatically detect active tools and guide in-session configuration seamlessly."
+          ),
+          "Operational Envelope"
+        );
       }
     }
   }
@@ -3259,6 +3768,14 @@ To use this bundle in Cline, Claude Code & others: agents update ${identifier} -
         "One library, every assistant"
       );
     }
+    if (!options.dryRun && targetBundleDef?.tier === "organization") {
+      note(
+        pc.cyan(
+          "\u{1F4A1} In-Session MCP Setup: Your Lead Orchestrator will automatically check your runtime tools\nand guide configuration of live browser automation, design tokens, or cloud APIs on demand."
+        ),
+        "Adaptive Tooling"
+      );
+    }
     outro(pc.green(`\u2714 Installed "${identifier}" successfully!`));
   } catch (err) {
     s.stop(pc.red("Failed resolution"));
@@ -3449,7 +3966,7 @@ Updates Available: ${report.outdatedCount > 0 ? pc.yellow(pc.bold(`${report.outd
       const unprojected = [];
       for (const rec of result.updated) {
         try {
-          const lf = await fs11.readJson(path13.join(rec.targetDir, "agents-united.json"));
+          const lf = await fs12.readJson(path14.join(rec.targetDir, "agents-united.json"));
           if (!lf.fanout || lf.fanout.length === 0) unprojected.push(rec.name);
         } catch {
         }