agentinit 1.8.0 → 1.8.1

package/dist/cli.js

@@ -14840,51 +14840,51 @@ var require_uri_all = __commonJS((exports, module) => {
       }
       return uriTokens.join("");
     }
-    function resolveComponents(base2, relative3) {
+    function resolveComponents(base2, relative4) {
       var options2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
       var skipNormalization = arguments[3];
       var target = {};
       if (!skipNormalization) {
         base2 = parse4(serialize(base2, options2), options2);
-        relative3 = parse4(serialize(relative3, options2), options2);
+        relative4 = parse4(serialize(relative4, options2), options2);
       }
       options2 = options2 || {};
-      if (!options2.tolerant && relative3.scheme) {
-        target.scheme = relative3.scheme;
-        target.userinfo = relative3.userinfo;
-        target.host = relative3.host;
-        target.port = relative3.port;
-        target.path = removeDotSegments(relative3.path || "");
-        target.query = relative3.query;
+      if (!options2.tolerant && relative4.scheme) {
+        target.scheme = relative4.scheme;
+        target.userinfo = relative4.userinfo;
+        target.host = relative4.host;
+        target.port = relative4.port;
+        target.path = removeDotSegments(relative4.path || "");
+        target.query = relative4.query;
       } else {
-        if (relative3.userinfo !== undefined || relative3.host !== undefined || relative3.port !== undefined) {
-          target.userinfo = relative3.userinfo;
-          target.host = relative3.host;
-          target.port = relative3.port;
-          target.path = removeDotSegments(relative3.path || "");
-          target.query = relative3.query;
+        if (relative4.userinfo !== undefined || relative4.host !== undefined || relative4.port !== undefined) {
+          target.userinfo = relative4.userinfo;
+          target.host = relative4.host;
+          target.port = relative4.port;
+          target.path = removeDotSegments(relative4.path || "");
+          target.query = relative4.query;
         } else {
-          if (!relative3.path) {
+          if (!relative4.path) {
             target.path = base2.path;
-            if (relative3.query !== undefined) {
-              target.query = relative3.query;
+            if (relative4.query !== undefined) {
+              target.query = relative4.query;
             } else {
               target.query = base2.query;
             }
           } else {
-            if (relative3.path.charAt(0) === "/") {
-              target.path = removeDotSegments(relative3.path);
+            if (relative4.path.charAt(0) === "/") {
+              target.path = removeDotSegments(relative4.path);
             } else {
               if ((base2.userinfo !== undefined || base2.host !== undefined || base2.port !== undefined) && !base2.path) {
-                target.path = "/" + relative3.path;
+                target.path = "/" + relative4.path;
               } else if (!base2.path) {
-                target.path = relative3.path;
+                target.path = relative4.path;
               } else {
-                target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative3.path;
+                target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative4.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative3.query;
+            target.query = relative4.query;
           }
           target.userinfo = base2.userinfo;
           target.host = base2.host;
@@ -14892,7 +14892,7 @@ var require_uri_all = __commonJS((exports, module) => {
         }
         target.scheme = base2.scheme;
       }
-      target.fragment = relative3.fragment;
+      target.fragment = relative4.fragment;
       return target;
     }
     function resolve10(baseURI, relativeURI, options2) {
@@ -35280,6 +35280,19 @@ class Agent {
     }
     return resolve5(projectPath, this.definition.skillPaths.project);
   }
+  getProjectRulesStandard() {
+    return this.definition.projectStandards?.rules || null;
+  }
+  getProjectSkillsStandard() {
+    return this.definition.projectStandards?.skills || null;
+  }
+  supportsProjectMcpConfig() {
+    const supportsAnyMcp = Object.values(this.capabilities.mcp).some(Boolean);
+    if (!supportsAnyMcp) {
+      return false;
+    }
+    return this.definition.mcpConfigScope !== "global-only";
+  }
   supportsGlobalRules() {
     return this.getGlobalRulesPath() !== null;
   }
@@ -35383,6 +35396,10 @@ class ClaudeAgent extends Agent {
       skillPaths: {
         project: ".claude/skills/",
         global: "~/.claude/skills/"
+      },
+      projectStandards: {
+        rules: "claude",
+        skills: "claude"
       }
     };
     super(definition);
@@ -35578,7 +35595,11 @@ class ClaudeDesktopAgent extends Agent {
       skillPaths: {
         project: ".claude/skills/",
         global: "~/.claude/skills/"
-      }
+      },
+      projectStandards: {
+        skills: "claude"
+      },
+      mcpConfigScope: "global-only"
     };
     super(definition);
   }
@@ -35712,8 +35733,12 @@ class CodexCliAgent extends Agent {
       rulesPath: ".codex/config.toml",
       globalRulesPath: "~/.codex/config.toml",
       skillPaths: {
-        project: ".codex/skills/",
+        project: ".agents/skills/",
         global: "~/.codex/skills/"
+      },
+      projectStandards: {
+        rules: "agents",
+        skills: "agents"
       }
     };
     super(definition);
@@ -35945,8 +35970,11 @@ class GeminiCliAgent extends Agent {
       rulesPath: ".gemini/settings.json",
       globalRulesPath: "~/.gemini/settings.json",
       skillPaths: {
-        project: ".gemini/skills/",
+        project: ".agents/skills/",
         global: "~/.gemini/skills/"
+      },
+      projectStandards: {
+        skills: "agents"
       }
     };
     super(definition);
@@ -36150,8 +36178,12 @@ class CursorAgent extends Agent {
       globalConfigPath: "~/.cursor/mcp.json",
       rulesPath: ".cursorrules",
       skillPaths: {
-        project: ".cursor/skills/",
+        project: ".agents/skills/",
         global: "~/.cursor/skills/"
+      },
+      projectStandards: {
+        rules: "agents",
+        skills: "agents"
       }
     };
     super(definition);
@@ -36303,9 +36335,14 @@ class DroidAgent extends Agent {
       globalConfigPath: "~/.factory/mcp.json",
       rulesPath: "AGENTS.md",
       skillPaths: {
-        project: ".factory/skills/",
+        project: ".agents/skills/",
         global: "~/.factory/skills/"
-      }
+      },
+      projectStandards: {
+        rules: "agents",
+        skills: "agents"
+      },
+      mcpConfigScope: "global-only"
     };
     super(definition);
   }
@@ -36547,8 +36584,12 @@ class CopilotAgent extends MarkdownRulesAgent {
       nativeConfigPath: ".vscode/mcp.json",
       rulesPath: "AGENTS.md",
       skillPaths: {
-        project: ".claude/skills/",
-        global: "~/.claude/skills/"
+        project: ".agents/skills/",
+        global: "~/.copilot/skills/"
+      },
+      projectStandards: {
+        rules: "agents",
+        skills: "agents"
       }
     };
     super(definition);
@@ -36680,7 +36721,10 @@ class AiderAgent extends MarkdownRulesAgent {
         }
       ],
       nativeConfigPath: ".mcp.json",
-      rulesPath: "AGENTS.md"
+      rulesPath: "AGENTS.md",
+      projectStandards: {
+        rules: "agents"
+      }
     };
     super(definition);
   }
@@ -36970,8 +37014,12 @@ class RooCodeAgent extends MarkdownRulesAgent {
       nativeConfigPath: ".roo/mcp.json",
       rulesPath: "AGENTS.md",
       skillPaths: {
-        project: ".roo/skills/",
+        project: ".agents/skills/",
         global: "~/.roo/skills/"
+      },
+      projectStandards: {
+        rules: "agents",
+        skills: "agents"
       }
     };
     super(definition);
@@ -37095,7 +37143,10 @@ class ZedAgent extends MarkdownRulesAgent {
         }
       ],
       nativeConfigPath: ".zed/settings.json",
-      rulesPath: "AGENTS.md"
+      rulesPath: "AGENTS.md",
+      projectStandards: {
+        rules: "agents"
+      }
     };
     super(definition);
   }
