mcpman 0.7.0 → 0.9.0

package/dist/index.js

@@ -4,19 +4,32 @@ import {
   addEntry,
   createEmptyLockfile,
   findLockfile,
+  listSnapshots,
   readLockfile,
+  readSnapshot,
   resolveLockfilePath,
+  restoreSnapshot,
   writeLockfile
-} from "./chunk-YZNTMR6O.js";
+} from "./chunk-6GGMDJQE.js";
 import {
   computeTrustScore
 } from "./chunk-RGKHLY5G.js";
 import {
+  getInstalledClients
+} from "./chunk-CC7ICP7U.js";
+import {
+  getAliasesFile,
   getConfigPath,
-  getInstalledClients,
+  getEnvDir,
+  getGroupsFile,
+  getHistoryFile,
+  getNotifyFile,
+  getPinsFile,
   getPluginDir,
-  getProfilesDir
-} from "./chunk-NS6HV723.js";
+  getProfilesDir,
+  getTemplatesDir,
+  resolveConfigPath
+} from "./chunk-DSCBWQ3W.js";
 import {
   getMasterPassword,
   getSecretsForServer,
@@ -29,34 +42,136 @@ import {
 } from "./chunk-6X6Q6UZC.js";
 
 // src/index.ts
-import { defineCommand as defineCommand27, runMain } from "citty";
+import { defineCommand as defineCommand39, runMain } from "citty";
+
+// src/commands/alias.ts
+import { defineCommand } from "citty";
+import pc from "picocolors";
+
+// src/core/alias-manager.ts
+import fs from "fs";
+function readAliases(file) {
+  const target = file ?? getAliasesFile();
+  if (!fs.existsSync(target)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(target, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeAliases(store, file) {
+  const target = file ?? getAliasesFile();
+  const dir = target.substring(0, target.lastIndexOf("/"));
+  if (dir && !fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(target, JSON.stringify(store, null, 2), "utf-8");
+}
+function addAlias(name, command, file) {
+  const store = readAliases(file);
+  store[name] = command;
+  writeAliases(store, file);
+}
+function removeAlias(name, file) {
+  const store = readAliases(file);
+  if (!(name in store)) return;
+  delete store[name];
+  writeAliases(store, file);
+}
+function listAliases(file) {
+  const store = readAliases(file);
+  return Object.entries(store).sort(([a], [b]) => a.localeCompare(b)).map(([name, command]) => ({ name, command }));
+}
+function aliasExists(name, file) {
+  return name in readAliases(file);
+}
+
+// src/commands/alias.ts
+var addCmd = defineCommand({
+  meta: { name: "add", description: "Add a command alias" },
+  args: {
+    name: { type: "positional", description: "Alias name", required: true },
+    command: { type: "positional", description: "Full command string to alias", required: true }
+  },
+  run({ args }) {
+    addAlias(args.name, args.command);
+    console.log(
+      `${pc.green("\u2713")} Alias ${pc.cyan(pc.bold(args.name))} \u2192 ${pc.dim(args.command)} saved`
+    );
+  }
+});
+var removeCmd = defineCommand({
+  meta: { name: "remove", description: "Remove an alias" },
+  args: {
+    name: { type: "positional", description: "Alias name to remove", required: true }
+  },
+  run({ args }) {
+    if (!aliasExists(args.name)) {
+      console.error(`${pc.red("\u2717")} Alias "${args.name}" does not exist.`);
+      process.exit(1);
+    }
+    removeAlias(args.name);
+    console.log(`${pc.green("\u2713")} Alias ${pc.cyan(args.name)} removed`);
+  }
+});
+var listCmd = defineCommand({
+  meta: { name: "list", description: "List all aliases" },
+  args: {},
+  run() {
+    const aliases = listAliases();
+    if (aliases.length === 0) {
+      console.log(pc.dim("\n  No aliases defined. Use `mcpman alias add <name> <command>`.\n"));
+      return;
+    }
+    const nameW = Math.max(4, ...aliases.map((a) => a.name.length));
+    console.log(pc.bold("\n  mcpman aliases\n"));
+    console.log(pc.dim(`  ${"\u2500".repeat(nameW + 30)}`));
+    for (const { name, command } of aliases) {
+      const padded = name.padEnd(nameW);
+      console.log(`  ${pc.cyan(pc.bold(padded))}  ${pc.dim("\u2192")}  ${command}`);
+    }
+    console.log(pc.dim(`  ${"\u2500".repeat(nameW + 30)}
+`));
+  }
+});
+var alias_default = defineCommand({
+  meta: {
+    name: "alias",
+    description: "Manage command aliases"
+  },
+  subCommands: {
+    add: addCmd,
+    remove: removeCmd,
+    list: listCmd
+  }
+});
 
 // src/commands/audit.ts
 import * as p from "@clack/prompts";
-import { defineCommand } from "citty";
+import { defineCommand as defineCommand2 } from "citty";
 import { createSpinner } from "nanospinner";
-import pc from "picocolors";
+import pc2 from "picocolors";
 
 // src/core/security-scanner.ts
-import fs from "fs";
+import fs2 from "fs";
 import os from "os";
 import path from "path";
 var CACHE_PATH = path.join(os.homedir(), ".mcpman", ".audit-cache.json");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 function readCache() {
   try {
-    if (!fs.existsSync(CACHE_PATH)) return {};
-    return JSON.parse(fs.readFileSync(CACHE_PATH, "utf-8"));
+    if (!fs2.existsSync(CACHE_PATH)) return {};
+    return JSON.parse(fs2.readFileSync(CACHE_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeCache(cache) {
   const dir = path.dirname(CACHE_PATH);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
   const tmp = `${CACHE_PATH}.tmp`;
-  fs.writeFileSync(tmp, JSON.stringify(cache, null, 2), "utf-8");
-  fs.renameSync(tmp, CACHE_PATH);
+  fs2.writeFileSync(tmp, JSON.stringify(cache, null, 2), "utf-8");
+  fs2.renameSync(tmp, CACHE_PATH);
 }
 function getCachedReport(name, version) {
   const cache = readCache();
@@ -167,11 +282,11 @@ async function scanAllServers(servers, concurrency = 3) {
   const results = [];
   const executing = /* @__PURE__ */ new Set();
   for (const [name, entry] of entries) {
-    const p12 = scanServer(name, entry).then((r) => {
+    const p13 = scanServer(name, entry).then((r) => {
       results.push(r);
-      executing.delete(p12);
+      executing.delete(p13);
     });
-    executing.add(p12);
+    executing.add(p13);
     if (executing.size >= concurrency) await Promise.race(executing);
   }
   await Promise.all(executing);
@@ -286,12 +401,12 @@ async function resolveFromGitHub(githubUrl) {
 
 // src/core/plugin-loader.ts
 import { execSync } from "child_process";
-import fs3 from "fs";
+import fs4 from "fs";
 import { createRequire } from "module";
 import path3 from "path";
 
 // src/core/config-service.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import path2 from "path";
 var VALID_KEYS = /* @__PURE__ */ new Set([
   "defaultClient",
@@ -302,7 +417,7 @@ var VALID_KEYS = /* @__PURE__ */ new Set([
 ]);
 function readConfig(configPath = getConfigPath()) {
   try {
-    const raw = fs2.readFileSync(configPath, "utf-8");
+    const raw = fs3.readFileSync(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       return {};
@@ -314,10 +429,10 @@ function readConfig(configPath = getConfigPath()) {
 }
 function writeConfig(data, configPath = getConfigPath()) {
   const dir = path2.dirname(configPath);
-  fs2.mkdirSync(dir, { recursive: true });
+  fs3.mkdirSync(dir, { recursive: true });
   const tmp = `${configPath}.tmp`;
-  fs2.writeFileSync(tmp, JSON.stringify(data, null, 2), { encoding: "utf-8" });
-  fs2.renameSync(tmp, configPath);
+  fs3.writeFileSync(tmp, JSON.stringify(data, null, 2), { encoding: "utf-8" });
+  fs3.renameSync(tmp, configPath);
 }
 function getConfigValue(key, configPath = getConfigPath()) {
   const data = readConfig(configPath);
@@ -336,8 +451,8 @@ function setConfigValue(key, value, configPath = getConfigPath()) {
 // src/core/plugin-loader.ts
 function isValidPlugin(obj) {
   if (typeof obj !== "object" || obj === null) return false;
-  const p12 = obj;
-  return typeof p12.name === "string" && typeof p12.prefix === "string" && typeof p12.resolve === "function";
+  const p13 = obj;
+  return typeof p13.name === "string" && typeof p13.prefix === "string" && typeof p13.resolve === "function";
 }
 function loadPlugin(pkg, pluginDir = getPluginDir()) {
   try {
@@ -362,10 +477,10 @@ function loadAllPlugins(pluginDir = getPluginDir()) {
   return plugins;
 }
 function installPluginPackage(name, pluginDir = getPluginDir()) {
-  fs3.mkdirSync(pluginDir, { recursive: true });
+  fs4.mkdirSync(pluginDir, { recursive: true });
   const pkgJsonPath = path3.join(pluginDir, "package.json");
-  if (!fs3.existsSync(pkgJsonPath)) {
-    fs3.writeFileSync(
+  if (!fs4.existsSync(pkgJsonPath)) {
+    fs4.writeFileSync(
       pkgJsonPath,
       JSON.stringify({ name: "mcpman-plugins", private: true }, null, 2)
     );
@@ -391,7 +506,7 @@ function removePluginPackage(name, pluginDir = getPluginDir()) {
   }
   const config = readConfig();
   const plugins = config.plugins ?? [];
-  config.plugins = plugins.filter((p12) => p12 !== name);
+  config.plugins = plugins.filter((p13) => p13 !== name);
   writeConfig(config);
 }
 function listPluginPackages() {
@@ -440,7 +555,7 @@ async function resolveServer(input) {
       if (source.type.startsWith("plugin:")) {
         const pluginName = source.type.slice(7);
         const plugins = loadAllPlugins();
-        const plugin = plugins.find((p12) => p12.name === pluginName);
+        const plugin = plugins.find((p13) => p13.name === pluginName);
         if (plugin) {
           const resolved = await plugin.resolve(source.input);
           return resolved;
@@ -494,6 +609,47 @@ async function applyServerUpdate(serverName, lockEntry, clients) {
   }
 }
 
+// src/core/pin-service.ts
+import fs5 from "fs";
+function readPins(file) {
+  const target = file ?? getPinsFile();
+  if (!fs5.existsSync(target)) return {};
+  try {
+    return JSON.parse(fs5.readFileSync(target, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writePins(store, file) {
+  const target = file ?? getPinsFile();
+  const dir = target.slice(0, target.lastIndexOf("/"));
+  if (dir && !fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
+  }
+  fs5.writeFileSync(target, JSON.stringify(store, null, 2), "utf-8");
+}
+function pinServer(server, version, file) {
+  const store = readPins(file);
+  store[server] = version;
+  writePins(store, file);
+}
+function unpinServer(server, file) {
+  const store = readPins(file);
+  if (!(server in store)) return;
+  delete store[server];
+  writePins(store, file);
+}
+function getPinnedVersion(server, file) {
+  return readPins(file)[server] ?? null;
+}
+function isPinned(server, file) {
+  return server in readPins(file);
+}
+function listPins(file) {
+  const store = readPins(file);
+  return Object.entries(store).sort(([a], [b]) => a.localeCompare(b)).map(([server, version]) => ({ server, version }));
+}
+
 // src/core/version-checker.ts
 function compareVersions(a, b) {
   const aParts = a.replace(/^v/, "").split(".").map(Number);
@@ -595,11 +751,12 @@ async function checkAllVersions(lockfile) {
   const results = [];
   const executing = /* @__PURE__ */ new Set();
   for (const [name, entry] of entries) {
-    const p12 = checkVersion(name, entry).then((r) => {
+    if (isPinned(name)) continue;
+    const p13 = checkVersion(name, entry).then((r) => {
       results.push(r);
-      executing.delete(p12);
+      executing.delete(p13);
     });
-    executing.add(p12);
+    executing.add(p13);
     if (executing.size >= 5) {
       await Promise.race(executing);
     }
@@ -611,11 +768,11 @@ async function checkAllVersions(lockfile) {
 // src/commands/audit.ts
 function colorRisk(level, score) {
   const label = score !== null ? `${score}/100 (${level})` : level;
-  if (level === "LOW") return pc.green(label);
-  if (level === "MEDIUM") return pc.yellow(label);
-  if (level === "HIGH") return pc.red(label);
-  if (level === "CRITICAL") return pc.bold(pc.red(label));
-  return pc.dim(label);
+  if (level === "LOW") return pc2.green(label);
+  if (level === "MEDIUM") return pc2.yellow(label);
+  if (level === "HIGH") return pc2.red(label);
+  if (level === "CRITICAL") return pc2.bold(pc2.red(label));
+  return pc2.dim(label);
 }
 function daysAgo(isoDate) {
   const days = Math.floor((Date.now() - new Date(isoDate).getTime()) / 864e5);
@@ -626,20 +783,20 @@ function daysAgo(isoDate) {
 function countVulns(vulns) {
   const c = { critical: 0, high: 0, moderate: 0, low: 0 };
   for (const v of vulns) c[v.severity]++;
-  if (vulns.length === 0) return pc.green("none");
+  if (vulns.length === 0) return pc2.green("none");
   const parts = [];
-  if (c.critical) parts.push(pc.bold(pc.red(`${c.critical} critical`)));
-  if (c.high) parts.push(pc.red(`${c.high} high`));
-  if (c.moderate) parts.push(pc.yellow(`${c.moderate} moderate`));
-  if (c.low) parts.push(pc.dim(`${c.low} low`));
+  if (c.critical) parts.push(pc2.bold(pc2.red(`${c.critical} critical`)));
+  if (c.high) parts.push(pc2.red(`${c.high} high`));
+  if (c.moderate) parts.push(pc2.yellow(`${c.moderate} moderate`));
+  if (c.low) parts.push(pc2.dim(`${c.low} low`));
   return parts.join(", ");
 }
 function printReport(report) {
   const riskColored = colorRisk(report.riskLevel, report.score);
-  const icon = report.riskLevel === "LOW" ? pc.green("\u25CF") : report.riskLevel === "MEDIUM" ? pc.yellow("\u25CF") : report.riskLevel === "UNKNOWN" ? pc.dim("\u25CB") : pc.red("\u25CF");
-  console.log(`  ${icon} ${pc.bold(report.server)}  Score: ${riskColored}`);
+  const icon = report.riskLevel === "LOW" ? pc2.green("\u25CF") : report.riskLevel === "MEDIUM" ? pc2.yellow("\u25CF") : report.riskLevel === "UNKNOWN" ? pc2.dim("\u25CB") : pc2.red("\u25CF");
+  console.log(`  ${icon} ${pc2.bold(report.server)}  Score: ${riskColored}`);
   if (report.source !== "npm") {
-    console.log(`    ${pc.dim("Non-npm source \u2014 security data unavailable")}`);
+    console.log(`    ${pc2.dim("Non-npm source \u2014 security data unavailable")}`);
     console.log();
     return;
   }
@@ -647,20 +804,20 @@ function printReport(report) {
     const { weeklyDownloads, packageAge, lastPublish, maintainerCount, deprecated } = report.metadata;
     const dlStr = weeklyDownloads.toLocaleString();
     console.log(
-      `    ${pc.dim("Downloads:")} ${dlStr}/week  ${pc.dim("|")}  ${pc.dim("Age:")} ${packageAge}d  ${pc.dim("|")}  ${pc.dim("Last publish:")} ${daysAgo(lastPublish)}  ${pc.dim("|")}  ${pc.dim("Maintainers:")} ${maintainerCount}${deprecated ? pc.red("  [DEPRECATED]") : ""}`
+      `    ${pc2.dim("Downloads:")} ${dlStr}/week  ${pc2.dim("|")}  ${pc2.dim("Age:")} ${packageAge}d  ${pc2.dim("|")}  ${pc2.dim("Last publish:")} ${daysAgo(lastPublish)}  ${pc2.dim("|")}  ${pc2.dim("Maintainers:")} ${maintainerCount}${deprecated ? pc2.red("  [DEPRECATED]") : ""}`
     );
   }
-  console.log(`    ${pc.dim("Vulnerabilities:")} ${countVulns(report.vulnerabilities)}`);
+  console.log(`    ${pc2.dim("Vulnerabilities:")} ${countVulns(report.vulnerabilities)}`);
   if (report.vulnerabilities.length > 0) {
     for (const v of report.vulnerabilities) {
-      const sevColor = v.severity === "critical" || v.severity === "high" ? pc.red : pc.yellow;
-      const url = v.url ? pc.dim(` ${v.url}`) : "";
+      const sevColor = v.severity === "critical" || v.severity === "high" ? pc2.red : pc2.yellow;
+      const url = v.url ? pc2.dim(` ${v.url}`) : "";
       console.log(`      ${sevColor("\u25B8")} [${v.severity}] ${v.title}${url}`);
     }
   }
   console.log();
 }
-var audit_default = defineCommand({
+var audit_default = defineCommand2({
   meta: {
     name: "audit",
     description: "Scan installed MCP servers for security vulnerabilities and trust scores"
@@ -692,14 +849,14 @@ var audit_default = defineCommand({
     const { servers } = lockfile;
     if (Object.keys(servers).length === 0) {
       console.log(
-        pc.dim("\n  No MCP servers installed. Run mcpman install <server> to get started.\n")
+        pc2.dim("\n  No MCP servers installed. Run mcpman install <server> to get started.\n")
       );
       return;
     }
     const targets = {};
     if (args.server) {
       if (!servers[args.server]) {
-        console.error(pc.red(`
+        console.error(pc2.red(`
   Server "${args.server}" not found in lockfile.
 `));
         process.exit(1);
@@ -714,7 +871,7 @@ var audit_default = defineCommand({
       reports = args.server ? [await scanServer(args.server, targets[args.server])] : await scanAllServers(targets);
     } catch (err) {
       spinner5.error({ text: "Scan failed" });
-      console.error(pc.red(String(err)));
+      console.error(pc2.red(String(err)));
       process.exit(1);
     }
     spinner5.success({ text: `Scanned ${reports.length} server(s)` });
@@ -722,23 +879,23 @@ var audit_default = defineCommand({
       console.log(JSON.stringify(reports, null, 2));
       return;
     }
-    console.log(pc.bold("\n  mcpman audit\n"));
-    console.log(pc.dim(`  ${"\u2500".repeat(60)}`));
+    console.log(pc2.bold("\n  mcpman audit\n"));
+    console.log(pc2.dim(`  ${"\u2500".repeat(60)}`));
     for (const report of reports) {
       printReport(report);
     }
-    console.log(pc.dim(`  ${"\u2500".repeat(60)}`));
+    console.log(pc2.dim(`  ${"\u2500".repeat(60)}`));
     const withIssues = reports.filter((r) => r.riskLevel !== "LOW" && r.riskLevel !== "UNKNOWN");
     const npmReports = reports.filter((r) => r.source === "npm");
     const parts = [];
     parts.push(`${reports.length} server(s) scanned`);
     if (npmReports.length < reports.length) {
-      parts.push(pc.dim(`${reports.length - npmReports.length} non-npm (unverified)`));
+      parts.push(pc2.dim(`${reports.length - npmReports.length} non-npm (unverified)`));
     }
     if (withIssues.length > 0) {
-      parts.push(pc.yellow(`${withIssues.length} with issues`));
+      parts.push(pc2.yellow(`${withIssues.length} with issues`));
     } else {
-      parts.push(pc.green("all clear"));
+      parts.push(pc2.green("all clear"));
     }
     console.log(`
   Summary: ${parts.join(" | ")}
@@ -750,7 +907,7 @@ var audit_default = defineCommand({
 });
 async function loadClients() {
   try {
-    const mod = await import("./client-detector-CY7WPF3K.js");
+    const mod = await import("./client-detector-O2HN4MUB.js");
     return mod.getInstalledClients();
   } catch {
     return [];
@@ -760,14 +917,14 @@ async function runAuditFix(reports, servers, skipConfirm) {
   const npmWithVulns = reports.filter((r) => r.vulnerabilities.length > 0 && r.source === "npm");
   const nonNpmWithVulns = reports.filter((r) => r.vulnerabilities.length > 0 && r.source !== "npm");
   if (nonNpmWithVulns.length > 0) {
-    console.log(pc.yellow("  Non-npm servers require manual update:"));
+    console.log(pc2.yellow("  Non-npm servers require manual update:"));
     for (const r of nonNpmWithVulns) {
-      console.log(`    ${pc.dim("\u2192")} ${r.server} (${r.source})`);
+      console.log(`    ${pc2.dim("\u2192")} ${r.server} (${r.source})`);
     }
     console.log();
   }
   if (npmWithVulns.length === 0) {
-    console.log(pc.green("  No fixable vulnerabilities found.\n"));
+    console.log(pc2.green("  No fixable vulnerabilities found.\n"));
     return;
   }
   const versionSpinner = createSpinner("Checking for available updates...").start();
@@ -778,20 +935,20 @@ async function runAuditFix(reports, servers, skipConfirm) {
   const updatable = versionChecks.filter((u) => u.hasUpdate);
   if (updatable.length === 0) {
     console.log(
-      pc.yellow(
+      pc2.yellow(
         "  Vulnerable servers have no newer versions available yet.\n  Allow time for registry to publish fixes.\n"
       )
     );
     return;
   }
   console.log(
-    pc.bold(`
+    pc2.bold(`
   ${updatable.length} server(s) can be updated to fix vulnerabilities:
 `)
   );
   for (const u of updatable) {
     console.log(
-      `    ${pc.cyan("\u2192")} ${u.server}  ${pc.dim(u.currentVersion)} \u2192 ${pc.green(u.latestVersion)}`
+      `    ${pc2.cyan("\u2192")} ${u.server}  ${pc2.dim(u.currentVersion)} \u2192 ${pc2.green(u.latestVersion)}`
     );
   }
   console.log();
@@ -813,11 +970,11 @@ async function runAuditFix(reports, servers, skipConfirm) {
     const result = await applyServerUpdate(u.server, servers[u.server], clients);
     if (result.success) {
       s.success({
-        text: `${pc.green("\u2713")} ${u.server}: ${result.fromVersion} \u2192 ${result.toVersion}`
+        text: `${pc2.green("\u2713")} ${u.server}: ${result.fromVersion} \u2192 ${result.toVersion}`
       });
       successCount++;
     } else {
-      s.error({ text: `${pc.red("\u2717")} ${u.server}: ${result.error}` });
+      s.error({ text: `${pc2.red("\u2717")} ${u.server}: ${result.error}` });
     }
     results.push({
       server: u.server,
@@ -836,14 +993,14 @@ async function runAuditFix(reports, servers, skipConfirm) {
       updatedNames.map((name) => scanServer(name, freshLockfile.servers[name]))
     );
     rescanSpinner.success({ text: "Re-scan complete" });
-    console.log(pc.bold("\n  Before / After:\n"));
+    console.log(pc2.bold("\n  Before / After:\n"));
     for (const after of afterReports) {
       const before = reports.find((r) => r.server === after.server);
       const beforeVulns = before?.vulnerabilities.length ?? 0;
       const afterVulns = after.vulnerabilities.length;
-      const improved = afterVulns < beforeVulns ? pc.green("improved") : pc.yellow("unchanged");
+      const improved = afterVulns < beforeVulns ? pc2.green("improved") : pc2.yellow("unchanged");
       console.log(
-        `    ${pc.bold(after.server)}  vulns: ${beforeVulns} \u2192 ${afterVulns}  [${improved}]`
+        `    ${pc2.bold(after.server)}  vulns: ${beforeVulns} \u2192 ${afterVulns}  [${improved}]`
       );
     }
     console.log();
@@ -853,12 +1010,204 @@ async function runAuditFix(reports, servers, skipConfirm) {
 `);
 }
 
+// src/commands/bench.ts
+import { defineCommand as defineCommand3 } from "citty";
+import pc3 from "picocolors";
+
+// src/core/bench-service.ts
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT_MS = 1e4;
+function measureOneRun(command, args, env, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    let settled = false;
+    let stdout = "";
+    const child = spawn(command, args, {
+      env: { ...process.env, ...env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const finish = (err) => {
+      if (settled) return;
+      settled = true;
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      if (err) reject(err);
+      else resolve(Date.now() - start);
+    };
+    const timer = setTimeout(() => {
+      finish(new Error("Timeout waiting for initialize response"));
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      finish(err);
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      if (!settled) finish(new Error(`Process exited with code ${code}`));
+    });
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+      for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const msg = JSON.parse(trimmed);
+          if (msg.jsonrpc === "2.0" && msg.id === 1) {
+            clearTimeout(timer);
+            finish();
+          }
+        } catch {
+        }
+      }
+    });
+    const initReq = JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        clientInfo: { name: "mcpman-bench", version: "0.8.0" }
+      }
+    });
+    child.stdin?.write(`${initReq}
+`);
+  });
+}
+function percentile(sorted, p13) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.ceil(p13 / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, idx)];
+}
+async function benchServer(command, args, env, runs = 5, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const allTimes = [];
+  for (let i = 0; i < runs; i++) {
+    try {
+      const ms = await measureOneRun(command, args, env, timeoutMs);
+      allTimes.push(ms);
+    } catch (err) {
+      return {
+        runs,
+        min: 0,
+        max: 0,
+        avg: 0,
+        p50: 0,
+        p95: 0,
+        allTimes,
+        error: String(err instanceof Error ? err.message : err)
+      };
+    }
+  }
+  const sorted = [...allTimes].sort((a, b) => a - b);
+  const sum = allTimes.reduce((a, b) => a + b, 0);
+  return {
+    runs,
+    min: sorted[0] ?? 0,
+    max: sorted[sorted.length - 1] ?? 0,
+    avg: Math.round(sum / allTimes.length),
+    p50: percentile(sorted, 50),
+    p95: percentile(sorted, 95),
+    allTimes
+  };
+}
+
+// src/commands/bench.ts
+var bench_default = defineCommand3({
+  meta: {
+    name: "bench",
+    description: "Benchmark MCP server latency (JSON-RPC initialize)"
+  },
+  args: {
+    server: {
+      type: "positional",
+      description: "Server name as stored in lockfile",
+      required: true
+    },
+    runs: {
+      type: "string",
+      description: "Number of benchmark runs (default: 5)",
+      default: "5"
+    },
+    timeout: {
+      type: "string",
+      description: "Per-run timeout in ms (default: 10000)",
+      default: "10000"
+    },
+    json: {
+      type: "boolean",
+      description: "Output results as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const lockfile = readLockfile();
+    const entry = lockfile.servers[args.server];
+    if (!entry) {
+      console.error(`${pc3.red("\u2717")} Server "${args.server}" not found in lockfile.`);
+      console.error(pc3.dim("Run `mcpman list` to see installed servers."));
+      process.exit(1);
+    }
+    const runs = Math.max(1, Number.parseInt(args.runs, 10) || 5);
+    const timeoutMs = Math.max(1e3, Number.parseInt(args.timeout, 10) || 1e4);
+    if (!args.json) {
+      console.log(`
+${pc3.cyan("mcpman bench")} \u2014 ${pc3.bold(args.server)}`);
+      console.log(pc3.dim(`  Command: ${entry.command} ${(entry.args ?? []).join(" ")}`));
+      console.log(pc3.dim(`  Runs: ${runs}  Timeout: ${timeoutMs}ms
+`));
+      process.stdout.write(pc3.dim("  Running"));
+    }
+    const env = {};
+    for (const ev of entry.envVars ?? []) {
+      const idx = ev.indexOf("=");
+      if (idx > 0) env[ev.slice(0, idx)] = ev.slice(idx + 1);
+    }
+    const result = await benchServer(entry.command, entry.args ?? [], env, runs, timeoutMs);
+    if (!args.json) process.stdout.write("\n");
+    if (result.error) {
+      if (args.json) {
+        console.log(JSON.stringify({ server: args.server, error: result.error }));
+      } else {
+        console.error(`
+${pc3.red("\u2717")} Benchmark failed: ${result.error}`);
+      }
+      process.exit(1);
+    }
+    if (args.json) {
+      console.log(JSON.stringify({ server: args.server, ...result }, null, 2));
+      if (result.p95 > timeoutMs) process.exit(1);
+      return;
+    }
+    const pad5 = (s, w) => s.padEnd(w);
+    const ms = (n) => `${n}ms`;
+    console.log(`
+  ${pc3.bold("Latency statistics")} for ${pc3.cyan(args.server)}`);
+    console.log(pc3.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`  ${pad5("min", 8)} ${pc3.green(ms(result.min))}`);
+    console.log(`  ${pad5("avg", 8)} ${ms(result.avg)}`);
+    console.log(`  ${pad5("p50", 8)} ${ms(result.p50)}`);
+    console.log(
+      `  ${pad5("p95", 8)} ${result.p95 > timeoutMs ? pc3.red(ms(result.p95)) : pc3.yellow(ms(result.p95))}`
+    );
+    console.log(`  ${pad5("max", 8)} ${ms(result.max)}`);
+    console.log(`  ${pad5("runs", 8)} ${result.runs}`);
+    console.log("");
+    if (result.p95 > timeoutMs) {
+      console.error(pc3.red(`  \u2717 p95 (${result.p95}ms) exceeds timeout (${timeoutMs}ms)`));
+      process.exit(1);
+    }
+    console.log(pc3.green("  \u2713 Benchmark complete"));
+  }
+});
+
 // src/commands/completions.ts
-import fs4 from "fs";
+import fs6 from "fs";
 import os2 from "os";
 import path4 from "path";
-import { defineCommand as defineCommand2 } from "citty";
-import pc2 from "picocolors";
+import { defineCommand as defineCommand4 } from "citty";
+import pc4 from "picocolors";
 
 // src/core/completion-generator.ts
 function getCommandList() {
@@ -888,7 +1237,13 @@ function getCommandList() {
     "watch",
     "registry",
     "completions",
-    "why"
+    "why",
+    "env",
+    "bench",
+    "diff",
+    "group",
+    "pin",
+    "rollback"
   ];
 }
 var SERVER_ARG_COMMANDS = [
@@ -1013,7 +1368,7 @@ complete -c mcpman -l runtime -s r \\
 }
 
 // src/commands/completions.ts
-var completions_default = defineCommand2({
+var completions_default = defineCommand4({
   meta: {
     name: "completions",
     description: "Generate shell completion scripts (bash, zsh, fish)"
@@ -1063,24 +1418,24 @@ var completions_default = defineCommand2({
         await installCompletion();
         break;
       default:
-        console.error(pc2.red(`  Error: Unknown shell '${shell}'. Use: bash, zsh, or fish.`));
+        console.error(pc4.red(`  Error: Unknown shell '${shell}'. Use: bash, zsh, or fish.`));
         process.exit(1);
     }
   }
 });
 function printUsage() {
-  console.log(pc2.bold("\n  mcpman completions \u2014 Shell completion setup\n"));
+  console.log(pc4.bold("\n  mcpman completions \u2014 Shell completion setup\n"));
   console.log("  Usage:");
-  console.log(`    ${pc2.cyan("mcpman completions bash")}    Output bash completion script`);
-  console.log(`    ${pc2.cyan("mcpman completions zsh")}     Output zsh completion script`);
-  console.log(`    ${pc2.cyan("mcpman completions fish")}    Output fish completion script`);
-  console.log(`    ${pc2.cyan("mcpman completions install")} Auto-detect shell and install
+  console.log(`    ${pc4.cyan("mcpman completions bash")}    Output bash completion script`);
+  console.log(`    ${pc4.cyan("mcpman completions zsh")}     Output zsh completion script`);
+  console.log(`    ${pc4.cyan("mcpman completions fish")}    Output fish completion script`);
+  console.log(`    ${pc4.cyan("mcpman completions install")} Auto-detect shell and install
 `);
   console.log("  Quick setup:");
-  console.log(`    ${pc2.dim("# bash")}`);
-  console.log(`    ${pc2.cyan("source <(mcpman completions bash)")}`);
-  console.log(`    ${pc2.dim("# zsh")}`);
-  console.log(`    ${pc2.cyan("source <(mcpman completions zsh)")}
+  console.log(`    ${pc4.dim("# bash")}`);
+  console.log(`    ${pc4.cyan("source <(mcpman completions bash)")}`);
+  console.log(`    ${pc4.dim("# zsh")}`);
+  console.log(`    ${pc4.cyan("source <(mcpman completions zsh)")}
 `);
 }
 async function installCompletion() {
@@ -1090,8 +1445,8 @@ async function installCompletion() {
   else if (shellBin.includes("fish")) detectedShell = "fish";
   else if (shellBin.includes("bash")) detectedShell = "bash";
   if (!detectedShell) {
-    console.error(pc2.red("  Could not detect shell from $SHELL. Run manually:"));
-    console.error(pc2.dim("    source <(mcpman completions bash|zsh|fish)"));
+    console.error(pc4.red("  Could not detect shell from $SHELL. Run manually:"));
+    console.error(pc4.dim("    source <(mcpman completions bash|zsh|fish)"));
     process.exit(1);
   }
   const home = os2.homedir();
@@ -1102,10 +1457,10 @@ async function installCompletion() {
     script = generateZshCompletion();
   } else if (detectedShell === "fish") {
     const fishDir = path4.join(home, ".config", "fish", "completions");
-    fs4.mkdirSync(fishDir, { recursive: true });
+    fs6.mkdirSync(fishDir, { recursive: true });
     rcFile = path4.join(fishDir, "mcpman.fish");
-    fs4.writeFileSync(rcFile, generateFishCompletion(), "utf-8");
-    console.log(pc2.green(`  Installed fish completions to ${rcFile}`));
+    fs6.writeFileSync(rcFile, generateFishCompletion(), "utf-8");
+    console.log(pc4.green(`  Installed fish completions to ${rcFile}`));
     return;
   } else {
     rcFile = path4.join(home, ".bashrc");
@@ -1114,25 +1469,25 @@ async function installCompletion() {
   const marker = "# mcpman completions";
   let existing = "";
   try {
-    existing = fs4.readFileSync(rcFile, "utf-8");
+    existing = fs6.readFileSync(rcFile, "utf-8");
   } catch {
   }
   if (existing.includes(marker)) {
-    console.log(pc2.yellow(`  Completions already installed in ${rcFile}. Skipping.`));
+    console.log(pc4.yellow(`  Completions already installed in ${rcFile}. Skipping.`));
     return;
   }
-  fs4.appendFileSync(rcFile, `
+  fs6.appendFileSync(rcFile, `
 ${marker}
 source <(mcpman completions ${detectedShell})
 `);
-  console.log(pc2.green(`  Installed ${detectedShell} completions in ${rcFile}`));
-  console.log(pc2.dim(`  Restart your shell or run: source ${rcFile}`));
+  console.log(pc4.green(`  Installed ${detectedShell} completions in ${rcFile}`));
+  console.log(pc4.dim(`  Restart your shell or run: source ${rcFile}`));
 }
 
 // src/commands/config.ts
 import * as p2 from "@clack/prompts";
-import { defineCommand as defineCommand3 } from "citty";
-import pc3 from "picocolors";
+import { defineCommand as defineCommand5 } from "citty";
+import pc5 from "picocolors";
 function coerceValue(raw) {
   if (raw === "true") return true;
   if (raw === "false") return false;
@@ -1140,7 +1495,7 @@ function coerceValue(raw) {
   if (!Number.isNaN(num) && raw.trim() !== "") return num;
   return raw;
 }
-var setCommand = defineCommand3({
+var setCommand = defineCommand5({
   meta: { name: "set", description: "Set a config value" },
   args: {
     key: {
@@ -1158,14 +1513,14 @@ var setCommand = defineCommand3({
     try {
       const coerced = coerceValue(args.value);
       setConfigValue(args.key, coerced);
-      console.log(`${pc3.green("\u2713")} Set ${pc3.bold(args.key)} = ${pc3.cyan(String(coerced))}`);
+      console.log(`${pc5.green("\u2713")} Set ${pc5.bold(args.key)} = ${pc5.cyan(String(coerced))}`);
     } catch (err) {
-      console.error(`${pc3.red("\u2717")} ${String(err)}`);
+      console.error(`${pc5.red("\u2717")} ${String(err)}`);
       process.exit(1);
     }
   }
 });
-var getCommand = defineCommand3({
+var getCommand = defineCommand5({
   meta: { name: "get", description: "Get a config value" },
   args: {
     key: {
@@ -1177,32 +1532,32 @@ var getCommand = defineCommand3({
   run({ args }) {
     const val = getConfigValue(args.key);
     if (val === void 0) {
-      console.log(pc3.dim(`${args.key}: (not set)`));
+      console.log(pc5.dim(`${args.key}: (not set)`));
     } else {
-      console.log(`${pc3.bold(args.key)}: ${pc3.cyan(String(val))}`);
+      console.log(`${pc5.bold(args.key)}: ${pc5.cyan(String(val))}`);
     }
   }
 });
-var listCommand = defineCommand3({
+var listCommand = defineCommand5({
   meta: { name: "list", description: "List all config values" },
   run() {
     const data = readConfig();
     const entries = Object.entries(data);
     if (entries.length === 0) {
-      console.log(pc3.dim("No config values set. Use `mcpman config set <key> <value>`."));
+      console.log(pc5.dim("No config values set. Use `mcpman config set <key> <value>`."));
       return;
     }
     console.log("");
-    console.log(pc3.bold("mcpman config:"));
+    console.log(pc5.bold("mcpman config:"));
     console.log("");
     for (const [key, val] of entries) {
-      console.log(`  ${pc3.green("\u25CF")} ${pc3.bold(key)}  ${pc3.cyan(String(val))}`);
+      console.log(`  ${pc5.green("\u25CF")} ${pc5.bold(key)}  ${pc5.cyan(String(val))}`);
     }
     console.log("");
-    console.log(pc3.dim(`  ${entries.length} key${entries.length !== 1 ? "s" : ""} configured`));
+    console.log(pc5.dim(`  ${entries.length} key${entries.length !== 1 ? "s" : ""} configured`));
   }
 });
-var resetCommand = defineCommand3({
+var resetCommand = defineCommand5({
   meta: { name: "reset", description: "Reset config to defaults (removes config file)" },
   async run() {
     const confirmed = await p2.confirm({
@@ -1214,10 +1569,10 @@ var resetCommand = defineCommand3({
       return;
     }
     writeConfig({});
-    console.log(`${pc3.green("\u2713")} Config reset to defaults.`);
+    console.log(`${pc5.green("\u2713")} Config reset to defaults.`);
   }
 });
-var config_default = defineCommand3({
+var config_default = defineCommand5({
   meta: {
     name: "config",
     description: "Manage mcpman CLI configuration"
@@ -1232,11 +1587,11 @@ var config_default = defineCommand3({
 
 // src/commands/create.ts
 import path6 from "path";
-import { defineCommand as defineCommand4 } from "citty";
-import pc4 from "picocolors";
+import { defineCommand as defineCommand6 } from "citty";
+import pc6 from "picocolors";
 
 // src/core/scaffold-service.ts
-import fs5 from "fs";
+import fs7 from "fs";
 import path5 from "path";
 function sanitizeName(name) {
   return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -1389,8 +1744,8 @@ if __name__ == "__main__":
   };
 }
 function writeScaffold(dir, files) {
-  if (fs5.existsSync(dir)) {
-    const existing = fs5.readdirSync(dir);
+  if (fs7.existsSync(dir)) {
+    const existing = fs7.readdirSync(dir);
     if (existing.length > 0) {
       throw new Error(`Directory '${dir}' already exists and is not empty.`);
     }
@@ -1398,13 +1753,13 @@ function writeScaffold(dir, files) {
   for (const [relativePath, content] of Object.entries(files)) {
     const fullPath = path5.join(dir, relativePath);
     const parentDir = path5.dirname(fullPath);
-    fs5.mkdirSync(parentDir, { recursive: true });
-    fs5.writeFileSync(fullPath, content, "utf-8");
+    fs7.mkdirSync(parentDir, { recursive: true });
+    fs7.writeFileSync(fullPath, content, "utf-8");
   }
 }
 
 // src/commands/create.ts
-var create_default = defineCommand4({
+var create_default = defineCommand6({
   meta: {
     name: "create",
     description: "Scaffold a new MCP server project"
@@ -1442,7 +1797,7 @@ var create_default = defineCommand4({
         const readline = await import("readline");
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
         projectName = await new Promise((resolve) => {
-          rl.question(pc4.cyan("  Project name: "), (answer) => {
+          rl.question(pc6.cyan("  Project name: "), (answer) => {
             rl.close();
             resolve(answer.trim());
           });
@@ -1452,7 +1807,7 @@ var create_default = defineCommand4({
         const readline = await import("readline");
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
         projectDescription = await new Promise((resolve) => {
-          rl.question(pc4.cyan("  Description (optional): "), (answer) => {
+          rl.question(pc6.cyan("  Description (optional): "), (answer) => {
             rl.close();
             resolve(answer.trim());
           });
@@ -1462,7 +1817,7 @@ var create_default = defineCommand4({
         const readline = await import("readline");
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
         const answer = await new Promise((resolve) => {
-          rl.question(pc4.cyan("  Runtime [node/python] (default: node): "), (a) => {
+          rl.question(pc6.cyan("  Runtime [node/python] (default: node): "), (a) => {
             rl.close();
             resolve(a.trim() || "node");
           });
@@ -1471,16 +1826,16 @@ var create_default = defineCommand4({
       }
     }
     if (!projectName) {
-      console.error(pc4.red("  Error: Project name is required."));
+      console.error(pc6.red("  Error: Project name is required."));
       process.exit(1);
     }
     const sanitized = sanitizeName(projectName);
     if (!sanitized) {
-      console.error(pc4.red(`  Error: Invalid project name '${projectName}'.`));
+      console.error(pc6.red(`  Error: Invalid project name '${projectName}'.`));
       process.exit(1);
     }
     if (runtime !== "node" && runtime !== "python") {
-      console.error(pc4.red(`  Error: Unknown runtime '${runtime}'. Use node or python.`));
+      console.error(pc6.red(`  Error: Unknown runtime '${runtime}'. Use node or python.`));
       process.exit(1);
     }
     const options = {
@@ -1494,90 +1849,252 @@ var create_default = defineCommand4({
     try {
       writeScaffold(targetDir, files);
     } catch (err) {
-      console.error(pc4.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+      console.error(pc6.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
       process.exit(1);
     }
-    console.log(pc4.green(`
-  Created ${pc4.bold(sanitized)}/
+    console.log(pc6.green(`
+  Created ${pc6.bold(sanitized)}/
 `));
-    console.log(pc4.dim("  Files generated:"));
+    console.log(pc6.dim("  Files generated:"));
     for (const file of Object.keys(files)) {
-      console.log(`    ${pc4.cyan(file)}`);
+      console.log(`    ${pc6.cyan(file)}`);
     }
     console.log("\n  Next steps:");
     if (runtime === "node") {
-      console.log(`    ${pc4.bold(`cd ${sanitized}`)}`);
-      console.log(`    ${pc4.bold("npm install")}`);
-      console.log(`    ${pc4.bold("mcpman link .")}`);
+      console.log(`    ${pc6.bold(`cd ${sanitized}`)}`);
+      console.log(`    ${pc6.bold("npm install")}`);
+      console.log(`    ${pc6.bold("mcpman link .")}`);
     } else {
-      console.log(`    ${pc4.bold(`cd ${sanitized}`)}`);
-      console.log(`    ${pc4.bold("pip install -e .")}`);
-      console.log(`    ${pc4.bold("mcpman link .")}`);
+      console.log(`    ${pc6.bold(`cd ${sanitized}`)}`);
+      console.log(`    ${pc6.bold("pip install -e .")}`);
+      console.log(`    ${pc6.bold("mcpman link .")}`);
     }
     console.log();
   }
 });
 
-// src/commands/doctor.ts
-import { defineCommand as defineCommand5 } from "citty";
-import pc5 from "picocolors";
-
-// src/core/diagnostics.ts
-import { exec } from "child_process";
-import { promisify } from "util";
+// src/commands/diff.ts
+import { defineCommand as defineCommand7 } from "citty";
+import pc7 from "picocolors";
 
-// src/core/mcp-process-checks.ts
-import { spawn } from "child_process";
-async function checkProcessSpawn(command, args, env, timeoutMs = 3e3) {
-  return new Promise((resolve) => {
-    let settled = false;
-    const child = spawn(command, args, {
-      env: { ...process.env, ...env },
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const timer = setTimeout(() => {
-      if (!settled) {
-        settled = true;
-        child.kill("SIGTERM");
-        resolve({ name: "Process", passed: true, message: "starts successfully (still running)" });
-      }
-    }, timeoutMs);
-    child.on("error", (err) => {
-      if (!settled) {
-        settled = true;
-        clearTimeout(timer);
-        resolve({ name: "Process", passed: false, message: `spawn error: ${err.message}` });
-      }
-    });
-    child.on("exit", (code) => {
-      if (!settled) {
-        settled = true;
-        clearTimeout(timer);
-        if (code === 0 || code === null) {
-          resolve({ name: "Process", passed: true, message: "exits cleanly" });
-        } else {
-          resolve({ name: "Process", passed: false, message: `exits with code ${code}` });
-        }
+// src/core/config-differ.ts
+function entryDiffs(a, b) {
+  const diffs = [];
+  if (a.command !== b.command) {
+    diffs.push(`command: ${a.command} \u2192 ${b.command}`);
+  }
+  const aArgs = JSON.stringify(a.args ?? []);
+  const bArgs = JSON.stringify(b.args ?? []);
+  if (aArgs !== bArgs) {
+    diffs.push(`args: ${aArgs} \u2192 ${bArgs}`);
+  }
+  const aEnv = JSON.stringify(a.env ?? {});
+  const bEnv = JSON.stringify(b.env ?? {});
+  if (aEnv !== bEnv) {
+    diffs.push(`env: ${aEnv} \u2192 ${bEnv}`);
+  }
+  return diffs;
+}
+function diffClientConfigs(configA, configB) {
+  const results = [];
+  const serversA = configA.servers;
+  const serversB = configB.servers;
+  for (const name of Object.keys(serversB)) {
+    if (!(name in serversA)) {
+      results.push({ server: name, change: "added" });
+    }
+  }
+  for (const name of Object.keys(serversA)) {
+    if (!(name in serversB)) {
+      results.push({ server: name, change: "removed" });
+    }
+  }
+  for (const name of Object.keys(serversA)) {
+    if (name in serversB) {
+      const details = entryDiffs(serversA[name], serversB[name]);
+      if (details.length > 0) {
+        results.push({ server: name, change: "changed", details });
       }
-    });
+    }
+  }
+  const order = { removed: 0, added: 1, changed: 2 };
+  results.sort((a, b) => {
+    const orderDiff = order[a.change] - order[b.change];
+    return orderDiff !== 0 ? orderDiff : a.server.localeCompare(b.server);
   });
+  return results;
 }
-var MCP_INIT_REQUEST = JSON.stringify({
-  jsonrpc: "2.0",
-  id: 1,
-  method: "initialize",
-  params: {
-    protocolVersion: "2024-11-05",
-    capabilities: {},
-    clientInfo: { name: "mcpman-doctor", version: "0.1.0" }
+async function loadClientConfig(type) {
+  try {
+    const { getClient } = await import("./client-detector-O2HN4MUB.js");
+    const handler = getClient(type);
+    return await handler.readConfig();
+  } catch {
+    return null;
   }
-});
-async function checkMcpHandshake(command, args, env, timeoutMs = 5e3) {
-  return new Promise((resolve) => {
-    let settled = false;
-    const start = Date.now();
+}
+
+// src/commands/diff.ts
+var VALID_CLIENTS = ["claude-desktop", "cursor", "vscode", "windsurf"];
+var CLIENT_DISPLAY = {
+  "claude-desktop": "Claude Desktop",
+  cursor: "Cursor",
+  vscode: "VS Code",
+  windsurf: "Windsurf"
+};
+var diff_default = defineCommand7({
+  meta: {
+    name: "diff",
+    description: "Show config diff between two AI clients"
+  },
+  args: {
+    clientA: {
+      type: "positional",
+      description: `Source client (${VALID_CLIENTS.join("|")})`,
+      required: true
+    },
+    clientB: {
+      type: "positional",
+      description: `Target client (${VALID_CLIENTS.join("|")})`,
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output results as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const clientA = args.clientA;
+    const clientB = args.clientB;
+    if (!VALID_CLIENTS.includes(clientA)) {
+      console.error(
+        `${pc7.red("\u2717")} Unknown client "${clientA}". Valid: ${VALID_CLIENTS.join(", ")}`
+      );
+      process.exit(1);
+    }
+    if (!VALID_CLIENTS.includes(clientB)) {
+      console.error(
+        `${pc7.red("\u2717")} Unknown client "${clientB}". Valid: ${VALID_CLIENTS.join(", ")}`
+      );
+      process.exit(1);
+    }
+    if (clientA === clientB) {
+      console.error(`${pc7.red("\u2717")} clientA and clientB must be different.`);
+      process.exit(1);
+    }
+    const [configA, configB] = await Promise.all([
+      loadClientConfig(clientA),
+      loadClientConfig(clientB)
+    ]);
+    if (!configA) {
+      console.error(`${pc7.red("\u2717")} Could not read config for ${CLIENT_DISPLAY[clientA]}.`);
+      process.exit(1);
+    }
+    if (!configB) {
+      console.error(`${pc7.red("\u2717")} Could not read config for ${CLIENT_DISPLAY[clientB]}.`);
+      process.exit(1);
+    }
+    const diffs = diffClientConfigs(configA, configB);
+    if (args.json) {
+      console.log(JSON.stringify({ clientA, clientB, diffs }, null, 2));
+      return;
+    }
+    const labelA = CLIENT_DISPLAY[clientA];
+    const labelB = CLIENT_DISPLAY[clientB];
+    console.log(`
+${pc7.bold("mcpman diff")}  ${pc7.cyan(labelA)} \u2192 ${pc7.cyan(labelB)}
+`);
+    if (diffs.length === 0) {
+      console.log(pc7.green("  \u2713 No differences \u2014 configs are identical."));
+      console.log("");
+      return;
+    }
+    for (const d of diffs) {
+      if (d.change === "added") {
+        console.log(`  ${pc7.green("+")} ${pc7.bold(d.server)}  ${pc7.dim(`(only in ${labelB})`)}`);
+      } else if (d.change === "removed") {
+        console.log(`  ${pc7.red("-")} ${pc7.bold(d.server)}  ${pc7.dim(`(only in ${labelA})`)}`);
+      } else {
+        console.log(`  ${pc7.yellow("~")} ${pc7.bold(d.server)}  ${pc7.dim("(changed)")}`);
+        for (const detail of d.details ?? []) {
+          console.log(`      ${pc7.dim(detail)}`);
+        }
+      }
+    }
+    const added = diffs.filter((d) => d.change === "added").length;
+    const removed = diffs.filter((d) => d.change === "removed").length;
+    const changed = diffs.filter((d) => d.change === "changed").length;
+    const parts = [];
+    if (added > 0) parts.push(pc7.green(`+${added} added`));
+    if (removed > 0) parts.push(pc7.red(`-${removed} removed`));
+    if (changed > 0) parts.push(pc7.yellow(`~${changed} changed`));
+    console.log(`
+  ${parts.join("  ")}
+`);
+  }
+});
+
+// src/commands/doctor.ts
+import { defineCommand as defineCommand8 } from "citty";
+import pc8 from "picocolors";
+
+// src/core/diagnostics.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/core/mcp-process-checks.ts
+import { spawn as spawn2 } from "child_process";
+async function checkProcessSpawn(command, args, env, timeoutMs = 3e3) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const child = spawn2(command, args, {
+      env: { ...process.env, ...env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        child.kill("SIGTERM");
+        resolve({ name: "Process", passed: true, message: "starts successfully (still running)" });
+      }
+    }, timeoutMs);
+    child.on("error", (err) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        resolve({ name: "Process", passed: false, message: `spawn error: ${err.message}` });
+      }
+    });
+    child.on("exit", (code) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        if (code === 0 || code === null) {
+          resolve({ name: "Process", passed: true, message: "exits cleanly" });
+        } else {
+          resolve({ name: "Process", passed: false, message: `exits with code ${code}` });
+        }
+      }
+    });
+  });
+}
+var MCP_INIT_REQUEST = JSON.stringify({
+  jsonrpc: "2.0",
+  id: 1,
+  method: "initialize",
+  params: {
+    protocolVersion: "2024-11-05",
+    capabilities: {},
+    clientInfo: { name: "mcpman-doctor", version: "0.1.0" }
+  }
+});
+async function checkMcpHandshake(command, args, env, timeoutMs = 5e3) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const start = Date.now();
     let stdout = "";
-    const child = spawn(command, args, {
+    const child = spawn2(command, args, {
       env: { ...process.env, ...env },
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -1865,12 +2382,12 @@ async function getInstalledServers(clientFilter) {
 
 // src/commands/doctor.ts
 var CHECK_ICON = {
-  pass: pc5.green("\u2713"),
-  fail: pc5.red("\u2717"),
-  skip: pc5.dim("-"),
-  warn: pc5.yellow("\u26A0")
+  pass: pc8.green("\u2713"),
+  fail: pc8.red("\u2717"),
+  skip: pc8.dim("-"),
+  warn: pc8.yellow("\u26A0")
 };
-var doctor_default = defineCommand5({
+var doctor_default = defineCommand8({
   meta: {
     name: "doctor",
     description: "Check MCP server health and configuration"
@@ -1883,11 +2400,11 @@ var doctor_default = defineCommand5({
     }
   },
   async run({ args }) {
-    console.log(pc5.bold("\n  mcpman doctor\n"));
+    console.log(pc8.bold("\n  mcpman doctor\n"));
     const servers = await getInstalledServers();
     if (servers.length === 0) {
       console.log(
-        pc5.dim("  No MCP servers installed. Run mcpman install <server> to get started.")
+        pc8.dim("  No MCP servers installed. Run mcpman install <server> to get started.")
       );
       return;
     }
@@ -1904,20 +2421,20 @@ var doctor_default = defineCommand5({
     if (pluginSummary.total > 0) {
       printPluginSection(pluginSummary);
     }
-    console.log(pc5.dim(`  ${"\u2500".repeat(50)}`));
+    console.log(pc8.dim(`  ${"\u2500".repeat(50)}`));
     const parts = [];
-    if (passed > 0) parts.push(pc5.green(`${passed} healthy`));
-    if (failed > 0) parts.push(pc5.red(`${failed} unhealthy`));
+    if (passed > 0) parts.push(pc8.green(`${passed} healthy`));
+    if (failed > 0) parts.push(pc8.red(`${failed} unhealthy`));
     console.log(`  Summary: ${parts.join(", ")}`);
     if (pluginSummary.total > 0) {
       const pParts = [];
-      if (pluginSummary.healthy > 0) pParts.push(pc5.green(`${pluginSummary.healthy} ok`));
-      if (pluginSummary.unhealthy > 0) pParts.push(pc5.red(`${pluginSummary.unhealthy} broken`));
+      if (pluginSummary.healthy > 0) pParts.push(pc8.green(`${pluginSummary.healthy} ok`));
+      if (pluginSummary.unhealthy > 0) pParts.push(pc8.red(`${pluginSummary.unhealthy} broken`));
       console.log(`  Plugins: ${pParts.join(", ")}`);
     }
     if (failed > 0 || pluginSummary.unhealthy > 0) {
       if (!args.fix) {
-        console.log(pc5.dim(`  Run ${pc5.cyan("mcpman doctor --fix")} for fix suggestions.
+        console.log(pc8.dim(`  Run ${pc8.cyan("mcpman doctor --fix")} for fix suggestions.
 `));
       }
       process.exit(1);
@@ -1926,26 +2443,26 @@ var doctor_default = defineCommand5({
   }
 });
 function printPluginSection(summary) {
-  console.log(pc5.bold(`  Plugins (${summary.total})`));
+  console.log(pc8.bold(`  Plugins (${summary.total})`));
   for (const r of summary.results) {
-    const icon = r.loadable && r.prefixUnique && r.resolvable ? pc5.green("\u2713") : pc5.red("\u2717");
+    const icon = r.loadable && r.prefixUnique && r.resolvable ? pc8.green("\u2713") : pc8.red("\u2717");
     const label = r.pluginName ? `${r.packageName} (${r.pluginName})` : r.packageName;
-    const prefix = r.prefix ? pc5.dim(` [${r.prefix}]`) : "";
+    const prefix = r.prefix ? pc8.dim(` [${r.prefix}]`) : "";
     console.log(`    ${icon} ${label}${prefix}`);
     if (r.error) {
-      console.log(`      ${pc5.yellow("\u2192")} ${r.error}`);
+      console.log(`      ${pc8.yellow("\u2192")} ${r.error}`);
     }
   }
   console.log();
 }
 function printServerResult(result, showFix) {
-  const icon = result.status === "healthy" ? pc5.green("\u25CF") : pc5.red("\u25CF");
-  console.log(`  ${icon} ${pc5.bold(result.serverName)}`);
+  const icon = result.status === "healthy" ? pc8.green("\u25CF") : pc8.red("\u25CF");
+  console.log(`  ${icon} ${pc8.bold(result.serverName)}`);
   for (const check of result.checks) {
     const checkIcon = check.skipped ? CHECK_ICON.skip : check.passed ? CHECK_ICON.pass : CHECK_ICON.fail;
     console.log(`    ${checkIcon} ${check.name}: ${check.message}`);
     if (showFix && !check.passed && !check.skipped && check.fix) {
-      console.log(`      ${pc5.yellow("\u2192")} Fix: ${pc5.cyan(check.fix)}`);
+      console.log(`      ${pc8.yellow("\u2192")} Fix: ${pc8.cyan(check.fix)}`);
     }
   }
   console.log();
@@ -1954,11 +2471,11 @@ async function runParallel(tasks, concurrency) {
   const results = [];
   const executing = /* @__PURE__ */ new Set();
   for (const task of tasks) {
-    const p12 = task().then((r) => {
+    const p13 = task().then((r) => {
       results.push(r);
-      executing.delete(p12);
+      executing.delete(p13);
     });
-    executing.add(p12);
+    executing.add(p13);
     if (executing.size >= concurrency) {
       await Promise.race(executing);
     }
@@ -1967,18 +2484,188 @@ async function runParallel(tasks, concurrency) {
   return results;
 }
 
-// src/commands/export-command.ts
-import fs7 from "fs";
+// src/commands/env.ts
+import { defineCommand as defineCommand9 } from "citty";
+import pc9 from "picocolors";
+
+// src/core/env-manager.ts
+import fs8 from "fs";
 import path7 from "path";
-import { defineCommand as defineCommand6 } from "citty";
-import pc6 from "picocolors";
+function envFilePath(server, dir) {
+  const base = dir ?? getEnvDir();
+  const safe = server.replace(/[/@]/g, "_");
+  return path7.join(base, `${safe}.json`);
+}
+function readStore(server, dir) {
+  const file = envFilePath(server, dir);
+  if (!fs8.existsSync(file)) return {};
+  try {
+    return JSON.parse(fs8.readFileSync(file, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeStore(server, store, dir) {
+  const base = dir ?? getEnvDir();
+  if (!fs8.existsSync(base)) {
+    fs8.mkdirSync(base, { recursive: true });
+  }
+  const file = envFilePath(server, dir);
+  fs8.writeFileSync(file, JSON.stringify(store, null, 2), "utf-8");
+}
+function setEnv(server, key, value, dir) {
+  const store = readStore(server, dir);
+  store[key] = value;
+  writeStore(server, store, dir);
+}
+function getEnv(server, key, dir) {
+  const store = readStore(server, dir);
+  return key in store ? store[key] : null;
+}
+function listEnv(server, dir) {
+  return readStore(server, dir);
+}
+function deleteEnv(server, key, dir) {
+  const store = readStore(server, dir);
+  if (!(key in store)) return;
+  delete store[key];
+  writeStore(server, store, dir);
+}
+function clearEnv(server, dir) {
+  const file = envFilePath(server, dir);
+  if (fs8.existsSync(file)) {
+    fs8.unlinkSync(file);
+  }
+}
+function listEnvServers(dir) {
+  const base = dir ?? getEnvDir();
+  if (!fs8.existsSync(base)) return [];
+  return fs8.readdirSync(base).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5));
+}
+
+// src/commands/env.ts
+var setCmd = defineCommand9({
+  meta: { name: "set", description: "Set env var(s) for a server" },
+  args: {
+    server: { type: "positional", description: "Server name", required: true },
+    pairs: { type: "positional", description: "KEY=VALUE pair(s)", required: true }
+  },
+  run({ args }) {
+    const pairs = Array.isArray(args.pairs) ? args.pairs : [args.pairs];
+    for (const pair of pairs) {
+      const idx = pair.indexOf("=");
+      if (idx <= 0) {
+        console.error(`${pc9.red("\u2717")} Invalid format: "${pair}". Expected KEY=VALUE`);
+        process.exit(1);
+      }
+      const key = pair.slice(0, idx);
+      const value = pair.slice(idx + 1);
+      setEnv(args.server, key, value);
+      console.log(
+        `${pc9.green("\u2713")} Set ${pc9.bold(key)}=${pc9.dim(value)} for ${pc9.cyan(args.server)}`
+      );
+    }
+  }
+});
+var getCmd = defineCommand9({
+  meta: { name: "get", description: "Get an env var for a server" },
+  args: {
+    server: { type: "positional", description: "Server name", required: true },
+    key: { type: "positional", description: "Variable name", required: true }
+  },
+  run({ args }) {
+    const value = getEnv(args.server, args.key);
+    if (value === null) {
+      console.error(`${pc9.red("\u2717")} No env var "${args.key}" for ${pc9.cyan(args.server)}`);
+      process.exit(1);
+    }
+    console.log(value);
+  }
+});
+var listCmd2 = defineCommand9({
+  meta: { name: "list", description: "List env vars for a server (or all servers)" },
+  args: {
+    server: { type: "positional", description: "Server name (optional)", required: false }
+  },
+  run({ args }) {
+    if (args.server) {
+      const store = listEnv(args.server);
+      const keys = Object.keys(store);
+      if (keys.length === 0) {
+        console.log(pc9.dim(`No env vars for ${pc9.cyan(args.server)}.`));
+        return;
+      }
+      console.log(`
+${pc9.bold(pc9.cyan(args.server))}`);
+      for (const [k, v] of Object.entries(store)) {
+        console.log(`  ${pc9.green("\u25CF")} ${pc9.bold(k)}=${pc9.dim(v)}`);
+      }
+      console.log("");
+    } else {
+      const servers = listEnvServers();
+      if (servers.length === 0) {
+        console.log(pc9.dim("No env vars stored."));
+        return;
+      }
+      for (const srv of servers) {
+        const store = listEnv(srv);
+        console.log(`
+${pc9.bold(pc9.cyan(srv))}`);
+        for (const [k, v] of Object.entries(store)) {
+          console.log(`  ${pc9.green("\u25CF")} ${pc9.bold(k)}=${pc9.dim(v)}`);
+        }
+      }
+      console.log("");
+    }
+  }
+});
+var delCmd = defineCommand9({
+  meta: { name: "del", description: "Delete an env var for a server" },
+  args: {
+    server: { type: "positional", description: "Server name", required: true },
+    key: { type: "positional", description: "Variable name to delete", required: true }
+  },
+  run({ args }) {
+    deleteEnv(args.server, args.key);
+    console.log(`${pc9.green("\u2713")} Deleted ${pc9.bold(args.key)} from ${pc9.cyan(args.server)}`);
+  }
+});
+var clearCmd = defineCommand9({
+  meta: { name: "clear", description: "Clear all env vars for a server" },
+  args: {
+    server: { type: "positional", description: "Server name", required: true }
+  },
+  run({ args }) {
+    clearEnv(args.server);
+    console.log(`${pc9.green("\u2713")} Cleared all env vars for ${pc9.cyan(args.server)}`);
+  }
+});
+var env_default = defineCommand9({
+  meta: {
+    name: "env",
+    description: "Manage per-server environment variables (non-sensitive)"
+  },
+  subCommands: {
+    set: setCmd,
+    get: getCmd,
+    list: listCmd2,
+    del: delCmd,
+    clear: clearCmd
+  }
+});
+
+// src/commands/export-command.ts
+import fs10 from "fs";
+import path8 from "path";
+import { defineCommand as defineCommand10 } from "citty";
+import pc10 from "picocolors";
 
 // src/core/export-import-service.ts
-import fs6 from "fs";
+import fs9 from "fs";
 
 // src/utils/constants.ts
 var APP_NAME = "mcpman";
-var APP_VERSION = "0.7.0";
+var APP_VERSION = "0.9.0";
 var APP_DESCRIPTION = "The package manager for MCP servers";
 
 // src/core/export-import-service.ts
@@ -1994,7 +2681,7 @@ function createExportBundle(opts = {}) {
   };
   if (includeVault) {
     const vaultPath = getVaultPath();
-    if (fs6.existsSync(vaultPath)) {
+    if (fs9.existsSync(vaultPath)) {
       bundle.vault = readVault();
     }
   }
@@ -2060,7 +2747,7 @@ function importBundle(bundle, opts = {}) {
 
 // src/commands/export-command.ts
 var DEFAULT_OUTPUT = "mcpman-export.json";
-var export_command_default = defineCommand6({
+var export_command_default = defineCommand10({
   meta: {
     name: "export",
     description: "Export mcpman config, lockfile, vault, and plugins to a portable JSON file"
@@ -2084,29 +2771,239 @@ var export_command_default = defineCommand6({
   },
   run({ args }) {
     const outputFile = args.output || DEFAULT_OUTPUT;
-    const outputPath = path7.resolve(outputFile);
+    const outputPath = path8.resolve(outputFile);
     const bundle = createExportBundle({
       includeVault: !args["no-vault"],
       includePlugins: !args["no-plugins"]
     });
     const serverCount = Object.keys(bundle.lockfile.servers).length;
     const configKeys = Object.keys(bundle.config).length;
-    fs7.writeFileSync(outputPath, JSON.stringify(bundle, null, 2), "utf-8");
-    console.log(`${pc6.green("\u2713")} Exported to ${pc6.bold(outputFile)}`);
-    console.log(pc6.dim(`  Config keys: ${configKeys}`));
-    console.log(pc6.dim(`  Servers: ${serverCount}`));
-    console.log(pc6.dim(`  Vault: ${bundle.vault ? "included" : "excluded"}`));
-    console.log(pc6.dim(`  Plugins: ${bundle.plugins?.length ?? 0}`));
+    fs10.writeFileSync(outputPath, JSON.stringify(bundle, null, 2), "utf-8");
+    console.log(`${pc10.green("\u2713")} Exported to ${pc10.bold(outputFile)}`);
+    console.log(pc10.dim(`  Config keys: ${configKeys}`));
+    console.log(pc10.dim(`  Servers: ${serverCount}`));
+    console.log(pc10.dim(`  Vault: ${bundle.vault ? "included" : "excluded"}`));
+    console.log(pc10.dim(`  Plugins: ${bundle.plugins?.length ?? 0}`));
+  }
+});
+
+// src/commands/group.ts
+import { spawn as spawn3 } from "child_process";
+import { defineCommand as defineCommand11 } from "citty";
+import pc11 from "picocolors";
+
+// src/core/group-manager.ts
+import fs11 from "fs";
+function readGroups(file) {
+  const target = file ?? getGroupsFile();
+  if (!fs11.existsSync(target)) return {};
+  try {
+    return JSON.parse(fs11.readFileSync(target, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeGroups(store, file) {
+  const target = file ?? getGroupsFile();
+  const dir = target.slice(0, target.lastIndexOf("/"));
+  if (dir && !fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
+  }
+  fs11.writeFileSync(target, JSON.stringify(store, null, 2), "utf-8");
+}
+function addToGroup(group, servers, file) {
+  const store = readGroups(file);
+  const existing = new Set(store[group] ?? []);
+  for (const s of servers) existing.add(s);
+  store[group] = [...existing].sort();
+  writeGroups(store, file);
+}
+function removeFromGroup(group, servers, file) {
+  const store = readGroups(file);
+  if (!store[group]) return;
+  const toRemove = new Set(servers);
+  store[group] = store[group].filter((s) => !toRemove.has(s));
+  if (store[group].length === 0) delete store[group];
+  writeGroups(store, file);
+}
+function getGroup(group, file) {
+  return readGroups(file)[group] ?? [];
+}
+function listGroups(file) {
+  return Object.keys(readGroups(file)).sort();
+}
+function deleteGroup(group, file) {
+  const store = readGroups(file);
+  if (!(group in store)) return;
+  delete store[group];
+  writeGroups(store, file);
+}
+function groupExists(group, file) {
+  return group in readGroups(file);
+}
+
+// src/commands/group.ts
+var addCmd2 = defineCommand11({
+  meta: { name: "add", description: "Add servers to a group" },
+  args: {
+    name: { type: "positional", description: "Group name", required: true },
+    servers: { type: "positional", description: "Server name(s)", required: true }
+  },
+  run({ args }) {
+    const servers = Array.isArray(args.servers) ? args.servers : [args.servers];
+    addToGroup(args.name, servers);
+    console.log(`${pc11.green("\u2713")} Added ${servers.join(", ")} to group ${pc11.cyan(args.name)}`);
+  }
+});
+var rmCmd = defineCommand11({
+  meta: { name: "rm", description: "Remove servers from a group" },
+  args: {
+    name: { type: "positional", description: "Group name", required: true },
+    servers: { type: "positional", description: "Server name(s)", required: true }
+  },
+  run({ args }) {
+    const servers = Array.isArray(args.servers) ? args.servers : [args.servers];
+    removeFromGroup(args.name, servers);
+    console.log(`${pc11.green("\u2713")} Removed ${servers.join(", ")} from group ${pc11.cyan(args.name)}`);
+  }
+});
+var listCmd3 = defineCommand11({
+  meta: { name: "list", description: "List all groups (or members of a group)" },
+  args: {
+    name: { type: "positional", description: "Group name (optional)", required: false }
+  },
+  run({ args }) {
+    if (args.name) {
+      const members = getGroup(args.name);
+      if (members.length === 0) {
+        console.log(pc11.dim(`Group "${args.name}" is empty or does not exist.`));
+        return;
+      }
+      console.log(`
+${pc11.bold(pc11.cyan(args.name))}`);
+      for (const s of members) console.log(`  ${pc11.green("\u25CF")} ${s}`);
+      console.log("");
+    } else {
+      const groups = listGroups();
+      if (groups.length === 0) {
+        console.log(pc11.dim("No groups defined. Use `mcpman group add <name> <server>`."));
+        return;
+      }
+      console.log("");
+      for (const g of groups) {
+        const members = getGroup(g);
+        console.log(
+          `  ${pc11.cyan(pc11.bold(g))}  ${pc11.dim(`(${members.length} server${members.length !== 1 ? "s" : ""})`)}`
+        );
+        for (const s of members) console.log(`    ${pc11.dim("\xB7")} ${s}`);
+      }
+      console.log("");
+    }
+  }
+});
+var deleteCmd = defineCommand11({
+  meta: { name: "delete", description: "Delete an entire group" },
+  args: {
+    name: { type: "positional", description: "Group name", required: true }
+  },
+  run({ args }) {
+    if (!groupExists(args.name)) {
+      console.error(`${pc11.red("\u2717")} Group "${args.name}" does not exist.`);
+      process.exit(1);
+    }
+    deleteGroup(args.name);
+    console.log(`${pc11.green("\u2713")} Deleted group ${pc11.cyan(args.name)}`);
+  }
+});
+var installCmd = defineCommand11({
+  meta: { name: "install", description: "Install all servers in a group" },
+  args: {
+    name: { type: "positional", description: "Group name", required: true }
+  },
+  async run({ args }) {
+    const members = getGroup(args.name);
+    if (members.length === 0) {
+      console.error(`${pc11.red("\u2717")} Group "${args.name}" is empty or does not exist.`);
+      process.exit(1);
+    }
+    console.log(
+      `${pc11.cyan("Installing")} group ${pc11.bold(args.name)} (${members.length} servers)...`
+    );
+    for (const server of members) {
+      console.log(`
+  ${pc11.dim("\u2192")} Installing ${pc11.bold(server)}...`);
+      await runInstall(server);
+    }
+    console.log(`
+${pc11.green("\u2713")} Group install complete.`);
+  }
+});
+var runCmd = defineCommand11({
+  meta: { name: "run", description: "Run all servers in a group concurrently" },
+  args: {
+    name: { type: "positional", description: "Group name", required: true }
+  },
+  run({ args }) {
+    const members = getGroup(args.name);
+    if (members.length === 0) {
+      console.error(`${pc11.red("\u2717")} Group "${args.name}" is empty or does not exist.`);
+      process.exit(1);
+    }
+    const lockfile = readLockfile();
+    console.log(
+      `${pc11.cyan("Spawning")} group ${pc11.bold(args.name)} (${members.length} servers)...
+`
+    );
+    for (const server of members) {
+      const entry = lockfile.servers[server];
+      if (!entry) {
+        console.warn(`  ${pc11.yellow("!")} ${server} not in lockfile \u2014 skipping`);
+        continue;
+      }
+      const child = spawn3(entry.command, entry.args ?? [], {
+        env: process.env,
+        stdio: "inherit",
+        detached: false
+      });
+      child.on("error", (err) => {
+        console.error(`  ${pc11.red("\u2717")} ${server}: ${err.message}`);
+      });
+      console.log(`  ${pc11.green("\u2713")} Spawned ${pc11.bold(server)} (pid ${child.pid ?? "?"})`);
+    }
+  }
+});
+function runInstall(server) {
+  return new Promise((resolve, reject) => {
+    const child = spawn3("mcpman", ["install", server], { stdio: "inherit" });
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`install exited with code ${code}`));
+    });
+    child.on("error", reject);
+  });
+}
+var group_default = defineCommand11({
+  meta: {
+    name: "group",
+    description: "Manage named server groups"
+  },
+  subCommands: {
+    add: addCmd2,
+    rm: rmCmd,
+    list: listCmd3,
+    delete: deleteCmd,
+    install: installCmd,
+    run: runCmd
   }
 });
 
 // src/commands/import-command.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs12 from "fs";
+import path9 from "path";
 import * as p3 from "@clack/prompts";
-import { defineCommand as defineCommand7 } from "citty";
-import pc7 from "picocolors";
-var import_command_default = defineCommand7({
+import { defineCommand as defineCommand12 } from "citty";
+import pc12 from "picocolors";
+var import_command_default = defineCommand12({
   meta: {
     name: "import",
     description: "Import mcpman config, lockfile, vault, and plugins from an export file"
@@ -2129,21 +3026,21 @@ var import_command_default = defineCommand7({
     }
   },
   async run({ args }) {
-    const filePath = path8.resolve(args.file);
-    if (!fs8.existsSync(filePath)) {
-      console.error(`${pc7.red("\u2717")} File not found: ${filePath}`);
+    const filePath = path9.resolve(args.file);
+    if (!fs12.existsSync(filePath)) {
+      console.error(`${pc12.red("\u2717")} File not found: ${filePath}`);
       process.exit(1);
     }
     let raw;
     try {
-      raw = JSON.parse(fs8.readFileSync(filePath, "utf-8"));
+      raw = JSON.parse(fs12.readFileSync(filePath, "utf-8"));
     } catch {
-      console.error(`${pc7.red("\u2717")} Invalid JSON in ${filePath}`);
+      console.error(`${pc12.red("\u2717")} Invalid JSON in ${filePath}`);
       process.exit(1);
     }
     const error2 = validateBundle(raw);
     if (error2) {
-      console.error(`${pc7.red("\u2717")} Invalid export bundle: ${error2}`);
+      console.error(`${pc12.red("\u2717")} Invalid export bundle: ${error2}`);
       process.exit(1);
     }
     const bundle = raw;
@@ -2153,16 +3050,16 @@ var import_command_default = defineCommand7({
     const hasVault = !!bundle.vault;
     const isDryRun = !!args["dry-run"];
     console.log("");
-    console.log(pc7.bold("Import summary:"));
-    console.log(pc7.dim(`  Source version: mcpman ${bundle.mcpmanVersion}`));
-    console.log(pc7.dim(`  Exported at: ${bundle.exportedAt}`));
-    console.log(`  Config keys: ${pc7.cyan(String(configKeys))}`);
-    console.log(`  Servers: ${pc7.cyan(String(serverCount))}`);
-    console.log(`  Vault: ${hasVault ? pc7.green("included") : pc7.dim("not included")}`);
-    console.log(`  Plugins: ${pc7.cyan(String(pluginCount))}`);
+    console.log(pc12.bold("Import summary:"));
+    console.log(pc12.dim(`  Source version: mcpman ${bundle.mcpmanVersion}`));
+    console.log(pc12.dim(`  Exported at: ${bundle.exportedAt}`));
+    console.log(`  Config keys: ${pc12.cyan(String(configKeys))}`);
+    console.log(`  Servers: ${pc12.cyan(String(serverCount))}`);
+    console.log(`  Vault: ${hasVault ? pc12.green("included") : pc12.dim("not included")}`);
+    console.log(`  Plugins: ${pc12.cyan(String(pluginCount))}`);
     console.log("");
     if (isDryRun) {
-      console.log(pc7.yellow("  [dry-run] No changes applied."));
+      console.log(pc12.yellow("  [dry-run] No changes applied."));
       return;
     }
     if (!args.yes) {
@@ -2176,18 +3073,18 @@ var import_command_default = defineCommand7({
       }
     }
     const summary = importBundle(bundle, { dryRun: false });
-    console.log(`${pc7.green("\u2713")} Import complete`);
-    console.log(pc7.dim(`  Config keys restored: ${summary.configKeys}`));
-    console.log(pc7.dim(`  Servers restored: ${summary.servers}`));
-    console.log(pc7.dim(`  Vault: ${summary.vaultImported ? "restored" : "skipped"}`));
-    console.log(pc7.dim(`  Plugins installed: ${summary.pluginsInstalled}`));
+    console.log(`${pc12.green("\u2713")} Import complete`);
+    console.log(pc12.dim(`  Config keys restored: ${summary.configKeys}`));
+    console.log(pc12.dim(`  Servers restored: ${summary.servers}`));
+    console.log(pc12.dim(`  Vault: ${summary.vaultImported ? "restored" : "skipped"}`));
+    console.log(pc12.dim(`  Plugins installed: ${summary.pluginsInstalled}`));
   }
 });
 
 // src/commands/info.ts
-import { defineCommand as defineCommand8 } from "citty";
+import { defineCommand as defineCommand13 } from "citty";
 import { createSpinner as createSpinner2 } from "nanospinner";
-import pc8 from "picocolors";
+import pc13 from "picocolors";
 
 // src/core/package-info.ts
 async function buildInfo(name, entry, source = "npm") {
@@ -2242,11 +3139,11 @@ async function getPackageInfo(serverName) {
 // src/commands/info.ts
 function colorRisk2(score, riskLevel) {
   const label = score !== null ? `${score}/100 (${riskLevel})` : riskLevel;
-  if (riskLevel === "LOW") return pc8.green(label);
-  if (riskLevel === "MEDIUM") return pc8.yellow(label);
-  if (riskLevel === "HIGH") return pc8.red(label);
-  if (riskLevel === "CRITICAL") return pc8.bold(pc8.red(label));
-  return pc8.dim(label);
+  if (riskLevel === "LOW") return pc13.green(label);
+  if (riskLevel === "MEDIUM") return pc13.yellow(label);
+  if (riskLevel === "HIGH") return pc13.red(label);
+  if (riskLevel === "CRITICAL") return pc13.bold(pc13.red(label));
+  return pc13.dim(label);
 }
 function formatDaysAgo(isoDate) {
   if (!isoDate) return "unknown";
@@ -2256,54 +3153,54 @@ function formatDaysAgo(isoDate) {
   return `${days} days ago`;
 }
 function printInfo(info2) {
-  const installedBadge = info2.isInstalled ? pc8.green(" [installed]") : pc8.dim(" [not installed]");
+  const installedBadge = info2.isInstalled ? pc13.green(" [installed]") : pc13.dim(" [not installed]");
   console.log();
-  console.log(pc8.bold(`  ${info2.name}@${info2.version}`) + installedBadge);
-  console.log(pc8.dim(`  ${"\u2500".repeat(60)}`));
-  console.log(`  ${pc8.dim("Source:")}   ${info2.source}`);
-  console.log(`  ${pc8.dim("Runtime:")}  ${info2.runtime}`);
+  console.log(pc13.bold(`  ${info2.name}@${info2.version}`) + installedBadge);
+  console.log(pc13.dim(`  ${"\u2500".repeat(60)}`));
+  console.log(`  ${pc13.dim("Source:")}   ${info2.source}`);
+  console.log(`  ${pc13.dim("Runtime:")}  ${info2.runtime}`);
   if (info2.description) {
-    console.log(`  ${pc8.dim("Description:")} ${info2.description}`);
+    console.log(`  ${pc13.dim("Description:")} ${info2.description}`);
   }
   if (info2.deprecated) {
-    console.log(`  ${pc8.red("[DEPRECATED]")} This package is deprecated`);
+    console.log(`  ${pc13.red("[DEPRECATED]")} This package is deprecated`);
   }
   console.log();
-  console.log(`  ${pc8.bold("Trust & Security")}`);
-  console.log(`  ${pc8.dim("Trust score:")}   ${colorRisk2(info2.trustScore, info2.riskLevel)}`);
+  console.log(`  ${pc13.bold("Trust & Security")}`);
+  console.log(`  ${pc13.dim("Trust score:")}   ${colorRisk2(info2.trustScore, info2.riskLevel)}`);
   if (info2.source === "npm") {
     console.log(
-      `  ${pc8.dim("Downloads:")}    ${info2.weeklyDownloads.toLocaleString()}/week  ${pc8.dim("|")}  ${pc8.dim("Age:")} ${info2.packageAge}d  ${pc8.dim("|")}  ${pc8.dim("Maintainers:")} ${info2.maintainerCount}`
+      `  ${pc13.dim("Downloads:")}    ${info2.weeklyDownloads.toLocaleString()}/week  ${pc13.dim("|")}  ${pc13.dim("Age:")} ${info2.packageAge}d  ${pc13.dim("|")}  ${pc13.dim("Maintainers:")} ${info2.maintainerCount}`
     );
     if (info2.lastPublish) {
-      console.log(`  ${pc8.dim("Last publish:")} ${formatDaysAgo(info2.lastPublish)}`);
+      console.log(`  ${pc13.dim("Last publish:")} ${formatDaysAgo(info2.lastPublish)}`);
     }
   } else {
-    console.log(pc8.dim("  (Trust data available for npm packages only)"));
+    console.log(pc13.dim("  (Trust data available for npm packages only)"));
   }
   console.log();
-  console.log(`  ${pc8.bold("Environment Variables")}`);
+  console.log(`  ${pc13.bold("Environment Variables")}`);
   if (info2.envVars.length > 0) {
     for (const env of info2.envVars) {
-      console.log(`    ${pc8.cyan("\u2022")} ${env}`);
+      console.log(`    ${pc13.cyan("\u2022")} ${env}`);
     }
   } else {
-    console.log(pc8.dim("    none required"));
+    console.log(pc13.dim("    none required"));
   }
   console.log();
-  console.log(`  ${pc8.bold("Installed Clients")}`);
+  console.log(`  ${pc13.bold("Installed Clients")}`);
   if (info2.installedClients.length > 0) {
     for (const client of info2.installedClients) {
-      console.log(`    ${pc8.green("\u2713")} ${client}`);
+      console.log(`    ${pc13.green("\u2713")} ${client}`);
     }
   } else {
-    console.log(pc8.dim("    Not installed in any client"));
+    console.log(pc13.dim("    Not installed in any client"));
   }
   console.log();
-  console.log(pc8.dim(`  ${"\u2500".repeat(60)}`));
+  console.log(pc13.dim(`  ${"\u2500".repeat(60)}`));
   console.log();
 }
-var info_default = defineCommand8({
+var info_default = defineCommand13({
   meta: {
     name: "info",
     description: "Show detailed metadata for an MCP server (installed or from registry)"
@@ -2327,13 +3224,13 @@ var info_default = defineCommand8({
       info2 = await getPackageInfo(args.server);
     } catch (err) {
       spinner5.error({ text: "Failed to fetch package info" });
-      console.error(pc8.red(String(err)));
+      console.error(pc13.red(String(err)));
       process.exit(1);
     }
     if (!info2) {
       spinner5.error({ text: `Package not found: ${args.server}` });
       console.log(
-        pc8.dim(`
+        pc13.dim(`
   "${args.server}" was not found in the npm registry or your lockfile.
 `)
       );
@@ -2349,10 +3246,10 @@ var info_default = defineCommand8({
 });
 
 // src/commands/init.ts
-import path9 from "path";
+import path10 from "path";
 import * as p4 from "@clack/prompts";
-import { defineCommand as defineCommand9 } from "citty";
-var init_default = defineCommand9({
+import { defineCommand as defineCommand14 } from "citty";
+var init_default = defineCommand14({
   meta: {
     name: "init",
     description: "Initialize mcpman.lock in the current project"
@@ -2368,7 +3265,7 @@ var init_default = defineCommand9({
   async run({ args }) {
     const nonInteractive = args.yes || !process.stdout.isTTY;
     p4.intro("mcpman init");
-    const targetPath = path9.join(process.cwd(), LOCKFILE_NAME);
+    const targetPath = path10.join(process.cwd(), LOCKFILE_NAME);
     const existing = findLockfile();
     if (existing) {
       if (nonInteractive) {
@@ -2384,7 +3281,7 @@ var init_default = defineCommand9({
     }
     let clients = [];
     try {
-      const mod = await import("./client-detector-CY7WPF3K.js");
+      const mod = await import("./client-detector-O2HN4MUB.js");
       clients = await mod.getInstalledClients();
     } catch {
       p4.log.warn("Could not detect AI clients \u2014 creating empty lockfile.");
@@ -2452,7 +3349,7 @@ var init_default = defineCommand9({
 
 // src/commands/install.ts
 import * as p7 from "@clack/prompts";
-import { defineCommand as defineCommand10 } from "citty";
+import { defineCommand as defineCommand15 } from "citty";
 
 // src/core/installer.ts
 import * as p6 from "@clack/prompts";
@@ -2492,7 +3389,7 @@ async function offerVaultSave(serverName, newVars, yes) {
 // src/core/installer.ts
 async function loadClients2() {
   try {
-    const mod = await import("./client-detector-CY7WPF3K.js");
+    const mod = await import("./client-detector-O2HN4MUB.js");
     return mod.getInstalledClients();
   } catch {
     return [];
@@ -2604,7 +3501,7 @@ async function installServer(input, options = {}) {
 }
 
 // src/utils/logger.ts
-import pc9 from "picocolors";
+import pc14 from "picocolors";
 var noColor = process.env.NO_COLOR !== void 0 || process.argv.includes("--no-color");
 var isVerbose = process.argv.includes("--verbose");
 var isJson = process.argv.includes("--json");
@@ -2613,18 +3510,18 @@ function colorize(fn, text2) {
 }
 function info(message) {
   if (isJson) return;
-  console.log(`${colorize(pc9.cyan, "i")} ${message}`);
+  console.log(`${colorize(pc14.cyan, "i")} ${message}`);
 }
 function error(message) {
   if (isJson) return;
-  console.error(`${colorize(pc9.red, "\u2717")} ${message}`);
+  console.error(`${colorize(pc14.red, "\u2717")} ${message}`);
 }
 function json(data) {
   console.log(JSON.stringify(data, null, 2));
 }
 
 // src/commands/install.ts
-var install_default = defineCommand10({
+var install_default = defineCommand15({
   meta: {
     name: "install",
     description: "Install an MCP server into one or more AI clients"
@@ -2686,23 +3583,23 @@ async function restoreFromLockfile() {
 }
 
 // src/commands/link.ts
-import path11 from "path";
-import { defineCommand as defineCommand11 } from "citty";
-import pc10 from "picocolors";
+import path12 from "path";
+import { defineCommand as defineCommand16 } from "citty";
+import pc15 from "picocolors";
 
 // src/core/link-service.ts
-import fs9 from "fs";
-import path10 from "path";
+import fs13 from "fs";
+import path11 from "path";
 function detectLocalServer(dir) {
-  if (!fs9.existsSync(dir)) {
+  if (!fs13.existsSync(dir)) {
     throw new Error(`Directory does not exist: ${dir}`);
   }
-  const pkgPath = path10.join(dir, "package.json");
-  if (fs9.existsSync(pkgPath)) {
+  const pkgPath = path11.join(dir, "package.json");
+  if (fs13.existsSync(pkgPath)) {
     return detectNodeServer(dir, pkgPath);
   }
-  const pyprojectPath = path10.join(dir, "pyproject.toml");
-  if (fs9.existsSync(pyprojectPath)) {
+  const pyprojectPath = path11.join(dir, "pyproject.toml");
+  if (fs13.existsSync(pyprojectPath)) {
     return detectPythonServer(dir, pyprojectPath);
   }
   throw new Error(
@@ -2710,28 +3607,28 @@ function detectLocalServer(dir) {
   );
 }
 function detectNodeServer(dir, pkgPath) {
-  const raw = fs9.readFileSync(pkgPath, "utf-8");
+  const raw = fs13.readFileSync(pkgPath, "utf-8");
   const pkg = JSON.parse(raw);
-  const name = String(pkg.name ?? path10.basename(dir));
+  const name = String(pkg.name ?? path11.basename(dir));
   const version = String(pkg.version ?? "0.0.0");
   let entryPoint = null;
   if (pkg.bin) {
     if (typeof pkg.bin === "string") {
-      entryPoint = path10.resolve(dir, pkg.bin);
+      entryPoint = path11.resolve(dir, pkg.bin);
     } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
       const binObj = pkg.bin;
       const firstBin = Object.values(binObj)[0];
-      if (firstBin) entryPoint = path10.resolve(dir, firstBin);
+      if (firstBin) entryPoint = path11.resolve(dir, firstBin);
     }
   }
   if (!entryPoint && pkg.main) {
-    entryPoint = path10.resolve(dir, String(pkg.main));
+    entryPoint = path11.resolve(dir, String(pkg.main));
   }
   if (!entryPoint) {
     const candidates = ["src/index.ts", "src/index.js", "index.ts", "index.js"];
     for (const c of candidates) {
-      const candidate = path10.join(dir, c);
-      if (fs9.existsSync(candidate)) {
+      const candidate = path11.join(dir, c);
+      if (fs13.existsSync(candidate)) {
         entryPoint = candidate;
         break;
       }
@@ -2756,20 +3653,20 @@ function detectNodeServer(dir, pkgPath) {
   return { name, version, command, args, envVars, absolutePath: dir, runtime: "node" };
 }
 function detectPythonServer(dir, pyprojectPath) {
-  const raw = fs9.readFileSync(pyprojectPath, "utf-8");
-  const name = extractTomlValue(raw, "name") ?? path10.basename(dir);
+  const raw = fs13.readFileSync(pyprojectPath, "utf-8");
+  const name = extractTomlValue(raw, "name") ?? path11.basename(dir);
   const version = extractTomlValue(raw, "version") ?? "0.0.0";
   let pythonCmd = "python3";
-  const venvPython = path10.join(dir, ".venv", "bin", "python");
-  if (fs9.existsSync(venvPython)) {
+  const venvPython = path11.join(dir, ".venv", "bin", "python");
+  if (fs13.existsSync(venvPython)) {
     pythonCmd = venvPython;
   }
   const entryCandidate = [
-    path10.join(dir, "main.py"),
-    path10.join(dir, name.replace(/-/g, "_"), "main.py"),
-    path10.join(dir, "__main__.py")
-  ].find((p12) => fs9.existsSync(p12));
-  const entryPoint = entryCandidate ?? path10.join(dir, "main.py");
+    path11.join(dir, "main.py"),
+    path11.join(dir, name.replace(/-/g, "_"), "main.py"),
+    path11.join(dir, "__main__.py")
+  ].find((p13) => fs13.existsSync(p13));
+  const entryPoint = entryCandidate ?? path11.join(dir, "main.py");
   return {
     name,
     version,
@@ -2811,13 +3708,13 @@ async function registerLinkedServer(linkResult, clients, lockfilePath, nameOverr
   };
   const existing = readLockfile(lockfilePath);
   existing.servers[serverName] = lockEntry;
-  const { writeLockfile: writeLockfile2 } = await import("./lockfile-RBA7HB24.js");
+  const { writeLockfile: writeLockfile2 } = await import("./lockfile-ITEBE7HU.js");
   writeLockfile2(existing, lockfilePath);
   return registered;
 }
 
 // src/commands/link.ts
-var link_default = defineCommand11({
+var link_default = defineCommand16({
   meta: {
     name: "link",
     description: "Register a local MCP server directory with AI clients"
@@ -2843,42 +3740,42 @@ var link_default = defineCommand11({
     const dirArg = args.dir ?? ".";
     const clientFilter = args.client;
     const nameOverride = args.name;
-    const absoluteDir = path11.resolve(dirArg);
+    const absoluteDir = path12.resolve(dirArg);
     let linkResult;
     try {
       linkResult = detectLocalServer(absoluteDir);
     } catch (err) {
-      console.error(pc10.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+      console.error(pc15.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
       process.exit(1);
     }
     const serverName = nameOverride ?? linkResult.name;
-    console.log(pc10.dim(`
-  Detected: ${pc10.cyan(serverName)} (${linkResult.runtime})`));
-    console.log(pc10.dim(`  Path: ${absoluteDir}`));
-    console.log(pc10.dim(`  Command: ${linkResult.command} ${linkResult.args.join(" ")}`));
+    console.log(pc15.dim(`
+  Detected: ${pc15.cyan(serverName)} (${linkResult.runtime})`));
+    console.log(pc15.dim(`  Path: ${absoluteDir}`));
+    console.log(pc15.dim(`  Command: ${linkResult.command} ${linkResult.args.join(" ")}`));
     const allClients = await getInstalledClients();
     const clients = clientFilter ? allClients.filter((c) => c.type === clientFilter) : allClients;
     if (clientFilter && clients.length === 0) {
-      console.error(pc10.red(`  Error: Unknown client '${clientFilter}'.`));
+      console.error(pc15.red(`  Error: Unknown client '${clientFilter}'.`));
       process.exit(1);
     }
     let registered;
     try {
       registered = await registerLinkedServer(linkResult, clients, void 0, nameOverride);
     } catch (err) {
-      console.error(pc10.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+      console.error(pc15.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
       process.exit(1);
     }
     if (registered.length === 0) {
-      console.log(pc10.yellow("  Warning: No clients registered. Are any AI clients installed?"));
-      console.log(pc10.dim(`  Server saved to lockfile with source "local".`));
+      console.log(pc15.yellow("  Warning: No clients registered. Are any AI clients installed?"));
+      console.log(pc15.dim(`  Server saved to lockfile with source "local".`));
     } else {
-      console.log(pc10.green(`
-  Linked ${pc10.bold(serverName)} to: ${registered.join(", ")}
+      console.log(pc15.green(`
+  Linked ${pc15.bold(serverName)} to: ${registered.join(", ")}
 `));
-      console.log(pc10.dim(`  Run ${pc10.cyan("mcpman list")} to verify.`));
+      console.log(pc15.dim(`  Run ${pc15.cyan("mcpman list")} to verify.`));
       console.log(
-        pc10.dim(`  Run ${pc10.cyan(`mcpman watch ${serverName}`)} to start with auto-restart.`)
+        pc15.dim(`  Run ${pc15.cyan(`mcpman watch ${serverName}`)} to start with auto-restart.`)
       );
     }
     console.log();
@@ -2886,14 +3783,14 @@ var link_default = defineCommand11({
 });
 
 // src/commands/list.ts
-import { defineCommand as defineCommand12 } from "citty";
-import pc11 from "picocolors";
+import { defineCommand as defineCommand17 } from "citty";
+import pc16 from "picocolors";
 var STATUS_ICON = {
-  healthy: pc11.green("\u25CF"),
-  unhealthy: pc11.red("\u25CF"),
-  unknown: pc11.dim("\u25CB")
+  healthy: pc16.green("\u25CF"),
+  unhealthy: pc16.red("\u25CF"),
+  unknown: pc16.dim("\u25CB")
 };
-var list_default = defineCommand12({
+var list_default = defineCommand17({
   meta: {
     name: "list",
     description: "List installed MCP servers"
@@ -2914,8 +3811,8 @@ var list_default = defineCommand12({
     if (servers.length === 0) {
       const filter = args.client ? ` for client "${args.client}"` : "";
       console.log(
-        pc11.dim(
-          `No MCP servers installed${filter}. Run ${pc11.cyan("mcpman install <server>")} to get started.`
+        pc16.dim(
+          `No MCP servers installed${filter}. Run ${pc16.cyan("mcpman install <server>")} to get started.`
         )
       );
       return;
@@ -2941,9 +3838,9 @@ var list_default = defineCommand12({
     const nameWidth = Math.max(4, ...withStatus.map((s) => s.name.length));
     const clientsWidth = Math.max(7, ...withStatus.map((s) => formatClients(s.clients).length));
     const header = `  ${pad("NAME", nameWidth)}  ${pad("CLIENT(S)", clientsWidth)}  ${pad("COMMAND", 20)}  STATUS`;
-    console.log(pc11.dim(header));
+    console.log(pc16.dim(header));
     console.log(
-      pc11.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientsWidth)}  ${"-".repeat(20)}  ------`)
+      pc16.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientsWidth)}  ${"-".repeat(20)}  ------`)
     );
     for (const s of withStatus) {
       const icon = STATUS_ICON[s.status];
@@ -2958,7 +3855,7 @@ var list_default = defineCommand12({
     }
     const clientSet = new Set(withStatus.flatMap((s) => s.clients));
     console.log(
-      pc11.dim(
+      pc16.dim(
         `
   ${withStatus.length} server${withStatus.length !== 1 ? "s" : ""} \xB7 ${clientSet.size} client${clientSet.size !== 1 ? "s" : ""}`
       )
@@ -2971,21 +3868,21 @@ function pad(s, width) {
 function truncate(s, max) {
   return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
 }
-var CLIENT_DISPLAY = {
+var CLIENT_DISPLAY2 = {
   "claude-desktop": "Claude",
   cursor: "Cursor",
   vscode: "VS Code",
   windsurf: "Windsurf"
 };
 function formatClients(clients) {
-  return clients.map((c) => CLIENT_DISPLAY[c] ?? c).join(", ");
+  return clients.map((c) => CLIENT_DISPLAY2[c] ?? c).join(", ");
 }
 
 // src/commands/logs.ts
-import { spawn as spawn2 } from "child_process";
-import { defineCommand as defineCommand13 } from "citty";
-import pc12 from "picocolors";
-var logs_default = defineCommand13({
+import { spawn as spawn4 } from "child_process";
+import { defineCommand as defineCommand18 } from "citty";
+import pc17 from "picocolors";
+var logs_default = defineCommand18({
   meta: {
     name: "logs",
     description: "Stream stdout/stderr from an MCP server"
@@ -3008,7 +3905,7 @@ var logs_default = defineCommand13({
     const lockfile = readLockfile();
     const entry = lockfile.servers[serverName];
     if (!entry) {
-      console.error(pc12.red(`  Error: Server '${serverName}' is not installed.`));
+      console.error(pc17.red(`  Error: Server '${serverName}' is not installed.`));
       process.exit(1);
     }
     const lockfileEnv = parseEnvFlags(entry.envVars);
@@ -3018,24 +3915,24 @@ var logs_default = defineCommand13({
       ...lockfileEnv,
       ...vaultEnv
     };
-    console.log(pc12.dim(`  Streaming logs for ${pc12.cyan(serverName)}... (Ctrl+C to stop)
+    console.log(pc17.dim(`  Streaming logs for ${pc17.cyan(serverName)}... (Ctrl+C to stop)
 `));
-    const child = spawn2(entry.command, entry.args, {
+    const child = spawn4(entry.command, entry.args, {
       env: finalEnv,
       stdio: ["pipe", "pipe", "pipe"]
     });
     child.stdout?.on("data", (chunk) => {
-      process.stdout.write(pc12.dim("[stdout] ") + chunk.toString());
+      process.stdout.write(pc17.dim("[stdout] ") + chunk.toString());
     });
     child.stderr?.on("data", (chunk) => {
-      process.stderr.write(pc12.yellow("[stderr] ") + chunk.toString());
+      process.stderr.write(pc17.yellow("[stderr] ") + chunk.toString());
     });
     child.on("error", (err) => {
-      console.error(pc12.red(`  Failed to start '${serverName}': ${err.message}`));
+      console.error(pc17.red(`  Failed to start '${serverName}': ${err.message}`));
       process.exit(1);
     });
     child.on("close", (code) => {
-      console.log(pc12.dim(`
+      console.log(pc17.dim(`
   Process exited with code ${code ?? 0}`));
       process.exit(code ?? 0);
     });
@@ -3048,22 +3945,315 @@ var logs_default = defineCommand13({
     });
   }
 });
-async function loadVaultSecrets(serverName) {
-  try {
-    const entries = listSecrets(serverName);
-    if (entries.length === 0 || entries[0].keys.length === 0) return {};
-    const password = await getMasterPassword();
-    return getSecretsForServer(serverName, password);
-  } catch {
-    return {};
-  }
-}
+async function loadVaultSecrets(serverName) {
+  try {
+    const entries = listSecrets(serverName);
+    if (entries.length === 0 || entries[0].keys.length === 0) return {};
+    const password = await getMasterPassword();
+    return getSecretsForServer(serverName, password);
+  } catch {
+    return {};
+  }
+}
+
+// src/commands/notify.ts
+import { defineCommand as defineCommand19 } from "citty";
+import pc18 from "picocolors";
+
+// src/core/notify-service.ts
+import { execSync as execSync2 } from "child_process";
+import fs14 from "fs";
+function readHooks(file) {
+  const target = file ?? getNotifyFile();
+  if (!fs14.existsSync(target)) return [];
+  try {
+    const parsed = JSON.parse(fs14.readFileSync(target, "utf-8"));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function writeHooks(hooks, file) {
+  const target = file ?? getNotifyFile();
+  const dir = target.substring(0, target.lastIndexOf("/"));
+  if (dir && !fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
+  }
+  fs14.writeFileSync(target, JSON.stringify(hooks, null, 2), "utf-8");
+}
+function addHook(event, type, target, file) {
+  const hooks = readHooks(file);
+  hooks.push({ event, type, target });
+  writeHooks(hooks, file);
+}
+function removeHook(index, file) {
+  const hooks = readHooks(file);
+  if (index < 0 || index >= hooks.length) {
+    throw new Error(`Hook index ${index} out of range (0\u2013${hooks.length - 1})`);
+  }
+  hooks.splice(index, 1);
+  writeHooks(hooks, file);
+}
+function listHooks(file) {
+  return readHooks(file);
+}
+async function fireEvent(event, payload, file) {
+  const hooks = readHooks(file).filter((h) => h.event === event);
+  if (hooks.length === 0) return;
+  const body = JSON.stringify({ event, ...payload });
+  await Promise.allSettled(
+    hooks.map(async (hook) => {
+      if (hook.type === "webhook") {
+        await fireWebhook(hook.target, body);
+      } else {
+        fireShell(hook.target, event, payload);
+      }
+    })
+  );
+}
+async function fireWebhook(url, body) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body
+  });
+  if (!response.ok) {
+    throw new Error(`Webhook ${url} returned ${response.status}`);
+  }
+}
+function fireShell(command, event, payload) {
+  const env = {
+    ...process.env,
+    MCPMAN_EVENT: event,
+    MCPMAN_PAYLOAD: JSON.stringify(payload)
+  };
+  execSync2(command, { stdio: "inherit", env });
+}
+
+// src/commands/notify.ts
+var VALID_EVENTS = ["install", "remove", "update", "health-fail"];
+var addCmd3 = defineCommand19({
+  meta: { name: "add", description: "Add a webhook or shell hook for an event" },
+  args: {
+    event: {
+      type: "string",
+      description: `Event to hook (${VALID_EVENTS.join(", ")})`,
+      required: true
+    },
+    webhook: {
+      type: "string",
+      description: "Webhook URL (POST JSON payload)"
+    },
+    shell: {
+      type: "string",
+      description: "Shell command to run"
+    }
+  },
+  run({ args }) {
+    const event = args.event;
+    if (!VALID_EVENTS.includes(event)) {
+      console.error(`${pc18.red("\u2717")} Invalid event "${event}". Valid: ${VALID_EVENTS.join(", ")}`);
+      process.exit(1);
+    }
+    if (!args.webhook && !args.shell) {
+      console.error(`${pc18.red("\u2717")} Provide --webhook <url> or --shell <command>`);
+      process.exit(1);
+    }
+    const type = args.webhook ? "webhook" : "shell";
+    const target = args.webhook ?? args.shell;
+    addHook(event, type, target);
+    const hooks = listHooks();
+    const idx = hooks.length - 1;
+    console.log(
+      `${pc18.green("\u2713")} Hook [${pc18.cyan(String(idx))}] added: ${pc18.bold(event)} \u2192 ${pc18.dim(type)}:${target}`
+    );
+  }
+});
+var removeCmd2 = defineCommand19({
+  meta: { name: "remove", description: "Remove a hook by index" },
+  args: {
+    index: { type: "positional", description: "Hook index (from `notify list`)", required: true }
+  },
+  run({ args }) {
+    const idx = Number(args.index);
+    if (Number.isNaN(idx) || idx < 0) {
+      console.error(`${pc18.red("\u2717")} Invalid index "${args.index}".`);
+      process.exit(1);
+    }
+    try {
+      removeHook(idx);
+      console.log(`${pc18.green("\u2713")} Hook [${idx}] removed`);
+    } catch (err) {
+      console.error(`${pc18.red("\u2717")} ${String(err)}`);
+      process.exit(1);
+    }
+  }
+});
+var listCmd4 = defineCommand19({
+  meta: { name: "list", description: "List all configured hooks" },
+  args: {},
+  run() {
+    const hooks = listHooks();
+    if (hooks.length === 0) {
+      console.log(
+        pc18.dim(
+          "\n  No hooks configured. Use `mcpman notify add --event <event> --webhook <url>`.\n"
+        )
+      );
+      return;
+    }
+    console.log(pc18.bold("\n  mcpman notify hooks\n"));
+    console.log(pc18.dim(`  ${"\u2500".repeat(60)}`));
+    hooks.forEach((h, i) => {
+      const typeLabel = h.type === "webhook" ? pc18.blue("webhook") : pc18.magenta("shell");
+      console.log(
+        `  ${pc18.dim(`[${i}]`)}  ${pc18.bold(h.event.padEnd(12))}  ${typeLabel}  ${pc18.dim(h.target)}`
+      );
+    });
+    console.log(pc18.dim(`  ${"\u2500".repeat(60)}
+`));
+  }
+});
+var testCmd = defineCommand19({
+  meta: { name: "test", description: "Fire a test event to all matching hooks" },
+  args: {
+    event: {
+      type: "positional",
+      description: `Event to test (${VALID_EVENTS.join(", ")})`,
+      required: true
+    }
+  },
+  async run({ args }) {
+    const event = args.event;
+    if (!VALID_EVENTS.includes(event)) {
+      console.error(`${pc18.red("\u2717")} Invalid event "${event}". Valid: ${VALID_EVENTS.join(", ")}`);
+      process.exit(1);
+    }
+    const hooks = listHooks().filter((h) => h.event === event);
+    if (hooks.length === 0) {
+      console.log(pc18.dim(`
+  No hooks configured for event "${event}".
+`));
+      return;
+    }
+    console.log(pc18.cyan(`
+  Firing test event: ${pc18.bold(event)} (${hooks.length} hook(s))...
+`));
+    try {
+      await fireEvent(event, { test: true, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      console.log(`${pc18.green("\u2713")} Test event fired
+`);
+    } catch (err) {
+      console.error(`${pc18.red("\u2717")} ${String(err)}`);
+      process.exit(1);
+    }
+  }
+});
+var notify_default = defineCommand19({
+  meta: {
+    name: "notify",
+    description: "Manage event webhooks and shell hooks"
+  },
+  subCommands: {
+    add: addCmd3,
+    remove: removeCmd2,
+    list: listCmd4,
+    test: testCmd
+  }
+});
+
+// src/commands/pin.ts
+import { defineCommand as defineCommand20 } from "citty";
+import pc19 from "picocolors";
+var pin_default = defineCommand20({
+  meta: {
+    name: "pin",
+    description: "Pin a server to a specific version"
+  },
+  args: {
+    server: {
+      type: "positional",
+      description: "Server name to pin/unpin",
+      required: false
+    },
+    version: {
+      type: "positional",
+      description: "Version to pin to (defaults to currently installed version)",
+      required: false
+    },
+    unpin: {
+      type: "boolean",
+      description: "Remove the pin for a server",
+      default: false
+    },
+    list: {
+      type: "boolean",
+      description: "List all pinned servers",
+      default: false
+    }
+  },
+  run({ args }) {
+    if (args.list) {
+      const pins = listPins();
+      if (pins.length === 0) {
+        console.log(pc19.dim("No servers are pinned."));
+        return;
+      }
+      console.log(`
+  ${pc19.bold("Pinned servers")}
+`);
+      for (const { server, version: version2 } of pins) {
+        console.log(`  ${pc19.cyan(pc19.bold(server))}  ${pc19.dim("@")}${pc19.green(version2)}`);
+      }
+      console.log("");
+      return;
+    }
+    if (args.unpin) {
+      if (!args.server) {
+        console.error(`${pc19.red("\u2717")} Specify a server name to unpin.`);
+        process.exit(1);
+      }
+      if (!isPinned(args.server)) {
+        console.log(pc19.dim(`"${args.server}" is not pinned.`));
+        return;
+      }
+      unpinServer(args.server);
+      console.log(`${pc19.green("\u2713")} Unpinned ${pc19.cyan(args.server)}`);
+      return;
+    }
+    if (!args.server) {
+      console.error(`${pc19.red("\u2717")} Specify a server name to pin. Use --list to see pins.`);
+      process.exit(1);
+    }
+    let version = args.version;
+    if (!version) {
+      const lockfile = readLockfile();
+      version = lockfile.servers[args.server]?.version;
+      if (!version) {
+        console.error(
+          `${pc19.red("\u2717")} "${args.server}" not found in lockfile. Specify a version explicitly.`
+        );
+        process.exit(1);
+      }
+    }
+    pinServer(args.server, version);
+    const prev = getPinnedVersion(args.server);
+    if (prev && prev !== version) {
+      console.log(
+        `${pc19.green("\u2713")} Re-pinned ${pc19.cyan(args.server)} ${pc19.dim(prev)} \u2192 ${pc19.green(version)}`
+      );
+    } else {
+      console.log(`${pc19.green("\u2713")} Pinned ${pc19.cyan(args.server)} @ ${pc19.green(version)}`);
+    }
+    console.log(pc19.dim("  Update notifications will be suppressed for this server."));
+  }
+});
 
 // src/commands/plugin.ts
-import { defineCommand as defineCommand14 } from "citty";
+import { defineCommand as defineCommand21 } from "citty";
 import { createSpinner as createSpinner3 } from "nanospinner";
-import pc13 from "picocolors";
-var addCommand = defineCommand14({
+import pc20 from "picocolors";
+var addCommand = defineCommand21({
   meta: { name: "add", description: "Install a plugin package" },
   args: {
     package: {
@@ -3081,23 +4271,23 @@ var addCommand = defineCommand14({
       spinner5.stop();
       if (loaded) {
         console.log(
-          `${pc13.green("\u2713")} Plugin ${pc13.bold(loaded.name)} installed (prefix: ${pc13.cyan(loaded.prefix)})`
+          `${pc20.green("\u2713")} Plugin ${pc20.bold(loaded.name)} installed (prefix: ${pc20.cyan(loaded.prefix)})`
         );
       } else {
         console.log(
-          `${pc13.yellow("\u26A0")} Package ${pc13.bold(pkg)} installed but does not export a valid mcpman plugin.`
+          `${pc20.yellow("\u26A0")} Package ${pc20.bold(pkg)} installed but does not export a valid mcpman plugin.`
         );
       }
     } catch (err) {
       spinner5.stop();
       console.error(
-        `${pc13.red("\u2717")} Failed to install plugin: ${err instanceof Error ? err.message : String(err)}`
+        `${pc20.red("\u2717")} Failed to install plugin: ${err instanceof Error ? err.message : String(err)}`
       );
       process.exit(1);
     }
   }
 });
-var removeCommand = defineCommand14({
+var removeCommand = defineCommand21({
   meta: { name: "remove", description: "Uninstall a plugin package" },
   args: {
     package: {
@@ -3110,46 +4300,46 @@ var removeCommand = defineCommand14({
     const pkg = args.package;
     const installed = listPluginPackages();
     if (!installed.includes(pkg)) {
-      console.log(pc13.dim(`Plugin "${pkg}" is not installed.`));
+      console.log(pc20.dim(`Plugin "${pkg}" is not installed.`));
       return;
     }
     try {
       removePluginPackage(pkg);
-      console.log(`${pc13.green("\u2713")} Plugin ${pc13.bold(pkg)} removed.`);
+      console.log(`${pc20.green("\u2713")} Plugin ${pc20.bold(pkg)} removed.`);
     } catch (err) {
       console.error(
-        `${pc13.red("\u2717")} Failed to remove plugin: ${err instanceof Error ? err.message : String(err)}`
+        `${pc20.red("\u2717")} Failed to remove plugin: ${err instanceof Error ? err.message : String(err)}`
       );
       process.exit(1);
     }
   }
 });
-var listCommand2 = defineCommand14({
+var listCommand2 = defineCommand21({
   meta: { name: "list", description: "List installed plugins" },
   run() {
     const packages = listPluginPackages();
     if (packages.length === 0) {
-      console.log(pc13.dim("No plugins installed. Use `mcpman plugin add <package>`."));
+      console.log(pc20.dim("No plugins installed. Use `mcpman plugin add <package>`."));
       return;
     }
     console.log("");
-    console.log(pc13.bold("Installed plugins:"));
+    console.log(pc20.bold("Installed plugins:"));
     console.log("");
     for (const pkg of packages) {
       const loaded = loadPlugin(pkg);
       if (loaded) {
         console.log(
-          `  ${pc13.green("\u25CF")} ${pc13.bold(loaded.name)}  prefix: ${pc13.cyan(loaded.prefix)}  pkg: ${pc13.dim(pkg)}`
+          `  ${pc20.green("\u25CF")} ${pc20.bold(loaded.name)}  prefix: ${pc20.cyan(loaded.prefix)}  pkg: ${pc20.dim(pkg)}`
         );
       } else {
-        console.log(`  ${pc13.yellow("\u25CF")} ${pc13.dim(pkg)}  ${pc13.yellow("(failed to load)")}`);
+        console.log(`  ${pc20.yellow("\u25CF")} ${pc20.dim(pkg)}  ${pc20.yellow("(failed to load)")}`);
       }
     }
     console.log("");
-    console.log(pc13.dim(`  ${packages.length} plugin${packages.length !== 1 ? "s" : ""} installed`));
+    console.log(pc20.dim(`  ${packages.length} plugin${packages.length !== 1 ? "s" : ""} installed`));
   }
 });
-var plugin_default = defineCommand14({
+var plugin_default = defineCommand21({
   meta: {
     name: "plugin",
     description: "Manage mcpman plugins for custom registries"
@@ -3162,22 +4352,22 @@ var plugin_default = defineCommand14({
 });
 
 // src/commands/profiles.ts
-import { defineCommand as defineCommand15 } from "citty";
-import pc14 from "picocolors";
+import { defineCommand as defineCommand22 } from "citty";
+import pc21 from "picocolors";
 
 // src/core/profile-service.ts
-import fs10 from "fs";
-import path12 from "path";
+import fs15 from "fs";
+import path13 from "path";
 function ensureDir(dir = getProfilesDir()) {
-  fs10.mkdirSync(dir, { recursive: true });
+  fs15.mkdirSync(dir, { recursive: true });
 }
 function profilePath(name, dir = getProfilesDir()) {
-  return path12.join(dir, `${name}.json`);
+  return path13.join(dir, `${name}.json`);
 }
 function createProfile(name, description = "", dir = getProfilesDir()) {
   ensureDir(dir);
   const filePath = profilePath(name, dir);
-  if (fs10.existsSync(filePath)) {
+  if (fs15.existsSync(filePath)) {
     throw new Error(`Profile '${name}' already exists. Delete it first or use a different name.`);
   }
   const lockfile = readLockfile();
@@ -3187,16 +4377,16 @@ function createProfile(name, description = "", dir = getProfilesDir()) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     servers: lockfile.servers
   };
-  fs10.writeFileSync(filePath, JSON.stringify(profile, null, 2), "utf-8");
+  fs15.writeFileSync(filePath, JSON.stringify(profile, null, 2), "utf-8");
   return profile;
 }
 function listProfiles(dir = getProfilesDir()) {
   ensureDir(dir);
-  const files = fs10.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const files = fs15.readdirSync(dir).filter((f) => f.endsWith(".json"));
   const profiles = [];
   for (const file of files) {
     try {
-      const raw = fs10.readFileSync(path12.join(dir, file), "utf-8");
+      const raw = fs15.readFileSync(path13.join(dir, file), "utf-8");
       const data = JSON.parse(raw);
       profiles.push(data);
     } catch {
@@ -3206,9 +4396,9 @@ function listProfiles(dir = getProfilesDir()) {
 }
 function loadProfile(name, dir = getProfilesDir()) {
   const filePath = profilePath(name, dir);
-  if (!fs10.existsSync(filePath)) return null;
+  if (!fs15.existsSync(filePath)) return null;
   try {
-    const raw = fs10.readFileSync(filePath, "utf-8");
+    const raw = fs15.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3216,13 +4406,13 @@ function loadProfile(name, dir = getProfilesDir()) {
 }
 function deleteProfile(name, dir = getProfilesDir()) {
   const filePath = profilePath(name, dir);
-  if (!fs10.existsSync(filePath)) return false;
-  fs10.unlinkSync(filePath);
+  if (!fs15.existsSync(filePath)) return false;
+  fs15.unlinkSync(filePath);
   return true;
 }
 
 // src/commands/profiles.ts
-var profiles_default = defineCommand15({
+var profiles_default = defineCommand22({
   meta: {
     name: "profiles",
     description: "Manage named server configuration profiles"
@@ -3251,16 +4441,16 @@ var profiles_default = defineCommand15({
       case "create": {
         if (!name) {
           console.error(
-            pc14.red("  Error: Profile name required. Usage: mcpman profiles create <name>")
+            pc21.red("  Error: Profile name required. Usage: mcpman profiles create <name>")
           );
           process.exit(1);
         }
         try {
           const profile = createProfile(name, args.description ?? "");
           const count = Object.keys(profile.servers).length;
-          console.log(pc14.green(`  \u2713 Profile '${name}' created with ${count} server(s).`));
+          console.log(pc21.green(`  \u2713 Profile '${name}' created with ${count} server(s).`));
         } catch (err) {
-          console.error(pc14.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+          console.error(pc21.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
           process.exit(1);
         }
         break;
@@ -3268,38 +4458,38 @@ var profiles_default = defineCommand15({
       case "switch": {
         if (!name) {
           console.error(
-            pc14.red("  Error: Profile name required. Usage: mcpman profiles switch <name>")
+            pc21.red("  Error: Profile name required. Usage: mcpman profiles switch <name>")
           );
           process.exit(1);
         }
         const profile = loadProfile(name);
         if (!profile) {
-          console.error(pc14.red(`  Error: Profile '${name}' not found.`));
+          console.error(pc21.red(`  Error: Profile '${name}' not found.`));
           process.exit(1);
         }
         const lockData = { lockfileVersion: 1, servers: profile.servers };
         writeLockfile(lockData);
         const count = Object.keys(profile.servers).length;
-        console.log(pc14.green(`  \u2713 Switched to profile '${name}' (${count} servers).`));
-        console.log(pc14.dim("  Run mcpman sync to apply to all clients."));
+        console.log(pc21.green(`  \u2713 Switched to profile '${name}' (${count} servers).`));
+        console.log(pc21.dim("  Run mcpman sync to apply to all clients."));
         break;
       }
       case "list": {
         const profiles = listProfiles();
         if (profiles.length === 0) {
           console.log(
-            pc14.dim("  No profiles saved. Create one with: mcpman profiles create <name>")
+            pc21.dim("  No profiles saved. Create one with: mcpman profiles create <name>")
           );
           return;
         }
-        console.log(pc14.bold(`
+        console.log(pc21.bold(`
   Profiles (${profiles.length})
 `));
-        for (const p12 of profiles) {
-          const count = Object.keys(p12.servers).length;
-          const desc = p12.description ? pc14.dim(` \u2014 ${p12.description}`) : "";
+        for (const p13 of profiles) {
+          const count = Object.keys(p13.servers).length;
+          const desc = p13.description ? pc21.dim(` \u2014 ${p13.description}`) : "";
           console.log(
-            `  ${pc14.cyan("\u25CF")} ${pc14.bold(p12.name)}  ${pc14.dim(`${count} server(s)`)}${desc}`
+            `  ${pc21.cyan("\u25CF")} ${pc21.bold(p13.name)}  ${pc21.dim(`${count} server(s)`)}${desc}`
           );
         }
         console.log();
@@ -3308,22 +4498,22 @@ var profiles_default = defineCommand15({
       case "delete": {
         if (!name) {
           console.error(
-            pc14.red("  Error: Profile name required. Usage: mcpman profiles delete <name>")
+            pc21.red("  Error: Profile name required. Usage: mcpman profiles delete <name>")
           );
           process.exit(1);
         }
         const deleted = deleteProfile(name);
         if (deleted) {
-          console.log(pc14.green(`  \u2713 Profile '${name}' deleted.`));
+          console.log(pc21.green(`  \u2713 Profile '${name}' deleted.`));
         } else {
-          console.error(pc14.red(`  Error: Profile '${name}' not found.`));
+          console.error(pc21.red(`  Error: Profile '${name}' not found.`));
           process.exit(1);
         }
         break;
       }
       default:
         console.error(
-          pc14.red(`  Unknown action '${action}'. Use: create, switch, list, or delete.`)
+          pc21.red(`  Unknown action '${action}'. Use: create, switch, list, or delete.`)
         );
         process.exit(1);
     }
@@ -3331,8 +4521,8 @@ var profiles_default = defineCommand15({
 });
 
 // src/commands/registry.ts
-import { defineCommand as defineCommand16 } from "citty";
-import pc15 from "picocolors";
+import { defineCommand as defineCommand23 } from "citty";
+import pc22 from "picocolors";
 
 // src/core/registry-manager.ts
 var BUILTIN_REGISTRIES = [
@@ -3402,7 +4592,7 @@ function getDefaultRegistry(configPath) {
 }
 
 // src/commands/registry.ts
-var registry_default = defineCommand16({
+var registry_default = defineCommand23({
   meta: {
     name: "registry",
     description: "Manage custom registry URLs"
@@ -3432,67 +4622,67 @@ var registry_default = defineCommand16({
       case "list": {
         const registries = getRegistries();
         const defaultName = getDefaultRegistry();
-        console.log(pc15.bold("\n  Registries\n"));
+        console.log(pc22.bold("\n  Registries\n"));
         for (const r of registries) {
           const isDefault = r.name === defaultName;
-          const defaultTag = isDefault ? pc15.green(" (default)") : "";
-          const builtinTag = r.builtin ? pc15.dim(" [builtin]") : "";
+          const defaultTag = isDefault ? pc22.green(" (default)") : "";
+          const builtinTag = r.builtin ? pc22.dim(" [builtin]") : "";
           console.log(
-            `  ${isDefault ? pc15.green("\u25CF") : pc15.dim("\u25CB")} ${pc15.bold(r.name)}${defaultTag}${builtinTag}`
+            `  ${isDefault ? pc22.green("\u25CF") : pc22.dim("\u25CB")} ${pc22.bold(r.name)}${defaultTag}${builtinTag}`
           );
-          console.log(`    ${pc15.dim(r.url)}`);
+          console.log(`    ${pc22.dim(r.url)}`);
         }
         console.log();
         break;
       }
       case "add": {
         if (!name) {
-          console.error(pc15.red("  Error: Usage: mcpman registry add <name> <url>"));
+          console.error(pc22.red("  Error: Usage: mcpman registry add <name> <url>"));
           process.exit(1);
         }
         if (!url) {
-          console.error(pc15.red("  Error: Usage: mcpman registry add <name> <url>"));
+          console.error(pc22.red("  Error: Usage: mcpman registry add <name> <url>"));
           process.exit(1);
         }
         try {
           addRegistry(name, url);
-          console.log(pc15.green(`  Added registry '${name}' \u2192 ${url}`));
+          console.log(pc22.green(`  Added registry '${name}' \u2192 ${url}`));
         } catch (err) {
-          console.error(pc15.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+          console.error(pc22.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
           process.exit(1);
         }
         break;
       }
       case "remove": {
         if (!name) {
-          console.error(pc15.red("  Error: Usage: mcpman registry remove <name>"));
+          console.error(pc22.red("  Error: Usage: mcpman registry remove <name>"));
           process.exit(1);
         }
         try {
           removeRegistry(name);
-          console.log(pc15.green(`  Removed registry '${name}'.`));
+          console.log(pc22.green(`  Removed registry '${name}'.`));
         } catch (err) {
-          console.error(pc15.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+          console.error(pc22.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
           process.exit(1);
         }
         break;
       }
       case "set-default": {
         if (!name) {
-          console.error(pc15.red("  Error: Usage: mcpman registry set-default <name>"));
+          console.error(pc22.red("  Error: Usage: mcpman registry set-default <name>"));
           process.exit(1);
         }
         try {
           setDefaultRegistry(name);
-          console.log(pc15.green(`  Default registry set to '${name}'.`));
+          console.log(pc22.green(`  Default registry set to '${name}'.`));
         } catch (err) {
-          console.error(pc15.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+          console.error(pc22.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
           process.exit(1);
         }
         break;
       }
       default:
-        console.error(pc15.red(`  Unknown action '${action}'. Use: list, add, remove, set-default.`));
+        console.error(pc22.red(`  Unknown action '${action}'. Use: list, add, remove, set-default.`));
         process.exit(1);
     }
   }
@@ -3500,18 +4690,18 @@ var registry_default = defineCommand16({
 
 // src/commands/remove.ts
 import * as p8 from "@clack/prompts";
-import { defineCommand as defineCommand17 } from "citty";
-import pc16 from "picocolors";
-var CLIENT_DISPLAY2 = {
+import { defineCommand as defineCommand24 } from "citty";
+import pc23 from "picocolors";
+var CLIENT_DISPLAY3 = {
   "claude-desktop": "Claude",
   cursor: "Cursor",
   vscode: "VS Code",
   windsurf: "Windsurf"
 };
 function clientDisplayName(type) {
-  return CLIENT_DISPLAY2[type] ?? type;
+  return CLIENT_DISPLAY3[type] ?? type;
 }
-var remove_default = defineCommand17({
+var remove_default = defineCommand24({
   meta: {
     name: "remove",
     description: "Remove an MCP server from one or more AI clients"
@@ -3538,7 +4728,7 @@ var remove_default = defineCommand17({
     }
   },
   async run({ args }) {
-    p8.intro(pc16.bold("mcpman remove"));
+    p8.intro(pc23.bold("mcpman remove"));
     const serverName = args.server;
     const servers = await getInstalledServers();
     const match = servers.find((s) => s.name === serverName);
@@ -3548,7 +4738,7 @@ var remove_default = defineCommand17({
         (s) => s.name.includes(serverName) || serverName.includes(s.name)
       );
       if (similar.length > 0) {
-        p8.log.info(`Did you mean: ${similar.map((s) => pc16.cyan(s.name)).join(", ")}?`);
+        p8.log.info(`Did you mean: ${similar.map((s) => pc23.cyan(s.name)).join(", ")}?`);
       }
       p8.outro("Nothing to remove.");
       return;
@@ -3583,7 +4773,7 @@ var remove_default = defineCommand17({
     if (!args.yes) {
       const clientNames = targetClients.map(clientDisplayName).join(", ");
       const confirmed = await p8.confirm({
-        message: `Remove ${pc16.cyan(serverName)} from ${pc16.yellow(clientNames)}?`
+        message: `Remove ${pc23.cyan(serverName)} from ${pc23.yellow(clientNames)}?`
       });
       if (p8.isCancel(confirmed) || !confirmed) {
         p8.outro("Cancelled.");
@@ -3608,18 +4798,222 @@ var remove_default = defineCommand17({
     }
     if (errors.length > 0) {
       for (const e of errors) p8.log.error(e);
-      p8.outro(pc16.red("Completed with errors."));
+      p8.outro(pc23.red("Completed with errors."));
+      process.exit(1);
+    }
+    p8.outro(pc23.green(`Removed "${serverName}" successfully.`));
+  }
+});
+
+// src/commands/replay.ts
+import { defineCommand as defineCommand25 } from "citty";
+import pc24 from "picocolors";
+
+// src/core/history-service.ts
+import { execSync as execSync3 } from "child_process";
+import fs16 from "fs";
+function readHistory(file) {
+  const target = file ?? getHistoryFile();
+  if (!fs16.existsSync(target)) return [];
+  try {
+    const parsed = JSON.parse(fs16.readFileSync(target, "utf-8"));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function getHistory(file) {
+  return readHistory(file);
+}
+function replayCommand(index, file) {
+  const history = readHistory(file);
+  if (history.length === 0) {
+    throw new Error("History is empty");
+  }
+  const reversed = [...history].reverse();
+  if (index < 0 || index >= reversed.length) {
+    throw new Error(`Index ${index} out of range (0\u2013${reversed.length - 1})`);
+  }
+  const entry = reversed[index];
+  const fullCommand = ["mcpman", entry.command, ...entry.args].filter(Boolean).join(" ");
+  execSync3(fullCommand, { stdio: "inherit" });
+}
+
+// src/commands/replay.ts
+var replay_default = defineCommand25({
+  meta: {
+    name: "replay",
+    description: "Replay a previous mcpman command from history"
+  },
+  args: {
+    index: {
+      type: "positional",
+      description: "History index to replay (0 = most recent)",
+      required: false
+    },
+    list: {
+      type: "boolean",
+      description: "Show last 20 history entries",
+      default: false
+    }
+  },
+  run({ args }) {
+    const history = getHistory();
+    if (args.list || args.index === void 0) {
+      if (history.length === 0) {
+        console.log(pc24.dim("\n  No command history found.\n"));
+        return;
+      }
+      const reversed2 = [...history].reverse().slice(0, 20);
+      console.log(pc24.bold("\n  mcpman history\n"));
+      console.log(pc24.dim(`  ${"\u2500".repeat(50)}`));
+      reversed2.forEach((entry2, i) => {
+        const cmdParts2 = [entry2.command, ...entry2.args].filter(Boolean).join(" ");
+        const ts = new Date(entry2.timestamp).toLocaleString();
+        console.log(`  ${pc24.cyan(String(i).padStart(2))}  ${pc24.bold(cmdParts2)}  ${pc24.dim(ts)}`);
+      });
+      console.log(pc24.dim(`  ${"\u2500".repeat(50)}
+`));
+      if (!args.list) {
+        console.log(pc24.dim("  Usage: mcpman replay <index> | mcpman replay --list\n"));
+      }
+      return;
+    }
+    const idx = Number(args.index);
+    if (Number.isNaN(idx) || idx < 0) {
+      console.error(pc24.red(`
+  Invalid index "${args.index}". Must be a non-negative number.
+`));
+      process.exit(1);
+    }
+    const reversed = [...history].reverse();
+    if (idx >= reversed.length) {
+      console.error(
+        pc24.red(`
+  Index ${idx} out of range. History has ${reversed.length} entries.
+`)
+      );
+      process.exit(1);
+    }
+    const entry = reversed[idx];
+    const cmdParts = [entry.command, ...entry.args].filter(Boolean).join(" ");
+    console.log(pc24.cyan(`
+  Replaying: mcpman ${cmdParts}
+`));
+    try {
+      replayCommand(idx);
+    } catch (err) {
+      console.error(pc24.red(`  ${String(err)}`));
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/rollback.ts
+import * as p9 from "@clack/prompts";
+import { defineCommand as defineCommand26 } from "citty";
+import pc25 from "picocolors";
+var rollback_default = defineCommand26({
+  meta: {
+    name: "rollback",
+    description: "Restore a previous lockfile snapshot"
+  },
+  args: {
+    index: {
+      type: "positional",
+      description: "Snapshot index to restore (0 = most recent). Omit to use --list.",
+      required: false
+    },
+    list: {
+      type: "boolean",
+      description: "List available snapshots",
+      default: false
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip confirmation prompt",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const snapshots = listSnapshots();
+    if (args.list || args.index === void 0) {
+      if (snapshots.length === 0) {
+        console.log(
+          pc25.dim("No snapshots available. Snapshots are created on each lockfile write.")
+        );
+        return;
+      }
+      console.log(
+        `
+  ${pc25.bold("Lockfile snapshots")}  ${pc25.dim(`(${snapshots.length} available, 0 = most recent)`)}
+`
+      );
+      for (const snap2 of snapshots) {
+        const size = `${Math.ceil(snap2.sizeBytes / 1024)}KB`;
+        const date2 = snap2.createdAt ? new Date(snap2.createdAt).toLocaleString() : "unknown";
+        console.log(`  ${pc25.cyan(`[${snap2.index}]`)}  ${pc25.dim(date2)}  ${pc25.dim(size)}`);
+      }
+      console.log("");
+      if (args.index === void 0) return;
+    }
+    const idx = Number.parseInt(String(args.index), 10);
+    if (Number.isNaN(idx) || idx < 0) {
+      console.error(
+        `${pc25.red("\u2717")} Invalid index "${args.index}". Must be a non-negative integer.`
+      );
+      process.exit(1);
+    }
+    const snap = snapshots[idx];
+    if (!snap) {
+      console.error(
+        `${pc25.red("\u2717")} Snapshot [${idx}] does not exist. Use --list to see available snapshots.`
+      );
+      process.exit(1);
+    }
+    const content = readSnapshot(idx);
+    if (!content) {
+      console.error(`${pc25.red("\u2717")} Could not read snapshot [${idx}].`);
+      process.exit(1);
+    }
+    const date = snap.createdAt ? new Date(snap.createdAt).toLocaleString() : "unknown";
+    console.log(`
+  ${pc25.bold("Restoring snapshot")} ${pc25.cyan(`[${idx}]`)}  ${pc25.dim(date)}
+`);
+    try {
+      const parsed = JSON.parse(content);
+      const count = Object.keys(parsed.servers ?? {}).length;
+      console.log(`  ${pc25.dim(`Preview: ${count} server(s) in snapshot`)}
+`);
+    } catch {
+    }
+    const lockfilePath = resolveLockfilePath();
+    if (!args.yes) {
+      const confirmed = await p9.confirm({
+        message: `Restore snapshot [${idx}] to ${lockfilePath}?`,
+        initialValue: false
+      });
+      if (p9.isCancel(confirmed) || !confirmed) {
+        p9.cancel("Cancelled.");
+        return;
+      }
+    }
+    const restored = restoreSnapshot(idx, lockfilePath);
+    if (!restored) {
+      console.error(`${pc25.red("\u2717")} Restore failed.`);
       process.exit(1);
     }
-    p8.outro(pc16.green(`Removed "${serverName}" successfully.`));
+    console.log(`
+${pc25.green("\u2713")} Lockfile restored from snapshot [${idx}].`);
+    console.log(pc25.dim(`  Written to: ${lockfilePath}`));
   }
 });
 
 // src/commands/run.ts
-import { spawn as spawn3 } from "child_process";
-import { defineCommand as defineCommand18 } from "citty";
-import pc17 from "picocolors";
-var run_default = defineCommand18({
+import { spawn as spawn5 } from "child_process";
+import { defineCommand as defineCommand27 } from "citty";
+import pc26 from "picocolors";
+var run_default = defineCommand27({
   meta: {
     name: "run",
     description: "Run an installed MCP server with vault secrets injected"
@@ -3641,8 +5035,8 @@ var run_default = defineCommand18({
     const lockfile = readLockfile();
     const entry = lockfile.servers[serverName];
     if (!entry) {
-      console.error(pc17.red(`  Error: Server '${serverName}' is not installed.`));
-      console.error(pc17.dim(`  Run ${pc17.cyan("mcpman install <server>")} to install it first.`));
+      console.error(pc26.red(`  Error: Server '${serverName}' is not installed.`));
+      console.error(pc26.dim(`  Run ${pc26.cyan("mcpman install <server>")} to install it first.`));
       process.exit(1);
     }
     const lockfileEnv = parseEnvFlags(entry.envVars);
@@ -3654,8 +5048,8 @@ var run_default = defineCommand18({
       ...vaultEnv,
       ...cliEnv
     };
-    console.log(pc17.dim(`  Running ${pc17.cyan(serverName)}...`));
-    const child = spawn3(entry.command, entry.args, {
+    console.log(pc26.dim(`  Running ${pc26.cyan(serverName)}...`));
+    const child = spawn5(entry.command, entry.args, {
       env: finalEnv,
       stdio: "inherit"
     });
@@ -3672,7 +5066,7 @@ var run_default = defineCommand18({
         resolve();
       });
       child.on("error", (err) => {
-        console.error(pc17.red(`  Failed to start '${serverName}': ${err.message}`));
+        console.error(pc26.red(`  Failed to start '${serverName}': ${err.message}`));
         process.exit(1);
         resolve();
       });
@@ -3688,15 +5082,15 @@ async function loadVaultSecrets2(serverName) {
     const password = await getMasterPassword();
     return getSecretsForServer(serverName, password);
   } catch {
-    console.warn(pc17.yellow("  Warning: Could not load vault secrets, continuing without them."));
+    console.warn(pc26.yellow("  Warning: Could not load vault secrets, continuing without them."));
     return {};
   }
 }
 
 // src/commands/search.ts
-import { defineCommand as defineCommand19 } from "citty";
+import { defineCommand as defineCommand28 } from "citty";
 import { createSpinner as createSpinner4 } from "nanospinner";
-import pc18 from "picocolors";
+import pc27 from "picocolors";
 
 // src/core/registry-search.ts
 var SEARCH_TIMEOUT_MS = 1e4;
@@ -3769,10 +5163,10 @@ function pad2(s, width) {
 function highlightMatch(name, query) {
   const idx = name.toLowerCase().indexOf(query.toLowerCase());
   if (idx === -1) return name;
-  return name.slice(0, idx) + pc18.yellow(name.slice(idx, idx + query.length)) + name.slice(idx + query.length);
+  return name.slice(0, idx) + pc27.yellow(name.slice(idx, idx + query.length)) + name.slice(idx + query.length);
 }
 function formatDownloads(n) {
-  if (!n) return pc18.dim("\u2014");
+  if (!n) return pc27.dim("\u2014");
   if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
   if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
   return String(n);
@@ -3783,9 +5177,9 @@ function printNpmResults(results, query) {
   const dlWidth = 9;
   const descMax = 50;
   const header = `  ${pad2("NAME", nameWidth)}  ${pad2("VERSION", verWidth)}  ${pad2("DOWNLOADS", dlWidth)}  DESCRIPTION`;
-  console.log(pc18.dim(header));
+  console.log(pc27.dim(header));
   console.log(
-    pc18.dim(
+    pc27.dim(
       `  ${"-".repeat(nameWidth)}  ${"-".repeat(verWidth)}  ${"-".repeat(dlWidth)}  ${"-".repeat(descMax)}`
     )
   );
@@ -3793,8 +5187,8 @@ function printNpmResults(results, query) {
     const name = highlightMatch(pad2(r.name, nameWidth), query);
     const ver = pad2(r.version, verWidth);
     const dl = pad2(formatDownloads(r.downloads), dlWidth);
-    const desc = truncate2(r.description || pc18.dim("(no description)"), descMax);
-    console.log(`  ${name}  ${pc18.dim(ver)}  ${dl}  ${desc}`);
+    const desc = truncate2(r.description || pc27.dim("(no description)"), descMax);
+    console.log(`  ${name}  ${pc27.dim(ver)}  ${dl}  ${desc}`);
   }
 }
 function printSmitheryResults(results, query) {
@@ -3802,19 +5196,19 @@ function printSmitheryResults(results, query) {
   const usesWidth = 8;
   const descMax = 50;
   const header = `  ${pad2("NAME", nameWidth)}  ${pad2("USES", usesWidth)}  DESCRIPTION`;
-  console.log(pc18.dim(header));
+  console.log(pc27.dim(header));
   console.log(
-    pc18.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(usesWidth)}  ${"-".repeat(descMax)}`)
+    pc27.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(usesWidth)}  ${"-".repeat(descMax)}`)
   );
   for (const r of results) {
     const name = highlightMatch(pad2(r.name, nameWidth), query);
     const uses = pad2(formatDownloads(r.useCount), usesWidth);
-    const badge = r.verified ? pc18.green(" \u2713") : "";
-    const desc = truncate2(r.description || pc18.dim("(no description)"), descMax);
+    const badge = r.verified ? pc27.green(" \u2713") : "";
+    const desc = truncate2(r.description || pc27.dim("(no description)"), descMax);
     console.log(`  ${name}${badge}  ${uses}  ${desc}`);
   }
 }
-var search_default = defineCommand19({
+var search_default = defineCommand28({
   meta: {
     name: "search",
     description: "Search for MCP servers on npm or Smithery registry"
@@ -3846,7 +5240,7 @@ var search_default = defineCommand19({
     const registry = args.registry.toLowerCase();
     const limit = Math.min(Math.max(1, Number.parseInt(args.limit, 10) || 20), 100);
     if (registry !== "npm" && registry !== "smithery") {
-      console.error(pc18.red(`  Unknown registry "${registry}". Use "npm" or "smithery".`));
+      console.error(pc27.red(`  Unknown registry "${registry}". Use "npm" or "smithery".`));
       process.exit(1);
     }
     const spinner5 = createSpinner4(`Searching ${registry} for "${query}"...`).start();
@@ -3854,20 +5248,20 @@ var search_default = defineCommand19({
       const results2 = await searchNpm(query, limit);
       spinner5.stop();
       if (results2.length === 0) {
-        console.log(pc18.dim(`
+        console.log(pc27.dim(`
   No results found for "${query}" on npm.
 `));
         return;
       }
       console.log(
-        pc18.bold(
+        pc27.bold(
           `
   mcpman search \u2014 npm (${results2.length} result${results2.length !== 1 ? "s" : ""})
 `
         )
       );
       printNpmResults(results2, query);
-      console.log(pc18.dim("\n  Install with: mcpman install <name>\n"));
+      console.log(pc27.dim("\n  Install with: mcpman install <name>\n"));
       if (args.all) {
         await printPluginResults(query, limit);
       }
@@ -3876,20 +5270,20 @@ var search_default = defineCommand19({
     const results = await searchSmithery(query, limit);
     spinner5.stop();
     if (results.length === 0) {
-      console.log(pc18.dim(`
+      console.log(pc27.dim(`
   No results found for "${query}" on Smithery.
 `));
       return;
     }
     console.log(
-      pc18.bold(
+      pc27.bold(
         `
   mcpman search \u2014 Smithery (${results.length} result${results.length !== 1 ? "s" : ""})
 `
       )
     );
     printSmitheryResults(results, query);
-    console.log(pc18.dim("\n  Install with: mcpman install <name>\n"));
+    console.log(pc27.dim("\n  Install with: mcpman install <name>\n"));
     if (args.all) {
       await printPluginResults(query, limit);
     }
@@ -3899,7 +5293,7 @@ async function printPluginResults(query, limit) {
   const pluginResults = await searchPlugins(query, limit);
   if (pluginResults.length === 0) return;
   console.log(
-    pc18.bold(
+    pc27.bold(
       `
   Plugins (${pluginResults.length} result${pluginResults.length !== 1 ? "s" : ""})
 `
@@ -3909,22 +5303,22 @@ async function printPluginResults(query, limit) {
   const srcWidth = Math.max(6, ...pluginResults.map((r) => r.source.length));
   const descMax = 50;
   const header = `  ${pad2("NAME", nameWidth)}  ${pad2("SOURCE", srcWidth)}  DESCRIPTION`;
-  console.log(pc18.dim(header));
+  console.log(pc27.dim(header));
   console.log(
-    pc18.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(srcWidth)}  ${"-".repeat(descMax)}`)
+    pc27.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(srcWidth)}  ${"-".repeat(descMax)}`)
   );
   for (const r of pluginResults) {
     const name = highlightMatch(pad2(r.name, nameWidth), query);
     const src = pad2(r.source, srcWidth);
-    const desc = truncate2(r.description || pc18.dim("(no description)"), descMax);
-    console.log(`  ${name}  ${pc18.dim(src)}  ${desc}`);
+    const desc = truncate2(r.description || pc27.dim("(no description)"), descMax);
+    console.log(`  ${name}  ${pc27.dim(src)}  ${desc}`);
   }
 }
 
 // src/commands/secrets.ts
-import * as p9 from "@clack/prompts";
-import { defineCommand as defineCommand20 } from "citty";
-import pc19 from "picocolors";
+import * as p10 from "@clack/prompts";
+import { defineCommand as defineCommand29 } from "citty";
+import pc28 from "picocolors";
 function maskValue(value) {
   if (value.length <= 8) return "***";
   return `${value.slice(0, 4)}***${value.slice(-3)}`;
@@ -3934,7 +5328,7 @@ function parseKeyValue(input) {
   if (idx <= 0) return null;
   return { key: input.slice(0, idx), value: input.slice(idx + 1) };
 }
-var setCommand2 = defineCommand20({
+var setCommand2 = defineCommand29({
   meta: { name: "set", description: "Store an encrypted secret for a server" },
   args: {
     server: {
@@ -3951,28 +5345,28 @@ var setCommand2 = defineCommand20({
   async run({ args }) {
     const parsed = parseKeyValue(args.keyvalue);
     if (!parsed) {
-      console.error(`${pc19.red("\u2717")} Invalid format. Expected KEY=VALUE`);
+      console.error(`${pc28.red("\u2717")} Invalid format. Expected KEY=VALUE`);
       process.exit(1);
     }
-    p9.intro(pc19.cyan("mcpman secrets set"));
+    p10.intro(pc28.cyan("mcpman secrets set"));
     const isNew = listSecrets(args.server).length === 0 || !listSecrets(args.server)[0]?.keys.includes(parsed.key);
     const vaultPath = (await import("./vault-service-UTZAV6N6.js")).getVaultPath();
     const vaultExists = (await import("fs")).existsSync(vaultPath);
     const password = await getMasterPassword(!vaultExists && isNew);
-    const spin = p9.spinner();
+    const spin = p10.spinner();
     spin.start("Encrypting secret...");
     try {
       setSecret(args.server, parsed.key, parsed.value, password);
-      spin.stop(`${pc19.green("\u2713")} Stored ${pc19.bold(parsed.key)} for ${pc19.cyan(args.server)}`);
+      spin.stop(`${pc28.green("\u2713")} Stored ${pc28.bold(parsed.key)} for ${pc28.cyan(args.server)}`);
     } catch (err) {
-      spin.stop(`${pc19.red("\u2717")} Failed to store secret`);
-      console.error(pc19.dim(String(err)));
+      spin.stop(`${pc28.red("\u2717")} Failed to store secret`);
+      console.error(pc28.dim(String(err)));
       process.exit(1);
     }
-    p9.outro(pc19.dim("Secret encrypted and saved to vault."));
+    p10.outro(pc28.dim("Secret encrypted and saved to vault."));
   }
 });
-var listCommand3 = defineCommand20({
+var listCommand3 = defineCommand29({
   meta: { name: "list", description: "List secret keys stored in the vault" },
   args: {
     server: {
@@ -3984,75 +5378,270 @@ var listCommand3 = defineCommand20({
   async run({ args }) {
     const results = listSecrets(args.server || void 0);
     if (results.length === 0) {
-      const filter = args.server ? ` for ${pc19.cyan(args.server)}` : "";
-      console.log(pc19.dim(`No secrets stored${filter}.`));
+      const filter = args.server ? ` for ${pc28.cyan(args.server)}` : "";
+      console.log(pc28.dim(`No secrets stored${filter}.`));
       return;
     }
     console.log("");
     for (const { server, keys } of results) {
-      console.log(pc19.bold(pc19.cyan(server)));
+      console.log(pc28.bold(pc28.cyan(server)));
       for (const key of keys) {
-        console.log(`  ${pc19.green("\u25CF")} ${pc19.bold(key)}  ${pc19.dim(maskValue("\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022"))}`);
+        console.log(`  ${pc28.green("\u25CF")} ${pc28.bold(key)}  ${pc28.dim(maskValue("\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022"))}`);
+      }
+      console.log("");
+    }
+    const total = results.reduce((n, r) => n + r.keys.length, 0);
+    console.log(
+      pc28.dim(
+        `  ${total} secret${total !== 1 ? "s" : ""} in ${results.length} server${results.length !== 1 ? "s" : ""}`
+      )
+    );
+  }
+});
+var removeCommand2 = defineCommand29({
+  meta: { name: "remove", description: "Delete a secret from the vault" },
+  args: {
+    server: {
+      type: "positional",
+      description: "Server name",
+      required: true
+    },
+    key: {
+      type: "positional",
+      description: "Secret key to remove",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const confirmed = await p10.confirm({
+      message: `Remove ${pc28.bold(args.key)} from ${pc28.cyan(args.server)}?`,
+      initialValue: false
+    });
+    if (p10.isCancel(confirmed) || !confirmed) {
+      p10.cancel("Cancelled.");
+      return;
+    }
+    try {
+      removeSecret(args.server, args.key);
+      console.log(`${pc28.green("\u2713")} Removed ${pc28.bold(args.key)} from ${pc28.cyan(args.server)}`);
+    } catch (err) {
+      console.error(`${pc28.red("\u2717")} Failed to remove secret`);
+      console.error(pc28.dim(String(err)));
+      process.exit(1);
+    }
+  }
+});
+var secrets_default = defineCommand29({
+  meta: {
+    name: "secrets",
+    description: "Manage encrypted secrets for MCP servers"
+  },
+  subCommands: {
+    set: setCommand2,
+    list: listCommand3,
+    remove: removeCommand2
+  }
+});
+
+// src/commands/status.ts
+import { defineCommand as defineCommand30 } from "citty";
+import { createSpinner as createSpinner5 } from "nanospinner";
+import pc29 from "picocolors";
+
+// src/core/status-checker.ts
+import { execSync as execSync4 } from "child_process";
+import { spawn as spawn6 } from "child_process";
+var MCP_INIT_REQUEST2 = JSON.stringify({
+  jsonrpc: "2.0",
+  id: 1,
+  method: "initialize",
+  params: {
+    protocolVersion: "2024-11-05",
+    capabilities: {},
+    clientInfo: { name: "mcpman-status", version: "0.9.0" }
+  }
+});
+async function probeServer(name, entry, timeoutMs = 3e3) {
+  const start = Date.now();
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = (status) => {
+      if (!settled) {
+        settled = true;
+        resolve(status);
+      }
+    };
+    let child = null;
+    const timer = setTimeout(() => {
+      child?.kill();
+      settle({
+        name,
+        alive: false,
+        responseTimeMs: null,
+        error: "timeout"
+      });
+    }, timeoutMs);
+    try {
+      child = spawn6(entry.command, entry.args ?? [], {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env }
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      settle({
+        name,
+        alive: false,
+        responseTimeMs: null,
+        error: String(err)
+      });
+      return;
+    }
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+      const lines = stdout.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const parsed = JSON.parse(trimmed);
+          if (parsed.jsonrpc === "2.0" && "result" in parsed) {
+            clearTimeout(timer);
+            child?.kill();
+            settle({
+              name,
+              alive: true,
+              responseTimeMs: Date.now() - start
+            });
+            return;
+          }
+        } catch {
+        }
       }
-      console.log("");
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      settle({
+        name,
+        alive: false,
+        responseTimeMs: null,
+        error: err.message
+      });
+    });
+    child.on("exit", (code) => {
+      if (!settled) {
+        clearTimeout(timer);
+        settle({
+          name,
+          alive: false,
+          responseTimeMs: null,
+          error: `exited with code ${code}`
+        });
+      }
+    });
+    try {
+      child.stdin?.write(`${MCP_INIT_REQUEST2}
+`);
+    } catch {
     }
-    const total = results.reduce((n, r) => n + r.keys.length, 0);
+  });
+}
+async function getServerStatuses(serverName) {
+  const lockfile = readLockfile();
+  const { servers } = lockfile;
+  if (serverName) {
+    const entry = servers[serverName];
+    if (!entry) {
+      return [{ name: serverName, alive: false, responseTimeMs: null, error: "not in lockfile" }];
+    }
+    return [await probeServer(serverName, entry)];
+  }
+  if (Object.keys(servers).length === 0) return [];
+  return Promise.all(Object.entries(servers).map(([name, entry]) => probeServer(name, entry)));
+}
+
+// src/commands/status.ts
+function pad3(s, width) {
+  return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+function formatStatus(s) {
+  return s.alive ? pc29.green("alive") : pc29.red("dead");
+}
+function formatResponseTime(s) {
+  if (!s.alive || s.responseTimeMs === null) return pc29.dim("\u2014");
+  return pc29.cyan(`${s.responseTimeMs}ms`);
+}
+function printTable(statuses) {
+  const nameW = Math.max(6, ...statuses.map((s) => s.name.length));
+  const header = `  ${pad3("SERVER", nameW)}  ${pad3("STATUS", 7)}  ${pad3("RESPONSE", 10)}  ERROR`;
+  console.log(pc29.dim(header));
+  console.log(
+    pc29.dim(`  ${"\u2500".repeat(nameW)}  ${"\u2500".repeat(7)}  ${"\u2500".repeat(10)}  ${"\u2500".repeat(20)}`)
+  );
+  for (const s of statuses) {
+    const errStr = s.error ? pc29.dim(s.error) : "";
     console.log(
-      pc19.dim(
-        `  ${total} secret${total !== 1 ? "s" : ""} in ${results.length} server${results.length !== 1 ? "s" : ""}`
-      )
+      `  ${pad3(s.name, nameW)}  ${pad3(
+        formatStatus(s),
+        7 + 10
+        /* color codes */
+      )}  ${pad3(formatResponseTime(s), 10 + 10)}  ${errStr}`
     );
   }
-});
-var removeCommand2 = defineCommand20({
-  meta: { name: "remove", description: "Delete a secret from the vault" },
+}
+var status_default = defineCommand30({
+  meta: {
+    name: "status",
+    description: "Show live process status for installed MCP servers"
+  },
   args: {
     server: {
-      type: "positional",
-      description: "Server name",
-      required: true
+      type: "string",
+      description: "Check a specific server by name"
     },
-    key: {
-      type: "positional",
-      description: "Secret key to remove",
-      required: true
+    json: {
+      type: "boolean",
+      description: "Output results as JSON",
+      default: false
     }
   },
   async run({ args }) {
-    const confirmed = await p9.confirm({
-      message: `Remove ${pc19.bold(args.key)} from ${pc19.cyan(args.server)}?`,
-      initialValue: false
-    });
-    if (p9.isCancel(confirmed) || !confirmed) {
-      p9.cancel("Cancelled.");
-      return;
-    }
+    const label = args.server ? `Probing ${args.server}...` : "Probing all servers...";
+    const spinner5 = createSpinner5(label).start();
+    let statuses;
     try {
-      removeSecret(args.server, args.key);
-      console.log(`${pc19.green("\u2713")} Removed ${pc19.bold(args.key)} from ${pc19.cyan(args.server)}`);
+      statuses = await getServerStatuses(args.server);
     } catch (err) {
-      console.error(`${pc19.red("\u2717")} Failed to remove secret`);
-      console.error(pc19.dim(String(err)));
+      spinner5.error({ text: "Status check failed" });
+      console.error(pc29.red(String(err)));
       process.exit(1);
     }
-  }
-});
-var secrets_default = defineCommand20({
-  meta: {
-    name: "secrets",
-    description: "Manage encrypted secrets for MCP servers"
-  },
-  subCommands: {
-    set: setCommand2,
-    list: listCommand3,
-    remove: removeCommand2
+    spinner5.success({ text: `Checked ${statuses.length} server(s)` });
+    if (statuses.length === 0) {
+      console.log(pc29.dim("\n  No MCP servers installed.\n"));
+      return;
+    }
+    if (args.json) {
+      console.log(JSON.stringify(statuses, null, 2));
+      return;
+    }
+    console.log(pc29.bold("\n  mcpman status\n"));
+    printTable(statuses);
+    const alive = statuses.filter((s) => s.alive).length;
+    const dead = statuses.length - alive;
+    const parts = [];
+    if (alive > 0) parts.push(pc29.green(`${alive} alive`));
+    if (dead > 0) parts.push(pc29.red(`${dead} dead`));
+    console.log(`
+  ${parts.join("  \xB7  ")}
+`);
   }
 });
 
 // src/commands/sync.ts
-import * as p10 from "@clack/prompts";
-import { defineCommand as defineCommand21 } from "citty";
-import pc20 from "picocolors";
+import * as p11 from "@clack/prompts";
+import { defineCommand as defineCommand31 } from "citty";
+import pc30 from "picocolors";
 
 // src/core/config-diff.ts
 function reconstructServerEntry(lockEntry) {
@@ -4197,14 +5786,14 @@ async function getClientConfigs() {
 }
 
 // src/commands/sync.ts
-var VALID_CLIENTS = ["claude-desktop", "cursor", "vscode", "windsurf"];
-var CLIENT_DISPLAY3 = {
+var VALID_CLIENTS2 = ["claude-desktop", "cursor", "vscode", "windsurf"];
+var CLIENT_DISPLAY4 = {
   "claude-desktop": "Claude Desktop",
   cursor: "Cursor",
   vscode: "VS Code",
   windsurf: "Windsurf"
 };
-var sync_default = defineCommand21({
+var sync_default = defineCommand31({
   meta: {
     name: "sync",
     description: "Sync MCP server configs across all detected AI clients"
@@ -4231,20 +5820,20 @@ var sync_default = defineCommand21({
     }
   },
   async run({ args }) {
-    p10.intro(`${pc20.cyan("mcpman sync")}`);
+    p11.intro(`${pc30.cyan("mcpman sync")}`);
     const sourceClient = args.source;
-    if (sourceClient && !VALID_CLIENTS.includes(sourceClient)) {
-      p10.log.error(
-        `Invalid --source "${sourceClient}". Must be one of: ${VALID_CLIENTS.join(", ")}`
+    if (sourceClient && !VALID_CLIENTS2.includes(sourceClient)) {
+      p11.log.error(
+        `Invalid --source "${sourceClient}". Must be one of: ${VALID_CLIENTS2.join(", ")}`
       );
       process.exit(1);
     }
-    const spinner5 = p10.spinner();
+    const spinner5 = p11.spinner();
     spinner5.start("Detecting clients and reading configs...");
     const { configs, handlers } = await getClientConfigs();
     spinner5.stop(`Found ${configs.size} client(s)`);
     if (configs.size === 0) {
-      p10.log.warn(
+      p11.log.warn(
         "No AI clients detected. Install Claude Desktop, Cursor, VS Code, or Windsurf first."
       );
       process.exit(0);
@@ -4253,10 +5842,10 @@ var sync_default = defineCommand21({
     let actions;
     if (sourceClient) {
       if (!configs.has(sourceClient)) {
-        p10.log.error(`Source client "${sourceClient}" is not detected or its config is unreadable.`);
+        p11.log.error(`Source client "${sourceClient}" is not detected or its config is unreadable.`);
         process.exit(1);
       }
-      p10.log.info(`Using ${CLIENT_DISPLAY3[sourceClient]} as source of truth`);
+      p11.log.info(`Using ${CLIENT_DISPLAY4[sourceClient]} as source of truth`);
       actions = computeDiffFromClient(sourceClient, configs, diffOptions);
     } else {
       const lockfile = readLockfile();
@@ -4267,32 +5856,32 @@ var sync_default = defineCommand21({
     const extraCount = actions.filter((a) => a.action === "extra").length;
     const removeCount = actions.filter((a) => a.action === "remove").length;
     if (addCount === 0 && removeCount === 0 && extraCount === 0) {
-      p10.outro(pc20.green("All clients are in sync."));
+      p11.outro(pc30.green("All clients are in sync."));
       process.exit(0);
     }
     const parts = [];
-    if (addCount > 0) parts.push(pc20.green(`${addCount} to add`));
-    if (removeCount > 0) parts.push(pc20.red(`${removeCount} to remove`));
-    if (extraCount > 0) parts.push(pc20.yellow(`${extraCount} extra (informational)`));
-    p10.log.info(parts.join("  \xB7  "));
+    if (addCount > 0) parts.push(pc30.green(`${addCount} to add`));
+    if (removeCount > 0) parts.push(pc30.red(`${removeCount} to remove`));
+    if (extraCount > 0) parts.push(pc30.yellow(`${extraCount} extra (informational)`));
+    p11.log.info(parts.join("  \xB7  "));
     if (args["dry-run"]) {
-      p10.outro(pc20.dim("Dry run \u2014 no changes applied."));
+      p11.outro(pc30.dim("Dry run \u2014 no changes applied."));
       process.exit(1);
     }
     if (addCount === 0 && removeCount === 0) {
-      p10.outro(pc20.dim("No additions needed. Extra servers left untouched."));
+      p11.outro(pc30.dim("No additions needed. Extra servers left untouched."));
       process.exit(1);
     }
     if (!args.yes) {
       const actionParts = [];
       if (addCount > 0) actionParts.push(`${addCount} addition(s)`);
       if (removeCount > 0) actionParts.push(`${removeCount} removal(s)`);
-      const confirmed = await p10.confirm({
+      const confirmed = await p11.confirm({
         message: `Apply ${actionParts.join(" and ")} to client configs?`,
         initialValue: true
       });
-      if (p10.isCancel(confirmed) || !confirmed) {
-        p10.outro(pc20.dim("Cancelled \u2014 no changes applied."));
+      if (p11.isCancel(confirmed) || !confirmed) {
+        p11.outro(pc30.dim("Cancelled \u2014 no changes applied."));
         process.exit(0);
       }
     }
@@ -4300,40 +5889,40 @@ var sync_default = defineCommand21({
     const result = await applySyncActions(actions, handlers);
     spinner5.stop("Done");
     if (result.applied > 0) {
-      p10.log.success(`Added ${result.applied} server(s) to client configs.`);
+      p11.log.success(`Added ${result.applied} server(s) to client configs.`);
     }
     if (result.removed > 0) {
-      p10.log.success(`Removed ${result.removed} server(s) from client configs.`);
+      p11.log.success(`Removed ${result.removed} server(s) from client configs.`);
     }
     if (result.failed > 0) {
       for (const e of result.errors) {
-        p10.log.error(`Failed to sync "${e.server}" on ${e.client}: ${e.error}`);
+        p11.log.error(`Failed to sync "${e.server}" on ${e.client}: ${e.error}`);
       }
     }
-    p10.outro(
-      result.failed === 0 ? pc20.green("Sync complete.") : pc20.yellow("Sync complete with errors.")
+    p11.outro(
+      result.failed === 0 ? pc30.green("Sync complete.") : pc30.yellow("Sync complete with errors.")
     );
     process.exit(result.failed > 0 ? 1 : 0);
   }
 });
 function printDiffTable(actions) {
   if (actions.length === 0) {
-    p10.log.info("No actions to display.");
+    p11.log.info("No actions to display.");
     return;
   }
   const nameWidth = Math.max(6, ...actions.map((a) => a.server.length));
   const clientWidth = Math.max(
     6,
-    ...actions.map((a) => CLIENT_DISPLAY3[a.client]?.length ?? a.client.length)
+    ...actions.map((a) => CLIENT_DISPLAY4[a.client]?.length ?? a.client.length)
   );
-  const header = `  ${pad3("SERVER", nameWidth)}  ${pad3("CLIENT", clientWidth)}  STATUS`;
-  console.log(pc20.dim(header));
-  console.log(pc20.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientWidth)}  ------`));
+  const header = `  ${pad4("SERVER", nameWidth)}  ${pad4("CLIENT", clientWidth)}  STATUS`;
+  console.log(pc30.dim(header));
+  console.log(pc30.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientWidth)}  ------`));
   for (const action of actions) {
-    const clientDisplay = CLIENT_DISPLAY3[action.client] ?? action.client;
+    const clientDisplay = CLIENT_DISPLAY4[action.client] ?? action.client;
     const [icon, statusText] = formatAction(action.action);
     console.log(
-      `  ${pad3(action.server, nameWidth)}  ${pad3(clientDisplay, clientWidth)}  ${icon} ${statusText}`
+      `  ${pad4(action.server, nameWidth)}  ${pad4(clientDisplay, clientWidth)}  ${icon} ${statusText}`
     );
   }
   console.log("");
@@ -4341,25 +5930,193 @@ function printDiffTable(actions) {
 function formatAction(action) {
   switch (action) {
     case "add":
-      return [pc20.green("+"), pc20.green("missing \u2014 will add")];
+      return [pc30.green("+"), pc30.green("missing \u2014 will add")];
     case "extra":
-      return [pc20.yellow("?"), pc20.yellow("extra (not in lockfile)")];
+      return [pc30.yellow("?"), pc30.yellow("extra (not in lockfile)")];
     case "remove":
-      return [pc20.red("\u2013"), pc20.red("extra \u2014 will remove")];
+      return [pc30.red("\u2013"), pc30.red("extra \u2014 will remove")];
     case "ok":
-      return [pc20.dim("\xB7"), pc20.dim("in sync")];
+      return [pc30.dim("\xB7"), pc30.dim("in sync")];
   }
 }
-function pad3(s, width) {
+function pad4(s, width) {
   return s.length >= width ? s : s + " ".repeat(width - s.length);
 }
 
+// src/commands/template.ts
+import { defineCommand as defineCommand32 } from "citty";
+import pc31 from "picocolors";
+
+// src/core/template-service.ts
+import fs17 from "fs";
+import path14 from "path";
+function templatePath(name, dir) {
+  return path14.join(dir ?? getTemplatesDir(), `${name}.json`);
+}
+function ensureDir2(dir) {
+  const target = dir ?? getTemplatesDir();
+  if (!fs17.existsSync(target)) {
+    fs17.mkdirSync(target, { recursive: true });
+  }
+}
+function saveTemplate(name, opts = {}) {
+  const lockfile = readLockfile();
+  const servers = Object.entries(lockfile.servers).map(([sName, entry]) => ({
+    name: sName,
+    source: entry.source,
+    version: entry.version,
+    args: entry.args
+  }));
+  const template = {
+    name,
+    description: opts.description ?? "",
+    servers,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  ensureDir2(opts.dir);
+  fs17.writeFileSync(templatePath(name, opts.dir), JSON.stringify(template, null, 2), "utf-8");
+}
+function loadTemplate(name, dir) {
+  const file = templatePath(name, dir);
+  if (!fs17.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs17.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listTemplates(dir) {
+  const target = dir ?? getTemplatesDir();
+  if (!fs17.existsSync(target)) return [];
+  return fs17.readdirSync(target).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, "")).sort();
+}
+function deleteTemplate(name, dir) {
+  const file = templatePath(name, dir);
+  if (fs17.existsSync(file)) {
+    fs17.unlinkSync(file);
+  }
+}
+function applyTemplate(name, dir) {
+  const template = loadTemplate(name, dir);
+  if (!template) {
+    throw new Error(`Template "${name}" not found`);
+  }
+  return template.servers.map((s) => {
+    const versionSuffix = s.version ? `@${s.version}` : "";
+    return `mcpman install ${s.name}${versionSuffix}`;
+  });
+}
+
+// src/commands/template.ts
+var saveCmd = defineCommand32({
+  meta: { name: "save", description: "Save current lockfile servers as a named template" },
+  args: {
+    name: { type: "positional", description: "Template name", required: true },
+    description: {
+      type: "string",
+      description: "Optional description for the template"
+    }
+  },
+  run({ args }) {
+    try {
+      saveTemplate(args.name, { description: args.description });
+      const tmpl = loadTemplate(args.name);
+      const count = tmpl?.servers.length ?? 0;
+      console.log(
+        `${pc31.green("\u2713")} Template ${pc31.cyan(pc31.bold(args.name))} saved (${count} server${count !== 1 ? "s" : ""})`
+      );
+    } catch (err) {
+      console.error(`${pc31.red("\u2717")} ${String(err)}`);
+      process.exit(1);
+    }
+  }
+});
+var applyCmd = defineCommand32({
+  meta: { name: "apply", description: "Print install commands for a template" },
+  args: {
+    name: { type: "positional", description: "Template name", required: true }
+  },
+  run({ args }) {
+    let commands;
+    try {
+      commands = applyTemplate(args.name);
+    } catch (err) {
+      console.error(`${pc31.red("\u2717")} ${String(err)}`);
+      process.exit(1);
+    }
+    if (commands.length === 0) {
+      console.log(pc31.dim(`
+  Template "${args.name}" has no servers.
+`));
+      return;
+    }
+    console.log(pc31.bold(`
+  Template: ${pc31.cyan(args.name)}
+`));
+    console.log(pc31.dim("  Run the following commands to install all servers:\n"));
+    for (const cmd of commands) {
+      console.log(`  ${pc31.green("$")} ${cmd}`);
+    }
+    console.log();
+  }
+});
+var listCmd5 = defineCommand32({
+  meta: { name: "list", description: "List all saved templates" },
+  args: {},
+  run() {
+    const names = listTemplates();
+    if (names.length === 0) {
+      console.log(pc31.dim("\n  No templates saved. Use `mcpman template save <name>`.\n"));
+      return;
+    }
+    console.log(pc31.bold("\n  mcpman templates\n"));
+    console.log(pc31.dim(`  ${"\u2500".repeat(50)}`));
+    for (const name of names) {
+      const tmpl = loadTemplate(name);
+      const count = tmpl?.servers.length ?? 0;
+      const desc = tmpl?.description ? pc31.dim(`  \u2014 ${tmpl.description}`) : "";
+      console.log(
+        `  ${pc31.cyan(pc31.bold(name.padEnd(20)))}  ${pc31.dim(`${count} server${count !== 1 ? "s" : ""}`)}${desc}`
+      );
+    }
+    console.log(pc31.dim(`  ${"\u2500".repeat(50)}
+`));
+  }
+});
+var deleteCmd2 = defineCommand32({
+  meta: { name: "delete", description: "Delete a saved template" },
+  args: {
+    name: { type: "positional", description: "Template name", required: true }
+  },
+  run({ args }) {
+    const existing = listTemplates();
+    if (!existing.includes(args.name)) {
+      console.error(`${pc31.red("\u2717")} Template "${args.name}" does not exist.`);
+      process.exit(1);
+    }
+    deleteTemplate(args.name);
+    console.log(`${pc31.green("\u2713")} Template ${pc31.cyan(args.name)} deleted`);
+  }
+});
+var template_default = defineCommand32({
+  meta: {
+    name: "template",
+    description: "Manage install templates"
+  },
+  subCommands: {
+    save: saveCmd,
+    apply: applyCmd,
+    list: listCmd5,
+    delete: deleteCmd2
+  }
+});
+
 // src/commands/test-command.ts
-import { defineCommand as defineCommand22 } from "citty";
-import pc21 from "picocolors";
+import { defineCommand as defineCommand33 } from "citty";
+import pc32 from "picocolors";
 
 // src/core/mcp-tester.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 var TIMEOUT_MS = 1e4;
 async function testMcpServer(serverName, command, args, env) {
   const start = Date.now();
@@ -4369,7 +6126,7 @@ async function testMcpServer(serverName, command, args, env) {
     let initOk = false;
     let toolsOk = false;
     let tools = [];
-    const child = spawn4(command, args, {
+    const child = spawn7(command, args, {
       env: { ...process.env, ...env },
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -4454,7 +6211,7 @@ async function testMcpServer(serverName, command, args, env) {
 }
 
 // src/commands/test-command.ts
-var test_command_default = defineCommand22({
+var test_command_default = defineCommand33({
   meta: {
     name: "test",
     description: "Test MCP server connectivity and capabilities"
@@ -4475,10 +6232,10 @@ var test_command_default = defineCommand22({
     const lockfile = readLockfile();
     const serverNames = args.all ? Object.keys(lockfile.servers) : args.server ? [args.server] : [];
     if (serverNames.length === 0) {
-      console.error(pc21.red("  Error: Specify a server name or use --all."));
+      console.error(pc32.red("  Error: Specify a server name or use --all."));
       process.exit(1);
     }
-    console.log(pc21.bold(`
+    console.log(pc32.bold(`
   mcpman test \u2014 ${serverNames.length} server(s)
 `));
     let passed = 0;
@@ -4486,7 +6243,7 @@ var test_command_default = defineCommand22({
     for (const name of serverNames) {
       const entry = lockfile.servers[name];
       if (!entry) {
-        console.log(`  ${pc21.red("\u2717")} ${pc21.bold(name)} \u2014 not installed`);
+        console.log(`  ${pc32.red("\u2717")} ${pc32.bold(name)} \u2014 not installed`);
         failed++;
         continue;
       }
@@ -4497,27 +6254,27 @@ var test_command_default = defineCommand22({
       if (result.passed) {
         passed++;
         console.log(
-          `  ${pc21.green("\u2713")} ${pc21.bold(name)} ${pc21.dim(`(${result.responseTimeMs}ms)`)}`
+          `  ${pc32.green("\u2713")} ${pc32.bold(name)} ${pc32.dim(`(${result.responseTimeMs}ms)`)}`
         );
         if (result.tools.length > 0) {
-          console.log(pc21.dim(`    Tools: ${result.tools.join(", ")}`));
+          console.log(pc32.dim(`    Tools: ${result.tools.join(", ")}`));
         }
       } else {
         failed++;
-        console.log(`  ${pc21.red("\u2717")} ${pc21.bold(name)} ${pc21.dim(`(${result.responseTimeMs}ms)`)}`);
+        console.log(`  ${pc32.red("\u2717")} ${pc32.bold(name)} ${pc32.dim(`(${result.responseTimeMs}ms)`)}`);
         if (result.error) {
-          console.log(`    ${pc21.red(result.error)}`);
+          console.log(`    ${pc32.red(result.error)}`);
         }
         console.log(
-          `    ${pc21.dim("initialize:")} ${result.initializeOk ? pc21.green("ok") : pc21.red("fail")}  ${pc21.dim("tools/list:")} ${result.toolsListOk ? pc21.green("ok") : pc21.red("fail")}`
+          `    ${pc32.dim("initialize:")} ${result.initializeOk ? pc32.green("ok") : pc32.red("fail")}  ${pc32.dim("tools/list:")} ${result.toolsListOk ? pc32.green("ok") : pc32.red("fail")}`
         );
       }
     }
-    console.log(pc21.dim(`
+    console.log(pc32.dim(`
   ${"\u2500".repeat(40)}`));
     const parts = [];
-    if (passed > 0) parts.push(pc21.green(`${passed} passed`));
-    if (failed > 0) parts.push(pc21.red(`${failed} failed`));
+    if (passed > 0) parts.push(pc32.green(`${passed} passed`));
+    if (failed > 0) parts.push(pc32.red(`${failed} failed`));
     console.log(`  ${parts.join(", ")}
 `);
     if (failed > 0) process.exit(1);
@@ -4535,24 +6292,24 @@ async function loadVaultSecrets3(serverName) {
 }
 
 // src/commands/update.ts
-import * as p11 from "@clack/prompts";
-import { defineCommand as defineCommand23 } from "citty";
-import pc23 from "picocolors";
+import * as p12 from "@clack/prompts";
+import { defineCommand as defineCommand34 } from "citty";
+import pc34 from "picocolors";
 
 // src/core/update-notifier.ts
-import fs11 from "fs";
+import fs18 from "fs";
 import os3 from "os";
-import path13 from "path";
-import pc22 from "picocolors";
-var CACHE_FILE = path13.join(os3.homedir(), ".mcpman", ".update-check");
+import path15 from "path";
+import pc33 from "picocolors";
+var CACHE_FILE = path15.join(os3.homedir(), ".mcpman", ".update-check");
 var TTL_MS = 24 * 60 * 60 * 1e3;
 function writeUpdateCache(data) {
   try {
-    const dir = path13.dirname(CACHE_FILE);
-    if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+    const dir = path15.dirname(CACHE_FILE);
+    if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
     const tmp = `${CACHE_FILE}.tmp`;
-    fs11.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
-    fs11.renameSync(tmp, CACHE_FILE);
+    fs18.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+    fs18.renameSync(tmp, CACHE_FILE);
   } catch {
   }
 }
@@ -4560,13 +6317,13 @@ function writeUpdateCache(data) {
 // src/commands/update.ts
 async function loadClients3() {
   try {
-    const mod = await import("./client-detector-CY7WPF3K.js");
+    const mod = await import("./client-detector-O2HN4MUB.js");
     return mod.getInstalledClients();
   } catch {
     return [];
   }
 }
-function printTable(updates) {
+function printTable2(updates) {
   const NAME_W = 28;
   const VER_W = 10;
   const header = [
@@ -4575,19 +6332,19 @@ function printTable(updates) {
     "LATEST".padEnd(VER_W),
     "STATUS"
   ].join("  ");
-  console.log(pc23.bold(`
+  console.log(pc34.bold(`
   ${header}`));
-  console.log(pc23.dim(`  ${"\u2500".repeat(NAME_W + VER_W * 2 + 20)}`));
+  console.log(pc34.dim(`  ${"\u2500".repeat(NAME_W + VER_W * 2 + 20)}`));
   for (const u of updates) {
     const nameCol = u.server.slice(0, NAME_W).padEnd(NAME_W);
     const curCol = u.currentVersion.padEnd(VER_W);
     const latCol = u.latestVersion.padEnd(VER_W);
-    const statusCol = u.hasUpdate ? pc23.yellow(`Update available${u.updateType ? ` [${u.updateType}]` : ""}`) : pc23.green("Up to date");
+    const statusCol = u.hasUpdate ? pc34.yellow(`Update available${u.updateType ? ` [${u.updateType}]` : ""}`) : pc34.green("Up to date");
     console.log(`  ${nameCol}  ${curCol}  ${latCol}  ${statusCol}`);
   }
   console.log();
 }
-var update_default = defineCommand23({
+var update_default = defineCommand34({
   meta: {
     name: "update",
     description: "Check for and apply updates to installed MCP servers"
@@ -4626,7 +6383,7 @@ var update_default = defineCommand23({
       }
       process.exit(1);
     }
-    const spinner5 = p11.spinner();
+    const spinner5 = p12.spinner();
     spinner5.start("Checking versions...");
     let updates;
     try {
@@ -4645,53 +6402,53 @@ var update_default = defineCommand23({
       console.log(JSON.stringify(updates, null, 2));
       return;
     }
-    printTable(updates);
+    printTable2(updates);
     const outdated = updates.filter((u) => u.hasUpdate);
     if (outdated.length === 0) {
-      console.log(pc23.green("  All servers are up to date."));
+      console.log(pc34.green("  All servers are up to date."));
       return;
     }
     if (args.check) {
       console.log(
-        pc23.yellow(`  ${outdated.length} update(s) available. Run mcpman update to apply.`)
+        pc34.yellow(`  ${outdated.length} update(s) available. Run mcpman update to apply.`)
       );
       return;
     }
     if (!args.yes) {
-      const confirmed = await p11.confirm({
+      const confirmed = await p12.confirm({
         message: `Apply ${outdated.length} update(s)?`,
         initialValue: true
       });
-      if (p11.isCancel(confirmed) || !confirmed) {
-        p11.outro("Cancelled.");
+      if (p12.isCancel(confirmed) || !confirmed) {
+        p12.outro("Cancelled.");
         return;
       }
     }
     const clients = await loadClients3();
     let successCount = 0;
     for (const update of outdated) {
-      const s = p11.spinner();
+      const s = p12.spinner();
       s.start(`Updating ${update.server}...`);
       const result = await applyServerUpdate(update.server, servers[update.server], clients);
       if (result.success) {
-        s.stop(`${pc23.green("\u2713")} ${update.server}: ${result.fromVersion} \u2192 ${result.toVersion}`);
+        s.stop(`${pc34.green("\u2713")} ${update.server}: ${result.fromVersion} \u2192 ${result.toVersion}`);
         successCount++;
       } else {
-        s.stop(`${pc23.red("\u2717")} ${update.server}: ${result.error}`);
+        s.stop(`${pc34.red("\u2717")} ${update.server}: ${result.error}`);
       }
     }
     const freshLockfile = readLockfile(resolveLockfilePath());
     const freshUpdates = await checkAllVersions(freshLockfile);
     writeUpdateCache({ lastCheck: (/* @__PURE__ */ new Date()).toISOString(), updates: freshUpdates });
-    p11.outro(`${successCount} of ${outdated.length} server(s) updated.`);
+    p12.outro(`${successCount} of ${outdated.length} server(s) updated.`);
   }
 });
 
 // src/commands/upgrade.ts
-import { execSync as execSync2 } from "child_process";
-import { defineCommand as defineCommand24 } from "citty";
-import pc24 from "picocolors";
-var upgrade_default = defineCommand24({
+import { execSync as execSync5 } from "child_process";
+import { defineCommand as defineCommand35 } from "citty";
+import pc35 from "picocolors";
+var upgrade_default = defineCommand35({
   meta: {
     name: "upgrade",
     description: "Upgrade mcpman to the latest version"
@@ -4704,42 +6461,214 @@ var upgrade_default = defineCommand24({
     }
   },
   async run({ args }) {
-    console.log(pc24.dim(`  Current version: ${APP_VERSION}`));
+    console.log(pc35.dim(`  Current version: ${APP_VERSION}`));
     let latest;
     try {
-      latest = execSync2("npm view mcpman version", { encoding: "utf-8", timeout: 15e3 }).trim();
+      latest = execSync5("npm view mcpman version", { encoding: "utf-8", timeout: 15e3 }).trim();
     } catch {
-      console.error(pc24.red("  Error: Could not check latest version from npm."));
+      console.error(pc35.red("  Error: Could not check latest version from npm."));
       process.exit(1);
     }
     if (latest === APP_VERSION) {
-      console.log(pc24.green("  \u2713 Already on the latest version."));
+      console.log(pc35.green("  \u2713 Already on the latest version."));
       return;
     }
-    console.log(pc24.yellow(`  Update available: ${APP_VERSION} \u2192 ${latest}`));
+    console.log(pc35.yellow(`  Update available: ${APP_VERSION} \u2192 ${latest}`));
     if (args.check) {
-      console.log(pc24.dim("  Run mcpman upgrade to install."));
+      console.log(pc35.dim("  Run mcpman upgrade to install."));
       return;
     }
-    console.log(pc24.dim("  Installing..."));
+    console.log(pc35.dim("  Installing..."));
     try {
-      execSync2(`npm install -g mcpman@${latest}`, { stdio: "inherit", timeout: 6e4 });
-      console.log(pc24.green(`
+      execSync5(`npm install -g mcpman@${latest}`, { stdio: "inherit", timeout: 6e4 });
+      console.log(pc35.green(`
   \u2713 Upgraded to mcpman@${latest}`));
     } catch {
-      console.error(pc24.red("  Error: Upgrade failed. Try manually: npm install -g mcpman@latest"));
+      console.error(pc35.red("  Error: Upgrade failed. Try manually: npm install -g mcpman@latest"));
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/validate.ts
+import { defineCommand as defineCommand36 } from "citty";
+import pc36 from "picocolors";
+
+// src/core/config-validator.ts
+import fs19 from "fs";
+var REQUIRED_LOCK_FIELDS = ["version", "source", "command", "args"];
+var VALID_SOURCES = ["npm", "smithery", "github", "local"];
+function validateLockfile(filePath) {
+  const target = filePath ?? resolveLockfilePath();
+  const errors = [];
+  if (!fs19.existsSync(target)) {
+    return { file: target, valid: false, errors: ["Lockfile not found"] };
+  }
+  let data;
+  try {
+    data = JSON.parse(fs19.readFileSync(target, "utf-8"));
+  } catch {
+    return { file: target, valid: false, errors: ["Invalid JSON"] };
+  }
+  if (typeof data !== "object" || data === null) {
+    return { file: target, valid: false, errors: ["Root must be an object"] };
+  }
+  const obj = data;
+  if (obj.lockfileVersion !== 1) {
+    errors.push(`lockfileVersion must be 1, got ${JSON.stringify(obj.lockfileVersion)}`);
+  }
+  if (typeof obj.servers !== "object" || obj.servers === null || Array.isArray(obj.servers)) {
+    errors.push("servers must be an object");
+    return { file: target, valid: errors.length === 0, errors };
+  }
+  const servers = obj.servers;
+  for (const [name, entry] of Object.entries(servers)) {
+    if (typeof entry !== "object" || entry === null) {
+      errors.push(`servers.${name}: must be an object`);
+      continue;
+    }
+    const e = entry;
+    for (const field of REQUIRED_LOCK_FIELDS) {
+      if (!(field in e)) {
+        errors.push(`servers.${name}: missing required field "${field}"`);
+      }
+    }
+    if (e.source && !VALID_SOURCES.includes(e.source)) {
+      errors.push(`servers.${name}: invalid source "${e.source}"`);
+    }
+    if (!Array.isArray(e.args)) {
+      errors.push(`servers.${name}: args must be an array`);
+    }
+  }
+  return { file: target, valid: errors.length === 0, errors };
+}
+function validateClientConfig(clientName) {
+  let filePath;
+  try {
+    filePath = resolveConfigPath(clientName);
+  } catch {
+    return { file: clientName, valid: false, errors: [`Unknown client: ${clientName}`] };
+  }
+  const errors = [];
+  if (!fs19.existsSync(filePath)) {
+    return { file: filePath, valid: false, errors: ["Config file not found"] };
+  }
+  let data;
+  try {
+    data = JSON.parse(fs19.readFileSync(filePath, "utf-8"));
+  } catch {
+    return { file: filePath, valid: false, errors: ["Invalid JSON"] };
+  }
+  if (typeof data !== "object" || data === null) {
+    return { file: filePath, valid: false, errors: ["Root must be an object"] };
+  }
+  const obj = data;
+  const servers = obj.mcpServers ?? obj["mcp.servers"];
+  if (!servers) {
+    return { file: filePath, valid: true, errors: [] };
+  }
+  if (typeof servers !== "object" || Array.isArray(servers)) {
+    errors.push("mcpServers must be an object");
+    return { file: filePath, valid: false, errors };
+  }
+  for (const [name, entry] of Object.entries(servers)) {
+    if (typeof entry !== "object" || entry === null) {
+      errors.push(`mcpServers.${name}: must be an object`);
+      continue;
+    }
+    const e = entry;
+    if (!("command" in e) || typeof e.command !== "string") {
+      errors.push(`mcpServers.${name}: missing or invalid "command"`);
+    }
+    if (!("args" in e) || !Array.isArray(e.args)) {
+      errors.push(`mcpServers.${name}: missing or invalid "args" (must be array)`);
+    }
+  }
+  return { file: filePath, valid: errors.length === 0, errors };
+}
+function validateAll(lockfilePath) {
+  const results = [validateLockfile(lockfilePath)];
+  const clients = ["claude-desktop", "cursor", "vscode", "windsurf"];
+  for (const client of clients) {
+    const r = validateClientConfig(client);
+    if (!r.errors.includes("Config file not found")) {
+      results.push(r);
+    }
+  }
+  return results;
+}
+
+// src/commands/validate.ts
+function printResult(r) {
+  const icon = r.valid ? pc36.green("\u2713") : pc36.red("\u2717");
+  const status = r.valid ? pc36.green("PASS") : pc36.red("FAIL");
+  console.log(`  ${icon} ${pc36.bold(r.file)}  ${status}`);
+  if (!r.valid) {
+    for (const err of r.errors) {
+      console.log(`      ${pc36.dim("\xB7")} ${pc36.yellow(err)}`);
+    }
+  }
+}
+var validate_default = defineCommand36({
+  meta: {
+    name: "validate",
+    description: "Validate lockfile and client configs against expected schema"
+  },
+  args: {
+    client: {
+      type: "string",
+      description: "Validate a specific client config (claude-desktop, cursor, vscode, windsurf)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output results as JSON",
+      default: false
+    }
+  },
+  run({ args }) {
+    let results;
+    if (args.client) {
+      results = [validateClientConfig(args.client)];
+    } else {
+      results = validateAll();
+    }
+    if (args.json) {
+      console.log(JSON.stringify(results, null, 2));
+      const anyFail = results.some((r) => !r.valid);
+      if (anyFail) process.exit(1);
+      return;
+    }
+    console.log(pc36.bold("\n  mcpman validate\n"));
+    console.log(pc36.dim(`  ${"\u2500".repeat(60)}`));
+    for (const r of results) {
+      printResult(r);
+    }
+    console.log(pc36.dim(`
+  ${"\u2500".repeat(60)}`));
+    const passed = results.filter((r) => r.valid).length;
+    const failed = results.filter((r) => !r.valid).length;
+    if (failed === 0) {
+      console.log(`
+  ${pc36.green("All files valid")} (${passed} checked)
+`);
+    } else {
+      console.log(
+        `
+  ${pc36.red(`${failed} file(s) failed`)}  ${pc36.dim("\xB7")}  ${pc36.green(`${passed} passed`)}
+`
+      );
       process.exit(1);
     }
   }
 });
 
 // src/commands/watch.ts
-import { defineCommand as defineCommand25 } from "citty";
-import pc25 from "picocolors";
+import { defineCommand as defineCommand37 } from "citty";
+import pc37 from "picocolors";
 
 // src/core/file-watcher-service.ts
-import { spawn as spawn5 } from "child_process";
-import fs12 from "fs";
+import { spawn as spawn8 } from "child_process";
+import fs20 from "fs";
 var IGNORE_PATTERNS = [
   "node_modules",
   ".git",
@@ -4751,7 +6680,7 @@ var IGNORE_PATTERNS = [
   ".tox"
 ];
 function shouldIgnore(filename) {
-  return IGNORE_PATTERNS.some((p12) => filename.includes(p12));
+  return IGNORE_PATTERNS.some((p13) => filename.includes(p13));
 }
 function hasWatchedExtension(filename, extensions) {
   return extensions.some((ext) => filename.endsWith(`.${ext}`));
@@ -4777,7 +6706,7 @@ var ServerWatcher = class {
 `);
     this.spawnChild();
     try {
-      this.watcher = fs12.watch(options.watchDir, { recursive: true }, (_event, filename) => {
+      this.watcher = fs20.watch(options.watchDir, { recursive: true }, (_event, filename) => {
         if (!filename) return;
         this.onFileChange(filename);
       });
@@ -4812,7 +6741,7 @@ var ServerWatcher = class {
       process.stdout.write("\x1Bc");
     }
     console.log(`  [${timestamp()}] Starting ${serverName}...`);
-    this.child = spawn5(command, args, { env, stdio: ["pipe", "pipe", "pipe"] });
+    this.child = spawn8(command, args, { env, stdio: ["pipe", "pipe", "pipe"] });
     this.child.stdout?.on("data", (data) => {
       process.stdout.write(`  [stdout] ${data.toString().trimEnd()}
 `);
@@ -4876,7 +6805,7 @@ var ServerWatcher = class {
 // src/commands/watch.ts
 var DEFAULT_EXTENSIONS = ["ts", "js", "json", "py", "mjs", "cjs"];
 var DEFAULT_DEBOUNCE_MS = 300;
-var watch_default = defineCommand25({
+var watch_default = defineCommand37({
   meta: {
     name: "watch",
     description: "Watch a local MCP server for file changes and auto-restart"
@@ -4915,8 +6844,8 @@ var watch_default = defineCommand25({
     const lockfile = readLockfile();
     const entry = lockfile.servers[serverName];
     if (!entry) {
-      console.error(pc25.red(`  Error: Server '${serverName}' not found in lockfile.`));
-      console.error(pc25.dim(`  Run ${pc25.cyan("mcpman link .")} to register a local server.`));
+      console.error(pc37.red(`  Error: Server '${serverName}' not found in lockfile.`));
+      console.error(pc37.dim(`  Run ${pc37.cyan("mcpman link .")} to register a local server.`));
       process.exit(1);
     }
     let watchDir = args.dir;
@@ -4924,8 +6853,8 @@ var watch_default = defineCommand25({
       if (entry.source === "local" && entry.resolved) {
         watchDir = entry.resolved;
       } else {
-        console.error(pc25.red(`  Error: Cannot determine watch directory for '${serverName}'.`));
-        console.error(pc25.dim("  Use --dir to specify the directory to watch."));
+        console.error(pc37.red(`  Error: Cannot determine watch directory for '${serverName}'.`));
+        console.error(pc37.dim("  Use --dir to specify the directory to watch."));
         process.exit(1);
       }
     }
@@ -4971,12 +6900,12 @@ async function loadVaultSecrets4(serverName) {
 }
 
 // src/commands/why.ts
-import { defineCommand as defineCommand26 } from "citty";
-import pc26 from "picocolors";
+import { defineCommand as defineCommand38 } from "citty";
+import pc38 from "picocolors";
 
 // src/core/why-service.ts
-import fs13 from "fs";
-import path14 from "path";
+import fs21 from "fs";
+import path16 from "path";
 var ALL_CLIENT_TYPES = ["claude-desktop", "cursor", "vscode", "windsurf"];
 async function getServerProvenance(serverName, lockfilePath, profilesDir) {
   const lockfile = readLockfile(lockfilePath);
@@ -5020,7 +6949,7 @@ async function buildClientStatuses(serverName, lockfileClients) {
   }));
 }
 async function findOrphanedClients(serverName) {
-  const { getInstalledClients: getInstalledClients2 } = await import("./client-detector-CY7WPF3K.js");
+  const { getInstalledClients: getInstalledClients2 } = await import("./client-detector-O2HN4MUB.js");
   const handlers = await getInstalledClients2();
   const results = [];
   for (const handler of handlers) {
@@ -5036,16 +6965,16 @@ async function findOrphanedClients(serverName) {
 }
 function scanProfiles(serverName, profilesDir) {
   const found = [];
-  if (!fs13.existsSync(profilesDir)) return found;
+  if (!fs21.existsSync(profilesDir)) return found;
   let files;
   try {
-    files = fs13.readdirSync(profilesDir).filter((f) => f.endsWith(".json"));
+    files = fs21.readdirSync(profilesDir).filter((f) => f.endsWith(".json"));
   } catch {
     return found;
   }
   for (const file of files) {
     try {
-      const raw = fs13.readFileSync(path14.join(profilesDir, file), "utf-8");
+      const raw = fs21.readFileSync(path16.join(profilesDir, file), "utf-8");
       const profile = JSON.parse(raw);
       if (serverName in (profile.servers ?? {})) {
         found.push(profile.name ?? file.replace(".json", ""));
@@ -5074,8 +7003,8 @@ function formatWhyOutput(result) {
   if (result.profiles.length > 0) {
     lines.push("");
     lines.push("  Profiles:");
-    for (const p12 of result.profiles) {
-      lines.push(`    ${p12}`);
+    for (const p13 of result.profiles) {
+      lines.push(`    ${p13}`);
     }
   }
   if (result.envVars.length > 0) {
@@ -5089,7 +7018,7 @@ function formatWhyOutput(result) {
 }
 
 // src/commands/why.ts
-var why_default = defineCommand26({
+var why_default = defineCommand38({
   meta: {
     name: "why",
     description: "Show why a server is installed (provenance, clients, profiles)"
@@ -5111,15 +7040,15 @@ var why_default = defineCommand26({
     const asJson = args.json;
     const result = await getServerProvenance(serverName);
     if (!result) {
-      console.error(pc26.red(`  Server '${serverName}' not found in lockfile or any client config.`));
-      console.error(pc26.dim(`  Run ${pc26.cyan("mcpman list")} to see installed servers.`));
+      console.error(pc38.red(`  Server '${serverName}' not found in lockfile or any client config.`));
+      console.error(pc38.dim(`  Run ${pc38.cyan("mcpman list")} to see installed servers.`));
       process.exit(1);
     }
     if (result.orphaned) {
-      console.log(pc26.yellow(`
+      console.log(pc38.yellow(`
   Server '${serverName}' is orphaned:`));
-      console.log(pc26.dim("  Found in client config(s) but not in lockfile."));
-      console.log(pc26.dim(`  Run ${pc26.cyan("mcpman sync --remove")} to clean up.
+      console.log(pc38.dim("  Found in client config(s) but not in lockfile."));
+      console.log(pc38.dim(`  Run ${pc38.cyan("mcpman sync --remove")} to clean up.
 `));
       const registeredClients = result.clients.filter((c) => c.registered).map((c) => c.type);
       if (registeredClients.length > 0) {
@@ -5142,7 +7071,7 @@ process.on("SIGINT", () => {
   console.log("\nAborted.");
   process.exit(130);
 });
-var main = defineCommand27({
+var main = defineCommand39({
   meta: {
     name: APP_NAME,
     version: APP_VERSION,
@@ -5174,7 +7103,19 @@ var main = defineCommand27({
     watch: watch_default,
     registry: registry_default,
     completions: completions_default,
-    why: why_default
+    why: why_default,
+    env: env_default,
+    bench: bench_default,
+    diff: diff_default,
+    group: group_default,
+    pin: pin_default,
+    rollback: rollback_default,
+    validate: validate_default,
+    status: status_default,
+    replay: replay_default,
+    alias: alias_default,
+    template: template_default,
+    notify: notify_default
   }
 });
 runMain(main);