@wuyax/mcps 0.1.0-beta.2 → 0.1.0-beta.3

package/dist/cli.cjs

@@ -27,7 +27,7 @@ var import_commander5 = require("commander");
 
 // src/cli/add.ts
 var import_commander2 = require("commander");
-var import_picocolors13 = __toESM(require("picocolors"), 1);
+var import_picocolors17 = __toESM(require("picocolors"), 1);
 
 // src/agents.ts
 var import_node_fs = require("fs");
@@ -994,6 +994,74 @@ var agentConfigStore = new AgentConfigStore();
 // src/utils/to-error-message.ts
 var toErrorMessage = (error, fallback = "Unknown error") => error instanceof Error ? error.message : fallback;
 
+// src/resolve-config-clusters.ts
+var getCandidateAgentsForScope = (options = {}) => {
+  return options.global ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
+};
+var getCoHostedAgents = (agentType, options = {}) => {
+  const currentAgent = getMcpAgentConfig(agentType);
+  const currentTarget = resolveMcpConfigTarget(currentAgent, options);
+  const candidates = getCandidateAgentsForScope(options);
+  const coHosted = [];
+  for (const candidateType of candidates) {
+    if (candidateType === agentType) continue;
+    const candidateConfig = getMcpAgentConfig(candidateType);
+    const candidateTarget = resolveMcpConfigTarget(candidateConfig, options);
+    if (candidateTarget.configPath === currentTarget.configPath && candidateTarget.configKey === currentTarget.configKey) {
+      coHosted.push(candidateType);
+    }
+  }
+  return coHosted;
+};
+var resolveConfigClusters = (agentTypes, options = {}) => {
+  const clustersByPath = /* @__PURE__ */ new Map();
+  for (const agentType of agentTypes) {
+    const agentConfig = getMcpAgentConfig(agentType);
+    const target = resolveMcpConfigTarget(agentConfig, options);
+    let keyMap = clustersByPath.get(target.configPath);
+    if (!keyMap) {
+      keyMap = /* @__PURE__ */ new Map();
+      clustersByPath.set(target.configPath, keyMap);
+    }
+    let cluster = keyMap.get(target.configKey);
+    if (!cluster) {
+      const allCoHosted = getCoHostedAgents(agentType, options);
+      cluster = {
+        configPath: target.configPath,
+        configKey: target.configKey,
+        targetAgents: [],
+        coHostedAgents: allCoHosted
+      };
+      keyMap.set(target.configKey, cluster);
+    }
+    if (!cluster.targetAgents.includes(agentType)) {
+      cluster.targetAgents.push(agentType);
+    }
+  }
+  const clusters = [];
+  for (const keyMap of clustersByPath.values()) {
+    for (const cluster of keyMap.values()) {
+      cluster.coHostedAgents = cluster.coHostedAgents.filter(
+        (co) => !cluster.targetAgents.includes(co)
+      );
+      clusters.push(cluster);
+    }
+  }
+  return clusters;
+};
+var sortAgentsWithClusters = (agentTypes, options = {}) => {
+  const clusters = resolveConfigClusters(agentTypes, options);
+  const sorted = [];
+  for (const cluster of clusters) {
+    for (const agent of cluster.targetAgents) {
+      if (!sorted.includes(agent)) {
+        sorted.push(agent);
+      }
+    }
+  }
+  return sorted;
+};
+
 // src/transforms/index.ts
 var DIALECT_PRESETS = {
   vscode: {
@@ -1202,24 +1270,61 @@ var transformServerConfigForAgent = (agent, serverName, config, context = { glob
 };
 
 // src/installer.ts
-var installMcpServerForAgent = (serverName, serverConfig, agentType, options = {}) => {
-  const agent = getMcpAgentConfig(agentType);
+var installMcpServerForAgents = (serverName, serverConfig, agentTypes, options = {}) => {
+  const clusters = resolveConfigClusters(agentTypes, options);
+  const resultsByAgent = /* @__PURE__ */ new Map();
   const isGlobal = options.global ?? false;
-  const { target } = agentConfigStore.resolveTarget(agent, options);
-  try {
-    const transformed = transformServerConfigForAgent(agent, serverName, serverConfig, {
-      global: isGlobal
-    });
-    agentConfigStore.writeServer(agent, serverName, transformed, options);
-    return { agent: agentType, success: true, path: target.configPath };
-  } catch (error) {
-    return {
-      agent: agentType,
-      success: false,
-      path: target.configPath,
-      error: toErrorMessage(error)
-    };
+  for (const cluster of clusters) {
+    const primaryAgentType = cluster.targetAgents[0];
+    const primaryAgent = getMcpAgentConfig(primaryAgentType);
+    try {
+      const transformed = transformServerConfigForAgent(primaryAgent, serverName, serverConfig, {
+        global: isGlobal
+      });
+      agentConfigStore.writeServer(primaryAgent, serverName, transformed, options);
+      for (const agentType of cluster.targetAgents) {
+        resultsByAgent.set(agentType, {
+          agent: agentType,
+          success: true,
+          path: cluster.configPath,
+          coConfiguredAgents: cluster.coHostedAgents.length > 0 ? cluster.coHostedAgents : void 0
+        });
+      }
+    } catch (error) {
+      const errorMsg = toErrorMessage(error);
+      for (const agentType of cluster.targetAgents) {
+        resultsByAgent.set(agentType, {
+          agent: agentType,
+          success: false,
+          path: cluster.configPath,
+          error: errorMsg
+        });
+      }
+    }
   }
+  return agentTypes.map((agentType) => resultsByAgent.get(agentType));
+};
+var installToCompatibleAgents = (serverName, serverConfig, options) => {
+  const { allAgents, incompatible = [], global: isGlobal, cwd } = options;
+  const incompatibleMap = new Map(incompatible.map((item) => [item.agent, item.reason]));
+  const compatibleAgents = allAgents.filter((a) => !incompatibleMap.has(a));
+  const installedResults = installMcpServerForAgents(serverName, serverConfig, compatibleAgents, {
+    global: isGlobal,
+    cwd
+  });
+  const installedMap = new Map(installedResults.map((r) => [r.agent, r]));
+  return allAgents.map((agentType) => {
+    const incompatibleReason = incompatibleMap.get(agentType);
+    if (incompatibleReason) {
+      return {
+        agent: agentType,
+        success: false,
+        path: "",
+        error: incompatibleReason
+      };
+    }
+    return installedMap.get(agentType);
+  });
 };
 
 // src/utils/parse-mcp-agent-list.ts
@@ -1423,18 +1528,11 @@ var installMcpServer = (options) => {
     cwd,
     transport: requestedTransport
   });
-  const incompatibleMap = new Map(incompatible.map((item) => [item.agent, item.reason]));
-  const results = allAgents.map((agentType) => {
-    const incompatibleReason = incompatibleMap.get(agentType);
-    if (incompatibleReason) {
-      return {
-        agent: agentType,
-        success: false,
-        path: "",
-        error: incompatibleReason
-      };
-    }
-    return installMcpServerForAgent(serverName, serverConfig, agentType, { global: isGlobal, cwd });
+  const results = installToCompatibleAgents(serverName, serverConfig, {
+    allAgents,
+    incompatible,
+    global: isGlobal,
+    cwd
   });
   return { serverName, config: serverConfig, results };
 };
@@ -1461,21 +1559,6 @@ var listInstalledMcpServers = (options = {}) => {
 };
 
 // src/remove.ts
-var removeMcpServerFromAgent = (serverName, agentType, options = {}) => {
-  const agent = getMcpAgentConfig(agentType);
-  const { target } = agentConfigStore.resolveTarget(agent, options);
-  try {
-    const { removed } = agentConfigStore.removeServer(agent, serverName, options);
-    return { agent: agentType, path: target.configPath, removed };
-  } catch (error) {
-    return {
-      agent: agentType,
-      path: target.configPath,
-      removed: false,
-      error: toErrorMessage(error)
-    };
-  }
-};
 var removeMcpServer = (options) => {
   const { allAgents } = resolveTargetAgents({
     requested: options.agents,
@@ -1483,24 +1566,153 @@ var removeMcpServer = (options) => {
     global: options.global,
     cwd: options.cwd
   });
+  const clusters = resolveConfigClusters(allAgents, {
+    global: options.global,
+    cwd: options.cwd
+  });
   const results = [];
-  for (const agentType of allAgents) {
-    const result = removeMcpServerFromAgent(options.name, agentType, {
-      global: options.global,
-      cwd: options.cwd
-    });
-    if (result.removed || result.error) results.push(result);
+  for (const cluster of clusters) {
+    const primaryAgentType = cluster.targetAgents[0];
+    const primaryAgent = getMcpAgentConfig(primaryAgentType);
+    try {
+      const { removed } = agentConfigStore.removeServer(primaryAgent, options.name, {
+        global: options.global,
+        cwd: options.cwd
+      });
+      if (removed) {
+        for (const agentType of cluster.targetAgents) {
+          results.push({
+            agent: agentType,
+            path: cluster.configPath,
+            removed: true,
+            coAffectedAgents: cluster.coHostedAgents.length > 0 ? cluster.coHostedAgents : void 0
+          });
+        }
+      }
+    } catch (error) {
+      const errorMsg = toErrorMessage(error);
+      for (const agentType of cluster.targetAgents) {
+        results.push({
+          agent: agentType,
+          path: cluster.configPath,
+          removed: false,
+          error: errorMsg
+        });
+      }
+    }
   }
   return results;
 };
 
+// src/update-mcp-server.ts
+var toRemoteServerConfig = (config, defaultTransport = "http") => {
+  const {
+    command: _droppedCommand,
+    args: _droppedArgs,
+    env: _droppedEnv,
+    ...remoteConfig
+  } = config;
+  return {
+    ...remoteConfig,
+    type: remoteConfig.type ?? defaultTransport
+  };
+};
+var toStdioServerConfig = (config) => {
+  const {
+    url: _droppedUrl,
+    type: _droppedType,
+    headers: _droppedHeaders,
+    ...stdioConfig
+  } = config;
+  return stdioConfig;
+};
+var detectUpdateTransition = (incoming, previous) => {
+  if (!previous) {
+    return incoming.url ? "switch-to-remote" : "switch-to-stdio";
+  }
+  if (incoming.url && !incoming.command) {
+    return "switch-to-remote";
+  }
+  if (incoming.command && !incoming.url) {
+    return "switch-to-stdio";
+  }
+  if (incoming.url || !incoming.command && previous.url) {
+    return "merge-remote";
+  }
+  return "merge-stdio";
+};
+var sanitizeUpdatedServerConfig = (incoming, previous) => {
+  const transition = detectUpdateTransition(incoming, previous);
+  const targetTransport = incoming.type ?? previous?.type ?? "http";
+  switch (transition) {
+    case "switch-to-remote": {
+      const cleanBase = previous ? toRemoteServerConfig(previous, targetTransport) : {};
+      return toRemoteServerConfig({ ...cleanBase, ...incoming }, targetTransport);
+    }
+    case "switch-to-stdio": {
+      const cleanBase = previous ? toStdioServerConfig(previous) : {};
+      return toStdioServerConfig({ ...cleanBase, ...incoming });
+    }
+    case "merge-remote": {
+      return toRemoteServerConfig({ ...previous, ...incoming }, targetTransport);
+    }
+    case "merge-stdio": {
+      return toStdioServerConfig({ ...previous, ...incoming });
+    }
+  }
+};
+var updateMcpServer = (options) => {
+  const isGlobal = options.global ?? false;
+  const cwd = options.cwd ?? process.cwd();
+  let previousConfig = options.previousConfig;
+  if (!previousConfig) {
+    const existing = listInstalledMcpServers({
+      global: isGlobal,
+      cwd,
+      agents: options.agents
+    });
+    const found = existing.find((s) => s.serverName === options.serverName && s.serverConfig);
+    if (found) {
+      previousConfig = found.serverConfig;
+    }
+  }
+  const serverConfig = sanitizeUpdatedServerConfig(options.config, previousConfig);
+  let targetAgents = options.agents;
+  if (!targetAgents || targetAgents.length === 0) {
+    const existing = listInstalledMcpServers({ global: isGlobal, cwd });
+    targetAgents = existing.filter((s) => s.serverName === options.serverName).map((s) => s.agent);
+  }
+  const requestedTransport = serverConfig.url ? serverConfig.type ?? "http" : "stdio";
+  const { allAgents, incompatible } = resolveTargetAgents({
+    requested: targetAgents,
+    global: isGlobal,
+    cwd,
+    transport: requestedTransport
+  });
+  const results = installToCompatibleAgents(options.serverName, serverConfig, {
+    allAgents,
+    incompatible,
+    global: isGlobal,
+    cwd
+  });
+  return {
+    serverName: options.serverName,
+    config: serverConfig,
+    results,
+    incompatible
+  };
+};
+
 // src/interactive/main-menu.ts
-var import_prompts11 = require("@inquirer/prompts");
-var import_picocolors11 = __toESM(require("picocolors"), 1);
+var import_prompts10 = require("@inquirer/prompts");
+var import_picocolors15 = __toESM(require("picocolors"), 1);
 
 // src/interactive/wizard-add.ts
-var import_prompts8 = require("@inquirer/prompts");
-var import_picocolors8 = __toESM(require("picocolors"), 1);
+var import_prompts7 = require("@inquirer/prompts");
+var import_picocolors11 = __toESM(require("picocolors"), 1);
+
+// src/utils/co-hosted-feedback.ts
+var import_picocolors2 = __toESM(require("picocolors"), 1);
 
 // src/utils/logger.ts
 var import_picocolors = __toESM(require("picocolors"), 1);
@@ -1519,13 +1731,269 @@ var logger = {
   }
 };
 
+// src/utils/co-hosted-feedback.ts
+var formatCoHostedBadge = (kind, agents) => {
+  if (!agents || agents.length === 0) return "";
+  const label = kind === "configured" ? "co-configured" : "co-affected";
+  return ` ${import_picocolors2.default.yellow(`(${label}: ${agents.join(", ")})`)}`;
+};
+var logCoHostedNotice = (kind, agents) => {
+  if (!agents || agents.length === 0) return;
+  const actionText = kind === "configured" ? "Also configured for" : "Also affects";
+  logger.info(
+    `  ${import_picocolors2.default.dim("Note:")} ${actionText} co-hosted agent(s): ${import_picocolors2.default.yellow(agents.join(", "))}`
+  );
+};
+
 // src/interactive/prompts/agents.ts
-var import_prompts2 = require("@inquirer/prompts");
+var import_picocolors6 = __toESM(require("picocolors"), 1);
+
+// src/interactive/utils/build-linked-agent-choices.ts
 var import_picocolors3 = __toESM(require("picocolors"), 1);
+var buildLinkedAgentChoices = (options) => {
+  const { agents, checkedAgents, detectedAgents = [], scopeOptions = {} } = options;
+  const alignedCheckedSet = new Set(checkedAgents);
+  for (const agent of checkedAgents) {
+    const coHosted = getCoHostedAgents(agent, scopeOptions);
+    for (const co of coHosted) {
+      if (agents.includes(co)) {
+        alignedCheckedSet.add(co);
+      }
+    }
+  }
+  return agents.map((agent) => {
+    const config = getMcpAgentConfig(agent);
+    const displayName = config?.displayName ?? agent;
+    const isDetected = detectedAgents.includes(agent);
+    const coHosted = getCoHostedAgents(agent, scopeOptions).filter(
+      (co) => agents.includes(co)
+    );
+    const detectedBadge = isDetected ? import_picocolors3.default.green(" [detected]") : "";
+    const sharedBadge = coHosted.length > 0 ? import_picocolors3.default.dim(` [shared: ${coHosted.join(", ")}]`) : "";
+    const label = `${displayName} ${import_picocolors3.default.dim(`(${agent})`)}${detectedBadge}${sharedBadge}`;
+    return {
+      name: label,
+      value: agent,
+      checked: alignedCheckedSet.has(agent),
+      linkedValues: coHosted,
+      description: coHosted.length > 0 ? `Linked with ${coHosted.map((a) => getMcpAgentConfig(a).displayName).join(", ")} (shared configuration)` : void 0
+    };
+  });
+};
+
+// src/interactive/prompts/linked-checkbox.ts
+var import_core = require("@inquirer/core");
+var import_picocolors4 = __toESM(require("picocolors"), 1);
+var defaultTheme = {
+  icon: {
+    checked: import_picocolors4.default.green("[x]"),
+    unchecked: import_picocolors4.default.dim("[ ]"),
+    cursor: import_picocolors4.default.cyan(">"),
+    disabledChecked: import_picocolors4.default.dim("[x]"),
+    disabledUnchecked: import_picocolors4.default.dim("[-]")
+  },
+  style: {
+    disabled: (text) => import_picocolors4.default.dim(text),
+    renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
+    description: (text) => import_picocolors4.default.cyan(text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${import_picocolors4.default.bold(key)} ${import_picocolors4.default.dim(action)}`).join(import_picocolors4.default.dim(" | ")),
+    highlight: (text) => import_picocolors4.default.cyan(text)
+  },
+  i18n: {
+    disabledError: "This option is disabled and cannot be toggled."
+  }
+};
+function isSelectable(item) {
+  return !import_core.Separator.isSeparator(item) && !item.disabled;
+}
+function isNavigable(item) {
+  return !import_core.Separator.isSeparator(item);
+}
+function isChecked(item) {
+  return !import_core.Separator.isSeparator(item) && item.checked;
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (import_core.Separator.isSeparator(choice)) {
+      return choice;
+    }
+    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+      const name2 = String(choice);
+      return {
+        value: choice,
+        name: name2,
+        short: name2,
+        checkedName: name2,
+        disabled: false,
+        checked: false,
+        linkedValues: []
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    return {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      checkedName: choice.checkedName ?? name,
+      description: choice.description,
+      disabled: choice.disabled ?? false,
+      checked: choice.checked ?? false,
+      linkedValues: choice.linkedValues ?? []
+    };
+  });
+}
+var linkedCheckbox = (0, import_core.createPrompt)(
+  (config, done) => {
+    const { pageSize = 10, loop = true, required, validate = () => true } = config;
+    const theme = (0, import_core.makeTheme)(defaultTheme, config.theme);
+    const [status, setStatus] = (0, import_core.useState)("idle");
+    const prefix = (0, import_core.usePrefix)({ status, theme });
+    const [items, setItems] = (0, import_core.useState)(() => normalizeChoices(config.choices));
+    const bounds = (0, import_core.useMemo)(() => {
+      const first = items.findIndex(isNavigable);
+      let last = -1;
+      for (let i = items.length - 1; i >= 0; i--) {
+        if (isNavigable(items[i])) {
+          last = i;
+          break;
+        }
+      }
+      if (first === -1 || last === -1) {
+        throw new import_core.ValidationError("[linkedCheckbox prompt] No selectable choices.");
+      }
+      return { first, last };
+    }, [items]);
+    const [active, setActive] = (0, import_core.useState)(bounds.first);
+    const [errorMsg, setError] = (0, import_core.useState)();
+    const toggleWithLinked = (targetIndex) => {
+      const targetItem = items[targetIndex];
+      if (!targetItem || import_core.Separator.isSeparator(targetItem) || targetItem.disabled) {
+        return;
+      }
+      const nextChecked = !targetItem.checked;
+      const targetValue = targetItem.value;
+      const linked = new Set(targetItem.linkedValues);
+      setItems(
+        (prevItems) => prevItems.map((item) => {
+          if (import_core.Separator.isSeparator(item) || item.disabled) {
+            return item;
+          }
+          const isTargetOrLinked = item.value === targetValue || linked.has(item.value) || item.linkedValues.includes(targetValue);
+          if (isTargetOrLinked) {
+            return { ...item, checked: nextChecked };
+          }
+          return item;
+        })
+      );
+    };
+    (0, import_core.useKeypress)(async (key) => {
+      if ((0, import_core.isEnterKey)(key)) {
+        const selection = items.filter(isChecked);
+        const isValid = await validate([...selection]);
+        if (required && selection.length === 0) {
+          setError("At least one choice must be selected");
+        } else if (isValid === true) {
+          setStatus("done");
+          done(selection.map((choice) => choice.value));
+        } else {
+          setError(typeof isValid === "string" ? isValid : "You must select a valid value");
+        }
+      } else if ((0, import_core.isUpKey)(key) || (0, import_core.isDownKey)(key)) {
+        if (errorMsg) setError(void 0);
+        if (loop || (0, import_core.isUpKey)(key) && active !== bounds.first || (0, import_core.isDownKey)(key) && active !== bounds.last) {
+          const offset = (0, import_core.isUpKey)(key) ? -1 : 1;
+          let next = active;
+          do {
+            next = (next + offset + items.length) % items.length;
+          } while (!isNavigable(items[next]));
+          setActive(next);
+        }
+      } else if ((0, import_core.isSpaceKey)(key)) {
+        const activeItem = items[active];
+        if (activeItem && !import_core.Separator.isSeparator(activeItem)) {
+          if (activeItem.disabled) {
+            setError(theme.i18n.disabledError);
+          } else {
+            setError(void 0);
+            toggleWithLinked(active);
+          }
+        }
+      } else if (key.name === "a") {
+        const hasUnchecked = items.some((choice) => isSelectable(choice) && !choice.checked);
+        setItems(
+          (prevItems) => prevItems.map((item) => isSelectable(item) ? { ...item, checked: hasUnchecked } : item)
+        );
+      } else if ((0, import_core.isNumberKey)(key)) {
+        const selectedIndex = Number(key.name) - 1;
+        let selectableIndex = -1;
+        const position = items.findIndex((item) => {
+          if (import_core.Separator.isSeparator(item)) return false;
+          selectableIndex++;
+          return selectableIndex === selectedIndex;
+        });
+        const selectedItem = items[position];
+        if (selectedItem && isSelectable(selectedItem)) {
+          setActive(position);
+          setError(void 0);
+          toggleWithLinked(position);
+        }
+      }
+    });
+    const message = theme.style.message(config.message, status);
+    let description;
+    const page = (0, import_core.usePagination)({
+      items,
+      active,
+      renderItem({ item, isActive }) {
+        if (import_core.Separator.isSeparator(item)) {
+          return ` ${item.separator}`;
+        }
+        const cursor = isActive ? theme.icon.cursor : " ";
+        if (item.disabled) {
+          const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+          const checkbox2 = item.checked ? theme.icon.disabledChecked : theme.icon.disabledUnchecked;
+          return theme.style.disabled(`${cursor} ${checkbox2} ${item.name} ${disabledLabel}`);
+        }
+        if (isActive) {
+          description = item.description;
+        }
+        const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
+        const name = item.checked ? item.checkedName : item.name;
+        const color = isActive ? theme.style.highlight : (x) => x;
+        return color(`${cursor} ${checkbox} ${name}`);
+      },
+      pageSize,
+      loop
+    });
+    if (status === "done") {
+      const selection = items.filter(isChecked);
+      const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
+      return [prefix, message, answer].filter(Boolean).join(" ");
+    }
+    const helpLine = theme.style.keysHelpTip([
+      ["up/down", "navigate"],
+      ["space", "toggle"],
+      ["a", "all"],
+      ["enter", "submit"]
+    ]);
+    const lines = [
+      [prefix, message].filter(Boolean).join(" "),
+      page,
+      helpLine
+    ];
+    if (description) {
+      lines.push(theme.style.description(description));
+    }
+    if (errorMsg) {
+      lines.push(theme.style.error(errorMsg));
+    }
+    return lines.join("\n");
+  }
+);
 
 // src/interactive/prompts/scope.ts
 var import_prompts = require("@inquirer/prompts");
-var import_picocolors2 = __toESM(require("picocolors"), 1);
+var import_picocolors5 = __toESM(require("picocolors"), 1);
 var promptScope = async (options = {}) => {
   const initialGlobal = options.defaultGlobal ?? options.global;
   if (initialGlobal !== void 0) {
@@ -1536,11 +2004,11 @@ var promptScope = async (options = {}) => {
     message: options.message ?? "Select MCP scope:",
     choices: [
       {
-        name: `Current Project - ${import_picocolors2.default.dim(cwd)}`,
+        name: `Current Project - ${import_picocolors5.default.dim(cwd)}`,
         value: false
       },
       {
-        name: `Global User Config - ${import_picocolors2.default.dim("applies across all projects")}`,
+        name: `Global User Config - ${import_picocolors5.default.dim("applies across all projects")}`,
         value: true
       }
     ]
@@ -1560,26 +2028,23 @@ var promptScopeAndAgents = async (options = {}) => {
     cwd
   });
   const detected = resolution.detected;
-  const availableAgentTypes = isGlobal ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
+  const rawAvailable = isGlobal ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
+  const availableAgentTypes = sortAgentsWithClusters(rawAvailable, { global: isGlobal, cwd });
   if (detected.length > 0) {
     logger.info(
-      `Detected configured agents: ${import_picocolors3.default.cyan(detected.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
+      `Detected configured agents: ${import_picocolors6.default.cyan(detected.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
     );
   } else {
     logger.warn(`No active ${isGlobal ? "global" : "project"} agents detected`);
   }
   const defaultChecked = options.defaultAgents && options.defaultAgents.length > 0 ? options.defaultAgents : detected;
-  const choices = availableAgentTypes.map((agentType) => {
-    const config = getMcpAgentConfig(agentType);
-    const isDetected = detected.includes(agentType);
-    const label = `${config.displayName} ${import_picocolors3.default.dim(`(${agentType})`)}${isDetected ? import_picocolors3.default.green(" [detected]") : ""}`;
-    return {
-      name: label,
-      value: agentType,
-      checked: defaultChecked.includes(agentType)
-    };
+  const choices = buildLinkedAgentChoices({
+    agents: availableAgentTypes,
+    checkedAgents: defaultChecked,
+    detectedAgents: detected,
+    scopeOptions: { global: isGlobal, cwd }
   });
-  const selectedAgents = await (0, import_prompts2.checkbox)({
+  const selectedAgents = await linkedCheckbox({
     message: "Select target agents (Space to select, Enter to confirm):",
     choices,
     validate: (chosen) => {
@@ -1596,7 +2061,7 @@ var promptScopeAndAgents = async (options = {}) => {
 };
 
 // src/interactive/prompts/args.ts
-var import_prompts3 = require("@inquirer/prompts");
+var import_prompts2 = require("@inquirer/prompts");
 var parseArgsString = (rawText) => {
   const matches = rawText.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
   if (!matches) return [];
@@ -1611,14 +2076,14 @@ var promptArgsConfig = async (initialArgs = []) => {
   if (initialArgs.length > 0) {
     return initialArgs;
   }
-  const needArgs = await (0, import_prompts3.confirm)({
+  const needArgs = await (0, import_prompts2.confirm)({
     message: "Configure command arguments (e.g. file paths, connection strings)?",
     default: false
   });
   if (!needArgs) {
     return [];
   }
-  const raw = await (0, import_prompts3.input)({
+  const raw = await (0, import_prompts2.input)({
     message: "Enter command arguments (space-separated, wrap paths with spaces in quotes):",
     validate: (val) => val.trim() ? true : "Arguments cannot be empty"
   });
@@ -1629,7 +2094,7 @@ var formatArgsString = (args) => {
 };
 var promptEditArgs = async (currentArgs = []) => {
   const defaultStr = formatArgsString(currentArgs);
-  const raw = await (0, import_prompts3.input)({
+  const raw = await (0, import_prompts2.input)({
     message: "Edit command arguments (space-separated, wrap paths with spaces in quotes, leave empty to clear):",
     default: defaultStr
   });
@@ -1641,17 +2106,37 @@ var promptEditArgs = async (currentArgs = []) => {
 };
 
 // src/interactive/prompts/env.ts
-var import_prompts6 = require("@inquirer/prompts");
-var import_picocolors6 = __toESM(require("picocolors"), 1);
+var import_prompts5 = require("@inquirer/prompts");
+var import_picocolors9 = __toESM(require("picocolors"), 1);
+
+// src/utils/mask-secret.ts
+var SECRET_KEY_PATTERN = /(token|key|secret|password|passwd|auth|credential)/i;
+var maskSecretValue = (key, value) => {
+  if (!SECRET_KEY_PATTERN.test(key) || value.length <= 4) {
+    return value;
+  }
+  return `${value.slice(0, 2)}***${value.slice(-2)}`;
+};
+var SECRET_HEADER_PATTERN = /(authorization|token|key|secret|auth)/i;
+var maskSecretHeader = (key, value) => {
+  if (!SECRET_HEADER_PATTERN.test(key) || value.length <= 8) {
+    return value;
+  }
+  return `${value.slice(0, 4)}***${value.slice(-3)}`;
+};
+
+// src/interactive/prompts/kv.ts
+var import_prompts4 = require("@inquirer/prompts");
+var import_picocolors8 = __toESM(require("picocolors"), 1);
 
 // src/interactive/prompts/multiline.ts
 var import_node_readline = require("readline");
-var import_prompts4 = require("@inquirer/prompts");
-var import_picocolors4 = __toESM(require("picocolors"), 1);
+var import_prompts3 = require("@inquirer/prompts");
+var import_picocolors7 = __toESM(require("picocolors"), 1);
 var readMultilineTextFromTerminal = async (message, endHint = "When done pasting, enter END on a new line or press Enter twice to finish") => {
-  console.log(import_picocolors4.default.cyan(`
+  console.log(import_picocolors7.default.cyan(`
 ${message}`));
-  console.log(import_picocolors4.default.dim(`  (Hint: ${endHint})
+  console.log(import_picocolors7.default.dim(`  (Hint: ${endHint})
 `));
   return new Promise((resolve) => {
     const rl = (0, import_node_readline.createInterface)({
@@ -1695,7 +2180,7 @@ ${message}`));
 };
 var promptEditorText = async (options) => {
   try {
-    return await (0, import_prompts4.editor)({
+    return await (0, import_prompts3.editor)({
       message: options.message,
       default: options.defaultText ?? "",
       postfix: options.postfix
@@ -1706,24 +2191,22 @@ var promptEditorText = async (options) => {
 };
 
 // src/interactive/prompts/kv.ts
-var import_prompts5 = require("@inquirer/prompts");
-var import_picocolors5 = __toESM(require("picocolors"), 1);
 var promptEditKeyValueConfig = async (currentItems = {}, options) => {
   let items = { ...currentItems };
   while (true) {
     const keys = Object.keys(items);
     console.log();
     if (keys.length === 0) {
-      console.log(import_picocolors5.default.dim(`  No ${options.itemsNoun} configured.`));
+      console.log(import_picocolors8.default.dim(`  No ${options.itemsNoun} configured.`));
     } else {
-      console.log(import_picocolors5.default.cyan(import_picocolors5.default.bold(`  Configured ${options.title} (${keys.length}):`)));
+      console.log(import_picocolors8.default.cyan(import_picocolors8.default.bold(`  Configured ${options.title} (${keys.length}):`)));
       for (const [k, v] of Object.entries(items)) {
         const sep = options.separator === "=" ? "=" : ": ";
-        console.log(`    ${import_picocolors5.default.bold(k)}${sep}${import_picocolors5.default.dim(options.maskValue(k, v))}`);
+        console.log(`    ${import_picocolors8.default.bold(k)}${sep}${import_picocolors8.default.dim(options.maskValue(k, v))}`);
       }
     }
     console.log();
-    const choice = await (0, import_prompts5.select)({
+    const choice = await (0, import_prompts4.select)({
       message: `Manage ${options.itemsNoun}:`,
       choices: [
         {
@@ -1770,7 +2253,7 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
       items = parsed;
       logger.success(`${options.title} updated (${Object.keys(items).length} total)`);
     } else if (choice === "upsert") {
-      const key = await (0, import_prompts5.input)({
+      const key = await (0, import_prompts4.input)({
         message: options.keyPromptMessage,
         validate: (val) => {
           const trimmed = val.trim();
@@ -1784,7 +2267,7 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
       const isSecret = options.isSecretKey(trimmedKey);
       let newVal;
       if (isSecret) {
-        newVal = await (0, import_prompts5.password)({
+        newVal = await (0, import_prompts4.password)({
           message: existingVal !== void 0 ? `New value for (${trimmedKey}) [leave empty to keep current]:` : `${options.valuePromptMessage} for (${trimmedKey}) [sensitive content masked]:`,
           mask: "*"
         });
@@ -1792,15 +2275,15 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
           newVal = existingVal;
         }
       } else {
-        newVal = await (0, import_prompts5.input)({
+        newVal = await (0, import_prompts4.input)({
           message: `${options.valuePromptMessage} for (${trimmedKey}):`,
           default: existingVal
         });
       }
       items[trimmedKey] = newVal;
-      logger.success(`${existingVal !== void 0 ? "Updated" : "Added"}: ${import_picocolors5.default.cyan(trimmedKey)}`);
+      logger.success(`${existingVal !== void 0 ? "Updated" : "Added"}: ${import_picocolors8.default.cyan(trimmedKey)}`);
     } else if (choice === "delete") {
-      const toDelete = await (0, import_prompts5.select)({
+      const toDelete = await (0, import_prompts4.select)({
         message: `Select ${options.itemNoun} to delete:`,
         choices: [
           ...keys.map((k) => ({ name: k, value: k })),
@@ -1809,7 +2292,7 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
       });
       if (toDelete !== "__cancel__") {
         delete items[toDelete];
-        logger.success(`Deleted: ${import_picocolors5.default.cyan(toDelete)}`);
+        logger.success(`Deleted: ${import_picocolors8.default.cyan(toDelete)}`);
       }
     } else if (choice === "paste") {
       const pasted = await readMultilineTextFromTerminal(options.pasteMessage);
@@ -1819,7 +2302,7 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
         logger.warn(`No valid ${options.itemsNoun} recognized`);
       } else {
         if (keys.length > 0) {
-          const pasteMode = await (0, import_prompts5.select)({
+          const pasteMode = await (0, import_prompts4.select)({
             message: `How to apply pasted ${options.itemsNoun}?`,
             choices: [
               { name: `Merge with existing ${options.itemsNoun}`, value: "merge" },
@@ -1834,10 +2317,10 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
         } else {
           items = parsed;
         }
-        logger.success(`Successfully applied ${import_picocolors5.default.cyan(String(count))} ${options.itemsNoun}`);
+        logger.success(`Successfully applied ${import_picocolors8.default.cyan(String(count))} ${options.itemsNoun}`);
       }
     } else if (choice === "clear") {
-      const confirmClear = await (0, import_prompts5.confirm)({
+      const confirmClear = await (0, import_prompts4.confirm)({
         message: `Are you sure you want to clear all ${options.itemsNoun}?`,
         default: false
       });
@@ -1850,13 +2333,6 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
 };
 
 // src/interactive/prompts/env.ts
-var SECRET_KEY_PATTERN = /(token|key|secret|password|passwd|auth|credential)/i;
-var maskSecretValue = (key, value) => {
-  if (!SECRET_KEY_PATTERN.test(key) || value.length <= 4) {
-    return value;
-  }
-  return `${value.slice(0, 2)}***${value.slice(-2)}`;
-};
 var formatEnvText = (env) => {
   return Object.entries(env).map(([key, value]) => {
     if (/[\s"']/.test(value)) {
@@ -1890,9 +2366,9 @@ var promptEnvConfig = async (initialEnv = {}) => {
   const env = { ...initialEnv };
   const initialCount = Object.keys(env).length;
   if (initialCount > 0) {
-    logger.info(`Includes ${import_picocolors6.default.cyan(String(initialCount))} preset environment variables`);
+    logger.info(`Includes ${import_picocolors9.default.cyan(String(initialCount))} preset environment variables`);
   }
-  const mode = await (0, import_prompts6.select)({
+  const mode = await (0, import_prompts5.select)({
     message: "Configure environment variables?",
     choices: [
       {
@@ -1928,16 +2404,16 @@ var promptEnvConfig = async (initialEnv = {}) => {
       logger.warn("No valid KEY=VALUE pairs recognized");
     } else {
       Object.assign(env, parsed);
-      logger.success(`Successfully parsed ${import_picocolors6.default.cyan(String(count))} environment variables:`);
+      logger.success(`Successfully parsed ${import_picocolors9.default.cyan(String(count))} environment variables:`);
       for (const [k, v] of Object.entries(parsed)) {
-        console.log(`  ${import_picocolors6.default.bold(k)}=${import_picocolors6.default.dim(maskSecretValue(k, v))}`);
+        console.log(`  ${import_picocolors9.default.bold(k)}=${import_picocolors9.default.dim(maskSecretValue(k, v))}`);
       }
     }
     return env;
   }
   logger.info("Entering environment variables (leave key empty and press enter to finish):");
   while (true) {
-    const key = await (0, import_prompts6.input)({
+    const key = await (0, import_prompts5.input)({
       message: "Variable name (Key, leave empty to finish):",
       validate: (val2) => {
         const trimmed = val2.trim();
@@ -1951,17 +2427,17 @@ var promptEnvConfig = async (initialEnv = {}) => {
     const isSecret = SECRET_KEY_PATTERN.test(trimmedKey);
     let val;
     if (isSecret) {
-      val = await (0, import_prompts6.password)({
+      val = await (0, import_prompts5.password)({
         message: `Value for (${trimmedKey}) [secret masked]:`,
         mask: "*"
       });
     } else {
-      val = await (0, import_prompts6.input)({
+      val = await (0, import_prompts5.input)({
         message: `Value for (${trimmedKey}):`
       });
     }
     env[trimmedKey] = val;
-    logger.success(`Added: ${import_picocolors6.default.cyan(trimmedKey)}`);
+    logger.success(`Added: ${import_picocolors9.default.cyan(trimmedKey)}`);
   }
   return env;
 };
@@ -1982,15 +2458,8 @@ var promptEditEnvConfig = async (currentEnv = {}) => promptEditKeyValueConfig(cu
 });
 
 // src/interactive/prompts/headers.ts
-var import_prompts7 = require("@inquirer/prompts");
-var import_picocolors7 = __toESM(require("picocolors"), 1);
-var SECRET_HEADER_PATTERN = /(authorization|token|key|secret|auth)/i;
-var maskSecretHeader = (key, value) => {
-  if (!SECRET_HEADER_PATTERN.test(key) || value.length <= 8) {
-    return value;
-  }
-  return `${value.slice(0, 4)}***${value.slice(-3)}`;
-};
+var import_prompts6 = require("@inquirer/prompts");
+var import_picocolors10 = __toESM(require("picocolors"), 1);
 var formatHeadersText = (headers) => {
   return Object.entries(headers).map(([key, value]) => `${key}: ${value}`).join("\n");
 };
@@ -2023,7 +2492,7 @@ var parseHeadersText = (rawText) => {
 };
 var promptHeadersConfig = async (initialHeaders = {}) => {
   const headers = { ...initialHeaders };
-  const mode = await (0, import_prompts7.select)({
+  const mode = await (0, import_prompts6.select)({
     message: "Select HTTP headers configuration method:",
     choices: [
       {
@@ -2060,16 +2529,16 @@ var promptHeadersConfig = async (initialHeaders = {}) => {
       logger.warn("No valid Key: Value pairs recognized");
     } else {
       Object.assign(headers, parsed);
-      logger.success(`Successfully parsed ${import_picocolors7.default.cyan(String(count))} headers:`);
+      logger.success(`Successfully parsed ${import_picocolors10.default.cyan(String(count))} headers:`);
       for (const [k, v] of Object.entries(parsed)) {
-        console.log(`  ${import_picocolors7.default.bold(k)}: ${import_picocolors7.default.dim(maskSecretHeader(k, v))}`);
+        console.log(`  ${import_picocolors10.default.bold(k)}: ${import_picocolors10.default.dim(maskSecretHeader(k, v))}`);
       }
     }
     return headers;
   }
   logger.info("Entering HTTP headers (leave header name empty and press enter to finish):");
   while (true) {
-    const name = await (0, import_prompts7.input)({
+    const name = await (0, import_prompts6.input)({
       message: "Header name (e.g. Authorization, leave empty to finish):",
       validate: (val2) => {
         const trimmed = val2.trim();
@@ -2083,17 +2552,17 @@ var promptHeadersConfig = async (initialHeaders = {}) => {
     const isSecret = SECRET_HEADER_PATTERN.test(trimmedName);
     let val;
     if (isSecret) {
-      val = await (0, import_prompts7.password)({
+      val = await (0, import_prompts6.password)({
         message: `Header value for (${trimmedName}) [sensitive content masked]:`,
         mask: "*"
       });
     } else {
-      val = await (0, import_prompts7.input)({
+      val = await (0, import_prompts6.input)({
         message: `Header value for (${trimmedName}):`
       });
     }
     headers[trimmedName] = val;
-    logger.success(`Added: ${import_picocolors7.default.cyan(trimmedName)}`);
+    logger.success(`Added: ${import_picocolors10.default.cyan(trimmedName)}`);
   }
   return headers;
 };
@@ -2115,10 +2584,10 @@ var promptEditHeadersConfig = async (currentHeaders = {}) => promptEditKeyValueC
 // src/interactive/wizard-add.ts
 var wizardAdd = async (initial = {}) => {
   const cwd = initial.cwd ?? process.cwd();
-  logger.info(import_picocolors8.default.bold("Welcome to the MCP interactive add wizard"));
+  logger.info(import_picocolors11.default.bold("Welcome to the MCP interactive add wizard"));
   let source = initial.source;
   if (!source) {
-    const sourceType = await (0, import_prompts8.select)({
+    const sourceType = await (0, import_prompts7.select)({
       message: "Select MCP server type:",
       choices: [
         {
@@ -2136,12 +2605,12 @@ var wizardAdd = async (initial = {}) => {
       ]
     });
     if (sourceType === "npm") {
-      source = await (0, import_prompts8.input)({
+      source = await (0, import_prompts7.input)({
         message: "Enter npm package name (e.g. @modelcontextprotocol/server-postgres):",
         validate: (val) => val.trim() ? true : "Package name cannot be empty"
       });
     } else if (sourceType === "remote") {
-      source = await (0, import_prompts8.input)({
+      source = await (0, import_prompts7.input)({
         message: "Enter remote server URL (e.g. https://mcp.example.com/sse):",
         validate: (val) => {
           const trimmed = val.trim();
@@ -2151,7 +2620,7 @@ var wizardAdd = async (initial = {}) => {
         }
       });
     } else {
-      source = await (0, import_prompts8.input)({
+      source = await (0, import_prompts7.input)({
         message: "Enter command and arguments (e.g. python -m my_mcp_server or docker run ...):",
         validate: (val) => val.trim() ? true : "Command cannot be empty"
       });
@@ -2161,7 +2630,7 @@ var wizardAdd = async (initial = {}) => {
   const parsed = parseMcpSource(source);
   let serverName = initial.name;
   if (!serverName) {
-    serverName = await (0, import_prompts8.input)({
+    serverName = await (0, import_prompts7.input)({
       message: "MCP server name:",
       default: parsed.inferredName,
       validate: (val) => val.trim() ? true : "Server name cannot be empty"
@@ -2173,7 +2642,7 @@ var wizardAdd = async (initial = {}) => {
   if (parsed.type === "remote") {
     if (!transport) {
       const isSseUrl = /\/sse\b/i.test(parsed.value);
-      transport = await (0, import_prompts8.select)({
+      transport = await (0, import_prompts7.select)({
         message: "Select remote transport protocol:",
         choices: [
           { name: "HTTP", value: "http" },
@@ -2183,7 +2652,7 @@ var wizardAdd = async (initial = {}) => {
       });
     }
     if (Object.keys(headers).length === 0) {
-      const needHeader = await (0, import_prompts8.confirm)({
+      const needHeader = await (0, import_prompts7.confirm)({
         message: "Configure HTTP headers (e.g. Authorization Bearer token)?",
         default: false
       });
@@ -2205,28 +2674,28 @@ var wizardAdd = async (initial = {}) => {
   if (parsed.type !== "remote") {
     env = await promptEnvConfig(env);
   }
-  console.log("\n" + import_picocolors8.default.cyan(import_picocolors8.default.bold("Configuration Preview:")));
-  console.log(`  ${import_picocolors8.default.bold("Server Name:")} ${import_picocolors8.default.green(serverName)}`);
-  console.log(`  ${import_picocolors8.default.bold("Server Type:")} ${import_picocolors8.default.magenta(parsed.type)}`);
-  console.log(`  ${import_picocolors8.default.bold("Source/Command:")} ${import_picocolors8.default.dim(source)}`);
-  console.log(`  ${import_picocolors8.default.bold("Scope:")} ${isGlobal ? import_picocolors8.default.yellow("Global") : import_picocolors8.default.blue("Project")}`);
-  console.log(`  ${import_picocolors8.default.bold("Target Agents:")} ${import_picocolors8.default.cyan(selectedAgents.join(", "))}`);
+  console.log("\n" + import_picocolors11.default.cyan(import_picocolors11.default.bold("Configuration Preview:")));
+  console.log(`  ${import_picocolors11.default.bold("Server Name:")} ${import_picocolors11.default.green(serverName)}`);
+  console.log(`  ${import_picocolors11.default.bold("Server Type:")} ${import_picocolors11.default.magenta(parsed.type)}`);
+  console.log(`  ${import_picocolors11.default.bold("Source/Command:")} ${import_picocolors11.default.dim(source)}`);
+  console.log(`  ${import_picocolors11.default.bold("Scope:")} ${isGlobal ? import_picocolors11.default.yellow("Global") : import_picocolors11.default.blue("Project")}`);
+  console.log(`  ${import_picocolors11.default.bold("Target Agents:")} ${import_picocolors11.default.cyan(selectedAgents.join(", "))}`);
   if (args.length > 0) {
-    console.log(`  ${import_picocolors8.default.bold("Arguments:")} ${import_picocolors8.default.dim(args.join(" "))}`);
+    console.log(`  ${import_picocolors11.default.bold("Arguments:")} ${import_picocolors11.default.dim(args.join(" "))}`);
   }
   if (transport) {
-    console.log(`  ${import_picocolors8.default.bold("Transport:")} ${import_picocolors8.default.magenta(transport)}`);
+    console.log(`  ${import_picocolors11.default.bold("Transport:")} ${import_picocolors11.default.magenta(transport)}`);
   }
   const envKeys = Object.keys(env);
   if (envKeys.length > 0) {
-    console.log(`  ${import_picocolors8.default.bold("Environment Variables:")} ${import_picocolors8.default.dim(envKeys.join(", "))} (${envKeys.length})`);
+    console.log(`  ${import_picocolors11.default.bold("Environment Variables:")} ${import_picocolors11.default.dim(envKeys.join(", "))} (${envKeys.length})`);
   }
   const headerKeys = Object.keys(headers);
   if (headerKeys.length > 0) {
-    console.log(`  ${import_picocolors8.default.bold("Headers:")} ${import_picocolors8.default.dim(headerKeys.join(", "))} (${headerKeys.length})`);
+    console.log(`  ${import_picocolors11.default.bold("Headers:")} ${import_picocolors11.default.dim(headerKeys.join(", "))} (${headerKeys.length})`);
   }
   console.log();
-  const proceed = await (0, import_prompts8.confirm)({
+  const proceed = await (0, import_prompts7.confirm)({
     message: "Confirm installation with this configuration?",
     default: true
   });
@@ -2246,103 +2715,162 @@ var wizardAdd = async (initial = {}) => {
     env
   });
   logger.info(
-    `Writing ${import_picocolors8.default.bold(result.serverName)} to ${import_picocolors8.default.cyan(String(result.results.length))} agent config files...`
+    `Writing ${import_picocolors11.default.bold(result.serverName)} to ${import_picocolors11.default.cyan(String(result.results.length))} agent config files...`
   );
   let allSuccess = true;
   for (const record of result.results) {
     if (record.success) {
-      logger.success(`${import_picocolors8.default.cyan(record.agent)}: Successfully written to ${import_picocolors8.default.dim(record.path)}`);
+      logger.success(
+        `${import_picocolors11.default.cyan(record.agent)}: Successfully written to ${import_picocolors11.default.dim(record.path)}${formatCoHostedBadge("configured", record.coConfiguredAgents)}`
+      );
     } else {
       allSuccess = false;
-      logger.error(`${import_picocolors8.default.cyan(record.agent)}: Failed to write - ${record.error}`);
+      logger.error(`${import_picocolors11.default.cyan(record.agent)}: Failed to write - ${record.error}`);
     }
   }
   if (allSuccess) {
-    logger.success(import_picocolors8.default.bold(`MCP server "${serverName}" configured successfully!`));
+    logger.success(import_picocolors11.default.bold(`MCP server "${serverName}" configured successfully!`));
   }
   return allSuccess;
 };
 
 // src/interactive/wizard-manage.ts
-var import_prompts9 = require("@inquirer/prompts");
-var import_picocolors9 = __toESM(require("picocolors"), 1);
-
-// src/interactive/utils/group-installed-servers.ts
-var normalizeServerConfig = parseServerConfig;
-var groupInstalledServersByName = (installed) => {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const item of installed) {
-    let entry = grouped.get(item.serverName);
-    if (!entry) {
-      entry = {
-        serverName: item.serverName,
-        agents: [],
-        paths: [],
-        config: normalizeServerConfig(item.config)
-      };
-      grouped.set(item.serverName, entry);
-    }
-    if (!entry.agents.includes(item.agent)) {
-      entry.agents.push(item.agent);
-    }
-    if (!entry.paths.includes(item.path)) {
-      entry.paths.push(item.path);
-    }
-  }
-  return grouped;
-};
+var import_prompts8 = require("@inquirer/prompts");
+var import_picocolors13 = __toESM(require("picocolors"), 1);
 
-// src/interactive/wizard-manage.ts
+// src/utils/display-server-details.ts
+var import_picocolors12 = __toESM(require("picocolors"), 1);
 var displayServerDetails = ({
   serverName,
   config,
   agents,
-  isGlobal,
+  hasDivergence,
+  global: isGlobal,
   titlePrefix = "MCP Server Details"
 }) => {
-  console.log("\n" + import_picocolors9.default.cyan(import_picocolors9.default.bold(`${titlePrefix}: [${serverName}]`)));
+  console.log("\n" + import_picocolors12.default.cyan(import_picocolors12.default.bold(`${titlePrefix}: [${serverName}]`)));
   if (isGlobal !== void 0) {
-    console.log(`  ${import_picocolors9.default.bold("Scope:")} ${isGlobal ? "Global" : "Project"}`);
+    console.log(`  ${import_picocolors12.default.bold("Scope:")} ${isGlobal ? "Global" : "Project"}`);
   }
   if (agents && agents.length > 0) {
     console.log(
-      `  ${import_picocolors9.default.bold("Configured Agents:")} ${import_picocolors9.default.green(agents.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
+      `  ${import_picocolors12.default.bold("Configured Agents:")} ${import_picocolors12.default.green(agents.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
+    );
+  }
+  if (hasDivergence) {
+    console.log(
+      `  ${import_picocolors12.default.yellow(import_picocolors12.default.bold("Notice:"))} ${import_picocolors12.default.yellow("Configurations differ across installed agents. Showing configuration from the first agent.")}`
     );
   }
   const isRemote = Boolean(config.url && config.url.length > 0);
   if (isRemote) {
-    console.log(`  ${import_picocolors9.default.bold("Transport:")} ${import_picocolors9.default.magenta(config.type ?? "http")}`);
-    console.log(`  ${import_picocolors9.default.bold("URL:")} ${import_picocolors9.default.dim(config.url ?? "")}`);
+    console.log(`  ${import_picocolors12.default.bold("Transport:")} ${import_picocolors12.default.magenta(config.type ?? "http")}`);
+    console.log(`  ${import_picocolors12.default.bold("URL:")} ${import_picocolors12.default.dim(config.url ?? "")}`);
     const headerKeys = Object.keys(config.headers ?? {});
     if (headerKeys.length > 0) {
-      console.log(`  ${import_picocolors9.default.bold("Headers:")} ${import_picocolors9.default.cyan(String(headerKeys.length))}`);
+      console.log(`  ${import_picocolors12.default.bold("Headers:")} ${import_picocolors12.default.cyan(String(headerKeys.length))}`);
       for (const [k, v] of Object.entries(config.headers ?? {})) {
-        console.log(`    ${import_picocolors9.default.bold(k)}: ${import_picocolors9.default.dim(maskSecretHeader(k, v))}`);
+        console.log(`    ${import_picocolors12.default.bold(k)}: ${import_picocolors12.default.dim(maskSecretHeader(k, v))}`);
       }
     } else {
-      console.log(`  ${import_picocolors9.default.bold("Headers:")} ${import_picocolors9.default.dim("(none)")}`);
+      console.log(`  ${import_picocolors12.default.bold("Headers:")} ${import_picocolors12.default.dim("(none)")}`);
     }
   } else {
-    console.log(`  ${import_picocolors9.default.bold("Command:")} ${import_picocolors9.default.magenta(config.command ?? "")}`);
+    console.log(`  ${import_picocolors12.default.bold("Command:")} ${import_picocolors12.default.magenta(config.command ?? "")}`);
     const argsStr = config.args && config.args.length > 0 ? config.args.join(" ") : "(none)";
-    console.log(`  ${import_picocolors9.default.bold("Arguments:")} ${import_picocolors9.default.dim(argsStr)}`);
+    console.log(`  ${import_picocolors12.default.bold("Arguments:")} ${import_picocolors12.default.dim(argsStr)}`);
     const envKeys = Object.keys(config.env ?? {});
     if (envKeys.length > 0) {
-      console.log(`  ${import_picocolors9.default.bold("Environment Variables:")} ${import_picocolors9.default.cyan(String(envKeys.length))}`);
+      console.log(`  ${import_picocolors12.default.bold("Environment Variables:")} ${import_picocolors12.default.cyan(String(envKeys.length))}`);
       for (const [k, v] of Object.entries(config.env ?? {})) {
-        console.log(`    ${import_picocolors9.default.bold(k)}=${import_picocolors9.default.dim(maskSecretValue(k, v))}`);
+        console.log(`    ${import_picocolors12.default.bold(k)}=${import_picocolors12.default.dim(maskSecretValue(k, v))}`);
       }
     } else {
-      console.log(`  ${import_picocolors9.default.bold("Environment Variables:")} ${import_picocolors9.default.dim("(none)")}`);
+      console.log(`  ${import_picocolors12.default.bold("Environment Variables:")} ${import_picocolors12.default.dim("(none)")}`);
     }
   }
   console.log();
 };
-var handleEditServerConfig = async ({
-  targetGroup,
-  isGlobal,
-  cwd
-}) => {
+
+// src/interactive/utils/group-installed-servers.ts
+var normalizeServerConfig = parseServerConfig;
+var groupInstalledServersByName = (installed) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of installed) {
+    const itemConfig = normalizeServerConfig(item.config);
+    let entry = grouped.get(item.serverName);
+    if (!entry) {
+      entry = {
+        serverName: item.serverName,
+        agents: [],
+        paths: [],
+        config: itemConfig,
+        hasDivergence: false
+      };
+      grouped.set(item.serverName, entry);
+    } else if (!entry.hasDivergence) {
+      if (JSON.stringify(entry.config) !== JSON.stringify(itemConfig)) {
+        entry.hasDivergence = true;
+      }
+    }
+    if (!entry.agents.includes(item.agent)) {
+      entry.agents.push(item.agent);
+    }
+    if (!entry.paths.includes(item.path)) {
+      entry.paths.push(item.path);
+    }
+  }
+  return grouped;
+};
+
+// src/interactive/wizard-manage.ts
+var promptSwitchServerType = async (currentConfig, serverName) => {
+  const isRemote = Boolean(currentConfig.url && currentConfig.url.length > 0);
+  if (isRemote) {
+    const newCmd = await (0, import_prompts8.input)({
+      message: "Executable command (e.g. node, npx):",
+      validate: (val) => val.trim() ? true : "Command cannot be empty"
+    });
+    const newArgs = await promptEditArgs([]);
+    const newEnv = await promptEditEnvConfig({});
+    logger.success(`Switched [${serverName}] configuration to stdio mode`);
+    return {
+      command: newCmd.trim(),
+      args: newArgs.length > 0 ? newArgs : void 0,
+      env: Object.keys(newEnv).length > 0 ? newEnv : void 0
+    };
+  }
+  const newUrl = await (0, import_prompts8.input)({
+    message: "Remote server URL:",
+    validate: (val) => {
+      const trimmed = val.trim();
+      if (!trimmed) return "URL cannot be empty";
+      if (!/^https?:\/\//i.test(trimmed)) {
+        return "Please enter a valid URL starting with http:// or https://";
+      }
+      return true;
+    }
+  });
+  const transport = await (0, import_prompts8.select)({
+    message: "Select remote transport protocol:",
+    choices: [
+      { name: "HTTP", value: "http" },
+      { name: "SSE (Server-Sent Events)", value: "sse" }
+    ],
+    default: "http"
+  });
+  const newHeaders = await promptEditHeadersConfig({});
+  logger.success(`Switched [${serverName}] configuration to remote mode`);
+  return {
+    url: newUrl.trim(),
+    type: transport,
+    headers: Object.keys(newHeaders).length > 0 ? newHeaders : void 0
+  };
+};
+var handleEditServerConfig = async (options) => {
+  const { targetGroup } = options;
+  const isGlobal = options.global ?? false;
+  const cwd = options.cwd ?? process.cwd();
   const serverName = targetGroup.serverName;
   let workingConfig = {
     ...targetGroup.config,
@@ -2361,6 +2889,7 @@ var handleEditServerConfig = async ({
       { name: "Edit HTTP Headers (headers)", value: "headers" },
       { name: "Edit Remote URL (url)", value: "url" },
       { name: "Edit Transport Protocol (type)", value: "transport" },
+      { name: "Switch to local command (stdio)", value: "switch_type" },
       { name: "Reset changes to original", value: "reset" },
       { name: "Save and apply changes", value: "save" },
       { name: "Cancel (discard changes)", value: "cancel" }
@@ -2368,11 +2897,12 @@ var handleEditServerConfig = async ({
       { name: "Edit Environment Variables (env)", value: "env" },
       { name: "Edit Command Arguments (args)", value: "args" },
       { name: "Edit Executable Command (command)", value: "command" },
+      { name: "Switch to remote server (HTTP/SSE)", value: "switch_type" },
       { name: "Reset changes to original", value: "reset" },
       { name: "Save and apply changes", value: "save" },
       { name: "Cancel (discard changes)", value: "cancel" }
     ];
-    const editAction = await (0, import_prompts9.select)({
+    const editAction = await (0, import_prompts8.select)({
       message: `What would you like to modify in [${serverName}]?`,
       choices: editChoices
     });
@@ -2390,12 +2920,16 @@ var handleEditServerConfig = async ({
       logger.info("Configuration reset to original");
       continue;
     }
+    if (editAction === "switch_type") {
+      workingConfig = await promptSwitchServerType(workingConfig, serverName);
+      continue;
+    }
     if (editAction === "env") {
       workingConfig.env = await promptEditEnvConfig(workingConfig.env ?? {});
     } else if (editAction === "args") {
       workingConfig.args = await promptEditArgs(workingConfig.args ?? []);
     } else if (editAction === "command") {
-      const newCmd = await (0, import_prompts9.input)({
+      const newCmd = await (0, import_prompts8.input)({
         message: "Executable command:",
         default: workingConfig.command,
         validate: (val) => val.trim() ? true : "Command cannot be empty"
@@ -2404,7 +2938,7 @@ var handleEditServerConfig = async ({
     } else if (editAction === "headers") {
       workingConfig.headers = await promptEditHeadersConfig(workingConfig.headers ?? {});
     } else if (editAction === "url") {
-      const newUrl = await (0, import_prompts9.input)({
+      const newUrl = await (0, import_prompts8.input)({
         message: "Remote server URL:",
         default: workingConfig.url,
         validate: (val) => {
@@ -2418,7 +2952,7 @@ var handleEditServerConfig = async ({
       });
       workingConfig.url = newUrl.trim();
     } else if (editAction === "transport") {
-      workingConfig.type = await (0, import_prompts9.select)({
+      workingConfig.type = await (0, import_prompts8.select)({
         message: "Select remote transport protocol:",
         choices: [
           { name: "HTTP", value: "http" },
@@ -2429,42 +2963,46 @@ var handleEditServerConfig = async ({
     } else if (editAction === "save") {
       let targetAgents = targetGroup.agents;
       if (targetGroup.agents.length > 1) {
-        targetAgents = await (0, import_prompts9.checkbox)({
+        const sortedAgents = sortAgentsWithClusters(targetGroup.agents, { global: isGlobal, cwd });
+        const choices = buildLinkedAgentChoices({
+          agents: sortedAgents,
+          checkedAgents: sortedAgents,
+          scopeOptions: { global: isGlobal, cwd }
+        });
+        targetAgents = await linkedCheckbox({
           message: "Select agents to update configuration (Space to toggle):",
-          choices: targetGroup.agents.map((a) => ({
-            name: `${getMcpAgentConfig(a).displayName} (${a})`,
-            value: a,
-            checked: true
-          })),
+          choices,
           loop: false,
           validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
         });
-      }
-      const requestedTransport = workingConfig.url ? workingConfig.type ?? "http" : "stdio";
-      const compatibleAgents = [];
-      const incompatibleAgents = [];
-      for (const agent of targetAgents) {
-        const agentConfig = getMcpAgentConfig(agent);
-        if (isMcpTransportSupported(agentConfig, requestedTransport)) {
-          compatibleAgents.push(agent);
-        } else {
-          const reason = agentConfig.unsupportedTransportMessage ?? `Agent does not support ${requestedTransport} transport`;
-          incompatibleAgents.push({ agent, reason });
+        if (targetAgents.length < targetGroup.agents.length) {
+          const unselected = targetGroup.agents.filter((a) => !targetAgents.includes(a));
+          const unselectedNames = unselected.map((a) => getMcpAgentConfig(a).displayName).join(", ");
+          logger.info(
+            `Note: Updating only a subset of agents. Server configurations will diverge from: ${unselectedNames}.`
+          );
         }
       }
-      if (incompatibleAgents.length > 0) {
-        for (const item of incompatibleAgents) {
-          logger.warn(`Skipping ${import_picocolors9.default.cyan(item.agent)}: ${item.reason}`);
+      const requestedTransport = workingConfig.url ? workingConfig.type ?? "http" : "stdio";
+      const resolution = resolveTargetAgents({
+        requested: targetAgents,
+        global: isGlobal,
+        cwd,
+        transport: requestedTransport
+      });
+      if (resolution.incompatible.length > 0) {
+        for (const item of resolution.incompatible) {
+          logger.warn(`Skipping ${import_picocolors13.default.cyan(item.agent)}: ${item.reason}`);
         }
       }
-      if (compatibleAgents.length === 0) {
+      if (resolution.compatibleAgents.length === 0) {
         logger.error(
           `None of the selected agents support ${requestedTransport} transport. Cannot update.`
         );
         continue;
       }
-      const agentNames = compatibleAgents.map((a) => getMcpAgentConfig(a).displayName).join(", ");
-      const confirmed = await (0, import_prompts9.confirm)({
+      const agentNames = resolution.compatibleAgents.map((a) => getMcpAgentConfig(a).displayName).join(", ");
+      const confirmed = await (0, import_prompts8.confirm)({
         message: `Confirm updating configuration for [${serverName}] across: ${agentNames}?`,
         default: true
       });
@@ -2472,22 +3010,32 @@ var handleEditServerConfig = async ({
         logger.warn("Update cancelled");
         continue;
       }
-      for (const targetAgent of compatibleAgents) {
-        const res = installMcpServerForAgent(serverName, workingConfig, targetAgent, {
-          global: isGlobal,
-          cwd
-        });
+      const updateResult = updateMcpServer({
+        serverName,
+        config: workingConfig,
+        previousConfig: targetGroup.config,
+        agents: resolution.compatibleAgents,
+        global: isGlobal,
+        cwd
+      });
+      let updatedAny = false;
+      const succeededAgents = [];
+      for (const res of updateResult.results) {
         if (res.success) {
+          updatedAny = true;
+          succeededAgents.push(res.agent);
           logger.success(
-            `${import_picocolors9.default.cyan(targetAgent)}: Successfully updated configuration in ${import_picocolors9.default.dim(res.path)}`
+            `${import_picocolors13.default.cyan(res.agent)}: Successfully updated configuration in ${import_picocolors13.default.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
           );
         } else {
-          logger.error(`${import_picocolors9.default.cyan(targetAgent)}: Update failed - ${res.error}`);
+          logger.error(`${import_picocolors13.default.cyan(res.agent)}: Update failed - ${res.error}`);
         }
       }
-      targetGroup.config = workingConfig;
-      logger.success(`Configuration for [${serverName}] updated successfully!`);
-      return;
+      if (updatedAny) {
+        targetGroup.config = updateResult.config;
+        logger.success(`Configuration for [${serverName}] updated successfully!`);
+        return;
+      }
     }
   }
 };
@@ -2505,6 +3053,14 @@ var wizardManage = async (options = {}) => {
   }
   const grouped = groupInstalledServersByName(installed);
   let pendingServerName = options.serverName;
+  const refreshGroupedServers = () => {
+    const freshInstalled = listInstalledMcpServers({ global: isGlobal, cwd });
+    const freshGrouped = groupInstalledServersByName(freshInstalled);
+    grouped.clear();
+    for (const [name, grp] of freshGrouped) {
+      grouped.set(name, grp);
+    }
+  };
   while (true) {
     let chosenServerName;
     if (pendingServerName && grouped.has(pendingServerName)) {
@@ -2515,7 +3071,7 @@ var wizardManage = async (options = {}) => {
       const choices = Array.from(grouped.values()).map((g) => {
         const agentNames = g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ");
         return {
-          name: `${import_picocolors9.default.bold(g.serverName)} ${import_picocolors9.default.dim(`(configured in: ${agentNames})`)}`,
+          name: `${import_picocolors13.default.bold(g.serverName)} ${import_picocolors13.default.dim(`(configured in: ${agentNames})`)}`,
           value: g.serverName
         };
       });
@@ -2523,7 +3079,7 @@ var wizardManage = async (options = {}) => {
         name: `Back`,
         value: "__back__"
       });
-      chosenServerName = await (0, import_prompts9.select)({
+      chosenServerName = await (0, import_prompts8.select)({
         message: "Select MCP server to manage or sync:",
         choices
       });
@@ -2537,9 +3093,10 @@ var wizardManage = async (options = {}) => {
       serverName: chosenServerName,
       config: targetGroup.config,
       agents: targetGroup.agents,
-      isGlobal
+      global: isGlobal,
+      hasDivergence: targetGroup.hasDivergence
     });
-    const action = await (0, import_prompts9.select)({
+    const action = await (0, import_prompts8.select)({
       message: `What would you like to do with [${chosenServerName}]?`,
       choices: [
         {
@@ -2560,31 +3117,34 @@ var wizardManage = async (options = {}) => {
     if (action === "edit") {
       await handleEditServerConfig({
         targetGroup,
-        isGlobal,
+        global: isGlobal,
         cwd
       });
+      refreshGroupedServers();
       continue;
     }
     if (action === "sync") {
       const allAllowedAgents = isGlobal ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
-      const candidateAgents = allAllowedAgents.filter((a) => !targetGroup.agents.includes(a));
-      if (candidateAgents.length === 0) {
+      const rawCandidateAgents = allAllowedAgents.filter((a) => !targetGroup.agents.includes(a));
+      if (rawCandidateAgents.length === 0) {
         logger.info(
           "All supported agents in this scope already have this MCP server configured; no sync needed"
         );
         continue;
       }
-      const selectedToSync = await (0, import_prompts9.checkbox)({
+      const candidateAgents = sortAgentsWithClusters(rawCandidateAgents, { global: isGlobal, cwd });
+      const choices = buildLinkedAgentChoices({
+        agents: candidateAgents,
+        checkedAgents: [],
+        scopeOptions: { global: isGlobal, cwd }
+      });
+      const selectedToSync = await linkedCheckbox({
         message: "Select target agents to sync to (Space to select):",
-        choices: candidateAgents.map((a) => ({
-          name: `${getMcpAgentConfig(a).displayName} (${a})`,
-          value: a,
-          checked: false
-        })),
+        choices,
         loop: false,
         validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
       });
-      const confirmed = await (0, import_prompts9.confirm)({
+      const confirmed = await (0, import_prompts8.confirm)({
         message: `Confirm syncing configuration of [${chosenServerName}] to: ${selectedToSync.join(", ")}?`,
         default: true
       });
@@ -2592,25 +3152,37 @@ var wizardManage = async (options = {}) => {
         logger.warn("Sync cancelled");
         continue;
       }
-      for (const targetAgent of selectedToSync) {
-        const res = installMcpServerForAgent(chosenServerName, targetGroup.config, targetAgent, {
-          global: isGlobal,
-          cwd
-        });
+      const syncResult = updateMcpServer({
+        serverName: chosenServerName,
+        config: targetGroup.config,
+        agents: selectedToSync,
+        global: isGlobal,
+        cwd
+      });
+      for (const item of syncResult.incompatible) {
+        logger.warn(`Skipping ${import_picocolors13.default.cyan(item.agent)}: ${item.reason}`);
+      }
+      for (const res of syncResult.results) {
+        if (syncResult.incompatible.some((i) => i.agent === res.agent)) {
+          continue;
+        }
         if (res.success) {
-          logger.success(`${import_picocolors9.default.cyan(targetAgent)}: Successfully synced to ${import_picocolors9.default.dim(res.path)}`);
-          targetGroup.agents.push(targetAgent);
+          logger.success(
+            `${import_picocolors13.default.cyan(res.agent)}: Successfully synced to ${import_picocolors13.default.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
+          );
+          targetGroup.agents.push(res.agent);
         } else {
-          logger.error(`${import_picocolors9.default.cyan(targetAgent)}: Sync failed - ${res.error}`);
+          logger.error(`${import_picocolors13.default.cyan(res.agent)}: Sync failed - ${res.error}`);
         }
       }
+      refreshGroupedServers();
     }
   }
 };
 
 // src/interactive/wizard-remove.ts
-var import_prompts10 = require("@inquirer/prompts");
-var import_picocolors10 = __toESM(require("picocolors"), 1);
+var import_prompts9 = require("@inquirer/prompts");
+var import_picocolors14 = __toESM(require("picocolors"), 1);
 var wizardRemove = async (options = {}) => {
   const cwd = options.cwd ?? process.cwd();
   const isGlobal = await promptScope({
@@ -2627,29 +3199,30 @@ var wizardRemove = async (options = {}) => {
   let serverName = options.name;
   if (!serverName) {
     const choices = Array.from(serverMap.values()).map((g) => ({
-      name: `${import_picocolors10.default.bold(g.serverName)} ${import_picocolors10.default.dim(`(installed in: ${g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ")})`)}`,
+      name: `${import_picocolors14.default.bold(g.serverName)} ${import_picocolors14.default.dim(`(installed in: ${g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ")})`)}`,
       value: g.serverName
     }));
-    serverName = await (0, import_prompts10.select)({
+    serverName = await (0, import_prompts9.select)({
       message: "Select MCP server to remove:",
       choices
     });
   }
-  const installedAgents = serverMap.get(serverName)?.agents || [];
-  if (installedAgents.length === 0) {
+  const rawInstalledAgents = serverMap.get(serverName)?.agents || [];
+  if (rawInstalledAgents.length === 0) {
     logger.warn(`No agents found with [${serverName}] installed`);
     return false;
   }
+  const installedAgents = sortAgentsWithClusters(rawInstalledAgents, { global: isGlobal, cwd });
   let targetAgents = options.agents;
   if (!targetAgents || targetAgents.length === 0) {
-    targetAgents = await (0, import_prompts10.checkbox)({
+    const choices = buildLinkedAgentChoices({
+      agents: installedAgents,
+      checkedAgents: installedAgents,
+      scopeOptions: { global: isGlobal, cwd }
+    });
+    targetAgents = await linkedCheckbox({
       message: `Select agents to remove [${serverName}] from:`,
-      choices: installedAgents.map((agent) => ({
-        name: `${getMcpAgentConfig(agent)?.displayName ?? agent} (${agent})`,
-        value: agent,
-        checked: true
-      })),
-      loop: false,
+      choices,
       validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
     });
   } else {
@@ -2660,7 +3233,7 @@ var wizardRemove = async (options = {}) => {
     }
     targetAgents = validAgents;
   }
-  const confirmed = await (0, import_prompts10.confirm)({
+  const confirmed = await (0, import_prompts9.confirm)({
     message: `Confirm removing MCP server [${serverName}] from ${targetAgents.join(", ")}?`,
     default: true
   });
@@ -2677,10 +3250,12 @@ var wizardRemove = async (options = {}) => {
   let removedCount = 0;
   for (const res of results) {
     if (res.removed) {
-      logger.success(`${import_picocolors10.default.cyan(res.agent)}: Successfully removed from ${import_picocolors10.default.dim(res.path)}`);
+      logger.success(
+        `${import_picocolors14.default.cyan(res.agent)}: Successfully removed from ${import_picocolors14.default.dim(res.path)}${formatCoHostedBadge("affected", res.coAffectedAgents)}`
+      );
       removedCount++;
     } else if (res.error) {
-      logger.error(`${import_picocolors10.default.cyan(res.agent)}: Failed to remove - ${res.error}`);
+      logger.error(`${import_picocolors14.default.cyan(res.agent)}: Failed to remove - ${res.error}`);
     }
   }
   if (removedCount > 0) {
@@ -2694,12 +3269,12 @@ var wizardRemove = async (options = {}) => {
 // src/interactive/main-menu.ts
 var mainMenu = async () => {
   console.log();
-  console.log(import_picocolors11.default.bold(import_picocolors11.default.cyan("mcps - Cross-Platform MCP Manager for AI Coding Agents")));
-  console.log(import_picocolors11.default.dim("Cross-platform MCP server configuration & synchronization tool"));
+  console.log(import_picocolors15.default.bold(import_picocolors15.default.cyan("mcps - Cross-Platform MCP Manager for AI Coding Agents")));
+  console.log(import_picocolors15.default.dim("Cross-platform MCP server configuration & synchronization tool"));
   console.log();
   while (true) {
     try {
-      const action = await (0, import_prompts11.select)({
+      const action = await (0, import_prompts10.select)({
         message: "Select an action:",
         choices: [
           {
@@ -2721,7 +3296,7 @@ var mainMenu = async () => {
         ]
       });
       if (action === "exit") {
-        console.log(import_picocolors11.default.dim("Goodbye!"));
+        console.log(import_picocolors15.default.dim("Goodbye!"));
         break;
       }
       if (action === "add") {
@@ -2734,7 +3309,7 @@ var mainMenu = async () => {
       console.log();
     } catch (error) {
       if (error?.name === "ExitPromptError") {
-        console.log("\n" + import_picocolors11.default.dim("Exited."));
+        console.log("\n" + import_picocolors15.default.dim("Exited."));
         break;
       }
       throw error;
@@ -2742,9 +3317,16 @@ var mainMenu = async () => {
   }
 };
 
+// src/utils/resolve-transport.ts
+var resolveTransport = (input7) => {
+  if (!input7) return void 0;
+  if (input7 === "http" || input7 === "sse") return input7;
+  throw new Error(`Unsupported transport "${input7}" (expected: http, sse)`);
+};
+
 // src/cli/manage.ts
 var import_commander = require("commander");
-var import_picocolors12 = __toESM(require("picocolors"), 1);
+var import_picocolors16 = __toESM(require("picocolors"), 1);
 
 // src/utils/parse-key-value-list.ts
 var parseKeyValueList = (entries, separator) => {
@@ -2764,72 +3346,124 @@ var parseKeyValueList = (entries, separator) => {
 };
 
 // src/cli/manage.ts
-var resolveTransport = (input7) => {
-  if (!input7) return void 0;
-  if (input7 === "http" || input7 === "sse") return input7;
-  throw new Error(`Unsupported transport "${input7}" (expected: http, sse)`);
+var requireTargetServerGroup = (serverName, scope) => {
+  const installed = listInstalledMcpServers(scope);
+  const grouped = groupInstalledServersByName(installed);
+  const targetGroup = grouped.get(serverName);
+  if (!targetGroup) {
+    logger.error(
+      `MCP server "${serverName}" is not configured in ${scope.global ? "global" : "project"} scope.`
+    );
+    process.exitCode = 1;
+    return void 0;
+  }
+  return targetGroup;
 };
-var mcpManageCommand = new import_commander.Command("manage").description("Inspect, modify, and sync installed MCP servers across coding agents").argument("[server-name]", "Optional server name to inspect or manage").option("-a, --agent <agents...>", "Target specific agents for update").option("-g, --global", "Manage global scope servers instead of project").option("-t, --transport <type>", "Transport type for remote servers (http or sse)").option("--header <header...>", "HTTP header (Header: Value), repeatable").option("--env <env...>", "Env var for stdio servers (KEY=VALUE), repeatable").option("--args <args...>", "CLI arguments for stdio/package servers").option("--command <command>", "Executable command for stdio servers").option("--url <url>", "Remote endpoint URL").option("-y, --yes", "Skip interactive prompts").action(async (serverName, options) => {
+var mcpManageCommand = new import_commander.Command("manage").description("Inspect, modify, and sync installed MCP servers across coding agents").argument("[server-name]", "Optional server name to inspect or manage").option("-a, --agent <agents...>", "Target specific agents for update").option("-g, --global", "Manage global scope servers instead of project").option("-t, --transport <type>", "Transport type for remote servers (http or sse)").option("--header <header...>", "HTTP header (Header: Value), repeatable").option("--clear-headers", "Clear all HTTP headers for remote servers").option("--env <env...>", "Env var for stdio servers (KEY=VALUE), repeatable").option("--clear-env", "Clear all environment variables for stdio servers").option("--args <args...>", "CLI arguments for stdio/package servers").option("--clear-args", "Clear all arguments for stdio/package servers").option("--command <command>", "Executable command for stdio servers").option("--url <url>", "Remote endpoint URL").option("-y, --yes", "Skip interactive prompts").action(async (serverName, options) => {
   try {
     const cwd = process.cwd();
     const isGlobal = Boolean(options.global);
-    const hasModifications = options.command !== void 0 || options.args !== void 0 || options.env !== void 0 || options.header !== void 0 || options.url !== void 0 || options.transport !== void 0;
+    const hasModifications = options.command !== void 0 || options.args !== void 0 || Boolean(options.clearArgs) || options.env !== void 0 || Boolean(options.clearEnv) || options.header !== void 0 || Boolean(options.clearHeaders) || options.url !== void 0 || options.transport !== void 0;
     const isInteractive = Boolean(process.stdin.isTTY && !options.yes);
     if (hasModifications) {
+      if (options.url !== void 0 && options.command !== void 0) {
+        logger.error('Cannot specify both "--url" (remote) and "--command" (stdio) simultaneously.');
+        process.exitCode = 1;
+        return;
+      }
       if (!serverName) {
         logger.error('Missing required argument: "server-name" when passing modification flags.');
         process.exitCode = 1;
         return;
       }
-      const installed = listInstalledMcpServers({ global: isGlobal, cwd });
-      const grouped = groupInstalledServersByName(installed);
-      const targetGroup = grouped.get(serverName);
+      const targetGroup = requireTargetServerGroup(serverName, { global: isGlobal, cwd });
       if (!targetGroup) {
-        logger.error(
-          `MCP server "${serverName}" is not configured in ${isGlobal ? "global" : "project"} scope.`
-        );
-        process.exitCode = 1;
         return;
       }
-      const updatedConfig = {
-        ...targetGroup.config,
-        args: targetGroup.config.args ? [...targetGroup.config.args] : void 0,
-        env: targetGroup.config.env ? { ...targetGroup.config.env } : void 0,
-        headers: targetGroup.config.headers ? { ...targetGroup.config.headers } : void 0
-      };
+      const isCurrentRemote = Boolean(targetGroup.config.url && targetGroup.config.url.length > 0);
+      const willBeRemote = options.url !== void 0 ? true : options.command !== void 0 ? false : isCurrentRemote;
+      if (willBeRemote) {
+        const ignoredStdioFlags = [];
+        if (options.env !== void 0) ignoredStdioFlags.push("--env");
+        if (options.clearEnv) ignoredStdioFlags.push("--clear-env");
+        if (options.args !== void 0) ignoredStdioFlags.push("--args");
+        if (options.clearArgs) ignoredStdioFlags.push("--clear-args");
+        if (ignoredStdioFlags.length > 0) {
+          const hint = options.url !== void 0 ? "When configuring a remote server, stdio flags are ignored." : "Use --command to switch to stdio mode.";
+          logger.warn(
+            `Server "${serverName}" is a remote server. The following stdio flags will be ignored: ${ignoredStdioFlags.join(", ")}. ${hint}`
+          );
+        }
+      } else {
+        const ignoredRemoteFlags = [];
+        if (options.header !== void 0) ignoredRemoteFlags.push("--header");
+        if (options.clearHeaders) ignoredRemoteFlags.push("--clear-headers");
+        if (options.transport !== void 0) ignoredRemoteFlags.push("--transport");
+        if (ignoredRemoteFlags.length > 0) {
+          const hint = options.command !== void 0 ? "When configuring a stdio server, remote flags are ignored." : "Use --url to switch to remote mode.";
+          logger.warn(
+            `Server "${serverName}" is a stdio server. The following remote flags will be ignored: ${ignoredRemoteFlags.join(", ")}. ${hint}`
+          );
+        }
+      }
+      const incomingDelta = {};
       if (options.command !== void 0) {
-        updatedConfig.command = options.command;
+        incomingDelta.command = options.command;
+      }
+      if (options.clearArgs) {
+        incomingDelta.args = void 0;
       }
       if (options.args !== void 0) {
-        updatedConfig.args = options.args;
+        incomingDelta.args = options.args;
       }
       if (options.url !== void 0) {
-        updatedConfig.url = options.url;
+        incomingDelta.url = options.url;
       }
       if (options.transport !== void 0) {
-        updatedConfig.type = resolveTransport(options.transport);
+        incomingDelta.type = resolveTransport(options.transport);
+      }
+      if (options.clearEnv) {
+        incomingDelta.env = void 0;
       }
       if (options.env !== void 0) {
         const parsedEnv = parseKeyValueList(options.env, "=");
-        updatedConfig.env = { ...updatedConfig.env ?? {}, ...parsedEnv };
+        const baseEnv = options.clearEnv ? {} : targetGroup.config.env ?? {};
+        incomingDelta.env = { ...baseEnv, ...parsedEnv };
+      }
+      if (options.clearHeaders) {
+        incomingDelta.headers = void 0;
       }
       if (options.header !== void 0) {
         const parsedHeaders = parseKeyValueList(options.header, ":");
-        updatedConfig.headers = { ...updatedConfig.headers ?? {}, ...parsedHeaders };
-      }
-      const targetAgents = options.agent ? parseMcpAgentList(options.agent) ?? targetGroup.agents : targetGroup.agents;
-      const requestedTransport = updatedConfig.url ? updatedConfig.type ?? "http" : "stdio";
-      const compatibleAgents = [];
-      for (const agent of targetAgents) {
-        const agentConfig = getMcpAgentConfig(agent);
-        if (isMcpTransportSupported(agentConfig, requestedTransport)) {
-          compatibleAgents.push(agent);
-        } else {
-          const reason = agentConfig.unsupportedTransportMessage ?? `Agent does not support ${requestedTransport} transport`;
-          logger.warn(`Skipping ${import_picocolors12.default.cyan(agent)}: ${reason}`);
+        const baseHeaders = options.clearHeaders ? {} : targetGroup.config.headers ?? {};
+        incomingDelta.headers = { ...baseHeaders, ...parsedHeaders };
+      }
+      let targetAgents = targetGroup.agents;
+      if (options.agent !== void 0) {
+        const parsed = parseMcpAgentList(options.agent);
+        if (!parsed || parsed.length === 0) {
+          logger.error(`No valid agents recognized from: "${options.agent.join(", ")}".`);
+          process.exitCode = 1;
+          return;
         }
+        targetAgents = parsed;
       }
-      if (compatibleAgents.length === 0) {
+      const updateResult = updateMcpServer({
+        serverName,
+        config: incomingDelta,
+        previousConfig: targetGroup.config,
+        agents: targetAgents,
+        global: isGlobal,
+        cwd
+      });
+      for (const item of updateResult.incompatible) {
+        logger.warn(`Skipping ${import_picocolors16.default.cyan(item.agent)}: ${item.reason}`);
+      }
+      const attemptedResults = updateResult.results.filter(
+        (r) => !updateResult.incompatible.some((i) => i.agent === r.agent)
+      );
+      if (attemptedResults.length === 0) {
+        const requestedTransport = updateResult.config.url ? updateResult.config.type ?? "http" : "stdio";
         logger.error(
           `None of the target agents support ${requestedTransport} transport. Update aborted.`
         );
@@ -2837,19 +3471,16 @@ var mcpManageCommand = new import_commander.Command("manage").description("Inspe
         return;
       }
       logger.info(
-        `Updating ${import_picocolors12.default.bold(serverName)} across ${import_picocolors12.default.cyan(String(compatibleAgents.length))} agent(s)...`
+        `Updating ${import_picocolors16.default.bold(serverName)} across ${import_picocolors16.default.cyan(String(attemptedResults.length))} agent(s)...`
       );
       let allSuccess = true;
-      for (const agent of compatibleAgents) {
-        const res = installMcpServerForAgent(serverName, updatedConfig, agent, {
-          global: isGlobal,
-          cwd
-        });
+      for (const res of attemptedResults) {
         if (res.success) {
-          logger.success(`${import_picocolors12.default.cyan(agent)}: Successfully updated in ${import_picocolors12.default.dim(res.path)}`);
+          logger.success(`${import_picocolors16.default.cyan(res.agent)}: Successfully updated in ${import_picocolors16.default.dim(res.path)}`);
+          logCoHostedNotice("configured", res.coConfiguredAgents);
         } else {
           allSuccess = false;
-          logger.error(`${import_picocolors12.default.cyan(agent)}: Update failed - ${res.error}`);
+          logger.error(`${import_picocolors16.default.cyan(res.agent)}: Update failed - ${res.error}`);
         }
       }
       if (!allSuccess) {
@@ -2865,21 +3496,16 @@ var mcpManageCommand = new import_commander.Command("manage").description("Inspe
         process.exitCode = 1;
         return;
       }
-      const installed = listInstalledMcpServers({ global: isGlobal, cwd });
-      const grouped = groupInstalledServersByName(installed);
-      const targetGroup = grouped.get(serverName);
+      const targetGroup = requireTargetServerGroup(serverName, { global: isGlobal, cwd });
       if (!targetGroup) {
-        logger.error(
-          `MCP server "${serverName}" is not configured in ${isGlobal ? "global" : "project"} scope.`
-        );
-        process.exitCode = 1;
         return;
       }
       displayServerDetails({
         serverName,
         config: targetGroup.config,
         agents: targetGroup.agents,
-        isGlobal
+        global: isGlobal,
+        hasDivergence: targetGroup.hasDivergence
       });
       return;
     }
@@ -2900,11 +3526,6 @@ var mcpManageCommand = new import_commander.Command("manage").description("Inspe
 var formatAgentList = (agentList, emptyLabel = "(none)") => agentList.length === 0 ? emptyLabel : agentList.join(", ");
 
 // src/cli/add.ts
-var resolveTransport2 = (input7) => {
-  if (!input7) return void 0;
-  if (input7 === "http" || input7 === "sse") return input7;
-  throw new Error(`Unsupported transport "${input7}" (expected: http, sse)`);
-};
 var mcpAddCommand = new import_commander2.Command("add").description("Add an MCP server to coding agents").argument("[source]", "Remote URL, npm package, or command line").option("-a, --agent <agents...>", "Target specific agents (use '*' for all)").option("-g, --global", "Install to user-level config instead of project").option("-t, --transport <type>", "Transport type for remote servers (http or sse)").option("--header <header...>", "HTTP header (Key: Value), repeatable").option("--env <env...>", "Env var for stdio servers (KEY=VALUE), repeatable").option("--args <args...>", "CLI arguments for stdio/package servers").option("-n, --name <name>", "Server name override").option("-y, --yes", "Skip all prompts").option("--all", "Install to all supported agents").action(async (source, options) => {
   try {
     const isInteractive = Boolean(process.stdin.isTTY && !options.yes);
@@ -2914,7 +3535,7 @@ var mcpAddCommand = new import_commander2.Command("add").description("Add an MCP
           name: options.name,
           global: options.global,
           args: options.args,
-          transport: resolveTransport2(options.transport),
+          transport: resolveTransport(options.transport),
           headers: parseKeyValueList(options.header, ":"),
           env: parseKeyValueList(options.env, "="),
           agents: options.all ? getMcpAgentTypes() : parseMcpAgentList(options.agent)
@@ -2929,7 +3550,7 @@ var mcpAddCommand = new import_commander2.Command("add").description("Add an MCP
     const parsed = parseMcpSource(source);
     const cwd = process.cwd();
     const isGlobal = Boolean(options.global);
-    const explicitTransport = resolveTransport2(options.transport);
+    const explicitTransport = resolveTransport(options.transport);
     const transport = explicitTransport ?? (parsed.type === "remote" ? "http" : "stdio");
     const resolvedTargets = resolveTargetAgents({
       requested: options.agent,
@@ -2939,19 +3560,19 @@ var mcpAddCommand = new import_commander2.Command("add").description("Add an MCP
       transport
     });
     if (resolvedTargets.agents.length === 0) {
-      const message = resolvedTargets.diagnostic ?? `No ${isGlobal ? "global" : "project"}-installed MCP agents detected. Pass ${import_picocolors13.default.cyan("-a <agent>")} (e.g. ${import_picocolors13.default.cyan("-a cursor")}) or ${import_picocolors13.default.cyan("--all")} to install.`;
+      const message = resolvedTargets.diagnostic ?? `No ${isGlobal ? "global" : "project"}-installed MCP agents detected. Pass ${import_picocolors17.default.cyan("-a <agent>")} (e.g. ${import_picocolors17.default.cyan("-a cursor")}) or ${import_picocolors17.default.cyan("--all")} to install.`;
       logger.warn(message);
       process.exitCode = 1;
       return;
     }
     if (resolvedTargets.isDetected) {
       logger.info(
-        `Detected ${isGlobal ? "global" : "project"} agents: ${import_picocolors13.default.cyan(formatAgentList(resolvedTargets.detected, "(none detected)"))}`
+        `Detected ${isGlobal ? "global" : "project"} agents: ${import_picocolors17.default.cyan(formatAgentList(resolvedTargets.detected, "(none detected)"))}`
       );
       if (resolvedTargets.incompatible.length > 0) {
         const skippedList = resolvedTargets.incompatible.map((item) => `${item.agent} (${item.reason})`).join(", ");
         logger.info(
-          `Skipping detected agents incompatible with ${transport}: ${import_picocolors13.default.yellow(skippedList)}`
+          `Skipping detected agents incompatible with ${transport}: ${import_picocolors17.default.yellow(skippedList)}`
         );
       }
     }
@@ -2968,13 +3589,14 @@ var mcpAddCommand = new import_commander2.Command("add").description("Add an MCP
       env: parseKeyValueList(options.env, "=")
     });
     logger.info(
-      `Installing ${import_picocolors13.default.bold(result.serverName)} (${import_picocolors13.default.cyan(parsed.type)}) to ${import_picocolors13.default.cyan(String(result.results.length))} agent(s)`
+      `Installing ${import_picocolors17.default.bold(result.serverName)} (${import_picocolors17.default.cyan(parsed.type)}) to ${import_picocolors17.default.cyan(String(result.results.length))} agent(s)`
     );
     for (const record of result.results) {
       if (record.success) {
-        logger.success(`${import_picocolors13.default.cyan(record.agent)} ${import_picocolors13.default.dim(record.path)}`);
+        logger.success(`${import_picocolors17.default.cyan(record.agent)} ${import_picocolors17.default.dim(record.path)}`);
+        logCoHostedNotice("configured", record.coConfiguredAgents);
       } else {
-        logger.error(`${import_picocolors13.default.cyan(record.agent)}: ${record.error}`);
+        logger.error(`${import_picocolors17.default.cyan(record.agent)}: ${record.error}`);
       }
     }
     if (result.results.some((record) => !record.success)) process.exitCode = 1;
@@ -2986,7 +3608,7 @@ var mcpAddCommand = new import_commander2.Command("add").description("Add an MCP
 
 // src/cli/list.ts
 var import_commander3 = require("commander");
-var import_picocolors14 = __toESM(require("picocolors"), 1);
+var import_picocolors18 = __toESM(require("picocolors"), 1);
 var mcpListCommand = new import_commander3.Command("list").alias("ls").description("List installed MCP servers across agents").option("-g, --global", "List global configs instead of project").option("-a, --agent <agents...>", "Filter by specific agents").option("--json", "Output as JSON").action((options) => {
   try {
     const entries = listInstalledMcpServers({
@@ -3010,9 +3632,9 @@ var mcpListCommand = new import_commander3.Command("list").alias("ls").descripti
     }
     for (const [serverName, group] of grouped) {
       const agentLabels = group.map((record) => record.agent).join(", ");
-      console.log(`  ${import_picocolors14.default.bold(serverName)} ${import_picocolors14.default.dim(`[${agentLabels}]`)}`);
+      console.log(`  ${import_picocolors18.default.bold(serverName)} ${import_picocolors18.default.dim(`[${agentLabels}]`)}`);
       const firstPath = group[0]?.path;
-      if (firstPath) console.log(`    ${import_picocolors14.default.dim(firstPath)}`);
+      if (firstPath) console.log(`    ${import_picocolors18.default.dim(firstPath)}`);
     }
   } catch (error) {
     logger.error(toErrorMessage(error));
@@ -3022,7 +3644,7 @@ var mcpListCommand = new import_commander3.Command("list").alias("ls").descripti
 
 // src/cli/remove.ts
 var import_commander4 = require("commander");
-var import_picocolors15 = __toESM(require("picocolors"), 1);
+var import_picocolors19 = __toESM(require("picocolors"), 1);
 var mcpRemoveCommand = new import_commander4.Command("remove").alias("rm").description("Remove an MCP server from agent configs").argument("[name]", "Server name").option("-g, --global", "Remove from global scope").option("-a, --agent <agents...>", "Filter by specific agents (use '*' for all)").option("-y, --yes", "Skip confirmation prompts").action(async (name, options) => {
   try {
     const isInteractive = Boolean(process.stdin.isTTY && !options.yes);
@@ -3046,16 +3668,17 @@ var mcpRemoveCommand = new import_commander4.Command("remove").alias("rm").descr
       cwd: process.cwd()
     });
     if (results.length === 0) {
-      logger.warn(`No agent config contained ${import_picocolors15.default.bold(name)}`);
+      logger.warn(`No agent config contained ${import_picocolors19.default.bold(name)}`);
       return;
     }
     for (const record of results) {
       if (record.removed) {
         logger.success(
-          `${import_picocolors15.default.cyan(record.agent)} removed ${import_picocolors15.default.bold(name)} ${import_picocolors15.default.dim(record.path)}`
+          `${import_picocolors19.default.cyan(record.agent)} removed ${import_picocolors19.default.bold(name)} ${import_picocolors19.default.dim(record.path)}`
         );
+        logCoHostedNotice("affected", record.coAffectedAgents);
       } else {
-        logger.error(`${import_picocolors15.default.cyan(record.agent)}: ${record.error ?? "not found"}`);
+        logger.error(`${import_picocolors19.default.cyan(record.agent)}: ${record.error ?? "not found"}`);
       }
     }
   } catch (error) {
@@ -3065,7 +3688,7 @@ var mcpRemoveCommand = new import_commander4.Command("remove").alias("rm").descr
 });
 
 // src/cli.ts
-var VERSION = "0.1.0-beta.2";
+var VERSION = "0.1.0-beta.3";
 process.on("SIGINT", () => process.exit(0));
 process.on("SIGTERM", () => process.exit(0));
 var program = new import_commander5.Command().name("mcps").description("Install, list, and remove MCP servers across AI coding agents").version(VERSION, "-v, --version", "display the version number");