@@ -37478,21 +37529,33 @@ class SkillsManager {
         };
       }
       const result = { installed: [], skipped: [] };
-      for (const skill of skills) {
-        for (const agent of agents) {
-          if (!agent.supportsSkills()) {
+      const dirToAgents = new Map;
+      for (const agent of agents) {
+        if (!agent.supportsSkills()) {
+          for (const skill of skills) {
             result.skipped.push({ skill, reason: `${agent.name} does not support skills` });
-            continue;
           }
-          const skillsDir = agent.getSkillsDir(projectPath, options2.global);
-          if (!skillsDir) {
+          continue;
+        }
+        const skillsDir = agent.getSkillsDir(projectPath, options2.global);
+        if (!skillsDir) {
+          for (const skill of skills) {
             result.skipped.push({ skill, reason: `No skills directory for ${agent.name}` });
-            continue;
           }
+          continue;
+        }
+        const existing = dirToAgents.get(skillsDir) || [];
+        existing.push(agent);
+        dirToAgents.set(skillsDir, existing);
+      }
+      for (const skill of skills) {
+        for (const [skillsDir, dirAgents] of dirToAgents) {
           try {
             const shouldCopy = options2.copy || resolved.type === "github";
             const installedPath = await this.installSkill(skill.path, skill.name, skillsDir, shouldCopy);
-            result.installed.push({ skill, agent: agent.id, path: installedPath });
+            for (const agent of dirAgents) {
+              result.installed.push({ skill, agent: agent.id, path: installedPath });
+            }
           } catch (error) {
             result.skipped.push({ skill, reason: error.message });
           }
@@ -37659,6 +37722,9 @@ async function detectCommand(options2) {
   }
 }
 
+// dist/commands/sync.js
+import {relative as relative3} from "path";
+
 // dist/core/propagator.js
 var import_gray_matter2 = __toESM(require_gray_matter(), 1);
 import {resolve as resolve7} from "path";
@@ -40409,6 +40475,7 @@ class Propagator {
       }
       result.changes.push({
         agent: generatedFile.agents.join(", "),
+        agents: [...generatedFile.agents],
         action: "backed_up",
         file: backupPath
       });
@@ -40418,6 +40485,7 @@ class Propagator {
     }
     result.changes.push({
       agent: generatedFile.agents.join(", "),
+      agents: [...generatedFile.agents],
       action: exists ? "updated" : "created",
       file: generatedFile.path
     });
@@ -40438,8 +40506,8 @@ class Propagator {
     this.agentAdapters.set("cursor", {
       buildOutputs: async (_projectPath, content) => [
         {
-          path: ".cursorrules",
-          content: this.formatForCursor(content)
+          path: "AGENTS.md",
+          content
         }
       ]
     });
@@ -40475,6 +40543,14 @@ class Propagator {
         }
       ]
     });
+    this.agentAdapters.set("codex", {
+      buildOutputs: async (_projectPath, content) => [
+        {
+          path: "AGENTS.md",
+          content
+        }
+      ]
+    });
     this.agentAdapters.set("zed", {
       buildOutputs: async (_projectPath, content) => [
         {
@@ -40483,6 +40559,14 @@ class Propagator {
         }
       ]
     });
+    this.agentAdapters.set("droid", {
+      buildOutputs: async (_projectPath, content) => [
+        {
+          path: "AGENTS.md",
+          content
+        }
+      ]
+    });
     this.agentAdapters.set("aider", {
       buildOutputs: async (projectPath, content) => [
         {
@@ -40758,6 +40842,7 @@ class ManagedStateStore {
 // dist/commands/sync.js
 async function syncCommand(options2) {
   const cwd = process.cwd();
+  const agentManager4 = new AgentManager;
   logger.title("\uD83D\uDD04 AgentInit - Sync Configuration");
   if (options2.dryRun) {
     logger.info("Running in dry-run mode - no files will be modified");
@@ -40790,7 +40875,9 @@ async function syncCommand(options2) {
         logger.success(`Applied ${result.changes.length} changes:`);
         for (const change of result.changes) {
           const action = change.action === "created" ? "\u2795" : change.action === "updated" ? "\uD83D\uDCDD" : "\uD83D\uDCBE";
-          logger.info(`  ${action} ${change.agent}: ${change.file}`);
+          const names = change.agents.map((id) => agentManager4.getAgentById(id)?.name || id).join(", ");
+          logger.info(`  ${action} ${relative3(cwd, change.file) || change.file}`);
+          logger.info(`     Agents: ${names}`);
         }
         if (options2.backup && result.changes.some((c) => c.action === "backed_up")) {
           logger.info("\uD83D\uDCBE Backup files created with .agentinit.backup extension");
@@ -40814,6 +40901,9 @@ async function syncCommand(options2) {
   }
 }
 
+// dist/commands/apply.js
+import {relative as relative4} from "path";
+
 // dist/types/index.js
 var MCPServerType;
 (function(MCPServerType2) {
@@ -49440,8 +49530,8 @@ class MCPVerifier {
 import {promises as fs24} from "fs";
 import {dirname as dirname5, join as join6} from "path";
 var normalizeIgnorePath = function(projectPath, value) {
-  const relative3 = value.startsWith(projectPath) ? value.slice(projectPath.length + 1) : value;
-  const normalized = relative3.replace(/\\/g, "/").replace(/^\/+/, "");
+  const relative4 = value.startsWith(projectPath) ? value.slice(projectPath.length + 1) : value;
+  const normalized = relative4.replace(/\\/g, "/").replace(/^\/+/, "");
   if (!normalized) {
     return normalized;
   }
@@ -49569,8 +49659,8 @@ async function discoverProjectSkills(projectPath, skillsManager3) {
   };
 }
 async function applyProjectSkills(projectPath, targetAgentIds, managedState2, options2 = {}) {
-  const agentManager4 = new AgentManager;
-  const skillsManager3 = new SkillsManager(agentManager4);
+  const agentManager5 = new AgentManager;
+  const skillsManager3 = new SkillsManager(agentManager5);
   const { sources, skills } = await discoverProjectSkills(projectPath, skillsManager3);
   const installed = [];
   const skipped = [];
@@ -49582,7 +49672,7 @@ async function applyProjectSkills(projectPath, targetAgentIds, managedState2, op
       skipped
     };
   }
-  const targetAgents = targetAgentIds.map((id) => agentManager4.getAgentById(id)).filter((agent) => !!agent);
+  const targetAgents = targetAgentIds.map((id) => agentManager5.getAgentById(id)).filter((agent) => !!agent);
   if (targetAgents.length === 0) {
     return {
       discovered: skills.length,
@@ -49662,6 +49752,7 @@ function hasLegacyApplyArgs(args) {
 }
 async function applyProjectCommand(options2) {
   const cwd = process.cwd();
+  const agentManager6 = new AgentManager;
   let managedState3 = null;
   logger.title("\uD83D\uDD27 AgentInit - Apply");
   if (options2.dryRun) {
@@ -49721,15 +49812,29 @@ async function applyProjectCommand(options2) {
         syncResult.changes.forEach((change) => {
           if (change.action === "backed_up")
             return;
-          logger.info(`  ${change.agent}: ${change.file}`);
+          const names = change.agents.map((id) => agentManager6.getAgentById(id)?.name || id).join(", ");
+          logger.info(`  ${relative4(cwd, change.file) || change.file}`);
+          logger.info(`    Agents: ${names}`);
         });
       }
       if (projectSkills2.installed.length > 0) {
         logger.info("");
         logger.info(`Installed ${green(String(projectSkills2.installed.length))} project skill target(s):`);
-        projectSkills2.installed.forEach((item) => {
-          logger.info(`  ${item.agent}: ${item.skill.name} -> ${item.path}`);
-        });
+        const installsByPath = new Map;
+        for (const item of projectSkills2.installed) {
+          const existing = installsByPath.get(item.path) || {
+            agents: new Set,
+            skills: new Set
+          };
+          existing.agents.add(agentManager6.getAgentById(item.agent)?.name || item.agent);
+          existing.skills.add(item.skill.name);
+          installsByPath.set(item.path, existing);
+        }
+        for (const [path, details] of installsByPath) {
+          logger.info(`  ${relative4(cwd, path) || path}`);
+          logger.info(`    Agents: ${[...details.agents].join(", ")}`);
+          logger.info(`    Skills: ${[...details.skills].join(", ")}`);
+        }
       }
     }
     if (projectSkills2.discovered > 0) {
@@ -49879,13 +49984,13 @@ async function applyCommand(args) {
       process.exit(1);
     }
     spinner.text = isGlobal ? "Preparing global configuration..." : "Detecting agents...";
-    const agentManager5 = new AgentManager;
+    const agentManager6 = new AgentManager;
     let targetAgents;
     if (specifiedClient) {
-      const agent = agentManager5.getAgentById(specifiedClient);
+      const agent = agentManager6.getAgentById(specifiedClient);
       if (!agent) {
         spinner.fail(`Unknown agent: ${specifiedClient}`);
-        logger.error(`Supported agents: ${agentManager5.getSupportedAgentIds().join(", ")}`);
+        logger.error(`Supported agents: ${agentManager6.getSupportedAgentIds().join(", ")}`);
         process.exit(1);
       }
       if (isGlobal) {
@@ -49918,11 +50023,11 @@ async function applyCommand(args) {
         spinner.fail("Global configuration requires specifying an agent with --agent");
         process.exit(1);
       }
-      const detectedAgents = await agentManager5.detectAgents(cwd);
+      const detectedAgents = await agentManager6.detectAgents(cwd);
       if (detectedAgents.length === 0) {
         spinner.warn("No AI coding agents detected in this project");
         logger.info("Supported agents:");
-        agentManager5.getAllAgents().forEach((agent) => {
+        agentManager6.getAllAgents().forEach((agent) => {
           logger.info(`  \u2022 ${agent.name} (${agent.id})`);
           logger.info(`    Files: ${agent.configFiles.map((c) => c.path).join(", ")}`);
         });
@@ -50247,8 +50352,8 @@ async function verifyMcpCommand(args) {
       spinner.text = `Verifying ${serversToVerify.length} MCP server(s) from arguments...`;
     } else {
       spinner = ora("Detecting agents and MCP configurations...").start();
-      const agentManager6 = new AgentManager;
-      const detectedAgents = await agentManager6.detectAgents(cwd);
+      const agentManager7 = new AgentManager;
+      const detectedAgents = await agentManager7.detectAgents(cwd);
       if (detectedAgents.length === 0) {
         spinner.warn("No AI coding agents detected in this project");
         logger.info("Run `agentinit detect` to see which agents are supported");
@@ -50416,12 +50521,13 @@ async function revertCommand(options2) {
 }
 
 // dist/commands/skills.js
+import {relative as relative5} from "path";
 function registerSkillsCommand(program2) {
   const skills = program2.command("skills").description("Manage agent skills");
   skills.command("add <source>").description("Add skills from a GitHub repo or local path").option("-g, --global", "Install skills globally").option("-a, --agent <agents...>", "Target specific agent(s)").option("-s, --skill <names...>", "Install only specific skills by name").option("-l, --list", "List available skills from the source without installing").option("--copy", "Copy skill files instead of symlinking").option("-y, --yes", "Skip confirmation prompts").action(async (source, options2) => {
     logger.title("\uD83D\uDCE6 AgentInit - Skills");
-    const agentManager7 = new AgentManager;
-    const skillsManager4 = new SkillsManager(agentManager7);
+    const agentManager8 = new AgentManager;
+    const skillsManager4 = new SkillsManager(agentManager8);
     if (options2.list) {
       const spinner2 = ora("Discovering skills...").start();
       try {
@@ -50476,13 +50582,23 @@ function registerSkillsCommand(program2) {
         spinner.warn("No skills found in the source.");
         return;
       }
-      spinner.succeed(`Installed ${green(String(result.installed.length))} skill(s)`);
-      const byAgent = new Map;
+      const uniqueInstallCount = new Set(result.installed.map((item) => `${item.path}:${item.skill.name}`)).size;
+      spinner.succeed(`Installed ${green(String(uniqueInstallCount))} skill(s)`);
+      const byPath = new Map;
       for (const item of result.installed) {
-        byAgent.set(item.agent, (byAgent.get(item.agent) || 0) + 1);
+        const path = item.path;
+        const existing = byPath.get(path) || {
+          agents: new Set,
+          skills: new Set
+        };
+        existing.agents.add(agentManager8.getAgentById(item.agent)?.name || item.agent);
+        existing.skills.add(item.skill.name);
+        byPath.set(path, existing);
       }
-      for (const [agent, count] of byAgent) {
-        logger.info(`  ${agent}: ${green(String(count))} skill(s) installed`);
+      for (const [path, details] of byPath) {
+        logger.info(`  ${relative5(process.cwd(), path) || path}`);
+        logger.info(`    Agents: ${[...details.agents].join(", ")}`);
+        logger.info(`    Skills: ${green(String(details.skills.size))} installed (${[...details.skills].join(", ")})`);
       }
       if (result.skipped.length > 0) {
         logger.info("");
@@ -50499,8 +50615,8 @@ function registerSkillsCommand(program2) {
   });
   skills.command("list").alias("ls").description("List installed skills").option("-g, --global", "List only global skills").option("-a, --agent <agents...>", "Filter by specific agent(s)").action(async (options2) => {
     logger.title("\uD83D\uDCE6 AgentInit - Skills");
-    const agentManager7 = new AgentManager;
-    const skillsManager4 = new SkillsManager(agentManager7);
+    const agentManager8 = new AgentManager;
+    const skillsManager4 = new SkillsManager(agentManager8);
     const installed = await skillsManager4.listInstalled(process.cwd(), {
       global: options2.global,
       agents: options2.agent
@@ -50533,8 +50649,8 @@ function registerSkillsCommand(program2) {
         return;
       }
     }
-    const agentManager7 = new AgentManager;
-    const skillsManager4 = new SkillsManager(agentManager7);
+    const agentManager8 = new AgentManager;
+    const skillsManager4 = new SkillsManager(agentManager8);
     const result = await skillsManager4.remove(names, process.cwd(), {
       global: options2.global,
       agents: options2.agent,
@@ -50574,26 +50690,23 @@ var filterMcpArgs = function(args) {
   }
   return filtered;
 };
-async function resolveAgents(agentManager8, agentIds, isGlobal, cwd) {
+async function resolveAgents(agentManager9, agentIds, isGlobal, cwd) {
   if (agentIds && agentIds.length > 0) {
     const results = [];
     for (const id of agentIds) {
-      const agent = agentManager8.getAgentById(id);
+      const agent = agentManager9.getAgentById(id);
       if (!agent) {
         logger.error(`Unknown agent: ${id}`);
-        logger.info(`Supported agents: ${agentManager8.getSupportedAgentIds().join(", ")}`);
+        logger.info(`Supported agents: ${agentManager9.getSupportedAgentIds().join(", ")}`);
         process.exit(1);
       }
       if (isGlobal && !agent.supportsGlobalConfig()) {
         logger.error(`Agent ${agent.name} does not support global configuration`);
         process.exit(1);
       }
-      if (!isGlobal) {
-        const detection = await agent.detectPresence(cwd);
-        if (!detection) {
-          logger.warning(`Agent ${id} not detected in project, skipping`);
-          continue;
-        }
+      if (!isGlobal && !agent.supportsProjectMcpConfig()) {
+        logger.error(`Agent ${agent.name} only supports global MCP configuration. Use --global.`);
+        process.exit(1);
       }
       results.push({ agent, isGlobal });
     }
@@ -50603,19 +50716,61 @@ async function resolveAgents(agentManager8, agentIds, isGlobal, cwd) {
     logger.error("--global requires --agent to specify target agent(s)");
     process.exit(1);
   }
-  const detected = await agentManager8.detectAgents(cwd);
+  const detector = new AgentDetector;
+  const detectedConfigs = await detector.detectAgents(cwd);
+  const detected = detectedConfigs.filter((config) => config.detected).map((config) => agentManager9.getAgentById(config.name)).filter((agent) => !!agent).filter((agent) => agent.supportsProjectMcpConfig());
   if (detected.length === 0) {
     logger.warning("No AI coding agents detected in this project");
     logger.info("Supported agents:");
-    agentManager8.getAllAgents().forEach((a) => {
+    agentManager9.getAllAgents().filter((a) => a.supportsProjectMcpConfig()).forEach((a) => {
       logger.info(`  - ${a.name} (${a.id})`);
     });
     logger.info("");
     logger.info("To target a specific agent, use: --agent <agent-id>");
     return [];
   }
-  return detected.map((d) => ({ agent: d.agent, isGlobal: false }));
+  return detected.map((agent) => ({ agent, isGlobal: false }));
 }
+var buildPlannedTargets = function(targets, servers, cwd) {
+  const plans = [];
+  for (const { agent, isGlobal } of targets) {
+    const filtered = MCPFilter.filterForAgent(agent, servers);
+    if (filtered.servers.length === 0) {
+      continue;
+    }
+    const configPath = isGlobal ? agent.getGlobalMcpPath() : agent.getNativeMcpPath(cwd);
+    if (!configPath) {
+      continue;
+    }
+    plans.push({
+      agent,
+      isGlobal,
+      configPath,
+      servers: filtered.servers,
+      transformations: filtered.transformations
+    });
+  }
+  return plans;
+};
+var logPlannedTargets = function(plans) {
+  if (plans.length === 0) {
+    return;
+  }
+  const grouped = new Map;
+  for (const plan of plans) {
+    const existing = grouped.get(plan.configPath) || [];
+    existing.push(plan.agent.name);
+    grouped.set(plan.configPath, existing);
+  }
+  logger.info("Planned targets:");
+  for (const [configPath, agentNames] of grouped) {
+    logger.info(`  - ${configPath}`);
+    for (const agentName of agentNames) {
+      logger.info(`    ${agentName}`);
+    }
+  }
+  logger.info("");
+};
 var registerAddCommand = function(mcp) {
   mcp.command("add").description("Add MCP server(s) to agent configurations").allowUnknownOption(true).option("--agent <agents...>", "Target specific agent(s)").option("-g, --global", "Apply to global configuration").option("--verify", "Verify MCP servers after adding").option("--timeout <ms>", "Connection timeout for verification (ms)").action(async (options2, command) => {
     const cwd = process.cwd();
@@ -50650,42 +50805,56 @@ var registerAddCommand = function(mcp) {
         return;
       }
       spinner.text = "Resolving target agents...";
-      const agentManager8 = new AgentManager;
+      const agentManager9 = new AgentManager;
       const isGlobal = !!options2.global;
-      const targets = await resolveAgents(agentManager8, options2.agent, isGlobal, cwd);
+      const targets = await resolveAgents(agentManager9, options2.agent, isGlobal, cwd);
       if (targets.length === 0) {
         spinner.warn("No target agents resolved");
         return;
       }
-      let totalApplied = 0;
-      for (const { agent, isGlobal: global3 } of targets) {
-        spinner.text = `Applying to ${agent.name}...`;
-        const filtered = MCPFilter.filterForAgent(agent, parsed.servers);
-        if (filtered.servers.length === 0) {
-          logger.warning(`${agent.name}: No compatible MCP servers`);
-          continue;
+      const plans = buildPlannedTargets(targets, parsed.servers, cwd);
+      if (plans.length === 0) {
+        spinner.warn("No servers were applied (all filtered out)");
+        return;
+      }
+      spinner.stop();
+      logPlannedTargets(plans);
+      if (options2.verify) {
+        const timeout = options2.timeout ? parseInt(options2.timeout, 10) : undefined;
+        const verificationSources = plans.flatMap((plan) => plan.servers.map((server) => ({
+          server,
+          agentName: plan.agent.name,
+          configPath: plan.configPath
+        })));
+        const verificationResult = await runVerification(plans.flatMap((plan) => plan.servers), timeout, undefined, verificationSources);
+        if (!verificationResult.allSucceeded) {
+          logger.error("Verification failed. No MCP configuration changes were applied.");
+          process.exit(1);
         }
-        if (global3) {
-          await agent.applyGlobalMCPConfig(filtered.servers);
+        logger.info("");
+      }
+      const spinnerApply = ora("Applying MCP configuration...").start();
+      let totalApplied = 0;
+      for (const plan of plans) {
+        spinnerApply.text = `Applying to ${plan.agent.name}...`;
+        if (plan.isGlobal) {
+          await plan.agent.applyGlobalMCPConfig(plan.servers);
         } else {
-          await agent.applyMCPConfig(cwd, filtered.servers);
-        }
-        totalApplied += filtered.servers.length;
-        const configPath = global3 ? agent.getGlobalMcpPath() : agent.getNativeMcpPath(cwd);
-        logger.info(`  ${green("+")} ${agent.name}: ${filtered.servers.length} server(s) added`);
-        if (configPath) {
-          logger.info(`    Config: ${configPath}`);
+          await plan.agent.applyMCPConfig(cwd, plan.servers);
         }
-        if (filtered.transformations.length > 0) {
-          filtered.transformations.forEach((t) => {
+        totalApplied += plan.servers.length;
+        logger.info(`  ${green("+")} ${plan.agent.name}: ${plan.servers.length} server(s) added`);
+        logger.info(`    Config: ${plan.configPath}`);
+        if (plan.transformations.length > 0) {
+          plan.transformations.forEach((t) => {
             logger.info(`    ${yellow("~")} ${t.original.name}: ${t.reason}`);
           });
         }
       }
       if (totalApplied === 0) {
-        spinner.warn("No servers were applied (all filtered out)");
+        spinnerApply.warn("No servers were applied (all filtered out)");
       } else {
-        spinner.succeed(`Added ${totalApplied} MCP server(s)`);
+        spinnerApply.succeed(`Added ${totalApplied} MCP server(s)`);
         parsed.servers.forEach((server) => {
           const typeLabel = server.type.toUpperCase();
           if (server.type === "stdio" && server.command) {
@@ -50695,11 +50864,6 @@ var registerAddCommand = function(mcp) {
           }
         });
       }
-      if (options2.verify && parsed.servers.length > 0) {
-        logger.info("");
-        const timeout = options2.timeout ? parseInt(options2.timeout, 10) : undefined;
-        await runVerification(parsed.servers, timeout);
-      }
     } catch (error) {
       spinner.fail("Failed to add MCP servers");
       if (error instanceof MCPParseError) {
@@ -50714,11 +50878,11 @@ var registerAddCommand = function(mcp) {
 var registerListCommand = function(mcp) {
   mcp.command("list").alias("ls").description("List configured MCP servers").option("--agent <agents...>", "Target specific agent(s)").option("-g, --global", "List global configuration").action(async (options2) => {
     const cwd = process.cwd();
-    const agentManager8 = new AgentManager;
+    const agentManager9 = new AgentManager;
     const isGlobal = !!options2.global;
     const spinner = ora("Reading MCP configurations...").start();
     try {
-      const targets = await resolveAgents(agentManager8, options2.agent, isGlobal, cwd);
+      const targets = await resolveAgents(agentManager9, options2.agent, isGlobal, cwd);
       if (targets.length === 0) {
         spinner.warn("No target agents resolved");
         return;
@@ -50781,11 +50945,11 @@ var registerListCommand = function(mcp) {
 var registerRemoveCommand = function(mcp) {
   mcp.command("remove <name>").description("Remove an MCP server by name").option("--agent <agents...>", "Target specific agent(s)").option("-g, --global", "Remove from global configuration").action(async (name, options2) => {
     const cwd = process.cwd();
-    const agentManager8 = new AgentManager;
+    const agentManager9 = new AgentManager;
     const isGlobal = !!options2.global;
     const spinner = ora(`Removing MCP server "${name}"...`).start();
     try {
-      const targets = await resolveAgents(agentManager8, options2.agent, isGlobal, cwd);
+      const targets = await resolveAgents(agentManager9, options2.agent, isGlobal, cwd);
       if (targets.length === 0) {
         spinner.warn("No target agents resolved");
         return;
@@ -50875,8 +51039,8 @@ var registerVerifyCommand = function(mcp) {
         spinner.text = `Verifying ${serversToVerify.length} MCP server(s) from arguments...`;
       } else {
         spinner.text = "Detecting agents and MCP configurations...";
-        const agentManager8 = new AgentManager;
-        const detectedAgents = await agentManager8.detectAgents(cwd);
+        const agentManager9 = new AgentManager;
+        const detectedAgents = await resolveAgents(agentManager9, undefined, false, cwd);
         if (detectedAgents.length === 0) {
           spinner.warn("No AI coding agents detected in this project");
           logger.info("Run `agentinit detect` to see which agents are supported");
@@ -50980,6 +51144,11 @@ async function runVerification(servers, timeout, spinner, serverSources) {
     logger.info("  3. Verify network connectivity for HTTP/SSE servers");
     logger.info("  4. Try increasing timeout with --timeout <ms>");
   }
+  return {
+    results,
+    successCount,
+    allSucceeded: successCount === results.length
+  };
 }
 function registerMcpCommand(program2) {
   const mcp = program2.command("mcp").description("Manage MCP server configurations");
@@ -51010,7 +51179,7 @@ var colorizeTokenDiff2 = function(diff) {
     return green(`+${diff}`);
   return red(`${diff}`);
 };
-async function resolveTargetAgents(agentManager9, options2, cwd) {
+async function resolveTargetAgents(agentManager10, options2, cwd) {
   if (options2.global && !options2.agent?.length) {
     logger.error("--global flag requires --agent to specify target agent(s)");
     logger.info("Example: agentinit rules add --global --agent claude --template git");
@@ -51019,10 +51188,10 @@ async function resolveTargetAgents(agentManager9, options2, cwd) {
   if (options2.agent?.length) {
     const agents = [];
     for (const id of options2.agent) {
-      const agent = agentManager9.getAgentById(id);
+      const agent = agentManager10.getAgentById(id);
       if (!agent) {
         logger.error(`Unknown agent: ${id}`);
-        logger.info(`Supported agents: ${agentManager9.getSupportedAgentIds().join(", ")}`);
+        logger.info(`Supported agents: ${agentManager10.getSupportedAgentIds().join(", ")}`);
         process.exit(1);
       }
       if (options2.global && !agent.supportsGlobalRules()) {
@@ -51033,11 +51202,11 @@ async function resolveTargetAgents(agentManager9, options2, cwd) {
     }
     return agents;
   }
-  const detected = await agentManager9.detectAgents(cwd);
+  const detected = await agentManager10.detectAgents(cwd);
   if (detected.length === 0) {
     logger.warning("No AI coding agents detected in this project");
     logger.info("Supported agents:");
-    agentManager9.getAllAgents().forEach((a) => {
+    agentManager10.getAllAgents().forEach((a) => {
       logger.info(`  - ${a.name} (${a.id})`);
     });
     logger.info("");
@@ -51112,8 +51281,8 @@ function registerRulesCommand(program2) {
         return;
       }
       spinner.text = "Resolving agents...";
-      const agentManager9 = new AgentManager;
-      const agents = await resolveTargetAgents(agentManager9, options2, cwd);
+      const agentManager10 = new AgentManager;
+      const agents = await resolveTargetAgents(agentManager10, options2, cwd);
       const results = [];
       for (const agent of agents) {
         if (!agent.capabilities.rules) {
@@ -51194,8 +51363,8 @@ function registerRulesCommand(program2) {
     logger.title("\uD83D\uDCCF AgentInit - Rules");
     const cwd = process.cwd();
     const isGlobal = !!options2.global;
-    const agentManager9 = new AgentManager;
-    const agents = await resolveTargetAgents(agentManager9, options2, cwd);
+    const agentManager10 = new AgentManager;
+    const agents = await resolveTargetAgents(agentManager10, options2, cwd);
     let foundAny = false;
     for (const agent of agents) {
       if (!agent.capabilities.rules) {
@@ -51242,8 +51411,8 @@ function registerRulesCommand(program2) {
     }
     const cwd = process.cwd();
     const isGlobal = !!options2.global;
-    const agentManager9 = new AgentManager;
-    const agents = await resolveTargetAgents(agentManager9, options2, cwd);
+    const agentManager10 = new AgentManager;
+    const agents = await resolveTargetAgents(agentManager10, options2, cwd);
     const spinner = ora("Removing rules...").start();
     let totalRemoved = 0;
     try {
@@ -51314,8 +51483,8 @@ var MARKETPLACES = [
 class PluginManager {
   agentManager;
   skillsManager;
-  constructor(agentManager10) {
-    this.agentManager = agentManager10 || new AgentManager;
+  constructor(agentManager11) {
+    this.agentManager = agentManager11 || new AgentManager;
     this.skillsManager = new SkillsManager(this.agentManager);
   }
   resolveSource(source, options2) {
@@ -51971,8 +52140,8 @@ function registerPluginsCommand(program2) {
   const plugins = program2.command("plugins").description("Install agent-agnostic plugins from any marketplace or source");
   plugins.command("install <source>").description("Install a plugin from <marketplace>/<name>, a GitHub repo, or a local path").option("--from <marketplace>", `Marketplace source override (available: ${marketplaceHelp})`).option("-a, --agent <agents...>", "Target specific agent(s)").option("-g, --global", "Install globally").option("-l, --list", "Preview plugin contents without installing").option("-y, --yes", "Skip confirmation prompts, auto-detect all agents").action(async (source, options2) => {
     logger.title("\uD83D\uDD0C AgentInit - Plugins");
-    const agentManager11 = new AgentManager;
-    const pluginManager2 = new PluginManager(agentManager11);
+    const agentManager12 = new AgentManager;
+    const pluginManager2 = new PluginManager(agentManager12);
     if (options2.list) {
       const spinner2 = ora("Fetching plugin...").start();
       try {