allagents 1.0.15 → 1.2.0

package/dist/index.js

@@ -6378,7 +6378,7 @@ var require_parse = __commonJS((exports, module) => {
   var token;
   var key;
   var root;
-  module.exports = function parse(text, reviver) {
+  module.exports = function parse2(text, reviver) {
     source = String(text);
     parseState = "start";
     stack = [];
@@ -11529,7 +11529,37 @@ var init_workspace_config = __esm(() => {
   ]);
   InstallModeSchema = exports_external.enum(["file", "native"]);
   ClientEntrySchema = exports_external.union([
-    ClientTypeSchema,
+    exports_external.string().transform((s, ctx) => {
+      const colonIdx = s.indexOf(":");
+      if (colonIdx === -1) {
+        const result = ClientTypeSchema.safeParse(s);
+        if (!result.success) {
+          for (const issue of result.error.issues)
+            ctx.addIssue(issue);
+          return exports_external.NEVER;
+        }
+        return result.data;
+      }
+      const name = s.slice(0, colonIdx);
+      const mode = s.slice(colonIdx + 1);
+      const nameResult = ClientTypeSchema.safeParse(name);
+      if (!nameResult.success) {
+        ctx.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          message: `Invalid client type: '${name}'`
+        });
+        return exports_external.NEVER;
+      }
+      const modeResult = InstallModeSchema.safeParse(mode);
+      if (!modeResult.success) {
+        ctx.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          message: `Invalid install mode: '${mode}'. Valid modes: ${InstallModeSchema.options.join(", ")}`
+        });
+        return exports_external.NEVER;
+      }
+      return { name: nameResult.data, install: modeResult.data };
+    }),
     exports_external.object({
       name: ClientTypeSchema,
       install: InstallModeSchema.default("file")
@@ -13446,7 +13476,7 @@ function gitInstanceFactory(baseDir, options2) {
 }
 var import_file_exists, import_debug, import_promise_deferred, import_promise_deferred2, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __hasOwnProp2, __esm2 = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
-}, __commonJS2 = (cb, mod) => function __require() {
+}, __commonJS2 = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 }, __export2 = (target, all) => {
   for (var name in all)
@@ -21933,7 +21963,7 @@ var require_is_extendable = __commonJS((exports, module) => {
 // node_modules/extend-shallow/index.js
 var require_extend_shallow = __commonJS((exports, module) => {
   var isObject2 = require_is_extendable();
-  module.exports = function extend(o) {
+  module.exports = function extend3(o) {
     if (!isObject2(o)) {
       o = {};
     }
@@ -22127,7 +22157,7 @@ var require_exception = __commonJS((exports, module) => {
   }
   YAMLException2.prototype = Object.create(Error.prototype);
   YAMLException2.prototype.constructor = YAMLException2;
-  YAMLException2.prototype.toString = function toString(compact) {
+  YAMLException2.prototype.toString = function toString2(compact) {
     var result = this.name + ": ";
     result += this.reason || "(unknown reason)";
     if (!compact && this.mark) {
@@ -22180,7 +22210,7 @@ var require_mark = __commonJS((exports, module) => {
     return common2.repeat(" ", indent) + head + snippet2 + tail + `
 ` + common2.repeat(" ", indent + this.position - start + head.length) + "^";
   };
-  Mark.prototype.toString = function toString(compact) {
+  Mark.prototype.toString = function toString2(compact) {
     var snippet2, where = "";
     if (this.name) {
       where += 'in "' + this.name + '" ';
@@ -23275,7 +23305,7 @@ var require_loader = __commonJS((exports, module) => {
     }
   }
   var directiveHandlers2 = {
-    YAML: function handleYamlDirective(state, name, args) {
+    YAML: function handleYamlDirective2(state, name, args) {
       var match, major, minor;
       if (state.version !== null) {
         throwError2(state, "duplication of %YAML directive");
@@ -23298,7 +23328,7 @@ var require_loader = __commonJS((exports, module) => {
         throwWarning2(state, "unsupported YAML version of the document");
       }
     },
-    TAG: function handleTagDirective(state, name, args) {
+    TAG: function handleTagDirective2(state, name, args) {
       var handle, prefix;
       if (args.length !== 2) {
         throwError2(state, "TAG directive accepts exactly two arguments");
@@ -28935,6 +28965,8 @@ function mergeNativeSyncResults(results) {
 var init_types2 = () => {};
 
 // src/core/codex-mcp.ts
+import { existsSync as existsSync12, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname as dirname8 } from "node:path";
 function buildCodexMcpAddArgs(name, config) {
   if (typeof config.url === "string") {
     return ["mcp", "add", name, "--url", config.url];
@@ -29036,11 +29068,410 @@ async function syncCodexMcpServers(validatedPlugins, options2) {
   }
   return result;
 }
+function toTomlValue(value) {
+  if (typeof value === "string")
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (Array.isArray(value))
+    return `[${value.map(toTomlValue).join(", ")}]`;
+  return `"${String(value)}"`;
+}
+function serverToToml(name, config) {
+  const lines = [`[mcp_servers.${name}]`];
+  const envEntries = [];
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "type")
+      continue;
+    if (key === "env" && typeof value === "object" && value !== null) {
+      envEntries.push(...Object.entries(value));
+      continue;
+    }
+    lines.push(`${key} = ${toTomlValue(value)}`);
+  }
+  if (envEntries.length > 0) {
+    lines.push("");
+    lines.push(`[mcp_servers.${name}.env]`);
+    for (const [envKey, envValue] of envEntries) {
+      lines.push(`${envKey} = ${toTomlValue(envValue)}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function parseCodexConfigToml(content) {
+  const serverNames = new Set;
+  const serverSections = new Map;
+  const nonMcpLines = [];
+  const lines = content.split(`
+`);
+  let currentServer = null;
+  let currentLines = [];
+  for (const line of lines) {
+    const sectionMatch = line.match(/^\[mcp_servers\.([^\].]+?)(?:\.[^\]]+)?\]$/);
+    if (sectionMatch) {
+      if (currentServer) {
+        serverSections.set(currentServer, (serverSections.get(currentServer) ?? "") + (serverSections.has(currentServer) ? `
+` : "") + currentLines.join(`
+`));
+      }
+      currentServer = sectionMatch[1] ?? null;
+      if (currentServer)
+        serverNames.add(currentServer);
+      currentLines = [line];
+      continue;
+    }
+    const otherSectionMatch = line.match(/^\[(?!mcp_servers\.)/);
+    if (otherSectionMatch) {
+      if (currentServer) {
+        serverSections.set(currentServer, (serverSections.get(currentServer) ?? "") + (serverSections.has(currentServer) ? `
+` : "") + currentLines.join(`
+`));
+        currentServer = null;
+        currentLines = [];
+      }
+      nonMcpLines.push(line);
+      continue;
+    }
+    if (currentServer) {
+      currentLines.push(line);
+    } else {
+      nonMcpLines.push(line);
+    }
+  }
+  if (currentServer) {
+    serverSections.set(currentServer, (serverSections.get(currentServer) ?? "") + (serverSections.has(currentServer) ? `
+` : "") + currentLines.join(`
+`));
+  }
+  return {
+    serverNames,
+    nonMcpContent: nonMcpLines.join(`
+`).replace(/\n{3,}/g, `
+
+`).trim(),
+    serverSections
+  };
+}
+function syncCodexProjectMcpConfig(validatedPlugins, options2) {
+  const dryRun = options2?.dryRun ?? false;
+  const force = options2?.force ?? false;
+  const configPath = options2?.configPath;
+  if (!configPath) {
+    throw new Error("configPath is required for syncCodexProjectMcpConfig");
+  }
+  const previouslyTracked = new Set(options2?.trackedServers ?? []);
+  const hasTracking = options2?.trackedServers !== undefined;
+  const { servers: pluginServers, warnings } = collectMcpServers(validatedPlugins);
+  const result = {
+    added: 0,
+    skipped: 0,
+    overwritten: 0,
+    removed: 0,
+    warnings: [...warnings],
+    addedServers: [],
+    skippedServers: [],
+    overwrittenServers: [],
+    removedServers: [],
+    trackedServers: []
+  };
+  let existingContent = "";
+  if (existsSync12(configPath)) {
+    try {
+      existingContent = readFileSync2(configPath, "utf-8");
+    } catch {
+      result.warnings.push(`Could not read existing ${configPath}, starting fresh`);
+    }
+  }
+  const { serverNames: existingNames, nonMcpContent, serverSections } = parseCodexConfigToml(existingContent);
+  const finalServers = new Map(serverSections);
+  for (const [name, config] of pluginServers) {
+    if (existingNames.has(name)) {
+      if (hasTracking && previouslyTracked.has(name)) {
+        finalServers.set(name, serverToToml(name, config));
+        result.overwritten++;
+        result.overwrittenServers.push(name);
+        result.trackedServers.push(name);
+      } else if (force) {
+        finalServers.set(name, serverToToml(name, config));
+        result.overwritten++;
+        result.overwrittenServers.push(name);
+        result.trackedServers.push(name);
+      } else {
+        result.skipped++;
+        result.skippedServers.push(name);
+      }
+    } else {
+      finalServers.set(name, serverToToml(name, config));
+      result.added++;
+      result.addedServers.push(name);
+      result.trackedServers.push(name);
+    }
+  }
+  if (hasTracking) {
+    const currentServerNames = new Set(pluginServers.keys());
+    for (const trackedName of previouslyTracked) {
+      if (!currentServerNames.has(trackedName) && finalServers.has(trackedName)) {
+        finalServers.delete(trackedName);
+        result.removed++;
+        result.removedServers.push(trackedName);
+      }
+    }
+  }
+  const hasChanges = result.added > 0 || result.overwritten > 0 || result.removed > 0;
+  if (hasChanges && !dryRun) {
+    const parts = [];
+    if (nonMcpContent) {
+      parts.push(nonMcpContent);
+    }
+    for (const toml of finalServers.values()) {
+      parts.push(toml);
+    }
+    const output = `${parts.join(`
+
+`)}
+`;
+    const dir = dirname8(configPath);
+    if (!existsSync12(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync2(configPath, output, "utf-8");
+    result.configPath = configPath;
+  }
+  return result;
+}
 var init_codex_mcp = __esm(() => {
   init_types2();
   init_vscode_mcp();
 });
 
+// src/core/claude-mcp.ts
+import { existsSync as existsSync13, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+function deepEqual2(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== typeof b)
+    return false;
+  if (a === null || b === null)
+    return a === b;
+  if (typeof a !== "object")
+    return false;
+  if (Array.isArray(a) !== Array.isArray(b))
+    return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    return a.every((val, i2) => deepEqual2(val, b[i2]));
+  }
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length)
+    return false;
+  return aKeys.every((key) => (key in bObj) && deepEqual2(aObj[key], bObj[key]));
+}
+function buildClaudeMcpAddArgs(name, config, scope = "user") {
+  if (typeof config.url === "string") {
+    return ["mcp", "add", "--transport", "http", "--scope", scope, name, config.url];
+  }
+  if (typeof config.command === "string") {
+    const args = ["mcp", "add", "--scope", scope];
+    if (config.env && typeof config.env === "object") {
+      for (const [key, value] of Object.entries(config.env)) {
+        args.push("-e", `${key}=${value}`);
+      }
+    }
+    args.push(name, "--", config.command);
+    if (Array.isArray(config.args)) {
+      args.push(...config.args);
+    }
+    return args;
+  }
+  return null;
+}
+function syncClaudeMcpConfig(validatedPlugins, options2) {
+  const dryRun = options2?.dryRun ?? false;
+  const force = options2?.force ?? false;
+  const configPath = options2?.configPath;
+  if (!configPath) {
+    throw new Error("configPath is required for syncClaudeMcpConfig");
+  }
+  const previouslyTracked = new Set(options2?.trackedServers ?? []);
+  const hasTracking = options2?.trackedServers !== undefined;
+  const { servers: pluginServers, warnings } = collectMcpServers(validatedPlugins);
+  const result = {
+    added: 0,
+    skipped: 0,
+    overwritten: 0,
+    removed: 0,
+    warnings: [...warnings],
+    addedServers: [],
+    skippedServers: [],
+    overwrittenServers: [],
+    removedServers: [],
+    trackedServers: []
+  };
+  let existingConfig = {};
+  if (existsSync13(configPath)) {
+    try {
+      const content = readFileSync3(configPath, "utf-8");
+      existingConfig = import_json52.default.parse(content);
+    } catch {
+      result.warnings.push(`Could not parse existing ${configPath}, starting fresh`);
+      existingConfig = {};
+    }
+  }
+  const existingServers = existingConfig.mcpServers ?? {};
+  for (const [name, config] of pluginServers) {
+    if (name in existingServers) {
+      if (!deepEqual2(existingServers[name], config)) {
+        if (hasTracking && previouslyTracked.has(name)) {
+          existingServers[name] = config;
+          result.overwritten++;
+          result.overwrittenServers.push(name);
+          result.trackedServers.push(name);
+        } else if (force) {
+          existingServers[name] = config;
+          result.overwritten++;
+          result.overwrittenServers.push(name);
+          result.trackedServers.push(name);
+        } else {
+          result.skipped++;
+          result.skippedServers.push(name);
+        }
+      } else if (hasTracking && previouslyTracked.has(name)) {
+        result.trackedServers.push(name);
+      }
+    } else {
+      existingServers[name] = config;
+      result.added++;
+      result.addedServers.push(name);
+      result.trackedServers.push(name);
+    }
+  }
+  if (hasTracking) {
+    const currentServerNames = new Set(pluginServers.keys());
+    for (const trackedName of previouslyTracked) {
+      if (!currentServerNames.has(trackedName) && trackedName in existingServers) {
+        delete existingServers[trackedName];
+        result.removed++;
+        result.removedServers.push(trackedName);
+      }
+    }
+  }
+  const hasChanges = result.added > 0 || result.overwritten > 0 || result.removed > 0;
+  if (hasChanges && !dryRun) {
+    existingConfig.mcpServers = existingServers;
+    writeFileSync3(configPath, `${JSON.stringify(existingConfig, null, 2)}
+`, "utf-8");
+    result.configPath = configPath;
+  }
+  if (pluginServers.size === 0 && hasTracking && previouslyTracked.size > 0) {
+    for (const trackedName of previouslyTracked) {
+      if (trackedName in existingServers) {
+        delete existingServers[trackedName];
+        result.removed++;
+        result.removedServers.push(trackedName);
+      }
+    }
+    if (result.removed > 0 && !dryRun) {
+      existingConfig.mcpServers = existingServers;
+      writeFileSync3(configPath, `${JSON.stringify(existingConfig, null, 2)}
+`, "utf-8");
+      result.configPath = configPath;
+    }
+  }
+  return result;
+}
+async function syncClaudeMcpServersViaCli(validatedPlugins, options2) {
+  const dryRun = options2?.dryRun ?? false;
+  const previouslyTracked = new Set(options2?.trackedServers ?? []);
+  const hasTracking = options2?.trackedServers !== undefined;
+  const exec = options2?._mockExecute ?? ((binary2, args) => executeCommand(binary2, args));
+  const { servers: pluginServers, warnings } = collectMcpServers(validatedPlugins);
+  const result = {
+    added: 0,
+    skipped: 0,
+    overwritten: 0,
+    removed: 0,
+    warnings: [...warnings],
+    addedServers: [],
+    skippedServers: [],
+    overwrittenServers: [],
+    removedServers: [],
+    trackedServers: []
+  };
+  if (pluginServers.size === 0 && previouslyTracked.size === 0) {
+    return result;
+  }
+  const versionResult = await exec("claude", ["--version"]);
+  if (!versionResult.success) {
+    result.warnings.push(`Claude CLI not available: ${versionResult.error ?? "unknown error"}`);
+    return result;
+  }
+  for (const [name, config] of pluginServers) {
+    const getResult = await exec("claude", ["mcp", "get", name]);
+    const exists2 = getResult.success;
+    if (exists2) {
+      if (hasTracking && previouslyTracked.has(name)) {
+        result.trackedServers.push(name);
+      } else {
+        result.skipped++;
+        result.skippedServers.push(name);
+      }
+    } else {
+      const addArgs = buildClaudeMcpAddArgs(name, config, "user");
+      if (!addArgs) {
+        result.warnings.push(`Unsupported MCP server config for '${name}', skipping`);
+        continue;
+      }
+      if (!dryRun) {
+        const addResult = await exec("claude", addArgs);
+        if (!addResult.success) {
+          result.warnings.push(`Failed to add MCP server '${name}': ${addResult.error ?? "unknown error"}`);
+          continue;
+        }
+      }
+      result.added++;
+      result.addedServers.push(name);
+      result.trackedServers.push(name);
+    }
+  }
+  if (hasTracking) {
+    const currentServerNames = new Set(pluginServers.keys());
+    for (const trackedName of previouslyTracked) {
+      if (!currentServerNames.has(trackedName)) {
+        const getResult = await exec("claude", ["mcp", "get", trackedName]);
+        if (getResult.success) {
+          if (!dryRun) {
+            const removeResult = await exec("claude", [
+              "mcp",
+              "remove",
+              trackedName,
+              "--scope",
+              "user"
+            ]);
+            if (!removeResult.success) {
+              result.warnings.push(`Failed to remove MCP server '${trackedName}': ${removeResult.error ?? "unknown error"}`);
+              continue;
+            }
+          }
+          result.removed++;
+          result.removedServers.push(trackedName);
+        }
+      }
+    }
+  }
+  return result;
+}
+var import_json52;
+var init_claude_mcp = __esm(() => {
+  init_types2();
+  init_vscode_mcp();
+  import_json52 = __toESM(require_lib(), 1);
+});
+
 // src/core/native/claude.ts
 class ClaudeNativeClient {
   async isAvailable() {
@@ -29259,9 +29690,9 @@ var init_native = __esm(() => {
 });
 
 // src/core/sync.ts
-import { existsSync as existsSync12, readFileSync as readFileSync2, writeFileSync as writeFileSync2, lstatSync } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync4, writeFileSync as writeFileSync4, lstatSync } from "node:fs";
 import { rm as rm4, unlink as unlink2, rmdir, copyFile } from "node:fs/promises";
-import { join as join15, resolve as resolve9, dirname as dirname8, relative as relative4 } from "node:path";
+import { join as join15, resolve as resolve9, dirname as dirname9, relative as relative4 } from "node:path";
 function deduplicateClientsByPath(clients, clientMappings = CLIENT_MAPPINGS) {
   const pathToClients = new Map;
   for (const client of clients) {
@@ -29389,16 +29820,16 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
   return result;
 }
 async function cleanupEmptyParents(workspacePath, filePath) {
-  let parentPath = dirname8(filePath);
+  let parentPath = dirname9(filePath);
   while (parentPath && parentPath !== "." && parentPath !== "/") {
     const fullParentPath = join15(workspacePath, parentPath);
-    if (!existsSync12(fullParentPath)) {
-      parentPath = dirname8(parentPath);
+    if (!existsSync14(fullParentPath)) {
+      parentPath = dirname9(parentPath);
       continue;
     }
     try {
       await rmdir(fullParentPath);
-      parentPath = dirname8(parentPath);
+      parentPath = dirname9(parentPath);
     } catch {
       break;
     }
@@ -29478,7 +29909,7 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         continue;
       }
       const fullPath = join15(defaultSourcePath, file);
-      if (!existsSync12(fullPath)) {
+      if (!existsSync14(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
       continue;
@@ -29497,7 +29928,7 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
           continue;
         }
         const fullPath = join15(cachePath, parsed.filePath);
-        if (!existsSync12(fullPath)) {
+        if (!existsSync14(fullPath)) {
           errors2.push(`Path not found in repository: ${cacheKey}/${parsed.filePath}`);
         }
       } else {
@@ -29511,7 +29942,7 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         } else {
           fullPath = resolve9(file.source);
         }
-        if (!existsSync12(fullPath)) {
+        if (!existsSync14(fullPath)) {
           errors2.push(`File source not found: ${fullPath}`);
         }
       }
@@ -29521,7 +29952,7 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         continue;
       }
       const fullPath = join15(defaultSourcePath, file.dest ?? "");
-      if (!existsSync12(fullPath)) {
+      if (!existsSync14(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
     }
@@ -29677,7 +30108,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
     };
   }
   const resolvedPath = resolve9(workspacePath, pluginSource);
-  if (!existsSync12(resolvedPath)) {
+  if (!existsSync14(resolvedPath)) {
     return {
       plugin: pluginSource,
       resolved: resolvedPath,
@@ -29841,9 +30272,9 @@ function generateVscodeWorkspaceFile(workspacePath, config) {
   const configDir = join15(workspacePath, CONFIG_DIR);
   const templatePath = join15(configDir, VSCODE_TEMPLATE_FILE);
   let template;
-  if (existsSync12(templatePath)) {
+  if (existsSync14(templatePath)) {
     try {
-      template = import_json52.default.parse(readFileSync2(templatePath, "utf-8"));
+      template = import_json53.default.parse(readFileSync4(templatePath, "utf-8"));
     } catch (error) {
       throw new Error(`Failed to parse ${templatePath}: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -29856,7 +30287,7 @@ function generateVscodeWorkspaceFile(workspacePath, config) {
   const outputPath = getWorkspaceOutputPath(workspacePath, config.vscode);
   const contentStr = `${JSON.stringify(content, null, "\t")}
 `;
-  writeFileSync2(outputPath, contentStr, "utf-8");
+  writeFileSync4(outputPath, contentStr, "utf-8");
   return contentStr;
 }
 function failedSyncResult(error, overrides) {
@@ -29988,8 +30419,8 @@ async function syncVscodeWorkspaceFile(workspacePath, config, configPath, previo
   let updatedConfig = config;
   if (previousState?.vscodeWorkspaceHash && previousState?.vscodeWorkspaceRepos) {
     const outputPath = getWorkspaceOutputPath(workspacePath, config.vscode);
-    if (existsSync12(outputPath)) {
-      const existingContent = readFileSync2(outputPath, "utf-8");
+    if (existsSync14(outputPath)) {
+      const existingContent = readFileSync4(outputPath, "utf-8");
       const currentHash = computeWorkspaceHash(existingContent);
       if (currentHash !== previousState.vscodeWorkspaceHash) {
         try {
@@ -30047,7 +30478,7 @@ async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
   const { offline = false, dryRun = false, workspaceSourceBase, skipAgentFiles = false } = options2;
   const configDir = join15(workspacePath, CONFIG_DIR);
   const configPath = join15(configDir, WORKSPACE_CONFIG_FILE);
-  if (!existsSync12(configPath)) {
+  if (!existsSync14(configPath)) {
     return failedSyncResult(`${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
   Run 'allagents workspace init <path>' to create a new workspace`);
   }
@@ -30115,9 +30546,10 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   const allSkills = await collectAllSkills(validPlugins, disabledSkillsSet, enabledSkillsSet);
   const pluginSkillMaps = buildPluginSkillNameMaps(allSkills);
   const syncMode = config.syncMode ?? "symlink";
-  const pluginResults = await Promise.all(validPlugins.map((validatedPlugin) => {
+  const pluginResults = await Promise.all(validPlugins.map(async (validatedPlugin) => {
     const skillNameMap = pluginSkillMaps.get(validatedPlugin.resolved);
-    return copyValidatedPlugin(validatedPlugin, workspacePath, validatedPlugin.clients, dryRun, skillNameMap, undefined, syncMode);
+    const result = await copyValidatedPlugin(validatedPlugin, workspacePath, validatedPlugin.clients, dryRun, skillNameMap, undefined, syncMode);
+    return { ...result, scope: "project" };
   }));
   const nativeResult = await syncNativePlugins(validPlugins, previousState, "project", workspacePath, dryRun, warnings, messages);
   let workspaceFileResults = [];
@@ -30127,7 +30559,7 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     if (hasRepositories && sourcePath) {
       for (const agentFile of AGENT_FILES) {
         const agentPath = join15(sourcePath, agentFile);
-        if (existsSync12(agentPath) && !filesToCopy.includes(agentFile)) {
+        if (existsSync14(agentPath) && !filesToCopy.includes(agentFile)) {
           filesToCopy.push(agentFile);
         }
       }
@@ -30153,8 +30585,8 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     if (hasRepositories && !dryRun && syncClients.includes("claude") && sourcePath) {
       const claudePath = join15(workspacePath, "CLAUDE.md");
       const agentsPath = join15(workspacePath, "AGENTS.md");
-      const claudeExistsInSource = existsSync12(join15(sourcePath, "CLAUDE.md"));
-      if (!claudeExistsInSource && existsSync12(agentsPath) && !existsSync12(claudePath)) {
+      const claudeExistsInSource = existsSync14(join15(sourcePath, "CLAUDE.md"));
+      if (!claudeExistsInSource && existsSync14(agentsPath) && !existsSync14(claudePath)) {
         await copyFile(agentsPath, claudePath);
       }
     }
@@ -30170,6 +30602,58 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
       vscodeState = { hash: result.hash, repos: result.repos };
     }
   }
+  const mcpResults = {};
+  if (syncClients.includes("vscode")) {
+    const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "vscode");
+    const projectMcpPath = join15(workspacePath, ".vscode", "mcp.json");
+    const vscodeMcp = syncVscodeMcpConfig(validPlugins, {
+      dryRun,
+      force: false,
+      configPath: projectMcpPath,
+      trackedServers: trackedMcpServers
+    });
+    if (vscodeMcp.warnings.length > 0) {
+      warnings.push(...vscodeMcp.warnings);
+    }
+    mcpResults.vscode = vscodeMcp;
+  }
+  if (syncClients.includes("claude")) {
+    const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "claude");
+    const projectMcpJsonPath = join15(workspacePath, ".mcp.json");
+    const claudeMcp = syncClaudeMcpConfig(validPlugins, {
+      dryRun,
+      force: false,
+      configPath: projectMcpJsonPath,
+      trackedServers: trackedMcpServers
+    });
+    if (claudeMcp.warnings.length > 0) {
+      warnings.push(...claudeMcp.warnings);
+    }
+    mcpResults.claude = claudeMcp;
+  }
+  if (syncClients.includes("codex")) {
+    const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "codex");
+    const projectCodexConfigPath = join15(workspacePath, ".codex", "config.toml");
+    const codexMcp = syncCodexProjectMcpConfig(validPlugins, {
+      dryRun,
+      force: false,
+      configPath: projectCodexConfigPath,
+      trackedServers: trackedMcpServers
+    });
+    if (codexMcp.warnings.length > 0) {
+      warnings.push(...codexMcp.warnings);
+    }
+    mcpResults.codex = codexMcp;
+  }
+  const PROJECT_MCP_CLIENTS = new Set(["claude", "codex", "vscode", "universal"]);
+  const { servers: allMcpServers } = collectMcpServers(validPlugins);
+  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);
@@ -30179,7 +30663,12 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   const deletedArtifacts = computeDeletedArtifacts(previousState, newStatePaths, syncClients, resolvedMappings, availableSkillNames);
   const { pluginsByClient: nativePluginsByClient } = collectNativePluginSources(validPlugins);
   if (!dryRun) {
-    await persistSyncState(workspacePath, pluginResults, workspaceFileResults, syncClients, nativePluginsByClient, nativeResult, vscodeState ? { vscodeState } : undefined);
+    await persistSyncState(workspacePath, pluginResults, workspaceFileResults, syncClients, nativePluginsByClient, nativeResult, {
+      ...vscodeState && { vscodeState },
+      ...Object.keys(mcpResults).length > 0 && {
+        mcpTrackedServers: Object.fromEntries(Object.entries(mcpResults).map(([scope, r]) => [scope, r.trackedServers]))
+      }
+    });
   }
   return {
     success: !hasFailures,
@@ -30192,6 +30681,7 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     ...deletedArtifacts.length > 0 && { deletedArtifacts },
     ...warnings.length > 0 && { warnings },
     ...messages.length > 0 && { messages },
+    ...Object.keys(mcpResults).length > 0 && { mcpResults },
     ...nativeResult && { nativeResult }
   };
 }
@@ -30238,10 +30728,11 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   const allSkills = await collectAllSkills(validPlugins, disabledSkillsSet, enabledSkillsSet);
   const pluginSkillMaps = buildPluginSkillNameMaps(allSkills);
   const syncMode = config.syncMode ?? "symlink";
-  const pluginResults = await Promise.all(validPlugins.map((vp) => {
+  const pluginResults = await Promise.all(validPlugins.map(async (vp) => {
     const skillNameMap = pluginSkillMaps.get(vp.resolved);
     const resolvedUserMappings2 = resolveClientMappings(vp.clients, USER_CLIENT_MAPPINGS);
-    return copyValidatedPlugin(vp, homeDir, vp.clients, dryRun, skillNameMap, resolvedUserMappings2, syncMode);
+    const result = await copyValidatedPlugin(vp, homeDir, vp.clients, dryRun, skillNameMap, resolvedUserMappings2, syncMode);
+    return { ...result, scope: "user" };
   }));
   const { totalCopied, totalFailed, totalSkipped, totalGenerated } = countCopyResults(pluginResults, []);
   const mcpResults = {};
@@ -30261,6 +30752,23 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     }
     mcpResults.codex = codexMcp;
   }
+  if (syncClients.includes("claude")) {
+    const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "claude");
+    const claudeMcp = await syncClaudeMcpServersViaCli(validPlugins, { dryRun, trackedServers: trackedMcpServers });
+    if (claudeMcp.warnings.length > 0) {
+      warnings.push(...claudeMcp.warnings);
+    }
+    mcpResults.claude = claudeMcp;
+  }
+  const USER_MCP_CLIENTS = new Set(["claude", "codex", "vscode", "universal"]);
+  const { servers: allUserMcpServers } = collectMcpServers(validPlugins);
+  if (allUserMcpServers.size > 0) {
+    for (const client of syncClients) {
+      if (!USER_MCP_CLIENTS.has(client)) {
+        warnings.push(`MCP servers not synced for ${client} (not supported at user scope)`);
+      }
+    }
+  }
   const nativeResult = await syncNativePlugins(validPlugins, previousState, "user", homeDir, dryRun, warnings, messages);
   const availableUserSkillNames = await collectAvailableSkillNames(validPlugins);
   const allCopyResultsForState = pluginResults.flatMap((r) => r.copyResults);
@@ -30290,7 +30798,7 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     ...nativeResult && { nativeResult }
   };
 }
-var import_json52, VSCODE_TEMPLATE_FILE = "template.code-workspace";
+var import_json53, VSCODE_TEMPLATE_FILE = "template.code-workspace";
 var init_sync = __esm(() => {
   init_constants();
   init_workspace_parser();
@@ -30308,17 +30816,18 @@ var init_sync = __esm(() => {
   init_workspace_modify();
   init_vscode_mcp();
   init_codex_mcp();
+  init_claude_mcp();
   init_native();
-  import_json52 = __toESM(require_lib(), 1);
+  import_json53 = __toESM(require_lib(), 1);
 });
 
 // src/core/github-fetch.ts
-import { existsSync as existsSync13, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync5 } from "node:fs";
 import { join as join16 } from "node:path";
 function readFileFromClone(tempDir, filePath) {
   const fullPath = join16(tempDir, filePath);
-  if (existsSync13(fullPath)) {
-    return readFileSync3(fullPath, "utf-8");
+  if (existsSync15(fullPath)) {
+    return readFileSync5(fullPath, "utf-8");
   }
   return null;
 }
@@ -30417,14 +30926,14 @@ var init_github_fetch = __esm(() => {
 
 // src/core/workspace.ts
 import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile7, copyFile as copyFile2, unlink as unlink3 } from "node:fs/promises";
-import { existsSync as existsSync14 } from "node:fs";
-import { join as join17, resolve as resolve10, dirname as dirname9, relative as relative5, sep as sep2, isAbsolute as isAbsolute4 } from "node:path";
+import { existsSync as existsSync16 } from "node:fs";
+import { join as join17, resolve as resolve10, dirname as dirname10, relative as relative5, sep as sep2, isAbsolute as isAbsolute4 } from "node:path";
 import { fileURLToPath } from "node:url";
 async function initWorkspace(targetPath = ".", options2 = {}) {
   const absoluteTarget = resolve10(targetPath);
   const configDir = join17(absoluteTarget, CONFIG_DIR);
   const configPath = join17(configDir, WORKSPACE_CONFIG_FILE);
-  if (existsSync14(configPath)) {
+  if (existsSync16(configPath)) {
     if (options2.force) {
       await unlink3(configPath);
     } else {
@@ -30433,7 +30942,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     }
   }
   const currentFilePath = fileURLToPath(import.meta.url);
-  const currentFileDir = dirname9(currentFilePath);
+  const currentFileDir = dirname10(currentFilePath);
   const isProduction = currentFilePath.includes(`${sep2}dist${sep2}`);
   const defaultTemplatePath = isProduction ? join17(currentFileDir, "templates", "default") : join17(currentFileDir, "..", "templates", "default");
   let githubTempDir;
@@ -30474,7 +30983,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${options2.from}`);
       } else {
         const fromPath = resolve10(options2.from);
-        if (!existsSync14(fromPath)) {
+        if (!existsSync16(fromPath)) {
           throw new Error(`Template not found: ${fromPath}`);
         }
         const { stat: stat2 } = await import("node:fs/promises");
@@ -30483,10 +30992,10 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         if (fromStat.isDirectory()) {
           const nestedPath = join17(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
           const rootPath = join17(fromPath, WORKSPACE_CONFIG_FILE);
-          if (existsSync14(nestedPath)) {
+          if (existsSync16(nestedPath)) {
             sourceYamlPath = nestedPath;
             sourceDir = fromPath;
-          } else if (existsSync14(rootPath)) {
+          } else if (existsSync16(rootPath)) {
             sourceYamlPath = rootPath;
             sourceDir = fromPath;
           } else {
@@ -30495,9 +31004,9 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           }
         } else {
           sourceYamlPath = fromPath;
-          const parentDir = dirname9(fromPath);
+          const parentDir = dirname10(fromPath);
           if (parentDir.endsWith(CONFIG_DIR)) {
-            sourceDir = dirname9(parentDir);
+            sourceDir = dirname10(parentDir);
           } else {
             sourceDir = parentDir;
           }
@@ -30518,7 +31027,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       }
     } else {
       const defaultYamlPath = join17(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-      if (!existsSync14(defaultYamlPath)) {
+      if (!existsSync16(defaultYamlPath)) {
         throw new Error(`Default template not found at: ${defaultTemplatePath}`);
       }
       workspaceYamlContent = await readFile10(defaultYamlPath, "utf-8");
@@ -30535,7 +31044,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     const VSCODE_TEMPLATE_FILE2 = "template.code-workspace";
     if (clientNames.includes("vscode") && options2.from) {
       const targetTemplatePath = join17(configDir, VSCODE_TEMPLATE_FILE2);
-      if (!existsSync14(targetTemplatePath)) {
+      if (!existsSync16(targetTemplatePath)) {
         if (isGitHubUrl(options2.from) && githubTempDir) {
           if (parsedFromUrl) {
             const templatePath = githubBasePath ? `${githubBasePath}/${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}` : `${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}`;
@@ -30546,7 +31055,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           }
         } else if (sourceDir) {
           const sourceTemplatePath = join17(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
-          if (existsSync14(sourceTemplatePath)) {
+          if (existsSync16(sourceTemplatePath)) {
             await copyFile2(sourceTemplatePath, targetTemplatePath);
           }
         }
@@ -30560,7 +31069,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         if (parsedFromUrl) {
           for (const agentFile of AGENT_FILES) {
             const targetFilePath = join17(absoluteTarget, agentFile);
-            if (existsSync14(targetFilePath)) {
+            if (existsSync16(targetFilePath)) {
               copiedAgentFiles.push(agentFile);
               continue;
             }
@@ -30576,12 +31085,12 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         const effectiveSourceDir = sourceDir ?? defaultTemplatePath;
         for (const agentFile of AGENT_FILES) {
           const targetFilePath = join17(absoluteTarget, agentFile);
-          if (existsSync14(targetFilePath)) {
+          if (existsSync16(targetFilePath)) {
             copiedAgentFiles.push(agentFile);
             continue;
           }
           const sourcePath = join17(effectiveSourceDir, agentFile);
-          if (existsSync14(sourcePath)) {
+          if (existsSync16(sourcePath)) {
             const content = await readFile10(sourcePath, "utf-8");
             await writeFile7(targetFilePath, content, "utf-8");
             copiedAgentFiles.push(agentFile);
@@ -30649,11 +31158,11 @@ var init_workspace = __esm(() => {
 });
 
 // src/core/status.ts
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 import { join as join18 } from "node:path";
 async function getWorkspaceStatus(workspacePath = process.cwd()) {
   const configPath = join18(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync15(configPath) || isUserConfigPath(workspacePath)) {
+  if (!existsSync17(configPath) || isUserConfigPath(workspacePath)) {
     const userPlugins = await getUserPluginStatuses();
     return {
       success: true,
@@ -30695,7 +31204,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 ? existsSync15(cachePath) : false;
+    const available2 = cachePath ? existsSync17(cachePath) : false;
     return {
       source: parsed.original,
       type: "github",
@@ -30705,7 +31214,7 @@ function getPluginStatus(parsed) {
       ...parsed.repo && { repo: parsed.repo }
     };
   }
-  const available = existsSync15(parsed.normalized);
+  const available = existsSync17(parsed.normalized);
   return {
     source: parsed.original,
     type: "local",
@@ -30866,15 +31375,13 @@ function formatSyncHeader(result) {
     `✓ Successfully updated ${successCount} plugin(s)`
   ];
 }
-function formatSyncSummary(result, { dryRun = false } = {}) {
+function formatPluginHeader(pluginResult) {
+  const status = pluginResult.success ? "✓" : "✗";
+  const scopeSuffix = pluginResult.scope ? ` (scope: ${pluginResult.scope})` : "";
+  return `${status} Plugin: ${pluginResult.plugin}${scopeSuffix}`;
+}
+function formatSyncSummary(result) {
   const lines = [];
-  const allCopied = result.pluginResults.flatMap((pr) => pr.copyResults.filter((r) => r.action === "copied"));
-  const classified = classifyCopyResults(allCopied);
-  if (classified.size > 0) {
-    lines.push(...formatArtifactLines(classified));
-  } else if (allCopied.length > 0) {
-    lines.push(`  Total ${dryRun ? "would copy" : "copied"}: ${result.totalCopied}`);
-  }
   if (result.totalGenerated > 0)
     lines.push(`  Total generated: ${result.totalGenerated}`);
   if (result.totalFailed > 0)
@@ -30914,7 +31421,8 @@ function formatMcpResult(mcpResult, scope) {
     parts.push(`${removed} removed`);
   if (skipped > 0)
     parts.push(`${skipped} skipped`);
-  const label = scope ? `MCP servers (${scope})` : "MCP servers";
+  const displayScope = scope ? getDisplayName(scope) : undefined;
+  const label = displayScope ? `MCP servers (${displayScope})` : "MCP servers";
   lines.push(`${label}: ${parts.join(", ")}`);
   for (const name of mcpResult.addedServers) {
     lines.push(`  + ${name}`);
@@ -32798,7 +33306,7 @@ var init_prompt_clients = __esm(() => {
 });
 
 // src/core/skills.ts
-import { existsSync as existsSync18 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 import { readFile as readFile12, readdir as readdir4 } from "node:fs/promises";
 import { join as join21, basename as basename6, resolve as resolve12 } from "node:path";
 async function resolvePluginPath(pluginSource, workspacePath) {
@@ -32825,11 +33333,11 @@ async function resolvePluginPath(pluginSource, workspacePath) {
     return { path };
   }
   const resolved = resolve12(workspacePath, pluginSource);
-  return existsSync18(resolved) ? { path: resolved } : null;
+  return existsSync20(resolved) ? { path: resolved } : null;
 }
 async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
   const configPath = join21(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync18(configPath)) {
+  if (!existsSync20(configPath)) {
     return [];
   }
   const content = await readFile12(configPath, "utf-8");
@@ -32849,7 +33357,7 @@ async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
     const pluginSkillsConfig = typeof pluginEntry === "string" ? undefined : pluginEntry.skills;
     const hasEnabledEntries = !pluginSkillsConfig && enabledSkills && [...enabledSkills].some((s) => s.startsWith(`${pluginName}`));
     let skillEntries;
-    if (existsSync18(skillsDir)) {
+    if (existsSync20(skillsDir)) {
       const entries = await readdir4(skillsDir, { withFileTypes: true });
       skillEntries = entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, skillPath: join21(skillsDir, e.name) }));
     } else {
@@ -32859,7 +33367,7 @@ async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
         if (!entry.isDirectory())
           continue;
         const skillMdPath = join21(pluginPath, entry.name, "SKILL.md");
-        if (existsSync18(skillMdPath)) {
+        if (existsSync20(skillMdPath)) {
           flatSkills.push({ name: entry.name, skillPath: join21(pluginPath, entry.name) });
         }
       }
@@ -32867,7 +33375,7 @@ async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
         skillEntries = flatSkills;
       } else {
         const rootSkillMd = join21(pluginPath, "SKILL.md");
-        if (existsSync18(rootSkillMd)) {
+        if (existsSync20(rootSkillMd)) {
           const skillContent = await readFile12(rootSkillMd, "utf-8");
           const metadata = parseSkillMetadata(skillContent);
           const skillName = metadata?.name ?? basename6(pluginPath);
@@ -32909,10 +33417,10 @@ async function findSkillByName(skillName, workspacePath = process.cwd()) {
   return allSkills.filter((s) => s.name === skillName);
 }
 async function discoverSkillNames(pluginPath) {
-  if (!existsSync18(pluginPath))
+  if (!existsSync20(pluginPath))
     return [];
   const skillsDir = join21(pluginPath, "skills");
-  if (existsSync18(skillsDir)) {
+  if (existsSync20(skillsDir)) {
     const entries2 = await readdir4(skillsDir, { withFileTypes: true });
     return entries2.filter((e) => e.isDirectory()).map((e) => e.name);
   }
@@ -32921,14 +33429,14 @@ async function discoverSkillNames(pluginPath) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    if (existsSync18(join21(pluginPath, entry.name, "SKILL.md"))) {
+    if (existsSync20(join21(pluginPath, entry.name, "SKILL.md"))) {
       flatSkills.push(entry.name);
     }
   }
   if (flatSkills.length > 0)
     return flatSkills;
   const rootSkillMd = join21(pluginPath, "SKILL.md");
-  if (existsSync18(rootSkillMd)) {
+  if (existsSync20(rootSkillMd)) {
     try {
       const content = await readFile12(rootSkillMd, "utf-8");
       const { parseSkillMetadata: parseSkillMetadata2 } = await Promise.resolve().then(() => (init_skill(), exports_skill));
@@ -33448,7 +33956,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "allagents",
-    version: "1.0.15",
+    version: "1.2.0",
     description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
     type: "module",
     bin: {
@@ -33652,7 +34160,7 @@ class TuiCache {
 }
 
 // src/cli/tui/context.ts
-import { existsSync as existsSync21 } from "node:fs";
+import { existsSync as existsSync23 } from "node:fs";
 import { join as join25 } from "node:path";
 async function getTuiContext(cwd = process.cwd(), cache2) {
   const cachedContext = cache2?.getContext();
@@ -33660,7 +34168,7 @@ async function getTuiContext(cwd = process.cwd(), cache2) {
     return cachedContext;
   }
   const configPath = join25(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  const hasWorkspace = existsSync21(configPath) && !isUserConfigPath(cwd);
+  const hasWorkspace = existsSync23(configPath) && !isUserConfigPath(cwd);
   let projectPluginCount = 0;
   if (hasWorkspace) {
     try {
@@ -33736,7 +34244,7 @@ async function runSync(context) {
       if (result.error) {
         kt2(result.error, "Sync Error");
       } else {
-        const lines = result.pluginResults.map((pr) => `${pr.success ? "✓" : "✗"} ${pr.plugin}`);
+        const lines = result.pluginResults.map((pr) => formatPluginHeader(pr));
         lines.push("");
         lines.push(...formatSyncSummary(result));
         if (result.nativeResult) {
@@ -33753,7 +34261,7 @@ async function runSync(context) {
       if (userResult.error) {
         kt2(userResult.error, "User Sync Error");
       } else {
-        const lines = userResult.pluginResults.map((pr) => `${pr.success ? "✓" : "✗"} ${pr.plugin}`);
+        const lines = userResult.pluginResults.map((pr) => formatPluginHeader(pr));
         lines.push("");
         lines.push(...formatSyncSummary(userResult));
         if (userResult.mcpResults) {
@@ -35048,7 +35556,7 @@ init_workspace();
 init_sync();
 init_status2();
 var import_cmd_ts2 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync19 } from "node:fs";
 import { join as join20, resolve as resolve11 } from "node:path";
 
 // src/core/prune.ts
@@ -35058,7 +35566,7 @@ init_marketplace();
 init_user_workspace();
 init_workspace_config();
 import { readFile as readFile11, writeFile as writeFile8 } from "node:fs/promises";
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 import { join as join19 } from "node:path";
 async function isOrphanedPlugin(pluginSpec) {
   if (!isPluginSpec(pluginSpec))
@@ -35087,7 +35595,7 @@ async function prunePlugins(plugins) {
 async function pruneOrphanedPlugins(workspacePath) {
   let projectResult = { removed: [], kept: [], keptEntries: [] };
   const projectConfigPath = join19(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (existsSync16(projectConfigPath) && !isUserConfigPath(workspacePath)) {
+  if (existsSync18(projectConfigPath) && !isUserConfigPath(workspacePath)) {
     const content = await readFile11(projectConfigPath, "utf-8");
     const config = load(content);
     projectResult = await prunePlugins(config.plugins);
@@ -35273,29 +35781,24 @@ var repoListMeta = {
 // src/cli/commands/workspace.ts
 init_format_sync();
 function parseClientEntries(input) {
-  const validClients = ClientTypeSchema.options;
-  const validModes = InstallModeSchema.options;
   const entries = [];
   for (const part of input.split(",").map((s) => s.trim()).filter(Boolean)) {
-    const colonIdx = part.indexOf(":");
-    if (colonIdx === -1) {
-      if (!validClients.includes(part)) {
+    const result = ClientEntrySchema.safeParse(part);
+    if (!result.success) {
+      const colonIdx = part.indexOf(":");
+      if (colonIdx === -1) {
         throw new Error(`Invalid client(s): ${part}
-  Valid clients: ${validClients.join(", ")}`);
+  Valid clients: ${ClientTypeSchema.options.join(", ")}`);
       }
-      entries.push(part);
-    } else {
       const name = part.slice(0, colonIdx);
       const mode = part.slice(colonIdx + 1);
-      if (!validClients.includes(name)) {
+      if (!ClientTypeSchema.options.includes(name)) {
         throw new Error(`Invalid client(s): ${name}
-  Valid clients: ${validClients.join(", ")}`);
+  Valid clients: ${ClientTypeSchema.options.join(", ")}`);
       }
-      if (!validModes.includes(mode)) {
-        throw new Error(`Invalid install mode '${mode}' for client '${name}'. Valid modes: ${validModes.join(", ")}`);
-      }
-      entries.push({ name, install: mode });
+      throw new Error(`Invalid install mode '${mode}' for client '${name}'. Valid modes: ${InstallModeSchema.options.join(", ")}`);
     }
+    entries.push(result.data);
   }
   return entries;
 }
@@ -35343,8 +35846,7 @@ var initCmd = import_cmd_ts2.command({
           console.log(`
 Plugin sync results:`);
           for (const pluginResult of syncResult.pluginResults) {
-            const status = pluginResult.success ? "✓" : "✗";
-            console.log(`  ${status} ${pluginResult.plugin}`);
+            console.log(`  ${formatPluginHeader(pluginResult)}`);
             if (pluginResult.error) {
               console.log(`    Error: ${pluginResult.error}`);
             }
@@ -35385,7 +35887,7 @@ var syncCmd = import_cmd_ts2.command({
       }
       const userConfigExists = !!await getUserWorkspaceConfig();
       const projectConfigPath = join20(process.cwd(), ".allagents", "workspace.yaml");
-      const projectConfigExists = existsSync17(projectConfigPath);
+      const projectConfigExists = existsSync19(projectConfigPath);
       if (!userConfigExists && !projectConfigExists) {
         await ensureUserWorkspace();
         if (isJsonMode()) {
@@ -35437,8 +35939,7 @@ var syncCmd = import_cmd_ts2.command({
       }
       console.log("");
       for (const pluginResult of result.pluginResults) {
-        const status = pluginResult.success ? "✓" : "✗";
-        console.log(`${status} Plugin: ${pluginResult.plugin}`);
+        console.log(formatPluginHeader(pluginResult));
         if (pluginResult.error) {
           console.log(`  Error: ${pluginResult.error}`);
         }
@@ -35492,9 +35993,12 @@ native:`);
           }
         }
       }
-      console.log("");
-      for (const line of formatSyncSummary(result, { dryRun })) {
-        console.log(line);
+      const summaryLines = formatSyncSummary(result);
+      if (summaryLines.length > 0) {
+        console.log("");
+        for (const line of summaryLines) {
+          console.log(line);
+        }
       }
       if (!result.success || result.totalFailed > 0) {
         process.exit(1);
@@ -36030,7 +36534,7 @@ init_workspace_modify();
 init_user_workspace();
 init_skills();
 var import_cmd_ts3 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 import { readFile as readFile13 } from "node:fs/promises";
 import { join as join22 } from "node:path";
 
@@ -36123,7 +36627,7 @@ init_skill();
 init_marketplace();
 init_marketplace_manifest_parser();
 function hasProjectConfig(dir) {
-  return existsSync19(join22(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
+  return existsSync21(join22(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
 }
 function resolveScope(cwd) {
   if (isUserConfigPath(cwd))
@@ -36712,12 +37216,12 @@ init_workspace_config();
 init_constants();
 init_js_yaml();
 import { readFile as readFile14 } from "node:fs/promises";
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync22 } from "node:fs";
 import { join as join23 } from "node:path";
 async function runSyncAndPrint(options2) {
   if (!isJsonMode()) {
     console.log(`
-Syncing workspace...
+Updating workspace...
 `);
   }
   const result = await syncWorkspace(process.cwd(), options2);
@@ -36730,8 +37234,7 @@ Syncing workspace...
   const syncData = buildSyncData(result);
   if (!isJsonMode()) {
     for (const pluginResult of result.pluginResults) {
-      const status = pluginResult.success ? "✓" : "✗";
-      console.log(`${status} Plugin: ${pluginResult.plugin}`);
+      console.log(formatPluginHeader(pluginResult));
       if (pluginResult.error) {
         console.log(`  Error: ${pluginResult.error}`);
       }
@@ -36749,6 +37252,19 @@ Syncing workspace...
         }
       }
     }
+    if (result.mcpResults) {
+      for (const [scope, mcpResult] of Object.entries(result.mcpResults)) {
+        if (!mcpResult)
+          continue;
+        const mcpLines = formatMcpResult(mcpResult, scope);
+        if (mcpLines.length > 0) {
+          console.log("");
+          for (const line of mcpLines) {
+            console.log(line);
+          }
+        }
+      }
+    }
     if (result.nativeResult) {
       const nativeLines = formatNativeResult(result.nativeResult);
       if (nativeLines.length > 0) {
@@ -36766,10 +37282,6 @@ Warnings:`);
         console.log(`  ⚠ ${warning}`);
       }
     }
-    console.log("");
-    for (const line of formatSyncSummary(result)) {
-      console.log(line);
-    }
   }
   return { ok: result.success && result.totalFailed === 0, syncData };
 }
@@ -36784,8 +37296,7 @@ async function runUserSyncAndPrint() {
   const syncData = buildSyncData(result);
   if (!isJsonMode()) {
     for (const pluginResult of result.pluginResults) {
-      const status = pluginResult.success ? "✓" : "✗";
-      console.log(`${status} Plugin: ${pluginResult.plugin}`);
+      console.log(formatPluginHeader(pluginResult));
       if (pluginResult.error) {
         console.log(`  Error: ${pluginResult.error}`);
       }
@@ -36826,10 +37337,6 @@ native:`);
         }
       }
     }
-    console.log("");
-    for (const line of formatSyncSummary(result)) {
-      console.log(line);
-    }
   }
   return { ok: result.success && result.totalFailed === 0, syncData };
 }
@@ -36955,7 +37462,7 @@ var marketplaceAddCmd = import_cmd_ts4.command({
         process.exit(1);
       }
       if (effectiveScope === "project") {
-        if (!existsSync20(join23(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE))) {
+        if (!existsSync22(join23(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 });
@@ -37262,7 +37769,7 @@ var pluginListCmd = import_cmd_ts4.command({
       };
       const pluginClients = new Map;
       async function loadConfigClients(configPath, scope) {
-        if (!existsSync20(configPath))
+        if (!existsSync22(configPath))
           return;
         try {
           const content = await readFile14(configPath, "utf-8");
@@ -37418,7 +37925,7 @@ var pluginInstallCmd = import_cmd_ts4.command({
       const isUser = scope === "user" || !scope && isUserConfigPath(process.cwd());
       if (!isUser) {
         const configPath = join23(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-        if (!existsSync20(configPath)) {
+        if (!existsSync22(configPath)) {
           const { promptForClients: promptForClients2 } = await Promise.resolve().then(() => (init_prompt_clients(), exports_prompt_clients));
           const clients = await promptForClients2();
           if (clients === null) {
@@ -37509,9 +38016,12 @@ Enabled skills: ${skills.join(", ")}`);
         if (result.autoRegistered) {
           console.log(`  Resolved marketplace: ${result.autoRegistered}`);
         }
-        console.log(`✓ Installed plugin (${isUser ? "user" : "project"} scope): ${displayPlugin}`);
+        console.log(`Installing plugin "${displayPlugin}"...`);
       }
       const { ok: syncOk, syncData } = isUser ? await runUserSyncAndPrint() : await runSyncAndPrint();
+      if (!isJsonMode() && syncOk) {
+        console.log(`✔ Successfully installed plugin: ${displayPlugin} (scope: ${isUser ? "user" : "project"})`);
+      }
       if (isJsonMode()) {
         jsonOutput({
           success: syncOk,
@@ -37701,13 +38211,13 @@ var pluginUpdateCmd = import_cmd_ts4.command({
         }
       }
       if (updateProject && !isUserConfigPath(process.cwd())) {
-        const { existsSync: existsSync21 } = await import("node:fs");
+        const { existsSync: existsSync23 } = await import("node:fs");
         const { readFile: readFile15 } = await import("node:fs/promises");
         const { join: join24 } = 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 = join24(process.cwd(), CONFIG_DIR2, WORKSPACE_CONFIG_FILE2);
-        if (existsSync21(configPath)) {
+        if (existsSync23(configPath)) {
           const content = await readFile15(configPath, "utf-8");
           const config = load2(content);
           for (const entry of config.plugins ?? []) {
@@ -38812,7 +39322,7 @@ var addPipeMethods = (spawned) => {
 };
 
 // node_modules/execa/lib/stream.js
-import { createReadStream, readFileSync as readFileSync4 } from "node:fs";
+import { createReadStream, readFileSync as readFileSync6 } from "node:fs";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 
 // node_modules/get-stream/source/contents.js
@@ -39008,7 +39518,7 @@ var getInputSync = ({ input, inputFile }) => {
     return input;
   }
   validateInputOptions(input);
-  return readFileSync4(inputFile);
+  return readFileSync6(inputFile);
 };
 var handleInputSync = (options2) => {
   const input = getInputSync(options2);