allagents 1.7.2 → 1.8.0

package/dist/index.js

@@ -11511,7 +11511,7 @@ function resolveInstallMode(pluginEntry, clientEntry) {
     return pluginMode;
   return clientEntry.install;
 }
-var ManagedModeSchema, RepositorySchema, WorkspaceFileSchema, WorkspaceSchema, PluginSourceSchema, ClientTypeSchema, InstallModeSchema, ClientEntrySchema, PluginSkillsConfigSchema, PluginEntrySchema, VscodeConfigSchema, SyncModeSchema, McpProxyServerSchema, McpProxyConfigSchema, WorkspaceConfigSchema;
+var ManagedModeSchema, RepositorySchema, WorkspaceFileSchema, WorkspaceSchema, PluginSourceSchema, ClientTypeSchema, InstallModeSchema, ClientEntrySchema, PluginSkillsConfigSchema, PluginEntrySchema, VscodeConfigSchema, SyncModeSchema, McpProxyServerSchema, McpProxyConfigSchema, McpServerConfigSchema, WorkspaceConfigSchema;
 var init_workspace_config = __esm(() => {
   init_zod();
   ManagedModeSchema = exports_external.union([
@@ -11629,6 +11629,21 @@ var init_workspace_config = __esm(() => {
     clients: exports_external.array(exports_external.string()),
     servers: exports_external.record(McpProxyServerSchema).optional()
   });
+  McpServerConfigSchema = exports_external.union([
+    exports_external.object({
+      type: exports_external.enum(["http"]).optional(),
+      url: exports_external.string(),
+      headers: exports_external.record(exports_external.string()).optional(),
+      clients: exports_external.array(ClientTypeSchema).optional()
+    }).strict(),
+    exports_external.object({
+      type: exports_external.enum(["stdio"]).optional(),
+      command: exports_external.string(),
+      args: exports_external.array(exports_external.string()).optional(),
+      env: exports_external.record(exports_external.string()).optional(),
+      clients: exports_external.array(ClientTypeSchema).optional()
+    }).strict()
+  ]);
   WorkspaceConfigSchema = exports_external.object({
     version: exports_external.number().optional(),
     workspace: WorkspaceSchema.optional(),
@@ -11638,6 +11653,7 @@ var init_workspace_config = __esm(() => {
     vscode: VscodeConfigSchema.optional(),
     syncMode: SyncModeSchema.optional(),
     mcpProxy: McpProxyConfigSchema.optional(),
+    mcpServers: exports_external.record(McpServerConfigSchema).optional(),
     disabledSkills: exports_external.array(exports_external.string()).optional(),
     enabledSkills: exports_external.array(exports_external.string()).optional()
   });
@@ -29175,7 +29191,11 @@ function readPluginMcpConfig(pluginPath) {
     return null;
   }
 }
-function collectMcpServers(validatedPlugins) {
+function stripWorkspaceMcpMeta(config) {
+  const { clients: _clients, ...rest } = config;
+  return rest;
+}
+function collectMcpServers(validatedPlugins, workspaceServers, targetClient) {
   const servers = new Map;
   const warnings = [];
   for (const plugin of validatedPlugins) {
@@ -29190,6 +29210,17 @@ function collectMcpServers(validatedPlugins) {
       }
     }
   }
+  if (workspaceServers) {
+    for (const [name, config] of Object.entries(workspaceServers)) {
+      if (targetClient && config.clients && !config.clients.includes(targetClient)) {
+        continue;
+      }
+      if (servers.has(name)) {
+        warnings.push(`MCP server '${name}' from workspace.yaml overrides plugin-provided server`);
+      }
+      servers.set(name, stripWorkspaceMcpMeta(config));
+    }
+  }
   return { servers, warnings };
 }
 function syncVscodeMcpConfig(validatedPlugins, options2) {
@@ -29929,6 +29960,170 @@ var init_copilot_mcp = __esm(() => {
   init_constants();
 });
 
+// src/core/mcp-sync.ts
+import { existsSync as existsSync17 } from "node:fs";
+import { join as join19 } from "node:path";
+function buildSyncSpecs(workspacePath) {
+  return [
+    {
+      client: "vscode",
+      scope: "vscode",
+      configPath: join19(workspacePath, ".vscode", "mcp.json"),
+      syncFn: syncVscodeMcpConfig
+    },
+    {
+      client: "claude",
+      scope: "claude",
+      configPath: join19(workspacePath, ".mcp.json"),
+      syncFn: syncClaudeMcpConfig
+    },
+    {
+      client: "codex",
+      scope: "codex",
+      configPath: join19(workspacePath, ".codex", "config.toml"),
+      syncFn: syncCodexProjectMcpConfig
+    },
+    {
+      client: "copilot",
+      scope: "copilot",
+      configPath: join19(workspacePath, ".copilot", "mcp-config.json"),
+      syncFn: syncClaudeMcpConfig
+    }
+  ];
+}
+function syncMcpServers(workspacePath, validPlugins, config, previousState, syncClients, options2 = {}) {
+  const { dryRun = false } = options2;
+  const warnings = [];
+  const mcpResults = {};
+  const trackedServers = {};
+  const mcpProxyConfig = config.mcpProxy;
+  let proxyMetadataPath;
+  if (mcpProxyConfig) {
+    if (!dryRun) {
+      ensureProxyMetadata();
+    }
+    proxyMetadataPath = getProxyMetadataPath();
+  }
+  let collectWarningsEmitted = false;
+  function getServersForClient(client) {
+    const { servers, warnings: collectWarnings } = collectMcpServers(validPlugins, config.mcpServers, client);
+    if (!collectWarningsEmitted) {
+      warnings.push(...collectWarnings);
+      collectWarningsEmitted = true;
+    }
+    if (mcpProxyConfig && proxyMetadataPath) {
+      return applyMcpProxy(servers, client, mcpProxyConfig, proxyMetadataPath);
+    }
+    return servers;
+  }
+  const specs = buildSyncSpecs(workspacePath);
+  for (const spec of specs) {
+    if (!syncClients.includes(spec.client))
+      continue;
+    const tracked = getPreviouslySyncedMcpServers(previousState, spec.scope);
+    const serverOverrides = getServersForClient(spec.client);
+    const result = spec.syncFn(validPlugins, {
+      dryRun,
+      force: false,
+      configPath: spec.configPath,
+      trackedServers: tracked,
+      serverOverrides
+    });
+    if (result.warnings.length > 0) {
+      warnings.push(...result.warnings);
+    }
+    mcpResults[spec.scope] = result;
+    trackedServers[spec.scope] = result.trackedServers;
+  }
+  const anyServers = collectMcpServers(validPlugins, config.mcpServers).servers;
+  if (anyServers.size > 0) {
+    for (const client of syncClients) {
+      if (!PROJECT_MCP_CLIENTS.has(client)) {
+        warnings.push(`MCP servers not synced for ${client} (not supported at project scope)`);
+      }
+    }
+  }
+  return { mcpResults, warnings, trackedServers };
+}
+async function syncMcpOnly(workspacePath = process.cwd(), options2 = {}) {
+  const { offline = false, dryRun = false } = options2;
+  await migrateWorkspaceSkillsV1toV2(workspacePath);
+  const configPath = join19(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync17(configPath)) {
+    return {
+      success: false,
+      mcpResults: {},
+      warnings: [],
+      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
+  Run 'allagents workspace init' to create a new workspace`
+    };
+  }
+  let config;
+  try {
+    config = await parseWorkspaceConfig(configPath);
+  } catch (error) {
+    return {
+      success: false,
+      mcpResults: {},
+      warnings: [],
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const warnings = [];
+  const { plans, warnings: planWarnings } = buildPluginSyncPlans(config.plugins, config.clients, "project");
+  warnings.push(...planWarnings);
+  const filteredPlans = plans.filter((plan) => plan.clients.length > 0 || plan.nativeClients.length > 0);
+  const syncClients = collectSyncClients(config.clients, filteredPlans);
+  if (!offline) {
+    const marketplaceResults = await ensureMarketplacesRegistered(filteredPlans.map((plan) => plan.source));
+    await seedFetchCacheFromMarketplaces(marketplaceResults);
+  }
+  const validatedPlugins = await validateAllPlugins(filteredPlans, workspacePath, offline);
+  const validPlugins = validatedPlugins.filter((v) => v.success);
+  warnings.push(...validatedPlugins.filter((v) => !v.success).map((v) => `${v.plugin}: ${v.error} (skipped)`));
+  const previousState = await loadSyncState(workspacePath);
+  const syncResult = syncMcpServers(workspacePath, validPlugins, config, previousState, syncClients, { dryRun });
+  warnings.push(...syncResult.warnings);
+  if (!dryRun) {
+    const hasMcpChanges = Object.values(syncResult.mcpResults).some((r) => r && (r.added > 0 || r.overwritten > 0 || r.removed > 0));
+    if (hasMcpChanges) {
+      await saveSyncState(workspacePath, {
+        files: previousState?.files ?? {},
+        mcpServers: syncResult.trackedServers,
+        ...previousState?.nativePlugins && { nativePlugins: previousState.nativePlugins },
+        ...previousState?.vscodeWorkspaceHash && { vscodeWorkspaceHash: previousState.vscodeWorkspaceHash },
+        ...previousState?.vscodeWorkspaceRepos && { vscodeWorkspaceRepos: previousState.vscodeWorkspaceRepos },
+        ...previousState?.skillsIndex && { skillsIndex: previousState.skillsIndex }
+      });
+    }
+  }
+  return {
+    success: true,
+    mcpResults: syncResult.mcpResults,
+    warnings
+  };
+}
+var PROJECT_MCP_CLIENTS;
+var init_mcp_sync = __esm(() => {
+  init_constants();
+  init_sync();
+  init_vscode_mcp();
+  init_claude_mcp();
+  init_codex_mcp();
+  init_mcp_proxy();
+  init_sync_state2();
+  init_marketplace();
+  init_workspace_parser();
+  init_workspace_modify();
+  PROJECT_MCP_CLIENTS = new Set([
+    "claude",
+    "codex",
+    "vscode",
+    "copilot",
+    "universal"
+  ]);
+});
+
 // src/core/native/claude.ts
 class ClaudeNativeClient {
   async isAvailable() {
@@ -30221,7 +30416,7 @@ function padStart2(str3, len) {
 }
 
 // src/core/managed-repos.ts
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 import { mkdir as mkdir8 } from "node:fs/promises";
 import { dirname as dirname11, resolve as resolve10 } from "node:path";
 function expandHome(p) {
@@ -30305,7 +30500,7 @@ async function processManagedRepos(repositories, workspacePath, options2 = {}) {
     }
     const expandedPath = expandHome(repo.path);
     const absolutePath = resolve10(workspacePath, expandedPath);
-    if (!existsSync17(absolutePath)) {
+    if (!existsSync18(absolutePath)) {
       if (!shouldClone(repo.managed)) {
         results.push({ path: repo.path, repo: repo.repo, action: "skipped" });
         continue;
@@ -30356,9 +30551,9 @@ var init_managed_repos = __esm(() => {
 });
 
 // src/core/sync.ts
-import { existsSync as existsSync18, readFileSync as readFileSync4, writeFileSync as writeFileSync6, lstatSync as lstatSync2 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync4, writeFileSync as writeFileSync6, lstatSync as lstatSync2 } from "node:fs";
 import { rm as rm4, unlink as unlink2, rmdir, copyFile } from "node:fs/promises";
-import { join as join19, resolve as resolve11, dirname as dirname12, relative as relative5 } from "node:path";
+import { join as join20, resolve as resolve11, dirname as dirname12, relative as relative5 } from "node:path";
 function deduplicateClientsByPath(clients, clientMappings = CLIENT_MAPPINGS) {
   const pathToClients = new Map;
   for (const client of clients) {
@@ -30477,7 +30672,7 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
     const previousFiles = getPreviouslySyncedFiles(state, client);
     const purgedPaths = [];
     for (const filePath of previousFiles) {
-      const fullPath = join19(workspacePath, filePath);
+      const fullPath = join20(workspacePath, filePath);
       const cleanPath = fullPath.replace(/\/$/, "");
       let stats;
       try {
@@ -30506,8 +30701,8 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
 async function cleanupEmptyParents(workspacePath, filePath) {
   let parentPath = dirname12(filePath);
   while (parentPath && parentPath !== "." && parentPath !== "/") {
-    const fullParentPath = join19(workspacePath, parentPath);
-    if (!existsSync18(fullParentPath)) {
+    const fullParentPath = join20(workspacePath, parentPath);
+    if (!existsSync19(fullParentPath)) {
       parentPath = dirname12(parentPath);
       continue;
     }
@@ -30592,8 +30787,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file}' - no workspace.source configured`);
         continue;
       }
-      const fullPath = join19(defaultSourcePath, file);
-      if (!existsSync18(fullPath)) {
+      const fullPath = join20(defaultSourcePath, file);
+      if (!existsSync19(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
       continue;
@@ -30611,8 +30806,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
           errors2.push(`GitHub cache not found for ${cacheKey}`);
           continue;
         }
-        const fullPath = join19(cachePath, parsed.filePath);
-        if (!existsSync18(fullPath)) {
+        const fullPath = join20(cachePath, parsed.filePath);
+        if (!existsSync19(fullPath)) {
           errors2.push(`Path not found in repository: ${cacheKey}/${parsed.filePath}`);
         }
       } else {
@@ -30622,11 +30817,11 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         } else if (file.source.startsWith("../")) {
           fullPath = resolve11(file.source);
         } else if (defaultSourcePath) {
-          fullPath = join19(defaultSourcePath, file.source);
+          fullPath = join20(defaultSourcePath, file.source);
         } else {
           fullPath = resolve11(file.source);
         }
-        if (!existsSync18(fullPath)) {
+        if (!existsSync19(fullPath)) {
           errors2.push(`File source not found: ${fullPath}`);
         }
       }
@@ -30635,8 +30830,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file.dest}' - no workspace.source configured and no explicit source provided`);
         continue;
       }
-      const fullPath = join19(defaultSourcePath, file.dest ?? "");
-      if (!existsSync18(fullPath)) {
+      const fullPath = join20(defaultSourcePath, file.dest ?? "");
+      if (!existsSync19(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
     }
@@ -30782,7 +30977,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
         ...fetchResult.error && { error: fetchResult.error }
       };
     }
-    const resolvedPath2 = parsed?.subpath ? join19(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
+    const resolvedPath2 = parsed?.subpath ? join20(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
     return {
       plugin: pluginSource,
       resolved: resolvedPath2,
@@ -30792,7 +30987,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
     };
   }
   const resolvedPath = resolve11(workspacePath, pluginSource);
-  if (!existsSync18(resolvedPath)) {
+  if (!existsSync19(resolvedPath)) {
     return {
       plugin: pluginSource,
       resolved: resolvedPath,
@@ -30953,10 +31148,10 @@ function buildPluginSkillNameMaps(allSkills) {
   return pluginMaps;
 }
 function generateVscodeWorkspaceFile(workspacePath, config) {
-  const configDir = join19(workspacePath, CONFIG_DIR);
-  const templatePath = join19(configDir, VSCODE_TEMPLATE_FILE);
+  const configDir = join20(workspacePath, CONFIG_DIR);
+  const templatePath = join20(configDir, VSCODE_TEMPLATE_FILE);
   let template;
-  if (existsSync18(templatePath)) {
+  if (existsSync19(templatePath)) {
     try {
       template = import_json53.default.parse(readFileSync4(templatePath, "utf-8"));
     } catch (error) {
@@ -31103,7 +31298,7 @@ async function syncVscodeWorkspaceFile(workspacePath, config, configPath, previo
   let updatedConfig = config;
   if (previousState?.vscodeWorkspaceHash && previousState?.vscodeWorkspaceRepos) {
     const outputPath = getWorkspaceOutputPath(workspacePath, config.vscode);
-    if (existsSync18(outputPath)) {
+    if (existsSync19(outputPath)) {
       const existingContent = readFileSync4(outputPath, "utf-8");
       const currentHash = computeWorkspaceHash(existingContent);
       if (currentHash !== previousState.vscodeWorkspaceHash) {
@@ -31168,9 +31363,9 @@ async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
   await migrateWorkspaceSkillsV1toV2(workspacePath);
   const { offline = false, dryRun = false, workspaceSourceBase, skipAgentFiles = false, skipManaged = false } = options2;
   const sw = new Stopwatch;
-  const configDir = join19(workspacePath, CONFIG_DIR);
-  const configPath = join19(configDir, WORKSPACE_CONFIG_FILE);
-  if (!existsSync18(configPath)) {
+  const configDir = join20(workspacePath, CONFIG_DIR);
+  const configPath = join20(configDir, WORKSPACE_CONFIG_FILE);
+  if (!existsSync19(configPath)) {
     return failedSyncResult(`${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
   Run 'allagents workspace init <path>' to create a new workspace`);
   }
@@ -31263,8 +31458,8 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     const filesToCopy = [...config.workspace.files];
     if (hasRepositories && sourcePath) {
       for (const agentFile of AGENT_FILES) {
-        const agentPath = join19(sourcePath, agentFile);
-        if (existsSync18(agentPath) && !filesToCopy.includes(agentFile)) {
+        const agentPath = join20(sourcePath, agentFile);
+        if (existsSync19(agentPath) && !filesToCopy.includes(agentFile)) {
           filesToCopy.push(agentFile);
         }
       }
@@ -31299,10 +31494,10 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     }
     workspaceFileResults = await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, { dryRun, githubCache, repositories: config.repositories, skillsIndexRefs });
     if (hasRepositories && !dryRun && syncClients.includes("claude") && sourcePath) {
-      const claudePath = join19(workspacePath, "CLAUDE.md");
-      const agentsPath = join19(workspacePath, "AGENTS.md");
-      const claudeExistsInSource = existsSync18(join19(sourcePath, "CLAUDE.md"));
-      if (!claudeExistsInSource && existsSync18(agentsPath) && !existsSync18(claudePath)) {
+      const claudePath = join20(workspacePath, "CLAUDE.md");
+      const agentsPath = join20(workspacePath, "AGENTS.md");
+      const claudeExistsInSource = existsSync19(join20(sourcePath, "CLAUDE.md"));
+      if (!claudeExistsInSource && existsSync19(agentsPath) && !existsSync19(claudePath)) {
         await copyFile(agentsPath, claudePath);
       }
     }
@@ -31319,103 +31514,11 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
       vscodeState = { hash: result.hash, repos: result.repos };
     }
   }
-  const mcpProxyConfig = config.mcpProxy;
-  let proxyMetadataPath;
-  let proxyBaseServers;
-  if (mcpProxyConfig) {
-    if (!dryRun) {
-      ensureProxyMetadata();
-    }
-    proxyMetadataPath = getProxyMetadataPath();
-    const { servers, warnings: proxyWarnings } = collectMcpServers(validPlugins);
-    if (proxyWarnings.length > 0) {
-      warnings.push(...proxyWarnings);
-    }
-    if (servers.size > 0) {
-      proxyBaseServers = servers;
-    }
-  }
-  function getServersForClient(client) {
-    if (!mcpProxyConfig || !proxyMetadataPath || !proxyBaseServers)
-      return;
-    return applyMcpProxy(proxyBaseServers, client, mcpProxyConfig, proxyMetadataPath);
-  }
   sw.start("mcp-sync");
-  const mcpResults = {};
-  if (syncClients.includes("vscode")) {
-    const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "vscode");
-    const projectMcpPath = join19(workspacePath, ".vscode", "mcp.json");
-    const vscodeMcpOverrides = getServersForClient("vscode");
-    const vscodeMcp = syncVscodeMcpConfig(validPlugins, {
-      dryRun,
-      force: false,
-      configPath: projectMcpPath,
-      trackedServers: trackedMcpServers,
-      ...vscodeMcpOverrides && { serverOverrides: vscodeMcpOverrides }
-    });
-    if (vscodeMcp.warnings.length > 0) {
-      warnings.push(...vscodeMcp.warnings);
-    }
-    mcpResults.vscode = vscodeMcp;
-  }
-  if (syncClients.includes("claude")) {
-    const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "claude");
-    const projectMcpJsonPath = join19(workspacePath, ".mcp.json");
-    const claudeMcpOverrides = getServersForClient("claude");
-    const claudeMcp = syncClaudeMcpConfig(validPlugins, {
-      dryRun,
-      force: false,
-      configPath: projectMcpJsonPath,
-      trackedServers: trackedMcpServers,
-      ...claudeMcpOverrides && { serverOverrides: claudeMcpOverrides }
-    });
-    if (claudeMcp.warnings.length > 0) {
-      warnings.push(...claudeMcp.warnings);
-    }
-    mcpResults.claude = claudeMcp;
-  }
-  if (syncClients.includes("codex")) {
-    const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "codex");
-    const projectCodexConfigPath = join19(workspacePath, ".codex", "config.toml");
-    const codexMcpOverrides = getServersForClient("codex");
-    const codexMcp = syncCodexProjectMcpConfig(validPlugins, {
-      dryRun,
-      force: false,
-      configPath: projectCodexConfigPath,
-      trackedServers: trackedMcpServers,
-      ...codexMcpOverrides && { serverOverrides: codexMcpOverrides }
-    });
-    if (codexMcp.warnings.length > 0) {
-      warnings.push(...codexMcp.warnings);
-    }
-    mcpResults.codex = codexMcp;
-  }
-  if (syncClients.includes("copilot")) {
-    const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "copilot");
-    const projectCopilotMcpPath = join19(workspacePath, ".copilot", "mcp-config.json");
-    const copilotMcpOverrides = getServersForClient("copilot");
-    const copilotMcp = syncClaudeMcpConfig(validPlugins, {
-      dryRun,
-      force: false,
-      configPath: projectCopilotMcpPath,
-      trackedServers: trackedMcpServers,
-      ...copilotMcpOverrides && { serverOverrides: copilotMcpOverrides }
-    });
-    if (copilotMcp.warnings.length > 0) {
-      warnings.push(...copilotMcp.warnings);
-    }
-    mcpResults.copilot = copilotMcp;
-  }
+  const mcpSyncResult = syncMcpServers(workspacePath, validPlugins, config, previousState, syncClients, { dryRun });
+  const mcpResults = { ...mcpSyncResult.mcpResults };
+  warnings.push(...mcpSyncResult.warnings);
   sw.stop("mcp-sync");
-  const PROJECT_MCP_CLIENTS = new Set(["claude", "codex", "vscode", "copilot", "universal"]);
-  const allMcpServers = proxyBaseServers ?? collectMcpServers(validPlugins).servers;
-  if (allMcpServers.size > 0) {
-    for (const client of syncClients) {
-      if (!PROJECT_MCP_CLIENTS.has(client)) {
-        warnings.push(`MCP servers not synced for ${client} (not supported at project scope)`);
-      }
-    }
-  }
   const { totalCopied, totalFailed, totalSkipped, totalGenerated } = countCopyResults(pluginResults, workspaceFileResults);
   const hasFailures = pluginResults.some((r) => !r.success) || totalFailed > 0;
   const availableSkillNames = await collectAvailableSkillNames(validPlugins);
@@ -31466,7 +31569,7 @@ async function seedFetchCacheFromMarketplaces(results) {
 }
 function readGitBranch(repoPath) {
   try {
-    const head = readFileSync4(join19(repoPath, ".git", "HEAD"), "utf-8").trim();
+    const head = readFileSync4(join20(repoPath, ".git", "HEAD"), "utf-8").trim();
     const prefix = "ref: refs/heads/";
     return head.startsWith(prefix) ? head.slice(prefix.length) : null;
   } catch {
@@ -31526,25 +31629,25 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   })), `${validPlugins.length} plugin(s)`);
   const { totalCopied, totalFailed, totalSkipped, totalGenerated } = countCopyResults(pluginResults, []);
   const userMcpProxyConfig = config.mcpProxy;
+  const userWorkspaceMcpServers = config.mcpServers;
   let userProxyMetadataPath;
-  let userProxyBaseServers;
   if (userMcpProxyConfig) {
     if (!dryRun) {
       ensureProxyMetadata();
     }
     userProxyMetadataPath = getProxyMetadataPath();
-    const { servers, warnings: proxyWarnings } = collectMcpServers(validPlugins);
-    if (proxyWarnings.length > 0) {
-      warnings.push(...proxyWarnings);
-    }
-    if (servers.size > 0) {
-      userProxyBaseServers = servers;
-    }
   }
+  let userCollectWarningsEmitted = false;
   function getUserServersForClient(client) {
-    if (!userMcpProxyConfig || !userProxyMetadataPath || !userProxyBaseServers)
-      return;
-    return applyMcpProxy(userProxyBaseServers, client, userMcpProxyConfig, userProxyMetadataPath);
+    const { servers, warnings: collectWarnings } = collectMcpServers(validPlugins, userWorkspaceMcpServers, client);
+    if (!userCollectWarningsEmitted) {
+      warnings.push(...collectWarnings);
+      userCollectWarningsEmitted = true;
+    }
+    if (userMcpProxyConfig && userProxyMetadataPath) {
+      return applyMcpProxy(servers, client, userMcpProxyConfig, userProxyMetadataPath);
+    }
+    return servers;
   }
   sw.start("mcp-sync");
   const mcpResults = {};
@@ -31555,7 +31658,7 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
       dryRun,
       force,
       trackedServers: trackedMcpServers,
-      ...vscodeMcpOverrides && { serverOverrides: vscodeMcpOverrides }
+      serverOverrides: vscodeMcpOverrides
     });
     if (vscodeMcp.warnings.length > 0) {
       warnings.push(...vscodeMcp.warnings);
@@ -31606,7 +31709,7 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   }
   sw.stop("mcp-sync");
   const USER_MCP_CLIENTS = new Set(["claude", "codex", "vscode", "copilot", "universal"]);
-  const allUserMcpServers = userProxyBaseServers ?? collectMcpServers(validPlugins).servers;
+  const allUserMcpServers = collectMcpServers(validPlugins, userWorkspaceMcpServers).servers;
   if (allUserMcpServers.size > 0) {
     for (const client of syncClients) {
       if (!USER_MCP_CLIENTS.has(client)) {
@@ -31666,17 +31769,18 @@ var init_sync = __esm(() => {
   init_codex_mcp();
   init_claude_mcp();
   init_copilot_mcp();
+  init_mcp_sync();
   init_native();
   init_managed_repos();
   import_json53 = __toESM(require_lib(), 1);
 });
 
 // src/core/github-fetch.ts
-import { existsSync as existsSync19, readFileSync as readFileSync5 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync5 } from "node:fs";
+import { join as join21 } from "node:path";
 function readFileFromClone(tempDir, filePath) {
-  const fullPath = join20(tempDir, filePath);
-  if (existsSync19(fullPath)) {
+  const fullPath = join21(tempDir, filePath);
+  if (existsSync20(fullPath)) {
     return readFileSync5(fullPath, "utf-8");
   }
   return null;
@@ -31776,14 +31880,14 @@ var init_github_fetch = __esm(() => {
 
 // src/core/workspace.ts
 import { cp as cp2, mkdir as mkdir9, readFile as readFile12, writeFile as writeFile8, copyFile as copyFile2, unlink as unlink3 } from "node:fs/promises";
-import { existsSync as existsSync20 } from "node:fs";
-import { join as join21, resolve as resolve12, dirname as dirname13, relative as relative6, sep as sep2, isAbsolute as isAbsolute4 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
+import { join as join22, resolve as resolve12, dirname as dirname13, relative as relative6, sep as sep2, isAbsolute as isAbsolute4 } from "node:path";
 import { fileURLToPath } from "node:url";
 async function initWorkspace(targetPath = ".", options2 = {}) {
   const absoluteTarget = resolve12(targetPath);
-  const configDir = join21(absoluteTarget, CONFIG_DIR);
-  const configPath = join21(configDir, WORKSPACE_CONFIG_FILE);
-  if (existsSync20(configPath)) {
+  const configDir = join22(absoluteTarget, CONFIG_DIR);
+  const configPath = join22(configDir, WORKSPACE_CONFIG_FILE);
+  if (existsSync21(configPath)) {
     if (options2.force) {
       await unlink3(configPath);
     } else {
@@ -31794,7 +31898,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
   const currentFilePath = fileURLToPath(import.meta.url);
   const currentFileDir = dirname13(currentFilePath);
   const isProduction = currentFilePath.includes(`${sep2}dist${sep2}`);
-  const defaultTemplatePath = isProduction ? join21(currentFileDir, "templates", "default") : join21(currentFileDir, "..", "templates", "default");
+  const defaultTemplatePath = isProduction ? join22(currentFileDir, "templates", "default") : join22(currentFileDir, "..", "templates", "default");
   let githubTempDir;
   let parsedFromUrl;
   let githubBasePath = "";
@@ -31834,19 +31938,19 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${options2.from}`);
       } else {
         const fromPath = resolve12(options2.from);
-        if (!existsSync20(fromPath)) {
+        if (!existsSync21(fromPath)) {
           throw new Error(`Template not found: ${fromPath}`);
         }
         const { stat: stat2 } = await import("node:fs/promises");
         const fromStat = await stat2(fromPath);
         let sourceYamlPath;
         if (fromStat.isDirectory()) {
-          const nestedPath = join21(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-          const rootPath = join21(fromPath, WORKSPACE_CONFIG_FILE);
-          if (existsSync20(nestedPath)) {
+          const nestedPath = join22(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+          const rootPath = join22(fromPath, WORKSPACE_CONFIG_FILE);
+          if (existsSync21(nestedPath)) {
             sourceYamlPath = nestedPath;
             sourceDir = fromPath;
-          } else if (existsSync20(rootPath)) {
+          } else if (existsSync21(rootPath)) {
             sourceYamlPath = rootPath;
             sourceDir = fromPath;
           } else {
@@ -31877,8 +31981,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${sourceYamlPath}`);
       }
     } else {
-      const defaultYamlPath = join21(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-      if (!existsSync20(defaultYamlPath)) {
+      const defaultYamlPath = join22(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+      if (!existsSync21(defaultYamlPath)) {
         throw new Error(`Default template not found at: ${defaultTemplatePath}`);
       }
       workspaceYamlContent = await readFile12(defaultYamlPath, "utf-8");
@@ -31894,8 +31998,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     const clientNames = getClientTypes(clients);
     const VSCODE_TEMPLATE_FILE2 = "template.code-workspace";
     if (clientNames.includes("vscode") && options2.from) {
-      const targetTemplatePath = join21(configDir, VSCODE_TEMPLATE_FILE2);
-      if (!existsSync20(targetTemplatePath)) {
+      const targetTemplatePath = join22(configDir, VSCODE_TEMPLATE_FILE2);
+      if (!existsSync21(targetTemplatePath)) {
         if (isGitHubUrl(options2.from) && githubTempDir) {
           if (parsedFromUrl) {
             const templatePath = githubBasePath ? `${githubBasePath}/${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}` : `${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}`;
@@ -31905,8 +32009,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
             }
           }
         } else if (sourceDir) {
-          const sourceTemplatePath = join21(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
-          if (existsSync20(sourceTemplatePath)) {
+          const sourceTemplatePath = join22(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
+          if (existsSync21(sourceTemplatePath)) {
             await copyFile2(sourceTemplatePath, targetTemplatePath);
           }
         }
@@ -31919,8 +32023,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       if (options2.from && isGitHubUrl(options2.from) && githubTempDir) {
         if (parsedFromUrl) {
           for (const agentFile of AGENT_FILES) {
-            const targetFilePath = join21(absoluteTarget, agentFile);
-            if (existsSync20(targetFilePath)) {
+            const targetFilePath = join22(absoluteTarget, agentFile);
+            if (existsSync21(targetFilePath)) {
               copiedAgentFiles.push(agentFile);
               continue;
             }
@@ -31935,13 +32039,13 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       } else {
         const effectiveSourceDir = sourceDir ?? defaultTemplatePath;
         for (const agentFile of AGENT_FILES) {
-          const targetFilePath = join21(absoluteTarget, agentFile);
-          if (existsSync20(targetFilePath)) {
+          const targetFilePath = join22(absoluteTarget, agentFile);
+          if (existsSync21(targetFilePath)) {
             copiedAgentFiles.push(agentFile);
             continue;
           }
-          const sourcePath = join21(effectiveSourceDir, agentFile);
-          if (existsSync20(sourcePath)) {
+          const sourcePath = join22(effectiveSourceDir, agentFile);
+          if (existsSync21(sourcePath)) {
             const content = await readFile12(sourcePath, "utf-8");
             await writeFile8(targetFilePath, content, "utf-8");
             copiedAgentFiles.push(agentFile);
@@ -31949,16 +32053,16 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         }
       }
       if (copiedAgentFiles.length === 0) {
-        await ensureWorkspaceRules(join21(absoluteTarget, "AGENTS.md"), repositories);
+        await ensureWorkspaceRules(join22(absoluteTarget, "AGENTS.md"), repositories);
         copiedAgentFiles.push("AGENTS.md");
       } else {
         for (const agentFile of copiedAgentFiles) {
-          await ensureWorkspaceRules(join21(absoluteTarget, agentFile), repositories);
+          await ensureWorkspaceRules(join22(absoluteTarget, agentFile), repositories);
         }
       }
       if (clientNames.includes("claude") && !copiedAgentFiles.includes("CLAUDE.md") && copiedAgentFiles.includes("AGENTS.md")) {
-        const agentsPath = join21(absoluteTarget, "AGENTS.md");
-        const claudePath = join21(absoluteTarget, "CLAUDE.md");
+        const agentsPath = join22(absoluteTarget, "AGENTS.md");
+        const claudePath = join22(absoluteTarget, "CLAUDE.md");
         await copyFile2(agentsPath, claudePath);
       }
     }
@@ -32003,14 +32107,14 @@ Next steps:`);
 async function seedCacheFromClone(tempDir, owner, repo, branch) {
   const cachePaths = [
     getPluginCachePath(owner, repo, branch),
-    join21(getMarketplacesDir(), repo)
+    join22(getMarketplacesDir(), repo)
   ];
   for (const cachePath of cachePaths) {
-    if (existsSync20(cachePath))
+    if (existsSync21(cachePath))
       continue;
     try {
       const parentDir = dirname13(cachePath);
-      if (!existsSync20(parentDir)) {
+      if (!existsSync21(parentDir)) {
         await mkdir9(parentDir, { recursive: true });
       }
       await cp2(tempDir, cachePath, { recursive: true });
@@ -32031,11 +32135,11 @@ var init_workspace = __esm(() => {
 });
 
 // src/core/status.ts
-import { existsSync as existsSync21 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
+import { join as join23 } from "node:path";
 async function getWorkspaceStatus(workspacePath = process.cwd()) {
-  const configPath = join22(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync21(configPath) || isUserConfigPath(workspacePath)) {
+  const configPath = join23(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync22(configPath) || isUserConfigPath(workspacePath)) {
     const userPlugins = await getUserPluginStatuses();
     return {
       success: true,
@@ -32077,7 +32181,7 @@ async function getWorkspaceStatus(workspacePath = process.cwd()) {
 function getPluginStatus(parsed) {
   if (parsed.type === "github") {
     const cachePath = parsed.owner && parsed.repo ? getPluginCachePath(parsed.owner, parsed.repo) : "";
-    const available2 = cachePath ? existsSync21(cachePath) : false;
+    const available2 = cachePath ? existsSync22(cachePath) : false;
     return {
       source: parsed.original,
       type: "github",
@@ -32087,7 +32191,7 @@ function getPluginStatus(parsed) {
       ...parsed.repo && { repo: parsed.repo }
     };
   }
-  const available = existsSync21(parsed.normalized);
+  const available = existsSync22(parsed.normalized);
   return {
     source: parsed.original,
     type: "local",
@@ -34249,9 +34353,9 @@ var init_prompt_clients = __esm(() => {
 });
 
 // src/core/skills.ts
-import { existsSync as existsSync24 } from "node:fs";
+import { existsSync as existsSync25 } from "node:fs";
 import { readFile as readFile14, readdir as readdir5 } from "node:fs/promises";
-import { join as join25, basename as basename7, resolve as resolve14 } from "node:path";
+import { join as join26, basename as basename7, resolve as resolve14 } from "node:path";
 async function resolvePluginPath(pluginSource, workspacePath) {
   if (isPluginSpec(pluginSource)) {
     const resolved2 = await resolvePluginSpecWithAutoRegister(pluginSource, {
@@ -34272,15 +34376,15 @@ async function resolvePluginPath(pluginSource, workspacePath) {
     });
     if (!result.success)
       return null;
-    const path = parsed?.subpath ? join25(result.cachePath, parsed.subpath) : result.cachePath;
+    const path = parsed?.subpath ? join26(result.cachePath, parsed.subpath) : result.cachePath;
     return { path };
   }
   const resolved = resolve14(workspacePath, pluginSource);
-  return existsSync24(resolved) ? { path: resolved } : null;
+  return existsSync25(resolved) ? { path: resolved } : null;
 }
 async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
-  const configPath = join25(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync24(configPath)) {
+  const configPath = join26(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync25(configPath)) {
     return [];
   }
   const content = await readFile14(configPath, "utf-8");
@@ -34296,29 +34400,29 @@ async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
       continue;
     const pluginPath = resolved.path;
     const pluginName = resolved.pluginName ?? getPluginName(pluginPath);
-    const skillsDir = join25(pluginPath, "skills");
+    const skillsDir = join26(pluginPath, "skills");
     const pluginSkillsConfig = typeof pluginEntry === "string" ? undefined : pluginEntry.skills;
     const hasEnabledEntries = !pluginSkillsConfig && enabledSkills && [...enabledSkills].some((s) => s.startsWith(`${pluginName}`));
     let skillEntries;
-    if (existsSync24(skillsDir)) {
+    if (existsSync25(skillsDir)) {
       const entries = await readdir5(skillsDir, { withFileTypes: true });
-      skillEntries = entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, skillPath: join25(skillsDir, e.name) }));
+      skillEntries = entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, skillPath: join26(skillsDir, e.name) }));
     } else {
       const entries = await readdir5(pluginPath, { withFileTypes: true });
       const flatSkills = [];
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
-        const skillMdPath = join25(pluginPath, entry.name, "SKILL.md");
-        if (existsSync24(skillMdPath)) {
-          flatSkills.push({ name: entry.name, skillPath: join25(pluginPath, entry.name) });
+        const skillMdPath = join26(pluginPath, entry.name, "SKILL.md");
+        if (existsSync25(skillMdPath)) {
+          flatSkills.push({ name: entry.name, skillPath: join26(pluginPath, entry.name) });
         }
       }
       if (flatSkills.length > 0) {
         skillEntries = flatSkills;
       } else {
-        const rootSkillMd = join25(pluginPath, "SKILL.md");
-        if (existsSync24(rootSkillMd)) {
+        const rootSkillMd = join26(pluginPath, "SKILL.md");
+        if (existsSync25(rootSkillMd)) {
           const skillContent = await readFile14(rootSkillMd, "utf-8");
           const metadata = parseSkillMetadata(skillContent);
           const skillName = metadata?.name ?? basename7(pluginPath);
@@ -34360,10 +34464,10 @@ async function findSkillByName(skillName, workspacePath = process.cwd()) {
   return allSkills.filter((s) => s.name === skillName);
 }
 async function discoverSkillNames(pluginPath) {
-  if (!existsSync24(pluginPath))
+  if (!existsSync25(pluginPath))
     return [];
-  const skillsDir = join25(pluginPath, "skills");
-  if (existsSync24(skillsDir)) {
+  const skillsDir = join26(pluginPath, "skills");
+  if (existsSync25(skillsDir)) {
     const entries2 = await readdir5(skillsDir, { withFileTypes: true });
     return entries2.filter((e) => e.isDirectory()).map((e) => e.name);
   }
@@ -34372,14 +34476,14 @@ async function discoverSkillNames(pluginPath) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    if (existsSync24(join25(pluginPath, entry.name, "SKILL.md"))) {
+    if (existsSync25(join26(pluginPath, entry.name, "SKILL.md"))) {
       flatSkills.push(entry.name);
     }
   }
   if (flatSkills.length > 0)
     return flatSkills;
-  const rootSkillMd = join25(pluginPath, "SKILL.md");
-  if (existsSync24(rootSkillMd)) {
+  const rootSkillMd = join26(pluginPath, "SKILL.md");
+  if (existsSync25(rootSkillMd)) {
     try {
       const content = await readFile14(rootSkillMd, "utf-8");
       const { parseSkillMetadata: parseSkillMetadata2 } = await Promise.resolve().then(() => (init_skill(), exports_skill));
@@ -34695,8 +34799,8 @@ var require_shebang_regex = __commonJS((exports, module) => {
 // node_modules/shebang-command/index.js
 var require_shebang_command = __commonJS((exports, module) => {
   var shebangRegex = require_shebang_regex();
-  module.exports = (string4 = "") => {
-    const match = string4.match(shebangRegex);
+  module.exports = (string5 = "") => {
+    const match = string5.match(shebangRegex);
     if (!match) {
       return null;
     }
@@ -34713,12 +34817,12 @@ var require_shebang_command = __commonJS((exports, module) => {
 var require_readShebang = __commonJS((exports, module) => {
   var fs = __require("fs");
   var shebangCommand = require_shebang_command();
-  function readShebang(command4) {
+  function readShebang(command5) {
     const size = 150;
     const buffer = Buffer.alloc(size);
     let fd;
     try {
-      fd = fs.openSync(command4, "r");
+      fd = fs.openSync(command5, "r");
       fs.readSync(fd, buffer, 0, size, 0);
       fs.closeSync(fd);
     } catch (e) {}
@@ -34764,7 +34868,7 @@ var require_parse5 = __commonJS((exports, module) => {
     }
     return parsed;
   }
-  function parse2(command4, args, options2) {
+  function parse2(command5, args, options2) {
     if (args && !Array.isArray(args)) {
       options2 = args;
       args = null;
@@ -34772,12 +34876,12 @@ var require_parse5 = __commonJS((exports, module) => {
     args = args ? args.slice(0) : [];
     options2 = Object.assign({}, options2);
     const parsed = {
-      command: command4,
+      command: command5,
       args,
       options: options2,
       file: undefined,
       original: {
-        command: command4,
+        command: command5,
         args
       }
     };
@@ -34838,14 +34942,14 @@ var require_cross_spawn = __commonJS((exports, module) => {
   var cp3 = __require("child_process");
   var parse2 = require_parse5();
   var enoent = require_enoent();
-  function spawn3(command4, args, options2) {
-    const parsed = parse2(command4, args, options2);
+  function spawn3(command5, args, options2) {
+    const parsed = parse2(command5, args, options2);
     const spawned = cp3.spawn(parsed.command, parsed.args, parsed.options);
     enoent.hookChildProcess(spawned, parsed);
     return spawned;
   }
-  function spawnSync(command4, args, options2) {
-    const parsed = parse2(command4, args, options2);
+  function spawnSync(command5, args, options2) {
+    const parsed = parse2(command5, args, options2);
     const result = cp3.spawnSync(parsed.command, parsed.args, parsed.options);
     result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
     return result;
@@ -34899,7 +35003,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "allagents",
-    version: "1.7.2",
+    version: "1.8.0",
     description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
     type: "module",
     bin: {
@@ -34981,13 +35085,13 @@ var init_package = __esm(() => {
 });
 
 // src/cli/update-check.ts
-import { readFile as readFile17 } from "node:fs/promises";
-import { join as join28 } from "node:path";
+import { readFile as readFile18 } from "node:fs/promises";
+import { join as join30 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 async function getCachedUpdateInfo(path3) {
-  const filePath = path3 ?? join28(getHomeDir(), CONFIG_DIR, CACHE_FILE);
+  const filePath = path3 ?? join30(getHomeDir(), CONFIG_DIR, CACHE_FILE);
   try {
-    const raw = await readFile17(filePath, "utf-8");
+    const raw = await readFile18(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.latestVersion === "string" && typeof data.lastCheckedAt === "string") {
       return data;
@@ -35023,8 +35127,8 @@ function buildNotice(currentVersion, latestVersion) {
 Run \`allagents self update\` to upgrade.`);
 }
 function backgroundUpdateCheck() {
-  const dir = join28(getHomeDir(), CONFIG_DIR);
-  const filePath = join28(dir, CACHE_FILE);
+  const dir = join30(getHomeDir(), CONFIG_DIR);
+  const filePath = join30(dir, CACHE_FILE);
   const script = `
     const https = require('https');
     const fs = require('fs');
@@ -35111,15 +35215,15 @@ class TuiCache {
 }
 
 // src/cli/tui/context.ts
-import { existsSync as existsSync27 } from "node:fs";
-import { join as join29 } from "node:path";
+import { existsSync as existsSync29 } from "node:fs";
+import { join as join31 } from "node:path";
 async function getTuiContext(cwd = process.cwd(), cache2) {
   const cachedContext = cache2?.getContext();
   if (cachedContext) {
     return cachedContext;
   }
-  const configPath = join29(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  const hasWorkspace = existsSync27(configPath) && !isUserConfigPath(cwd);
+  const configPath = join31(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  const hasWorkspace = existsSync29(configPath) && !isUserConfigPath(cwd);
   let projectPluginCount = 0;
   if (hasWorkspace) {
     try {
@@ -36485,7 +36589,7 @@ var init_wizard = __esm(() => {
 });
 
 // src/cli/index.ts
-var import_cmd_ts6 = __toESM(require_cjs(), 1);
+var import_cmd_ts7 = __toESM(require_cjs(), 1);
 
 // src/cli/help.ts
 var import_cmd_ts = __toESM(require_cjs(), 1);
@@ -36535,8 +36639,8 @@ init_workspace();
 init_sync();
 init_status2();
 var import_cmd_ts2 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync23 } from "node:fs";
-import { join as join24, resolve as resolve13 } from "node:path";
+import { existsSync as existsSync24 } from "node:fs";
+import { join as join25, resolve as resolve13 } from "node:path";
 
 // src/core/prune.ts
 init_js_yaml();
@@ -36545,8 +36649,8 @@ init_marketplace();
 init_user_workspace();
 init_workspace_config();
 import { readFile as readFile13, writeFile as writeFile9 } from "node:fs/promises";
-import { existsSync as existsSync22 } from "node:fs";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { join as join24 } from "node:path";
 async function isOrphanedPlugin(pluginSpec) {
   if (!isPluginSpec(pluginSpec))
     return false;
@@ -36573,8 +36677,8 @@ async function prunePlugins(plugins) {
 }
 async function pruneOrphanedPlugins(workspacePath) {
   let projectResult = { removed: [], kept: [], keptEntries: [] };
-  const projectConfigPath = join23(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (existsSync22(projectConfigPath) && !isUserConfigPath(workspacePath)) {
+  const projectConfigPath = join24(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (existsSync23(projectConfigPath) && !isUserConfigPath(workspacePath)) {
     const content = await readFile13(projectConfigPath, "utf-8");
     const config = load(content);
     projectResult = await prunePlugins(config.plugins);
@@ -36867,8 +36971,8 @@ var syncCmd = import_cmd_ts2.command({
 `);
       }
       const userConfigExists = !!await getUserWorkspaceConfig();
-      const projectConfigPath = join24(process.cwd(), ".allagents", "workspace.yaml");
-      const projectConfigExists = existsSync23(projectConfigPath);
+      const projectConfigPath = join25(process.cwd(), ".allagents", "workspace.yaml");
+      const projectConfigExists = existsSync24(projectConfigPath);
       if (!userConfigExists && !projectConfigExists) {
         await ensureUserWorkspace();
         if (isJsonMode()) {
@@ -37543,9 +37647,9 @@ init_workspace_modify();
 init_user_workspace();
 init_skills();
 var import_cmd_ts3 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync25 } from "node:fs";
+import { existsSync as existsSync26 } from "node:fs";
 import { readFile as readFile15 } from "node:fs/promises";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 
 // src/cli/metadata/plugin-skills.ts
 var skillsListMeta = {
@@ -37636,7 +37740,7 @@ init_skill();
 init_marketplace();
 init_marketplace_manifest_parser();
 function hasProjectConfig(dir) {
-  return existsSync25(join26(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
+  return existsSync26(join27(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
 }
 function resolveScope(cwd) {
   if (isUserConfigPath(cwd))
@@ -37667,7 +37771,7 @@ async function resolveSkillNameFromRepo(url, parsed, fallbackName, fetchFn = fet
   if (!fetchResult.success)
     return fallbackName;
   try {
-    const skillMd = await readFile15(join26(fetchResult.cachePath, "SKILL.md"), "utf-8");
+    const skillMd = await readFile15(join27(fetchResult.cachePath, "SKILL.md"), "utf-8");
     const metadata = parseSkillMetadata(skillMd);
     return metadata?.name ?? fallbackName;
   } catch {
@@ -38225,8 +38329,8 @@ init_workspace_config();
 init_constants();
 init_js_yaml();
 import { readFile as readFile16 } from "node:fs/promises";
-import { existsSync as existsSync26 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync27 } from "node:fs";
+import { join as join28 } from "node:path";
 async function runSyncAndPrint(options2) {
   if (!isJsonMode()) {
     console.log(`
@@ -38471,7 +38575,7 @@ var marketplaceAddCmd = import_cmd_ts4.command({
         process.exit(1);
       }
       if (effectiveScope === "project") {
-        if (!existsSync26(join27(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE))) {
+        if (!existsSync27(join28(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE))) {
           const msg = 'No workspace found in current directory. Run "allagents workspace init" first.';
           if (isJsonMode()) {
             jsonOutput({ success: false, command: "plugin marketplace add", error: msg });
@@ -38778,7 +38882,7 @@ var pluginListCmd = import_cmd_ts4.command({
       };
       const pluginClients = new Map;
       async function loadConfigClients(configPath, scope) {
-        if (!existsSync26(configPath))
+        if (!existsSync27(configPath))
           return;
         try {
           const content = await readFile16(configPath, "utf-8");
@@ -38793,8 +38897,8 @@ var pluginListCmd = import_cmd_ts4.command({
           }
         } catch {}
       }
-      const userConfigPath = join27(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
-      const projectConfigPath = join27(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+      const userConfigPath = join28(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
+      const projectConfigPath = join28(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
       const cwdIsHome = isUserConfigPath(process.cwd());
       await loadConfigClients(userConfigPath, "user");
       if (!cwdIsHome) {
@@ -38936,7 +39040,7 @@ var pluginInstallCmd = import_cmd_ts4.command({
       const isUser = scope === "user" || !scope && isUserConfigPath(process.cwd());
       if (isUser) {
         const userConfigPath = getUserWorkspaceConfigPath();
-        if (!existsSync26(userConfigPath)) {
+        if (!existsSync27(userConfigPath)) {
           const { promptForClients: promptForClients2 } = await Promise.resolve().then(() => (init_prompt_clients(), exports_prompt_clients));
           const clients = await promptForClients2();
           if (clients === null) {
@@ -38948,8 +39052,8 @@ var pluginInstallCmd = import_cmd_ts4.command({
           await ensureUserWorkspace(clients);
         }
       } else {
-        const configPath = join27(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-        if (!existsSync26(configPath)) {
+        const configPath = join28(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+        if (!existsSync27(configPath)) {
           const { promptForClients: promptForClients2 } = await Promise.resolve().then(() => (init_prompt_clients(), exports_prompt_clients));
           const clients = await promptForClients2();
           if (clients === null) {
@@ -39226,13 +39330,13 @@ var pluginUpdateCmd = import_cmd_ts4.command({
         }
       }
       if (updateProject && !isUserConfigPath(process.cwd())) {
-        const { existsSync: existsSync27 } = await import("node:fs");
+        const { existsSync: existsSync28 } = await import("node:fs");
         const { readFile: readFile17 } = await import("node:fs/promises");
-        const { join: join28 } = await import("node:path");
+        const { join: join29 } = await import("node:path");
         const { load: load2 } = await Promise.resolve().then(() => (init_js_yaml(), exports_js_yaml));
         const { CONFIG_DIR: CONFIG_DIR2, WORKSPACE_CONFIG_FILE: WORKSPACE_CONFIG_FILE2 } = await Promise.resolve().then(() => (init_constants(), exports_constants));
-        const configPath = join28(process.cwd(), CONFIG_DIR2, WORKSPACE_CONFIG_FILE2);
-        if (existsSync27(configPath)) {
+        const configPath = join29(process.cwd(), CONFIG_DIR2, WORKSPACE_CONFIG_FILE2);
+        if (existsSync28(configPath)) {
           const content = await readFile17(configPath, "utf-8");
           const config = load2(content);
           for (const entry of config.plugins ?? []) {
@@ -39389,9 +39493,530 @@ var pluginCmd = conciseSubcommands({
   }
 });
 
-// src/cli/commands/self.ts
+// src/cli/commands/mcp.ts
+init_js_yaml();
 var import_cmd_ts5 = __toESM(require_cjs(), 1);
 
+// src/core/mcp-servers.ts
+init_js_yaml();
+init_constants();
+init_workspace_config();
+init_workspace_modify();
+import { existsSync as existsSync28 } from "node:fs";
+import { readFile as readFile17, writeFile as writeFile10 } from "node:fs/promises";
+import { join as join29 } from "node:path";
+function getConfigPath(workspacePath) {
+  return join29(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+}
+async function readConfig(configPath) {
+  const content = await readFile17(configPath, "utf-8");
+  return load(content);
+}
+async function writeConfig(configPath, config) {
+  await writeFile10(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+}
+function validateServerConfig(config) {
+  const result = McpServerConfigSchema.safeParse(config);
+  if (!result.success) {
+    const issues = result.error.issues.map((i2) => `  - ${i2.path.join(".")}: ${i2.message}`);
+    return { valid: false, error: `Invalid MCP server config:
+${issues.join(`
+`)}` };
+  }
+  return { valid: true, data: result.data };
+}
+async function addWorkspaceMcpServer(name, config, workspacePath = process.cwd(), force = false) {
+  const validation = validateServerConfig(config);
+  if (!validation.valid) {
+    return { success: false, error: validation.error };
+  }
+  try {
+    await ensureWorkspace(workspacePath);
+    const configPath = getConfigPath(workspacePath);
+    const workspaceConfig = await readConfig(configPath);
+    workspaceConfig.mcpServers ??= {};
+    if (workspaceConfig.mcpServers[name] && !force) {
+      return {
+        success: false,
+        error: `MCP server '${name}' already exists in workspace.yaml. Pass --force to replace it.`
+      };
+    }
+    workspaceConfig.mcpServers[name] = validation.data;
+    await writeConfig(configPath, workspaceConfig);
+    return { success: true, config: validation.data };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function removeWorkspaceMcpServer(name, workspacePath = process.cwd()) {
+  const configPath = getConfigPath(workspacePath);
+  if (!existsSync28(configPath)) {
+    return {
+      success: false,
+      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
+    };
+  }
+  try {
+    const workspaceConfig = await readConfig(configPath);
+    if (!workspaceConfig.mcpServers || !(name in workspaceConfig.mcpServers)) {
+      return {
+        success: false,
+        error: `MCP server '${name}' not found in workspace.yaml`
+      };
+    }
+    delete workspaceConfig.mcpServers[name];
+    if (Object.keys(workspaceConfig.mcpServers).length === 0) {
+      workspaceConfig.mcpServers = undefined;
+    }
+    await writeConfig(configPath, workspaceConfig);
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function getWorkspaceMcpServer(name, workspacePath = process.cwd()) {
+  const configPath = getConfigPath(workspacePath);
+  if (!existsSync28(configPath))
+    return null;
+  const workspaceConfig = await readConfig(configPath);
+  return workspaceConfig.mcpServers?.[name] ?? null;
+}
+async function listWorkspaceMcpServers(workspacePath = process.cwd()) {
+  const configPath = getConfigPath(workspacePath);
+  if (!existsSync28(configPath))
+    return {};
+  const workspaceConfig = await readConfig(configPath);
+  return workspaceConfig.mcpServers ?? {};
+}
+function buildMcpServerConfigFromFlags(options2) {
+  const { commandOrUrl, args, env: env2, headers, clients } = options2;
+  const transport = options2.transport ?? (/^https?:\/\//i.test(commandOrUrl) ? "http" : "stdio");
+  if (transport === "http") {
+    if (!/^https?:\/\//i.test(commandOrUrl)) {
+      return {
+        error: `HTTP transport requires a URL starting with http:// or https:// (got '${commandOrUrl}')`
+      };
+    }
+    if (args && args.length > 0) {
+      return { error: "--arg is not supported for HTTP transport" };
+    }
+    if (env2 && Object.keys(env2).length > 0) {
+      return { error: "-e/--env is not supported for HTTP transport" };
+    }
+    const config2 = {
+      type: "http",
+      url: commandOrUrl,
+      ...headers && Object.keys(headers).length > 0 && { headers },
+      ...clients && clients.length > 0 && { clients }
+    };
+    return { config: config2 };
+  }
+  if (options2.transport === "stdio" && /^https?:\/\//i.test(commandOrUrl)) {
+    return {
+      error: `stdio transport requires a command, not a URL (got '${commandOrUrl}')`
+    };
+  }
+  if (headers && Object.keys(headers).length > 0) {
+    return { error: "--header is not supported for stdio transport" };
+  }
+  const config = {
+    type: "stdio",
+    command: commandOrUrl,
+    ...args && args.length > 0 && { args },
+    ...env2 && Object.keys(env2).length > 0 && { env: env2 },
+    ...clients && clients.length > 0 && { clients }
+  };
+  return { config };
+}
+function parseKeyValuePairs(pairs2, flagName) {
+  const values = {};
+  for (const pair of pairs2) {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx <= 0) {
+      return { error: `Invalid ${flagName}: '${pair}' (expected KEY=VALUE)` };
+    }
+    const key = pair.slice(0, eqIdx);
+    const value = pair.slice(eqIdx + 1);
+    values[key] = value;
+  }
+  return { values };
+}
+
+// src/cli/commands/mcp.ts
+init_mcp_sync();
+init_workspace_config();
+init_format_sync();
+
+// src/cli/metadata/mcp.ts
+var mcpAddMeta = {
+  command: "mcp add",
+  description: "Add an MCP server to workspace.yaml and sync to clients",
+  whenToUse: "When adding a new MCP server that you want AllAgents to manage and sync to all configured clients",
+  examples: [
+    "allagents mcp add deepwiki https://mcp.deepwiki.com/mcp",
+    "allagents mcp add my-server npx --arg=-y --arg=@my/mcp-server",
+    "allagents mcp add gh-api npx -e GH_TOKEN=abc123 --arg=-y --arg=@modelcontextprotocol/server-github",
+    "allagents mcp add deepwiki https://mcp.deepwiki.com/mcp --client claude,copilot"
+  ],
+  expectedOutput: "Adds the server to workspace.yaml and syncs it to all configured clients. Exit 0 on success, 1 on failure.",
+  positionals: [
+    { name: "name", type: "string", required: true, description: "Server name (unique within workspace.yaml)" },
+    {
+      name: "commandOrUrl",
+      type: "string",
+      required: true,
+      description: "HTTP URL (http://, https://) for http transport, or a command for stdio transport"
+    }
+  ],
+  options: [
+    { flag: "--transport", type: "string", description: "Transport type: 'http' or 'stdio' (auto-detected from URL by default)" },
+    { flag: "--arg", type: "string", description: "Argument to pass to the stdio command (repeatable)" },
+    { flag: "--env", short: "-e", type: "string", description: "Environment variable KEY=VALUE for stdio transport (repeatable)" },
+    { flag: "--header", type: "string", description: "HTTP header KEY=VALUE for http transport (repeatable)" },
+    { flag: "--client", type: "string", description: "Comma-separated list of clients that should receive this server (default: all project-scoped clients)" },
+    { flag: "--force", short: "-f", type: "boolean", description: "Replace an existing server with the same name" }
+  ]
+};
+var mcpRemoveMeta = {
+  command: "mcp remove",
+  description: "Remove an MCP server from workspace.yaml and all clients",
+  whenToUse: "When you no longer need an MCP server that AllAgents added",
+  examples: ["allagents mcp remove deepwiki"],
+  expectedOutput: "Removes the server from workspace.yaml and unsyncs it from all configured clients. Exit 0 on success, 1 if the server is not defined in workspace.yaml.",
+  positionals: [
+    { name: "name", type: "string", required: true, description: "Server name to remove" }
+  ]
+};
+var mcpListMeta = {
+  command: "mcp list",
+  description: "List MCP servers defined in workspace.yaml",
+  whenToUse: "To inspect MCP servers AllAgents is managing at the workspace level",
+  examples: ["allagents mcp list"],
+  expectedOutput: "Prints a table of workspace-defined MCP servers with transport, target, and client filter. Exit 0 on success."
+};
+var mcpGetMeta = {
+  command: "mcp get",
+  description: "Show the workspace definition for an MCP server",
+  whenToUse: "To see how an MCP server is configured in workspace.yaml",
+  examples: ["allagents mcp get deepwiki"],
+  expectedOutput: "Prints the server config (YAML). Exit 0 on success, 1 if not found.",
+  positionals: [
+    { name: "name", type: "string", required: true, description: "Server name" }
+  ]
+};
+var mcpUpdateMeta = {
+  command: "mcp update",
+  description: "Sync MCP servers only, without touching other artifacts",
+  whenToUse: "When you've edited workspace.yaml's mcpServers block or plugin .mcp.json files and want to re-sync only MCP servers without re-running the full workspace sync. To modify a server definition use 'mcp add --force'.",
+  examples: ["allagents mcp update", "allagents mcp update --offline"],
+  expectedOutput: "Runs the MCP portion of sync for all project-scoped clients. Prints per-scope added/updated/removed counts. Exit 0 on success, 1 on failure.",
+  options: [
+    { flag: "--offline", type: "boolean", description: "Use cached plugins without fetching from remote" }
+  ]
+};
+
+// src/cli/commands/mcp.ts
+function parseClientFilter(input) {
+  const items = input.split(",").map((s) => s.trim()).filter(Boolean);
+  const result = [];
+  for (const item of items) {
+    const parsed = ClientTypeSchema.safeParse(item);
+    if (!parsed.success) {
+      throw new Error(`Invalid client '${item}'. Valid clients: ${ClientTypeSchema.options.join(", ")}`);
+    }
+    result.push(parsed.data);
+  }
+  return result;
+}
+function exitWithError(command5, error) {
+  if (isJsonMode()) {
+    jsonOutput({ success: false, command: command5, error });
+  } else {
+    console.error(`Error: ${error}`);
+  }
+  process.exit(1);
+}
+function buildConfigFromAddFlags(commandName, commandOrUrl, transport, args, env2, header, client) {
+  if (transport && transport !== "http" && transport !== "stdio") {
+    exitWithError(commandName, `Invalid transport '${transport}'. Expected 'http' or 'stdio'.`);
+  }
+  const envResult = parseKeyValuePairs(env2, "-e/--env");
+  if ("error" in envResult)
+    exitWithError(commandName, envResult.error);
+  const headerResult = parseKeyValuePairs(header, "--header");
+  if ("error" in headerResult)
+    exitWithError(commandName, headerResult.error);
+  let clients;
+  if (client) {
+    try {
+      clients = parseClientFilter(client);
+    } catch (e) {
+      exitWithError(commandName, e instanceof Error ? e.message : String(e));
+    }
+  }
+  const buildOpts = {
+    commandOrUrl,
+    args,
+    env: envResult.values,
+    headers: headerResult.values
+  };
+  if (transport)
+    buildOpts.transport = transport;
+  if (clients)
+    buildOpts.clients = clients;
+  const built = buildMcpServerConfigFromFlags(buildOpts);
+  if ("error" in built)
+    exitWithError(commandName, built.error);
+  return built.config;
+}
+async function runPostMutationSync(commandName, successMessage, jsonExtra) {
+  const syncResult = await syncMcpOnly(process.cwd(), { offline: true });
+  if (!syncResult.success) {
+    exitWithError(commandName, syncResult.error ?? "MCP sync failed");
+  }
+  if (isJsonMode()) {
+    jsonOutput({
+      success: true,
+      command: commandName,
+      data: { ...jsonExtra, mcpResults: syncResult.mcpResults }
+    });
+    return;
+  }
+  console.log(successMessage);
+  for (const [scope, result] of Object.entries(syncResult.mcpResults)) {
+    if (!result)
+      continue;
+    const lines = formatMcpResult(result, scope);
+    if (lines.length > 0) {
+      console.log("");
+      for (const line of lines)
+        console.log(line);
+    }
+  }
+  for (const warning of syncResult.warnings) {
+    console.log(`  ⚠ ${warning}`);
+  }
+}
+function serverToDisplay(name, config) {
+  const lines = [`${name}:`];
+  const isHttp = "url" in config;
+  lines.push(`  transport: ${isHttp ? "http" : "stdio"}`);
+  if (isHttp) {
+    lines.push(`  url: ${config.url}`);
+    if (config.headers && Object.keys(config.headers).length > 0) {
+      lines.push("  headers:");
+      for (const [k3, v] of Object.entries(config.headers)) {
+        lines.push(`    ${k3}: ${v}`);
+      }
+    }
+  } else {
+    lines.push(`  command: ${config.command}`);
+    if (config.args && config.args.length > 0) {
+      lines.push(`  args: ${JSON.stringify(config.args)}`);
+    }
+    if (config.env && Object.keys(config.env).length > 0) {
+      lines.push("  env:");
+      for (const [k3, v] of Object.entries(config.env)) {
+        lines.push(`    ${k3}: ${v}`);
+      }
+    }
+  }
+  if (config.clients && config.clients.length > 0) {
+    lines.push(`  clients: [${config.clients.join(", ")}]`);
+  }
+  return lines;
+}
+var addArgs = {
+  name: import_cmd_ts5.positional({ type: import_cmd_ts5.string, displayName: "name" }),
+  commandOrUrl: import_cmd_ts5.positional({ type: import_cmd_ts5.string, displayName: "commandOrUrl" }),
+  transport: import_cmd_ts5.option({
+    type: import_cmd_ts5.optional(import_cmd_ts5.string),
+    long: "transport",
+    description: "Transport: 'http' or 'stdio' (auto-detected from URL if omitted)"
+  }),
+  args: import_cmd_ts5.multioption({
+    type: import_cmd_ts5.array(import_cmd_ts5.string),
+    long: "arg",
+    description: "Argument for stdio command (repeatable)"
+  }),
+  env: import_cmd_ts5.multioption({
+    type: import_cmd_ts5.array(import_cmd_ts5.string),
+    long: "env",
+    short: "e",
+    description: "Environment variable KEY=VALUE (repeatable)"
+  }),
+  header: import_cmd_ts5.multioption({
+    type: import_cmd_ts5.array(import_cmd_ts5.string),
+    long: "header",
+    description: "HTTP header KEY=VALUE (repeatable)"
+  }),
+  client: import_cmd_ts5.option({
+    type: import_cmd_ts5.optional(import_cmd_ts5.string),
+    long: "client",
+    description: "Comma-separated list of client filters"
+  })
+};
+var mcpAddCmd = import_cmd_ts5.command({
+  name: "add",
+  description: buildDescription(mcpAddMeta),
+  args: {
+    ...addArgs,
+    force: import_cmd_ts5.flag({ long: "force", short: "f", description: "Replace an existing server with the same name" })
+  },
+  handler: async ({ name, commandOrUrl, transport, args, env: env2, header, client, force }) => {
+    const config = buildConfigFromAddFlags("mcp add", commandOrUrl, transport, args, env2, header, client);
+    const addResult = await addWorkspaceMcpServer(name, config, process.cwd(), force);
+    if (!addResult.success)
+      exitWithError("mcp add", addResult.error ?? "Unknown error");
+    await runPostMutationSync("mcp add", `✓ Added MCP server '${name}' to workspace.yaml`, {
+      name,
+      config: addResult.config
+    });
+  }
+});
+var mcpRemoveCmd = import_cmd_ts5.command({
+  name: "remove",
+  description: buildDescription(mcpRemoveMeta),
+  args: {
+    name: import_cmd_ts5.positional({ type: import_cmd_ts5.string, displayName: "name" })
+  },
+  handler: async ({ name }) => {
+    const removeResult = await removeWorkspaceMcpServer(name, process.cwd());
+    if (!removeResult.success)
+      exitWithError("mcp remove", removeResult.error ?? "Unknown error");
+    await runPostMutationSync("mcp remove", `✓ Removed MCP server '${name}' from workspace.yaml`, { name });
+  }
+});
+var mcpListCmd = import_cmd_ts5.command({
+  name: "list",
+  description: buildDescription(mcpListMeta),
+  args: {},
+  handler: async () => {
+    let servers;
+    try {
+      servers = await listWorkspaceMcpServers(process.cwd());
+    } catch (e) {
+      exitWithError("mcp list", e instanceof Error ? e.message : String(e));
+    }
+    const names = Object.keys(servers);
+    if (isJsonMode()) {
+      jsonOutput({
+        success: true,
+        command: "mcp list",
+        data: { servers, total: names.length }
+      });
+      return;
+    }
+    if (names.length === 0) {
+      console.log("No MCP servers defined in workspace.yaml.");
+      console.log("");
+      console.log("Add one with:");
+      console.log("  allagents mcp add <name> <commandOrUrl>");
+      return;
+    }
+    console.log(`MCP servers (${names.length}):`);
+    console.log("");
+    for (const name of names) {
+      const config = servers[name];
+      if (!config)
+        continue;
+      for (const line of serverToDisplay(name, config)) {
+        console.log(`  ${line}`);
+      }
+      console.log("");
+    }
+  }
+});
+var mcpGetCmd = import_cmd_ts5.command({
+  name: "get",
+  description: buildDescription(mcpGetMeta),
+  args: {
+    name: import_cmd_ts5.positional({ type: import_cmd_ts5.string, displayName: "name" })
+  },
+  handler: async ({ name }) => {
+    let config;
+    try {
+      config = await getWorkspaceMcpServer(name, process.cwd());
+    } catch (e) {
+      exitWithError("mcp get", e instanceof Error ? e.message : String(e));
+    }
+    if (!config) {
+      exitWithError("mcp get", `MCP server '${name}' not found in workspace.yaml`);
+    }
+    if (isJsonMode()) {
+      jsonOutput({
+        success: true,
+        command: "mcp get",
+        data: { name, config }
+      });
+      return;
+    }
+    console.log(dump({ [name]: config }, { lineWidth: -1 }).trimEnd());
+  }
+});
+var mcpUpdateCmd = import_cmd_ts5.command({
+  name: "update",
+  description: buildDescription(mcpUpdateMeta),
+  args: {
+    offline: import_cmd_ts5.flag({ long: "offline", description: "Use cached plugins without fetching from remote" })
+  },
+  handler: async ({ offline }) => {
+    const result = await syncMcpOnly(process.cwd(), { offline });
+    if (!result.success) {
+      exitWithError("mcp update", result.error ?? "MCP sync failed");
+    }
+    if (isJsonMode()) {
+      jsonOutput({
+        success: true,
+        command: "mcp update",
+        data: { mcpResults: result.mcpResults, warnings: result.warnings }
+      });
+      return;
+    }
+    const hasAnyChanges = Object.values(result.mcpResults).some((r) => r && (r.added > 0 || r.overwritten > 0 || r.removed > 0 || r.skipped > 0));
+    if (!hasAnyChanges) {
+      console.log("No MCP server changes.");
+    } else {
+      for (const [scope, mcpResult] of Object.entries(result.mcpResults)) {
+        if (!mcpResult)
+          continue;
+        const lines = formatMcpResult(mcpResult, scope);
+        if (lines.length > 0) {
+          for (const line of lines)
+            console.log(line);
+          console.log("");
+        }
+      }
+    }
+    if (result.warnings.length > 0) {
+      console.log("Warnings:");
+      for (const warning of result.warnings) {
+        console.log(`  ⚠ ${warning}`);
+      }
+    }
+  }
+});
+var mcpCmd = conciseSubcommands({
+  name: "mcp",
+  description: "Manage MCP servers for AI clients",
+  cmds: {
+    add: mcpAddCmd,
+    remove: mcpRemoveCmd,
+    list: mcpListCmd,
+    get: mcpGetCmd,
+    update: mcpUpdateCmd
+  }
+});
+
+// src/cli/commands/self.ts
+var import_cmd_ts6 = __toESM(require_cjs(), 1);
+
 // node_modules/execa/index.js
 var import_cross_spawn = __toESM(require_cross_spawn(), 1);
 import { Buffer as Buffer5 } from "node:buffer";
@@ -39939,7 +40564,7 @@ var makeError = ({
   error,
   signal,
   exitCode,
-  command: command4,
+  command: command5,
   escapedCommand,
   timedOut,
   isCanceled,
@@ -39951,7 +40576,7 @@ var makeError = ({
   const signalDescription = signal === undefined ? undefined : signalsByName[signal].description;
   const errorCode = error && error.code;
   const prefix = getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
-  const execaMessage = `Command ${prefix}: ${command4}`;
+  const execaMessage = `Command ${prefix}: ${command5}`;
   const isError = Object.prototype.toString.call(error) === "[object Error]";
   const shortMessage = isError ? `${execaMessage}
 ${error.message}` : execaMessage;
@@ -39964,7 +40589,7 @@ ${error.message}` : execaMessage;
     error = new Error(message);
   }
   error.shortMessage = shortMessage;
-  error.command = command4;
+  error.command = command5;
   error.escapedCommand = escapedCommand;
   error.exitCode = exitCode;
   error.signal = signal;
@@ -40771,7 +41396,7 @@ var handleOutput = (options2, value, error) => {
 };
 function execa(file, args, options2) {
   const parsed = handleArguments(file, args, options2);
-  const command4 = joinCommand(file, args);
+  const command5 = joinCommand(file, args);
   const escapedCommand = getEscapedCommand(file, args);
   logCommand(escapedCommand, parsed.options);
   validateTimeout(parsed.options);
@@ -40785,7 +41410,7 @@ function execa(file, args, options2) {
       stdout: "",
       stderr: "",
       all: "",
-      command: command4,
+      command: command5,
       escapedCommand,
       parsed,
       timedOut: false,
@@ -40814,7 +41439,7 @@ function execa(file, args, options2) {
         stdout,
         stderr,
         all,
-        command: command4,
+        command: command5,
         escapedCommand,
         parsed,
         timedOut,
@@ -40827,7 +41452,7 @@ function execa(file, args, options2) {
       throw returnedError;
     }
     return {
-      command: command4,
+      command: command5,
       escapedCommand,
       exitCode: 0,
       stdout,
@@ -40848,7 +41473,7 @@ function execa(file, args, options2) {
 }
 function execaSync(file, args, options2) {
   const parsed = handleArguments(file, args, options2);
-  const command4 = joinCommand(file, args);
+  const command5 = joinCommand(file, args);
   const escapedCommand = getEscapedCommand(file, args);
   logCommand(escapedCommand, parsed.options);
   const input = handleInputSync(parsed.options);
@@ -40861,7 +41486,7 @@ function execaSync(file, args, options2) {
       stdout: "",
       stderr: "",
       all: "",
-      command: command4,
+      command: command5,
       escapedCommand,
       parsed,
       timedOut: false,
@@ -40878,7 +41503,7 @@ function execaSync(file, args, options2) {
       error: result.error,
       signal: result.signal,
       exitCode: result.status,
-      command: command4,
+      command: command5,
       escapedCommand,
       parsed,
       timedOut: result.error && result.error.code === "ETIMEDOUT",
@@ -40891,7 +41516,7 @@ function execaSync(file, args, options2) {
     throw error;
   }
   return {
-    command: command4,
+    command: command5,
     escapedCommand,
     exitCode: 0,
     stdout,
@@ -40963,12 +41588,12 @@ function detectPackageManager() {
 function getCurrentVersion() {
   return package_default.version;
 }
-var updateCmd = import_cmd_ts5.command({
+var updateCmd = import_cmd_ts6.command({
   name: "update",
   description: buildDescription(updateMeta),
   args: {
-    npm: import_cmd_ts5.flag({ long: "npm", description: "Force update using npm" }),
-    bun: import_cmd_ts5.flag({ long: "bun", description: "Force update using bun" })
+    npm: import_cmd_ts6.flag({ long: "npm", description: "Force update using npm" }),
+    bun: import_cmd_ts6.flag({ long: "bun", description: "Force update using bun" })
   },
   handler: async ({ npm, bun }) => {
     try {
@@ -41152,6 +41777,7 @@ var app = conciseSubcommands({
     update: syncCmd,
     workspace: workspaceCmd,
     plugin: pluginCmd,
+    mcp: mcpCmd,
     self: selfCmd,
     skills: skillsCmd
   }
@@ -41174,5 +41800,5 @@ if (agentHelp) {
   const { runWizard: runWizard2 } = await Promise.resolve().then(() => (init_wizard(), exports_wizard));
   await runWizard2();
 } else {
-  import_cmd_ts6.run(app, finalArgs);
+  import_cmd_ts7.run(app, finalArgs);
 }