@cleocode/caamp 2026.4.0 → 2026.4.3

package/dist/{chunk-3WKBFXLE.js → chunk-6NBM4CAF.js}

@@ -2,7 +2,7 @@ import {
   getAllProviders,
   groupByInstructFile,
   injectAll
-} from "./chunk-5UUABVWS.js";
+} from "./chunk-CRU25LRL.js";
 import {
   __export,
   getAgentsConfigPath,
@@ -12,10 +12,9 @@ import {
   getCanonicalSkillsDir,
   getLockFilePath,
   getPlatformLocations,
-  resolveProviderConfigPath,
   resolveProviderProjectPath,
   resolveProviderSkillsDirs
-} from "./chunk-3IEKCREL.js";
+} from "./chunk-XWQ5WPHC.js";
 
 // src/core/logger.ts
 var verboseMode = false;
@@ -43,880 +42,364 @@ function isHuman() {
   return humanMode;
 }
 
-// src/core/formats/utils.ts
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    const sourceVal = source[key];
-    const targetVal = target[key];
-    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
-      result[key] = deepMerge(
-        targetVal,
-        sourceVal
-      );
-    } else {
-      result[key] = sourceVal;
-    }
-  }
-  return result;
-}
-function getNestedValue(obj, keyPath) {
-  const parts = keyPath.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || typeof current !== "object") return void 0;
-    current = current[part];
+// src/core/registry/detection.ts
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+var DEFAULT_DETECTION_CACHE_TTL_MS = 3e4;
+var detectionCache = null;
+function checkBinary(binary) {
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    execFileSync(cmd, [binary], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
   }
-  return current;
 }
-async function ensureDir(filePath) {
-  const { mkdir: mkdir4 } = await import("fs/promises");
-  const { dirname: dirname3 } = await import("path");
-  await mkdir4(dirname3(filePath), { recursive: true });
+function checkDirectory(dir) {
+  return existsSync(dir);
 }
-
-// src/core/formats/json.ts
-import { existsSync } from "fs";
-import { readFile, writeFile } from "fs/promises";
-import * as jsonc from "jsonc-parser";
-async function readJsonConfig(filePath) {
-  if (!existsSync(filePath)) return {};
-  const content = await readFile(filePath, "utf-8");
-  if (!content.trim()) return {};
-  const errors = [];
-  const result = jsonc.parse(content, errors);
-  if (errors.length > 0) {
-    return JSON.parse(content);
-  }
-  return result ?? {};
+function checkAppBundle(appName) {
+  if (process.platform !== "darwin") return false;
+  const applications = getPlatformLocations().applications;
+  return applications.some((base) => existsSync(join(base, appName)));
 }
-function detectIndent(content) {
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const match = line.match(/^(\s+)/);
-    if (match?.[1]) {
-      const ws = match[1];
-      if (ws.startsWith("	")) {
-        return { indent: "	", insertSpaces: false, tabSize: 1 };
-      }
-      return { indent: ws, insertSpaces: true, tabSize: ws.length };
-    }
+function checkFlatpak(flatpakId) {
+  if (process.platform !== "linux") return false;
+  try {
+    execFileSync("flatpak", ["info", flatpakId], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
   }
-  return { indent: "  ", insertSpaces: true, tabSize: 2 };
 }
-async function writeJsonConfig(filePath, configKey, serverName, serverConfig) {
-  await ensureDir(filePath);
-  let content;
-  if (existsSync(filePath)) {
-    content = await readFile(filePath, "utf-8");
-    if (!content.trim()) {
-      content = "{}";
+function detectProvider(provider) {
+  const matchedMethods = [];
+  const detection = provider.detection;
+  debug(`detecting provider ${provider.id} via methods: ${detection.methods.join(", ")}`);
+  for (const method of detection.methods) {
+    switch (method) {
+      case "binary":
+        if (detection.binary && checkBinary(detection.binary)) {
+          debug(`  ${provider.id}: binary "${detection.binary}" found`);
+          matchedMethods.push("binary");
+        }
+        break;
+      case "directory":
+        if (detection.directories) {
+          for (const dir of detection.directories) {
+            if (checkDirectory(dir)) {
+              matchedMethods.push("directory");
+              break;
+            }
+          }
+        }
+        break;
+      case "appBundle":
+        if (detection.appBundle && checkAppBundle(detection.appBundle)) {
+          matchedMethods.push("appBundle");
+        }
+        break;
+      case "flatpak":
+        if (detection.flatpakId && checkFlatpak(detection.flatpakId)) {
+          matchedMethods.push("flatpak");
+        }
+        break;
     }
-  } else {
-    content = "{}";
   }
-  const { tabSize, insertSpaces } = detectIndent(content);
-  const formatOptions = {
-    tabSize,
-    insertSpaces,
-    eol: "\n"
+  return {
+    provider,
+    installed: matchedMethods.length > 0,
+    methods: matchedMethods,
+    projectDetected: false
   };
-  const keyParts = configKey.split(".");
-  const jsonPath = [...keyParts, serverName];
-  const edits = jsonc.modify(content, jsonPath, serverConfig, { formattingOptions: formatOptions });
-  if (edits.length > 0) {
-    content = jsonc.applyEdits(content, edits);
-  }
-  if (!content.endsWith("\n")) {
-    content += "\n";
-  }
-  await writeFile(filePath, content, "utf-8");
 }
-async function removeJsonConfig(filePath, configKey, serverName) {
-  if (!existsSync(filePath)) return false;
-  let content = await readFile(filePath, "utf-8");
-  if (!content.trim()) return false;
-  const { tabSize, insertSpaces } = detectIndent(content);
-  const formatOptions = {
-    tabSize,
-    insertSpaces,
-    eol: "\n"
+function providerSignature(provider) {
+  return JSON.stringify({
+    id: provider.id,
+    methods: provider.detection.methods,
+    binary: provider.detection.binary,
+    directories: provider.detection.directories,
+    appBundle: provider.detection.appBundle,
+    flatpakId: provider.detection.flatpakId
+  });
+}
+function buildProvidersSignature(providers) {
+  if (!providers || !Array.isArray(providers)) return "";
+  return providers.map(providerSignature).join("|");
+}
+function cloneDetectionResults(results) {
+  return results.map((result) => ({
+    provider: result.provider,
+    installed: result.installed,
+    methods: [...result.methods],
+    projectDetected: result.projectDetected
+  }));
+}
+function getCachedResults(signature, options) {
+  if (!detectionCache || options.forceRefresh) return null;
+  if (detectionCache.signature !== signature) return null;
+  const ttlMs = options.ttlMs ?? DEFAULT_DETECTION_CACHE_TTL_MS;
+  if (ttlMs <= 0) return null;
+  if (Date.now() - detectionCache.createdAt > ttlMs) return null;
+  return cloneDetectionResults(detectionCache.results);
+}
+function setCachedResults(signature, results) {
+  detectionCache = {
+    createdAt: Date.now(),
+    signature,
+    results: cloneDetectionResults(results)
   };
-  const keyParts = configKey.split(".");
-  const jsonPath = [...keyParts, serverName];
-  const edits = jsonc.modify(content, jsonPath, void 0, { formattingOptions: formatOptions });
-  if (edits.length === 0) return false;
-  content = jsonc.applyEdits(content, edits);
-  if (!content.endsWith("\n")) {
-    content += "\n";
-  }
-  await writeFile(filePath, content, "utf-8");
-  return true;
 }
-
-// src/core/formats/toml.ts
-import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import TOML from "@iarna/toml";
-async function readTomlConfig(filePath) {
-  if (!existsSync2(filePath)) return {};
-  const content = await readFile2(filePath, "utf-8");
-  if (!content.trim()) return {};
-  const result = TOML.parse(content);
-  return result;
+function detectProjectProvider(provider, projectDir) {
+  if (!provider.pathProject) return false;
+  return existsSync(resolveProviderProjectPath(provider, projectDir));
 }
-async function writeTomlConfig(filePath, configKey, serverName, serverConfig) {
-  await ensureDir(filePath);
-  const existing = await readTomlConfig(filePath);
-  const keyParts = configKey.split(".");
-  let newEntry = { [serverName]: serverConfig };
-  for (const part of [...keyParts].reverse()) {
-    newEntry = { [part]: newEntry };
+function detectAllProviders(options = {}) {
+  const providers = getAllProviders() ?? [];
+  const signature = buildProvidersSignature(providers);
+  const cached = getCachedResults(signature, options);
+  if (cached) {
+    debug(`detection cache hit for ${providers.length} providers`);
+    return cached;
   }
-  const merged = deepMerge(existing, newEntry);
-  const content = TOML.stringify(merged);
-  await writeFile2(filePath, content, "utf-8");
+  const results = providers.map(detectProvider);
+  setCachedResults(signature, results);
+  return cloneDetectionResults(results);
 }
-async function removeTomlConfig(filePath, configKey, serverName) {
-  if (!existsSync2(filePath)) return false;
-  const existing = await readTomlConfig(filePath);
-  const keyParts = configKey.split(".");
-  let current = existing;
-  for (const part of keyParts) {
-    const next = current[part];
-    if (typeof next !== "object" || next === null) return false;
-    current = next;
-  }
-  if (!(serverName in current)) return false;
-  delete current[serverName];
-  const content = TOML.stringify(existing);
-  await writeFile2(filePath, content, "utf-8");
-  return true;
+function getInstalledProviders(options = {}) {
+  return detectAllProviders(options).filter((r) => r.installed).map((r) => r.provider);
 }
-
-// src/core/formats/yaml.ts
-import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import yaml from "js-yaml";
-async function readYamlConfig(filePath) {
-  if (!existsSync3(filePath)) return {};
-  const content = await readFile3(filePath, "utf-8");
-  if (!content.trim()) return {};
-  const result = yaml.load(content);
-  return result ?? {};
+function detectProjectProviders(projectDir, options = {}) {
+  const results = detectAllProviders(options);
+  return results.map((r) => ({
+    ...r,
+    projectDetected: detectProjectProvider(r.provider, projectDir)
+  }));
 }
-async function writeYamlConfig(filePath, configKey, serverName, serverConfig) {
-  await ensureDir(filePath);
-  const existing = await readYamlConfig(filePath);
-  const keyParts = configKey.split(".");
-  let newEntry = { [serverName]: serverConfig };
-  for (const part of [...keyParts].reverse()) {
-    newEntry = { [part]: newEntry };
-  }
-  const merged = deepMerge(existing, newEntry);
-  const content = yaml.dump(merged, {
-    indent: 2,
-    lineWidth: -1,
-    noRefs: true,
-    sortKeys: false
-  });
-  await writeFile3(filePath, content, "utf-8");
-}
-async function removeYamlConfig(filePath, configKey, serverName) {
-  if (!existsSync3(filePath)) return false;
-  const existing = await readYamlConfig(filePath);
-  const keyParts = configKey.split(".");
-  let current = existing;
-  for (const part of keyParts) {
-    const next = current[part];
-    if (typeof next !== "object" || next === null) return false;
-    current = next;
-  }
-  if (!(serverName in current)) return false;
-  delete current[serverName];
-  const content = yaml.dump(existing, {
-    indent: 2,
-    lineWidth: -1,
-    noRefs: true,
-    sortKeys: false
-  });
-  await writeFile3(filePath, content, "utf-8");
-  return true;
-}
-
-// src/core/formats/index.ts
-async function readConfig(filePath, format) {
-  debug(`reading config: ${filePath} (format: ${format})`);
-  switch (format) {
-    case "json":
-    case "jsonc":
-      return readJsonConfig(filePath);
-    case "yaml":
-      return readYamlConfig(filePath);
-    case "toml":
-      return readTomlConfig(filePath);
-    default:
-      throw new Error(`Unsupported config format: ${format}`);
-  }
-}
-async function writeConfig(filePath, format, key, serverName, serverConfig) {
-  debug(`writing config: ${filePath} (format: ${format}, key: ${key}, server: ${serverName})`);
-  switch (format) {
-    case "json":
-    case "jsonc":
-      return writeJsonConfig(filePath, key, serverName, serverConfig);
-    case "yaml":
-      return writeYamlConfig(filePath, key, serverName, serverConfig);
-    case "toml":
-      return writeTomlConfig(filePath, key, serverName, serverConfig);
-    default:
-      throw new Error(`Unsupported config format: ${format}`);
-  }
-}
-async function removeConfig(filePath, format, key, serverName) {
-  switch (format) {
-    case "json":
-    case "jsonc":
-      return removeJsonConfig(filePath, key, serverName);
-    case "yaml":
-      return removeYamlConfig(filePath, key, serverName);
-    case "toml":
-      return removeTomlConfig(filePath, key, serverName);
-    default:
-      throw new Error(`Unsupported config format: ${format}`);
-  }
+function resetDetectionCache() {
+  detectionCache = null;
 }
 
-// src/core/mcp/reader.ts
-import { existsSync as existsSync4 } from "fs";
-function resolveConfigPath(provider, scope, projectDir) {
-  return resolveProviderConfigPath(provider, scope, projectDir ?? process.cwd());
-}
-async function listMcpServers(provider, scope, projectDir) {
-  const configPath = resolveConfigPath(provider, scope, projectDir);
-  debug(`listing MCP servers for ${provider.id} (${scope}) at ${configPath ?? "(none)"}`);
-  if (!configPath || !existsSync4(configPath)) return [];
-  try {
-    const config = await readConfig(configPath, provider.configFormat);
-    const servers = getNestedValue(config, provider.configKey);
-    if (!servers || typeof servers !== "object") return [];
-    const entries = [];
-    for (const [name, cfg] of Object.entries(servers)) {
-      entries.push({
-        name,
-        providerId: provider.id,
-        providerName: provider.toolName,
-        scope,
-        configPath,
-        config: cfg ?? {}
-      });
-    }
-    return entries;
-  } catch {
-    return [];
-  }
+// src/core/skills/installer.ts
+import { existsSync as existsSync2, lstatSync } from "fs";
+import { cp, mkdir, rm, symlink } from "fs/promises";
+import { join as join2 } from "path";
+async function ensureCanonicalDir() {
+  await mkdir(getCanonicalSkillsDir(), { recursive: true });
 }
-async function listAgentsMcpServers(scope, projectDir) {
-  const serversPath = getAgentsMcpServersPath(scope, projectDir);
-  debug(`listing .agents/ MCP servers (${scope}) at ${serversPath}`);
-  if (!existsSync4(serversPath)) return [];
+async function installToCanonical(sourcePath, skillName) {
+  await ensureCanonicalDir();
+  const targetDir = join2(getCanonicalSkillsDir(), skillName);
+  await rm(targetDir, { recursive: true, force: true });
   try {
-    const config = await readConfig(serversPath, "json");
-    const servers = config["servers"];
-    if (!servers || typeof servers !== "object") return [];
-    const entries = [];
-    for (const [name, cfg] of Object.entries(servers)) {
-      entries.push({
-        name,
-        providerId: ".agents",
-        providerName: ".agents/ standard",
-        scope,
-        configPath: serversPath,
-        config: cfg ?? {}
-      });
+    await cp(sourcePath, targetDir, { recursive: true });
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "EEXIST") {
+      await rm(targetDir, { recursive: true, force: true });
+      await cp(sourcePath, targetDir, { recursive: true });
+    } else {
+      throw err;
     }
-    return entries;
-  } catch {
-    return [];
   }
+  return targetDir;
 }
-async function listAllMcpServers(providers, scope, projectDir) {
-  const seen = /* @__PURE__ */ new Set();
-  const allEntries = [];
-  const agentsServersPath = getAgentsMcpServersPath(scope, projectDir);
-  const agentsEntries = await listAgentsMcpServers(scope, projectDir);
-  if (agentsEntries.length > 0) {
-    allEntries.push(...agentsEntries);
-    seen.add(agentsServersPath);
+async function linkToAgent(canonicalPath, provider, skillName, isGlobal, projectDir) {
+  const scope = isGlobal ? "global" : "project";
+  const targetDirs = resolveProviderSkillsDirs(provider, scope, projectDir);
+  if (targetDirs.length === 0) {
+    return { success: false, error: `Provider ${provider.id} has no skills directory` };
   }
-  for (const provider of providers) {
-    const configPath = resolveConfigPath(provider, scope, projectDir);
-    if (!configPath || seen.has(configPath)) continue;
-    seen.add(configPath);
-    const entries = await listMcpServers(provider, scope, projectDir);
-    allEntries.push(...entries);
+  const errors = [];
+  let anySuccess = false;
+  for (const targetSkillsDir of targetDirs) {
+    if (!targetSkillsDir) continue;
+    try {
+      await mkdir(targetSkillsDir, { recursive: true });
+      const linkPath = join2(targetSkillsDir, skillName);
+      if (existsSync2(linkPath)) {
+        const stat2 = lstatSync(linkPath);
+        if (stat2.isSymbolicLink()) {
+          await rm(linkPath);
+        } else {
+          await rm(linkPath, { recursive: true });
+        }
+      }
+      const symlinkType = process.platform === "win32" ? "junction" : "dir";
+      try {
+        await symlink(canonicalPath, linkPath, symlinkType);
+      } catch {
+        await cp(canonicalPath, linkPath, { recursive: true });
+      }
+      anySuccess = true;
+    } catch (err) {
+      errors.push(err instanceof Error ? err.message : String(err));
+    }
   }
-  return allEntries;
-}
-async function removeMcpServer(provider, serverName, scope, projectDir) {
-  const configPath = resolveConfigPath(provider, scope, projectDir);
-  if (!configPath) return false;
-  return removeConfig(configPath, provider.configFormat, provider.configKey, serverName);
-}
-
-// src/core/mcp/transforms.ts
-function transformGoose(serverName, config) {
-  if (config.url) {
-    const transport = config.type === "sse" ? "sse" : "streamable_http";
-    return {
-      name: serverName,
-      type: transport,
-      uri: config.url,
-      ...config.headers ? { headers: config.headers } : {},
-      enabled: true,
-      timeout: 300
-    };
+  if (anySuccess) {
+    return { success: true };
   }
   return {
-    name: serverName,
-    type: "stdio",
-    cmd: config.command,
-    args: config.args ?? [],
-    ...config.env ? { envs: config.env } : {},
-    enabled: true,
-    timeout: 300
+    success: false,
+    error: errors.join("; ") || `Provider ${provider.id} has no skills directory`
   };
 }
-function transformZed(_serverName, config) {
-  if (config.url) {
-    return {
-      source: "custom",
-      type: config.type ?? "http",
-      url: config.url,
-      ...config.headers ? { headers: config.headers } : {}
-    };
+async function installSkill(sourcePath, skillName, providers, isGlobal, projectDir) {
+  const errors = [];
+  const linkedAgents = [];
+  const canonicalPath = await installToCanonical(sourcePath, skillName);
+  for (const provider of providers) {
+    const result = await linkToAgent(canonicalPath, provider, skillName, isGlobal, projectDir);
+    if (result.success) {
+      linkedAgents.push(provider.id);
+    } else if (result.error) {
+      errors.push(`${provider.id}: ${result.error}`);
+    }
   }
   return {
-    source: "custom",
-    command: config.command,
-    args: config.args ?? [],
-    ...config.env ? { env: config.env } : {}
+    name: skillName,
+    canonicalPath,
+    linkedAgents,
+    errors,
+    success: linkedAgents.length > 0
   };
 }
-function transformOpenCode(_serverName, config) {
-  if (config.url) {
-    return {
-      type: "remote",
-      url: config.url,
-      enabled: true,
-      ...config.headers ? { headers: config.headers } : {}
-    };
+async function removeSkill(skillName, providers, isGlobal, projectDir) {
+  const removed = [];
+  const errors = [];
+  for (const provider of providers) {
+    const scope = isGlobal ? "global" : "project";
+    const targetDirs = resolveProviderSkillsDirs(provider, scope, projectDir);
+    let providerRemoved = false;
+    for (const skillsDir of targetDirs) {
+      if (!skillsDir) continue;
+      const linkPath = join2(skillsDir, skillName);
+      if (existsSync2(linkPath)) {
+        try {
+          await rm(linkPath, { recursive: true });
+          providerRemoved = true;
+        } catch (err) {
+          errors.push(`${provider.id}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+    if (providerRemoved) {
+      removed.push(provider.id);
+    }
   }
-  return {
-    type: "local",
-    command: [config.command, ...config.args ?? []],
-    enabled: true,
-    ...config.env ? { environment: config.env } : {}
-  };
-}
-function transformCodex(_serverName, config) {
-  if (config.url) {
-    return {
-      type: config.type ?? "http",
-      url: config.url,
-      ...config.headers ? { headers: config.headers } : {}
-    };
+  const canonicalPath = join2(getCanonicalSkillsDir(), skillName);
+  if (existsSync2(canonicalPath)) {
+    try {
+      await rm(canonicalPath, { recursive: true });
+    } catch (err) {
+      errors.push(`canonical: ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
-  return {
-    command: config.command,
-    args: config.args ?? [],
-    ...config.env ? { env: config.env } : {}
-  };
+  return { removed, errors };
 }
-function transformCursor(_serverName, config) {
-  if (config.url) {
-    return {
-      url: config.url,
-      ...config.headers ? { headers: config.headers } : {}
-    };
-  }
-  return config;
-}
-function getTransform(providerId) {
-  switch (providerId) {
-    case "goose":
-      return transformGoose;
-    case "zed":
-      return transformZed;
-    case "opencode":
-      return transformOpenCode;
-    case "codex":
-      return transformCodex;
-    case "cursor":
-      return transformCursor;
-    default:
-      return void 0;
-  }
+async function listCanonicalSkills() {
+  if (!existsSync2(getCanonicalSkillsDir())) return [];
+  const { readdir: readdir2 } = await import("fs/promises");
+  const entries = await readdir2(getCanonicalSkillsDir(), { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
 }
 
-// src/core/mcp/installer.ts
-function buildConfig(provider, serverName, config) {
-  const transform = getTransform(provider.id);
-  if (transform) {
-    return transform(serverName, config);
-  }
-  return config;
-}
-async function installMcpServer(provider, serverName, config, scope = "project", projectDir) {
-  const configPath = resolveConfigPath(provider, scope, projectDir);
-  debug(`installing MCP server "${serverName}" for ${provider.id} (${scope})`);
-  debug(`  config path: ${configPath ?? "(none)"}`);
-  if (!configPath) {
-    return {
-      provider,
-      scope,
-      configPath: "",
-      success: false,
-      error: `Provider ${provider.id} does not support ${scope} config`
-    };
-  }
-  try {
-    const transformedConfig = buildConfig(provider, serverName, config);
-    const transform = getTransform(provider.id);
-    debug(`  transform applied: ${transform ? "yes" : "no"}`);
-    await writeConfig(
-      configPath,
-      provider.configFormat,
-      provider.configKey,
-      serverName,
-      transformedConfig
-    );
-    return {
-      provider,
-      scope,
-      configPath,
-      success: true
-    };
-  } catch (err) {
-    return {
-      provider,
-      scope,
-      configPath,
-      success: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
+// src/core/advanced/orchestration.ts
+import { existsSync as existsSync3, lstatSync as lstatSync2 } from "fs";
+import { cp as cp2, mkdir as mkdir2, readlink, rm as rm2, symlink as symlink2 } from "fs/promises";
+import { tmpdir } from "os";
+import { basename, dirname, join as join3 } from "path";
+
+// src/core/paths/agents.ts
+var AGENTS_HOME = getAgentsHome();
+var LOCK_FILE_PATH = getLockFilePath();
+var CANONICAL_SKILLS_DIR = getCanonicalSkillsDir();
+var AGENTS_MCP_DIR = getAgentsMcpDir();
+var AGENTS_MCP_SERVERS_PATH = getAgentsMcpServersPath();
+var AGENTS_CONFIG_PATH = getAgentsConfigPath();
+
+// src/core/advanced/orchestration.ts
+var PRIORITY_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+function selectProvidersByMinimumPriority(providers, minimumPriority = "low") {
+  const maxRank = PRIORITY_ORDER[minimumPriority];
+  return [...providers].filter((provider) => PRIORITY_ORDER[provider.priority] <= maxRank).sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
 }
-async function installMcpServerToAll(providers, serverName, config, scope = "project", projectDir) {
-  const results = [];
-  for (const provider of providers) {
-    const result = await installMcpServer(provider, serverName, config, scope, projectDir);
-    results.push(result);
-  }
-  return results;
+function resolveSkillLinkPath(provider, skillName, isGlobal, projectDir) {
+  const skillDir = isGlobal ? provider.pathSkills : join3(projectDir, provider.pathProjectSkills);
+  return join3(skillDir, skillName);
 }
-function buildServerConfig(source, transport, headers) {
-  if (source.type === "remote") {
-    return {
-      type: transport ?? "http",
-      url: source.value,
-      ...headers && Object.keys(headers).length > 0 ? { headers } : {}
-    };
-  }
-  if (source.type === "package") {
-    return {
-      command: "npx",
-      args: ["-y", source.value]
-    };
-  }
-  const parts = source.value.trim().split(/\s+/);
-  const command = parts[0] ?? source.value;
-  return {
-    command,
-    args: parts.slice(1)
-  };
-}
-
-// src/core/registry/detection.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import { join } from "path";
-var DEFAULT_DETECTION_CACHE_TTL_MS = 3e4;
-var detectionCache = null;
-function checkBinary(binary) {
-  try {
-    const cmd = process.platform === "win32" ? "where" : "which";
-    execFileSync(cmd, [binary], { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function checkDirectory(dir) {
-  return existsSync5(dir);
-}
-function checkAppBundle(appName) {
-  if (process.platform !== "darwin") return false;
-  const applications = getPlatformLocations().applications;
-  return applications.some((base) => existsSync5(join(base, appName)));
-}
-function checkFlatpak(flatpakId) {
-  if (process.platform !== "linux") return false;
-  try {
-    execFileSync("flatpak", ["info", flatpakId], { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
+async function snapshotSkillState(providerTargets, operation, projectDir, backupRoot) {
+  const skillName = operation.skillName;
+  const isGlobal = operation.isGlobal ?? true;
+  const canonicalPath = join3(CANONICAL_SKILLS_DIR, skillName);
+  const canonicalExisted = existsSync3(canonicalPath);
+  const canonicalBackupPath = join3(backupRoot, "canonical", skillName);
+  if (canonicalExisted) {
+    await mkdir2(dirname(canonicalBackupPath), { recursive: true });
+    await cp2(canonicalPath, canonicalBackupPath, { recursive: true });
   }
-}
-function detectProvider(provider) {
-  const matchedMethods = [];
-  const detection = provider.detection;
-  debug(`detecting provider ${provider.id} via methods: ${detection.methods.join(", ")}`);
-  for (const method of detection.methods) {
-    switch (method) {
-      case "binary":
-        if (detection.binary && checkBinary(detection.binary)) {
-          debug(`  ${provider.id}: binary "${detection.binary}" found`);
-          matchedMethods.push("binary");
-        }
-        break;
-      case "directory":
-        if (detection.directories) {
-          for (const dir of detection.directories) {
-            if (checkDirectory(dir)) {
-              matchedMethods.push("directory");
-              break;
-            }
-          }
-        }
-        break;
-      case "appBundle":
-        if (detection.appBundle && checkAppBundle(detection.appBundle)) {
-          matchedMethods.push("appBundle");
-        }
-        break;
-      case "flatpak":
-        if (detection.flatpakId && checkFlatpak(detection.flatpakId)) {
-          matchedMethods.push("flatpak");
-        }
-        break;
+  const pathSnapshots = [];
+  for (const provider of providerTargets) {
+    const linkPath = resolveSkillLinkPath(provider, skillName, isGlobal, projectDir);
+    if (!existsSync3(linkPath)) {
+      pathSnapshots.push({ linkPath, state: "missing" });
+      continue;
+    }
+    const stat2 = lstatSync2(linkPath);
+    if (stat2.isSymbolicLink()) {
+      pathSnapshots.push({
+        linkPath,
+        state: "symlink",
+        symlinkTarget: await readlink(linkPath)
+      });
+      continue;
+    }
+    const backupPath = join3(backupRoot, "links", provider.id, `${skillName}-${basename(linkPath)}`);
+    await mkdir2(dirname(backupPath), { recursive: true });
+    if (stat2.isDirectory()) {
+      await cp2(linkPath, backupPath, { recursive: true });
+      pathSnapshots.push({ linkPath, state: "directory", backupPath });
+      continue;
     }
+    await cp2(linkPath, backupPath);
+    pathSnapshots.push({ linkPath, state: "file", backupPath });
   }
   return {
-    provider,
-    installed: matchedMethods.length > 0,
-    methods: matchedMethods,
-    projectDetected: false
-  };
-}
-function providerSignature(provider) {
-  return JSON.stringify({
-    id: provider.id,
-    methods: provider.detection.methods,
-    binary: provider.detection.binary,
-    directories: provider.detection.directories,
-    appBundle: provider.detection.appBundle,
-    flatpakId: provider.detection.flatpakId
-  });
-}
-function buildProvidersSignature(providers) {
-  if (!providers || !Array.isArray(providers)) return "";
-  return providers.map(providerSignature).join("|");
-}
-function cloneDetectionResults(results) {
-  return results.map((result) => ({
-    provider: result.provider,
-    installed: result.installed,
-    methods: [...result.methods],
-    projectDetected: result.projectDetected
-  }));
-}
-function getCachedResults(signature, options) {
-  if (!detectionCache || options.forceRefresh) return null;
-  if (detectionCache.signature !== signature) return null;
-  const ttlMs = options.ttlMs ?? DEFAULT_DETECTION_CACHE_TTL_MS;
-  if (ttlMs <= 0) return null;
-  if (Date.now() - detectionCache.createdAt > ttlMs) return null;
-  return cloneDetectionResults(detectionCache.results);
-}
-function setCachedResults(signature, results) {
-  detectionCache = {
-    createdAt: Date.now(),
-    signature,
-    results: cloneDetectionResults(results)
+    skillName,
+    isGlobal,
+    canonicalPath,
+    canonicalBackupPath: canonicalExisted ? canonicalBackupPath : void 0,
+    canonicalExisted,
+    pathSnapshots
   };
 }
-function detectProjectProvider(provider, projectDir) {
-  if (!provider.pathProject) return false;
-  return existsSync5(resolveProviderProjectPath(provider, projectDir));
-}
-function detectAllProviders(options = {}) {
-  const providers = getAllProviders() ?? [];
-  const signature = buildProvidersSignature(providers);
-  const cached = getCachedResults(signature, options);
-  if (cached) {
-    debug(`detection cache hit for ${providers.length} providers`);
-    return cached;
-  }
-  const results = providers.map(detectProvider);
-  setCachedResults(signature, results);
-  return cloneDetectionResults(results);
-}
-function getInstalledProviders(options = {}) {
-  return detectAllProviders(options).filter((r) => r.installed).map((r) => r.provider);
-}
-function detectProjectProviders(projectDir, options = {}) {
-  const results = detectAllProviders(options);
-  return results.map((r) => ({
-    ...r,
-    projectDetected: detectProjectProvider(r.provider, projectDir)
-  }));
-}
-function resetDetectionCache() {
-  detectionCache = null;
-}
-
-// src/core/skills/installer.ts
-import { existsSync as existsSync6, lstatSync } from "fs";
-import { cp, mkdir, rm, symlink } from "fs/promises";
-import { join as join2 } from "path";
-async function ensureCanonicalDir() {
-  await mkdir(getCanonicalSkillsDir(), { recursive: true });
-}
-async function installToCanonical(sourcePath, skillName) {
-  await ensureCanonicalDir();
-  const targetDir = join2(getCanonicalSkillsDir(), skillName);
-  await rm(targetDir, { recursive: true, force: true });
-  try {
-    await cp(sourcePath, targetDir, { recursive: true });
-  } catch (err) {
-    if (err && typeof err === "object" && "code" in err && err.code === "EEXIST") {
-      await rm(targetDir, { recursive: true, force: true });
-      await cp(sourcePath, targetDir, { recursive: true });
-    } else {
-      throw err;
-    }
+async function restoreSkillSnapshot(snapshot) {
+  if (existsSync3(snapshot.canonicalPath)) {
+    await rm2(snapshot.canonicalPath, { recursive: true, force: true });
   }
-  return targetDir;
-}
-async function linkToAgent(canonicalPath, provider, skillName, isGlobal, projectDir) {
-  const scope = isGlobal ? "global" : "project";
-  const targetDirs = resolveProviderSkillsDirs(provider, scope, projectDir);
-  if (targetDirs.length === 0) {
-    return { success: false, error: `Provider ${provider.id} has no skills directory` };
+  if (snapshot.canonicalExisted && snapshot.canonicalBackupPath && existsSync3(snapshot.canonicalBackupPath)) {
+    await mkdir2(dirname(snapshot.canonicalPath), { recursive: true });
+    await cp2(snapshot.canonicalBackupPath, snapshot.canonicalPath, { recursive: true });
   }
-  const errors = [];
-  let anySuccess = false;
-  for (const targetSkillsDir of targetDirs) {
-    if (!targetSkillsDir) continue;
-    try {
-      await mkdir(targetSkillsDir, { recursive: true });
-      const linkPath = join2(targetSkillsDir, skillName);
-      if (existsSync6(linkPath)) {
-        const stat2 = lstatSync(linkPath);
-        if (stat2.isSymbolicLink()) {
-          await rm(linkPath);
-        } else {
-          await rm(linkPath, { recursive: true });
-        }
-      }
-      const symlinkType = process.platform === "win32" ? "junction" : "dir";
-      try {
-        await symlink(canonicalPath, linkPath, symlinkType);
-      } catch {
-        await cp(canonicalPath, linkPath, { recursive: true });
-      }
-      anySuccess = true;
-    } catch (err) {
-      errors.push(err instanceof Error ? err.message : String(err));
-    }
-  }
-  if (anySuccess) {
-    return { success: true };
-  }
-  return {
-    success: false,
-    error: errors.join("; ") || `Provider ${provider.id} has no skills directory`
-  };
-}
-async function installSkill(sourcePath, skillName, providers, isGlobal, projectDir) {
-  const errors = [];
-  const linkedAgents = [];
-  const canonicalPath = await installToCanonical(sourcePath, skillName);
-  for (const provider of providers) {
-    const result = await linkToAgent(canonicalPath, provider, skillName, isGlobal, projectDir);
-    if (result.success) {
-      linkedAgents.push(provider.id);
-    } else if (result.error) {
-      errors.push(`${provider.id}: ${result.error}`);
-    }
-  }
-  return {
-    name: skillName,
-    canonicalPath,
-    linkedAgents,
-    errors,
-    success: linkedAgents.length > 0
-  };
-}
-async function removeSkill(skillName, providers, isGlobal, projectDir) {
-  const removed = [];
-  const errors = [];
-  for (const provider of providers) {
-    const scope = isGlobal ? "global" : "project";
-    const targetDirs = resolveProviderSkillsDirs(provider, scope, projectDir);
-    let providerRemoved = false;
-    for (const skillsDir of targetDirs) {
-      if (!skillsDir) continue;
-      const linkPath = join2(skillsDir, skillName);
-      if (existsSync6(linkPath)) {
-        try {
-          await rm(linkPath, { recursive: true });
-          providerRemoved = true;
-        } catch (err) {
-          errors.push(`${provider.id}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-      }
-    }
-    if (providerRemoved) {
-      removed.push(provider.id);
-    }
-  }
-  const canonicalPath = join2(getCanonicalSkillsDir(), skillName);
-  if (existsSync6(canonicalPath)) {
-    try {
-      await rm(canonicalPath, { recursive: true });
-    } catch (err) {
-      errors.push(`canonical: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  return { removed, errors };
-}
-async function listCanonicalSkills() {
-  if (!existsSync6(getCanonicalSkillsDir())) return [];
-  const { readdir: readdir2 } = await import("fs/promises");
-  const entries = await readdir2(getCanonicalSkillsDir(), { withFileTypes: true });
-  return entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
-}
-
-// src/core/advanced/orchestration.ts
-import { existsSync as existsSync7, lstatSync as lstatSync2 } from "fs";
-import { cp as cp2, mkdir as mkdir2, readFile as readFile4, readlink, rm as rm2, symlink as symlink2, writeFile as writeFile4 } from "fs/promises";
-import { tmpdir } from "os";
-import { basename, dirname, join as join3 } from "path";
-
-// src/core/paths/agents.ts
-var AGENTS_HOME = getAgentsHome();
-var LOCK_FILE_PATH = getLockFilePath();
-var CANONICAL_SKILLS_DIR = getCanonicalSkillsDir();
-var AGENTS_MCP_DIR = getAgentsMcpDir();
-var AGENTS_MCP_SERVERS_PATH = getAgentsMcpServersPath();
-var AGENTS_CONFIG_PATH = getAgentsConfigPath();
-
-// src/core/advanced/orchestration.ts
-var PRIORITY_ORDER = {
-  high: 0,
-  medium: 1,
-  low: 2
-};
-function selectProvidersByMinimumPriority(providers, minimumPriority = "low") {
-  const maxRank = PRIORITY_ORDER[minimumPriority];
-  return [...providers].filter((provider) => PRIORITY_ORDER[provider.priority] <= maxRank).sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
-}
-function resolveSkillLinkPath(provider, skillName, isGlobal, projectDir) {
-  const skillDir = isGlobal ? provider.pathSkills : join3(projectDir, provider.pathProjectSkills);
-  return join3(skillDir, skillName);
-}
-async function snapshotConfigs(paths) {
-  const snapshots = /* @__PURE__ */ new Map();
-  for (const path of paths) {
-    if (!path || snapshots.has(path)) continue;
-    if (!existsSync7(path)) {
-      snapshots.set(path, null);
-      continue;
-    }
-    snapshots.set(path, await readFile4(path, "utf-8"));
-  }
-  return snapshots;
-}
-async function restoreConfigSnapshots(snapshots) {
-  for (const [path, content] of snapshots) {
-    if (content === null) {
-      await rm2(path, { force: true });
-      continue;
-    }
-    await mkdir2(dirname(path), { recursive: true });
-    await writeFile4(path, content, "utf-8");
-  }
-}
-async function snapshotSkillState(providerTargets, operation, projectDir, backupRoot) {
-  const skillName = operation.skillName;
-  const isGlobal = operation.isGlobal ?? true;
-  const canonicalPath = join3(CANONICAL_SKILLS_DIR, skillName);
-  const canonicalExisted = existsSync7(canonicalPath);
-  const canonicalBackupPath = join3(backupRoot, "canonical", skillName);
-  if (canonicalExisted) {
-    await mkdir2(dirname(canonicalBackupPath), { recursive: true });
-    await cp2(canonicalPath, canonicalBackupPath, { recursive: true });
-  }
-  const pathSnapshots = [];
-  for (const provider of providerTargets) {
-    const linkPath = resolveSkillLinkPath(provider, skillName, isGlobal, projectDir);
-    if (!existsSync7(linkPath)) {
-      pathSnapshots.push({ linkPath, state: "missing" });
-      continue;
-    }
-    const stat2 = lstatSync2(linkPath);
-    if (stat2.isSymbolicLink()) {
-      pathSnapshots.push({
-        linkPath,
-        state: "symlink",
-        symlinkTarget: await readlink(linkPath)
-      });
-      continue;
-    }
-    const backupPath = join3(backupRoot, "links", provider.id, `${skillName}-${basename(linkPath)}`);
-    await mkdir2(dirname(backupPath), { recursive: true });
-    if (stat2.isDirectory()) {
-      await cp2(linkPath, backupPath, { recursive: true });
-      pathSnapshots.push({ linkPath, state: "directory", backupPath });
-      continue;
-    }
-    await cp2(linkPath, backupPath);
-    pathSnapshots.push({ linkPath, state: "file", backupPath });
-  }
-  return {
-    skillName,
-    isGlobal,
-    canonicalPath,
-    canonicalBackupPath: canonicalExisted ? canonicalBackupPath : void 0,
-    canonicalExisted,
-    pathSnapshots
-  };
-}
-async function restoreSkillSnapshot(snapshot) {
-  if (existsSync7(snapshot.canonicalPath)) {
-    await rm2(snapshot.canonicalPath, { recursive: true, force: true });
-  }
-  if (snapshot.canonicalExisted && snapshot.canonicalBackupPath && existsSync7(snapshot.canonicalBackupPath)) {
-    await mkdir2(dirname(snapshot.canonicalPath), { recursive: true });
-    await cp2(snapshot.canonicalBackupPath, snapshot.canonicalPath, { recursive: true });
-  }
-  for (const pathSnapshot of snapshot.pathSnapshots) {
-    await rm2(pathSnapshot.linkPath, { recursive: true, force: true });
-    if (pathSnapshot.state === "missing") continue;
-    await mkdir2(dirname(pathSnapshot.linkPath), { recursive: true });
-    if (pathSnapshot.state === "symlink" && pathSnapshot.symlinkTarget) {
-      const linkType = process.platform === "win32" ? "junction" : "dir";
-      await symlink2(pathSnapshot.symlinkTarget, pathSnapshot.linkPath, linkType);
-      continue;
-    }
-    if ((pathSnapshot.state === "directory" || pathSnapshot.state === "file") && pathSnapshot.backupPath) {
-      if (pathSnapshot.state === "directory") {
-        await cp2(pathSnapshot.backupPath, pathSnapshot.linkPath, { recursive: true });
-      } else {
-        await cp2(pathSnapshot.backupPath, pathSnapshot.linkPath);
+  for (const pathSnapshot of snapshot.pathSnapshots) {
+    await rm2(pathSnapshot.linkPath, { recursive: true, force: true });
+    if (pathSnapshot.state === "missing") continue;
+    await mkdir2(dirname(pathSnapshot.linkPath), { recursive: true });
+    if (pathSnapshot.state === "symlink" && pathSnapshot.symlinkTarget) {
+      const linkType = process.platform === "win32" ? "junction" : "dir";
+      await symlink2(pathSnapshot.symlinkTarget, pathSnapshot.linkPath, linkType);
+      continue;
+    }
+    if ((pathSnapshot.state === "directory" || pathSnapshot.state === "file") && pathSnapshot.backupPath) {
+      if (pathSnapshot.state === "directory") {
+        await cp2(pathSnapshot.backupPath, pathSnapshot.linkPath, { recursive: true });
+      } else {
+        await cp2(pathSnapshot.backupPath, pathSnapshot.linkPath);
       }
     }
   }
@@ -924,19 +407,9 @@ async function restoreSkillSnapshot(snapshot) {
 async function installBatchWithRollback(options) {
   const projectDir = options.projectDir ?? process.cwd();
   const minimumPriority = options.minimumPriority ?? "low";
-  const mcpOps = options.mcp ?? [];
   const skillOps = options.skills ?? [];
   const baseProviders = options.providers ?? getInstalledProviders();
   const providers = selectProvidersByMinimumPriority(baseProviders, minimumPriority);
-  const configPaths = providers.flatMap((provider) => {
-    const paths = [];
-    for (const operation of mcpOps) {
-      const path = resolveConfigPath(provider, operation.scope ?? "project", projectDir);
-      if (path) paths.push(path);
-    }
-    return paths;
-  });
-  const configSnapshots = await snapshotConfigs(configPaths);
   const backupRoot = join3(
     tmpdir(),
     `caamp-skill-backup-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
@@ -946,26 +419,9 @@ async function installBatchWithRollback(options) {
   );
   const appliedSkills = [];
   const rollbackErrors = [];
-  let mcpApplied = 0;
   let skillsApplied = 0;
   let rollbackPerformed = false;
   try {
-    for (const operation of mcpOps) {
-      const scope = operation.scope ?? "project";
-      for (const provider of providers) {
-        const result = await installMcpServer(
-          provider,
-          operation.serverName,
-          operation.config,
-          scope,
-          projectDir
-        );
-        if (!result.success) {
-          throw new Error(result.error ?? `Failed MCP install for ${provider.id}`);
-        }
-        mcpApplied += 1;
-      }
-    }
     for (const operation of skillOps) {
       const isGlobal = operation.isGlobal ?? true;
       const result = await installSkill(
@@ -992,7 +448,6 @@ async function installBatchWithRollback(options) {
     return {
       success: true,
       providerIds: providers.map((provider) => provider.id),
-      mcpApplied,
       skillsApplied,
       rollbackPerformed: false,
       rollbackErrors: []
@@ -1006,11 +461,6 @@ async function installBatchWithRollback(options) {
         rollbackErrors.push(err instanceof Error ? err.message : String(err));
       }
     }
-    try {
-      await restoreConfigSnapshots(configSnapshots);
-    } catch (err) {
-      rollbackErrors.push(err instanceof Error ? err.message : String(err));
-    }
     for (const snapshot of skillSnapshots) {
       try {
         await restoreSkillSnapshot(snapshot);
@@ -1022,7 +472,6 @@ async function installBatchWithRollback(options) {
     return {
       success: false,
       providerIds: providers.map((provider) => provider.id),
-      mcpApplied,
       skillsApplied,
       rollbackPerformed,
       rollbackErrors,
@@ -1030,99 +479,6 @@ async function installBatchWithRollback(options) {
     };
   }
 }
-function stableStringify(value) {
-  if (Array.isArray(value)) {
-    return `[${value.map(stableStringify).join(",")}]`;
-  }
-  if (value && typeof value === "object") {
-    const record = value;
-    const keys = Object.keys(record).sort();
-    return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-async function detectMcpConfigConflicts(providers, operations, projectDir = process.cwd()) {
-  const conflicts = [];
-  for (const provider of providers) {
-    for (const operation of operations) {
-      const scope = operation.scope ?? "project";
-      if (operation.config.type && !provider.supportedTransports.includes(operation.config.type)) {
-        conflicts.push({
-          providerId: provider.id,
-          serverName: operation.serverName,
-          scope,
-          code: "unsupported-transport",
-          message: `${provider.id} does not support transport ${operation.config.type}`
-        });
-      }
-      if (operation.config.headers && !provider.supportsHeaders) {
-        conflicts.push({
-          providerId: provider.id,
-          serverName: operation.serverName,
-          scope,
-          code: "unsupported-headers",
-          message: `${provider.id} does not support header configuration`
-        });
-      }
-      const existingEntries = await listMcpServers(provider, scope, projectDir);
-      const current = existingEntries.find((entry) => entry.name === operation.serverName);
-      if (!current) continue;
-      const transform = getTransform(provider.id);
-      const desired = transform ? transform(operation.serverName, operation.config) : operation.config;
-      if (stableStringify(current.config) !== stableStringify(desired)) {
-        conflicts.push({
-          providerId: provider.id,
-          serverName: operation.serverName,
-          scope,
-          code: "existing-mismatch",
-          message: `${provider.id} has existing config mismatch for ${operation.serverName}`
-        });
-      }
-    }
-  }
-  return conflicts;
-}
-async function applyMcpInstallWithPolicy(providers, operations, policy = "fail", projectDir = process.cwd()) {
-  const conflicts = await detectMcpConfigConflicts(providers, operations, projectDir);
-  const conflictKey = (providerId, serverName, scope) => `${providerId}::${serverName}::${scope}`;
-  const conflictMap = /* @__PURE__ */ new Map();
-  for (const conflict of conflicts) {
-    conflictMap.set(
-      conflictKey(conflict.providerId, conflict.serverName, conflict.scope),
-      conflict
-    );
-  }
-  if (policy === "fail" && conflicts.length > 0) {
-    return { conflicts, applied: [], skipped: [] };
-  }
-  const applied = [];
-  const skipped = [];
-  for (const provider of providers) {
-    for (const operation of operations) {
-      const scope = operation.scope ?? "project";
-      const key = conflictKey(provider.id, operation.serverName, scope);
-      const conflict = conflictMap.get(key);
-      if (policy === "skip" && conflict) {
-        skipped.push({
-          providerId: provider.id,
-          serverName: operation.serverName,
-          scope,
-          reason: conflict.code
-        });
-        continue;
-      }
-      const result = await installMcpServer(
-        provider,
-        operation.serverName,
-        operation.config,
-        scope,
-        projectDir
-      );
-      applied.push(result);
-    }
-  }
-  return { conflicts, applied, skipped };
-}
 async function updateInstructionsSingleOperation(providers, content, scope = "project", projectDir = process.cwd()) {
   const actions = await injectAll(providers, projectDir, scope, content);
   const groupedByFile = groupByInstructFile(providers);
@@ -1147,634 +503,254 @@ async function updateInstructionsSingleOperation(providers, content, scope = "pr
   }
   return summary;
 }
-async function configureProviderGlobalAndProject(provider, options) {
-  const projectDir = options.projectDir ?? process.cwd();
-  const globalOps = options.globalMcp ?? [];
-  const projectOps = options.projectMcp ?? [];
-  const globalResults = [];
-  for (const operation of globalOps) {
-    globalResults.push(
-      await installMcpServer(
-        provider,
-        operation.serverName,
-        operation.config,
-        "global",
-        projectDir
-      )
-    );
-  }
-  const projectResults = [];
-  for (const operation of projectOps) {
-    projectResults.push(
-      await installMcpServer(
-        provider,
-        operation.serverName,
-        operation.config,
-        "project",
-        projectDir
-      )
-    );
-  }
-  const instructionResults = {};
-  const instructionContent = options.instructionContent;
-  if (typeof instructionContent === "string") {
-    instructionResults.global = await injectAll(
-      [provider],
-      projectDir,
-      "global",
-      instructionContent
-    );
-    instructionResults.project = await injectAll(
-      [provider],
-      projectDir,
-      "project",
-      instructionContent
-    );
-  } else if (instructionContent) {
-    if (instructionContent.global) {
-      instructionResults.global = await injectAll(
-        [provider],
-        projectDir,
-        "global",
-        instructionContent.global
-      );
-    }
-    if (instructionContent.project) {
-      instructionResults.project = await injectAll(
-        [provider],
-        projectDir,
-        "project",
-        instructionContent.project
+
+// src/core/formats/utils.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(
+        targetVal,
+        sourceVal
       );
+    } else {
+      result[key] = sourceVal;
     }
   }
-  return {
-    providerId: provider.id,
-    configPaths: {
-      global: resolveConfigPath(provider, "global", projectDir),
-      project: resolveConfigPath(provider, "project", projectDir)
-    },
-    mcp: {
-      global: globalResults,
-      project: projectResults
-    },
-    instructions: instructionResults
-  };
-}
-
-// src/core/mcp/cleo.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
-import { homedir } from "os";
-import { isAbsolute, resolve } from "path";
-var CLEO_SERVER_NAMES = {
-  stable: "cleo",
-  beta: "cleo-beta",
-  dev: "cleo-dev"
-};
-var CLEO_MCP_NPM_PACKAGE = "@cleocode/cleo";
-var CLEO_DEV_DIR_DEFAULT = "~/.cleo-dev";
-function normalizeCleoChannel(value) {
-  if (!value || value.trim() === "") return "stable";
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "stable" || normalized === "beta" || normalized === "dev") {
-    return normalized;
-  }
-  throw new Error(`Invalid channel "${value}". Expected stable, beta, or dev.`);
-}
-function resolveCleoServerName(channel) {
-  return CLEO_SERVER_NAMES[channel];
-}
-function resolveChannelFromServerName(serverName) {
-  if (serverName === CLEO_SERVER_NAMES.stable) return "stable";
-  if (serverName === CLEO_SERVER_NAMES.beta) return "beta";
-  if (serverName === CLEO_SERVER_NAMES.dev) return "dev";
-  return null;
+  return result;
 }
-function splitCommand(command, explicitArgs = []) {
-  if (explicitArgs.length > 0) {
-    return { command, args: explicitArgs };
-  }
-  const parts = command.trim().split(/\s+/);
-  const binary = parts[0] ?? "";
-  if (!binary) {
-    throw new Error("Command is required for dev channel.");
+function getNestedValue(obj, keyPath) {
+  const parts = keyPath.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[part];
   }
-  return {
-    command: binary,
-    args: parts.slice(1)
-  };
+  return current;
 }
-function normalizeEnv(env, channel, cleoDir) {
-  const result = { ...env ?? {} };
-  if (channel === "dev" && !result.CLEO_DIR) {
-    result.CLEO_DIR = cleoDir ?? CLEO_DEV_DIR_DEFAULT;
-  }
-  return Object.keys(result).length > 0 ? result : void 0;
+async function ensureDir(filePath) {
+  const { mkdir: mkdir4 } = await import("fs/promises");
+  const { dirname: dirname3 } = await import("path");
+  await mkdir4(dirname3(filePath), { recursive: true });
 }
-function resolvePackageSpec(channel, version) {
-  const tag = version?.trim() || (channel === "stable" ? "latest" : "beta");
-  return `${CLEO_MCP_NPM_PACKAGE}@${tag}`;
+
+// src/core/formats/json.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import * as jsonc from "jsonc-parser";
+async function readJsonConfig(filePath) {
+  if (!existsSync4(filePath)) return {};
+  const content = await readFile(filePath, "utf-8");
+  if (!content.trim()) return {};
+  const errors = [];
+  const result = jsonc.parse(content, errors);
+  if (errors.length > 0) {
+    return JSON.parse(content);
+  }
+  return result ?? {};
 }
-function buildCleoProfile(options) {
-  const channel = options.channel;
-  const serverName = resolveCleoServerName(channel);
-  if (channel === "dev") {
-    if (!options.command || options.command.trim() === "") {
-      throw new Error("Dev channel requires --command.");
-    }
-    const parsed = splitCommand(options.command, options.args ?? []);
-    const env = normalizeEnv(options.env, channel, options.cleoDir);
-    return {
-      channel,
-      serverName,
-      config: {
-        command: parsed.command,
-        args: parsed.args,
-        ...env ? { env } : {}
+function detectIndent(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^(\s+)/);
+    if (match?.[1]) {
+      const ws = match[1];
+      if (ws.startsWith("	")) {
+        return { indent: "	", insertSpaces: false, tabSize: 1 };
       }
-    };
+      return { indent: ws, insertSpaces: true, tabSize: ws.length };
+    }
   }
-  const packageSpec = resolvePackageSpec(channel, options.version);
-  return {
-    channel,
-    serverName,
-    packageSpec,
-    config: {
-      command: "npx",
-      args: ["-y", packageSpec, "mcp"]
-    }
-  };
-}
-function expandHome(pathValue) {
-  if (pathValue === "~") return homedir();
-  if (pathValue.startsWith("~/")) {
-    return resolve(homedir(), pathValue.slice(2));
-  }
-  return pathValue;
+  return { indent: "  ", insertSpaces: true, tabSize: 2 };
 }
-function checkCommandReachability(command) {
-  const hasPathSeparator = command.includes("/") || command.includes("\\");
-  if (hasPathSeparator || command.startsWith("~")) {
-    const expanded = expandHome(command);
-    const candidate = isAbsolute(expanded) ? expanded : resolve(process.cwd(), expanded);
-    if (existsSync8(candidate)) {
-      return { reachable: true, method: "path", detail: candidate };
+async function writeJsonConfig(filePath, configKey, serverName, serverConfig) {
+  await ensureDir(filePath);
+  let content;
+  if (existsSync4(filePath)) {
+    content = await readFile(filePath, "utf-8");
+    if (!content.trim()) {
+      content = "{}";
     }
-    return { reachable: false, method: "path", detail: candidate };
-  }
-  try {
-    const lookup = process.platform === "win32" ? "where" : "which";
-    execFileSync2(lookup, [command], { stdio: "pipe" });
-    return { reachable: true, method: "lookup", detail: command };
-  } catch {
-    return { reachable: false, method: "lookup", detail: command };
+  } else {
+    content = "{}";
   }
-}
-function parseEnvAssignments(values) {
-  const env = {};
-  for (const value of values) {
-    const idx = value.indexOf("=");
-    if (idx <= 0) {
-      throw new Error(`Invalid --env value "${value}". Use KEY=value.`);
-    }
-    const key = value.slice(0, idx).trim();
-    const val = value.slice(idx + 1).trim();
-    if (!key) {
-      throw new Error(`Invalid --env value "${value}". Key cannot be empty.`);
-    }
-    env[key] = val;
+  const { tabSize, insertSpaces } = detectIndent(content);
+  const formatOptions = {
+    tabSize,
+    insertSpaces,
+    eol: "\n"
+  };
+  const keyParts = configKey.split(".");
+  const jsonPath = [...keyParts, serverName];
+  const edits = jsonc.modify(content, jsonPath, serverConfig, { formattingOptions: formatOptions });
+  if (edits.length > 0) {
+    content = jsonc.applyEdits(content, edits);
   }
-  return env;
-}
-function extractVersionTag(packageSpec) {
-  if (!packageSpec) return void 0;
-  const atIndex = packageSpec.lastIndexOf("@");
-  if (atIndex <= 0) return void 0;
-  return packageSpec.slice(atIndex + 1);
-}
-function isCleoSource(source) {
-  return source.trim().toLowerCase() === "cleo";
-}
-
-// src/core/lock-utils.ts
-import { existsSync as existsSync9 } from "fs";
-import { mkdir as mkdir3, open, readFile as readFile5, rename, rm as rm3, stat, writeFile as writeFile5 } from "fs/promises";
-var LOCK_GUARD_PATH = `${LOCK_FILE_PATH}.lock`;
-var STALE_LOCK_MS = 5e3;
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-async function removeStaleLock() {
-  try {
-    const info = await stat(LOCK_GUARD_PATH);
-    if (Date.now() - info.mtimeMs > STALE_LOCK_MS) {
-      await rm3(LOCK_GUARD_PATH, { force: true });
-      return true;
-    }
-  } catch {
+  if (!content.endsWith("\n")) {
+    content += "\n";
   }
-  return false;
+  await writeFile(filePath, content, "utf-8");
 }
-async function acquireLockGuard(retries = 40, delayMs = 25) {
-  await mkdir3(AGENTS_HOME, { recursive: true });
-  for (let attempt = 0; attempt < retries; attempt += 1) {
-    try {
-      const handle = await open(LOCK_GUARD_PATH, "wx");
-      await handle.close();
-      return;
-    } catch (error) {
-      if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
-        throw error;
-      }
-      if (attempt === 0) {
-        const removed = await removeStaleLock();
-        if (removed) continue;
-      }
-      await sleep(delayMs);
-    }
+async function removeJsonConfig(filePath, configKey, serverName) {
+  if (!existsSync4(filePath)) return false;
+  let content = await readFile(filePath, "utf-8");
+  if (!content.trim()) return false;
+  const { tabSize, insertSpaces } = detectIndent(content);
+  const formatOptions = {
+    tabSize,
+    insertSpaces,
+    eol: "\n"
+  };
+  const keyParts = configKey.split(".");
+  const jsonPath = [...keyParts, serverName];
+  const edits = jsonc.modify(content, jsonPath, void 0, { formattingOptions: formatOptions });
+  if (edits.length === 0) return false;
+  content = jsonc.applyEdits(content, edits);
+  if (!content.endsWith("\n")) {
+    content += "\n";
   }
-  throw new Error("Timed out waiting for lock file guard");
-}
-async function releaseLockGuard() {
-  await rm3(LOCK_GUARD_PATH, { force: true });
+  await writeFile(filePath, content, "utf-8");
+  return true;
 }
-async function writeLockFileUnsafe(lock) {
-  const tmpPath = `${LOCK_FILE_PATH}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile5(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
-  await rename(tmpPath, LOCK_FILE_PATH);
+
+// src/core/formats/toml.ts
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import TOML from "@iarna/toml";
+async function readTomlConfig(filePath) {
+  if (!existsSync5(filePath)) return {};
+  const content = await readFile2(filePath, "utf-8");
+  if (!content.trim()) return {};
+  const result = TOML.parse(content);
+  return result;
 }
-async function readLockFile() {
-  try {
-    if (!existsSync9(LOCK_FILE_PATH)) {
-      return { version: 1, skills: {}, mcpServers: {} };
-    }
-    const content = await readFile5(LOCK_FILE_PATH, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return { version: 1, skills: {}, mcpServers: {} };
+async function writeTomlConfig(filePath, configKey, serverName, serverConfig) {
+  await ensureDir(filePath);
+  const existing = await readTomlConfig(filePath);
+  const keyParts = configKey.split(".");
+  let newEntry = { [serverName]: serverConfig };
+  for (const part of [...keyParts].reverse()) {
+    newEntry = { [part]: newEntry };
   }
+  const merged = deepMerge(existing, newEntry);
+  const content = TOML.stringify(merged);
+  await writeFile2(filePath, content, "utf-8");
 }
-async function updateLockFile(updater) {
-  await acquireLockGuard();
-  try {
-    const lock = await readLockFile();
-    await updater(lock);
-    await writeLockFileUnsafe(lock);
-    return lock;
-  } finally {
-    await releaseLockGuard();
+async function removeTomlConfig(filePath, configKey, serverName) {
+  if (!existsSync5(filePath)) return false;
+  const existing = await readTomlConfig(filePath);
+  const keyParts = configKey.split(".");
+  let current = existing;
+  for (const part of keyParts) {
+    const next = current[part];
+    if (typeof next !== "object" || next === null) return false;
+    current = next;
   }
+  if (!(serverName in current)) return false;
+  delete current[serverName];
+  const content = TOML.stringify(existing);
+  await writeFile2(filePath, content, "utf-8");
+  return true;
 }
 
-// src/core/mcp/lock.ts
-async function recordMcpInstall(serverName, source, sourceType, agents, isGlobal, version) {
-  await updateLockFile((lock) => {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const existing = lock.mcpServers[serverName];
-    lock.mcpServers[serverName] = {
-      name: serverName,
-      scopedName: serverName,
-      source,
-      sourceType,
-      version: version ?? existing?.version,
-      installedAt: existing?.installedAt ?? now,
-      updatedAt: now,
-      agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
-      canonicalPath: "",
-      isGlobal
-    };
-  });
-}
-async function removeMcpFromLock(serverName) {
-  let removed = false;
-  await updateLockFile((lock) => {
-    if (!(serverName in lock.mcpServers)) return;
-    delete lock.mcpServers[serverName];
-    removed = true;
-  });
-  return removed;
-}
-async function getTrackedMcpServers() {
-  const lock = await readLockFile();
-  return lock.mcpServers;
-}
-async function saveLastSelectedAgents(agents) {
-  await updateLockFile((lock) => {
-    lock.lastSelectedAgents = agents;
-  });
-}
-async function getLastSelectedAgents() {
-  const lock = await readLockFile();
-  return lock.lastSelectedAgents;
+// src/core/formats/yaml.ts
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import yaml from "js-yaml";
+async function readYamlConfig(filePath) {
+  if (!existsSync6(filePath)) return {};
+  const content = await readFile3(filePath, "utf-8");
+  if (!content.trim()) return {};
+  const result = yaml.load(content);
+  return result ?? {};
 }
-
-// src/core/mcp/reconcile.ts
-function inferCleoLockData(config, channel) {
-  const command = typeof config.command === "string" ? config.command : "";
-  const args = Array.isArray(config.args) ? config.args.filter((a) => typeof a === "string") : [];
-  const packageArg = args.find((a) => a.includes(CLEO_MCP_NPM_PACKAGE));
-  if (packageArg) {
-    const version = extractVersionTag(packageArg);
-    return {
-      source: packageArg,
-      sourceType: "package",
-      version
-    };
-  }
-  if (channel === "dev" || command.includes("/") || command.includes("\\")) {
-    return {
-      source: command,
-      sourceType: "command",
-      version: void 0
-    };
+async function writeYamlConfig(filePath, configKey, serverName, serverConfig) {
+  await ensureDir(filePath);
+  const existing = await readYamlConfig(filePath);
+  const keyParts = configKey.split(".");
+  let newEntry = { [serverName]: serverConfig };
+  for (const part of [...keyParts].reverse()) {
+    newEntry = { [part]: newEntry };
   }
-  const full = args.length > 0 ? `${command} ${args.join(" ")}` : command;
-  return {
-    source: full || "unknown",
-    sourceType: "command",
-    version: void 0
-  };
+  const merged = deepMerge(existing, newEntry);
+  const content = yaml.dump(merged, {
+    indent: 2,
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false
+  });
+  await writeFile3(filePath, content, "utf-8");
 }
-async function reconcileCleoLock(options = {}) {
-  const result = {
-    backfilled: [],
-    pruned: [],
-    alreadyTracked: 0,
-    errors: []
-  };
-  const lockEntries = await getTrackedMcpServers();
-  const providers = getInstalledProviders();
-  const targetProviders = options.providerIds?.length ? providers.filter((p) => options.providerIds.includes(p.id)) : providers;
-  const scopes = [];
-  if (options.global && !options.project) {
-    scopes.push("global");
-  } else if (options.project && !options.global) {
-    scopes.push("project");
-  } else {
-    scopes.push("project", "global");
-  }
-  const groups = /* @__PURE__ */ new Map();
-  const liveCleoServerNames = /* @__PURE__ */ new Set();
-  for (const scope of scopes) {
-    for (const provider of targetProviders) {
-      let entries;
-      try {
-        entries = await listMcpServers(provider, scope);
-      } catch {
-        result.errors.push({
-          message: `Failed to read config for ${provider.id} (${scope})`
-        });
-        continue;
-      }
-      for (const entry of entries) {
-        const channel = resolveChannelFromServerName(entry.name);
-        if (!channel) continue;
-        liveCleoServerNames.add(entry.name);
-        const isGlobal = scope === "global";
-        const groupKey = `${entry.name}:${isGlobal ? "global" : "project"}`;
-        if (lockEntries[entry.name] !== void 0) {
-          const existing2 = groups.get(groupKey);
-          if (!existing2) {
-            result.alreadyTracked++;
-          }
-          continue;
-        }
-        const existing = groups.get(groupKey);
-        if (existing) {
-          if (!existing.agents.includes(provider.id)) {
-            existing.agents.push(provider.id);
-          }
-        } else {
-          groups.set(groupKey, {
-            serverName: entry.name,
-            channel,
-            scope,
-            agents: [provider.id],
-            config: entry.config
-          });
-        }
-      }
-    }
-  }
-  for (const group of groups.values()) {
-    const inferred = inferCleoLockData(group.config, group.channel);
-    if (!options.dryRun) {
-      try {
-        await recordMcpInstall(
-          group.serverName,
-          inferred.source,
-          inferred.sourceType,
-          group.agents,
-          group.scope === "global",
-          inferred.version
-        );
-      } catch (err) {
-        result.errors.push({
-          message: `Failed to backfill ${group.serverName}: ${err instanceof Error ? err.message : String(err)}`
-        });
-        continue;
-      }
-    }
-    result.backfilled.push({
-      serverName: group.serverName,
-      channel: group.channel,
-      scope: group.scope,
-      agents: group.agents,
-      source: inferred.source,
-      sourceType: inferred.sourceType,
-      version: inferred.version
-    });
-  }
-  if (options.prune) {
-    for (const [serverName] of Object.entries(lockEntries)) {
-      const channel = resolveChannelFromServerName(serverName);
-      if (!channel) continue;
-      if (!liveCleoServerNames.has(serverName)) {
-        if (!options.dryRun) {
-          try {
-            await removeMcpFromLock(serverName);
-          } catch (err) {
-            result.errors.push({
-              message: `Failed to prune ${serverName}: ${err instanceof Error ? err.message : String(err)}`
-            });
-            continue;
-          }
-        }
-        result.pruned.push(serverName);
-      }
-    }
+async function removeYamlConfig(filePath, configKey, serverName) {
+  if (!existsSync6(filePath)) return false;
+  const existing = await readYamlConfig(filePath);
+  const keyParts = configKey.split(".");
+  let current = existing;
+  for (const part of keyParts) {
+    const next = current[part];
+    if (typeof next !== "object" || next === null) return false;
+    current = next;
   }
-  return result;
+  if (!(serverName in current)) return false;
+  delete current[serverName];
+  const content = yaml.dump(existing, {
+    indent: 2,
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false
+  });
+  await writeFile3(filePath, content, "utf-8");
+  return true;
 }
 
-// src/core/sources/parser.ts
-var GITHUB_SHORTHAND = /^([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)(?:\/(.+))?$/;
-var GITHUB_URL = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+)(?:\/(?:tree|blob)\/([^/]+)(?:\/(.+))?)?/;
-var GITLAB_URL = /^https?:\/\/(?:www\.)?gitlab\.com\/([^/]+)\/([^/]+)(?:\/-\/(?:tree|blob)\/([^/]+)(?:\/(.+))?)?/;
-var HTTP_URL = /^https?:\/\//;
-var NPM_SCOPED = /^@[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
-var NPM_PACKAGE = /^[a-zA-Z0-9_.-]+$/;
-var LIBRARY_SKILL = /^(@[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+|[a-zA-Z0-9_.-]+):([a-zA-Z0-9_.-]+)$/;
-function inferName(source, type) {
-  if (type === "library") {
-    const match = source.match(LIBRARY_SKILL);
-    return match?.[2] ?? source;
-  }
-  if (type === "remote") {
-    try {
-      const url = new URL(source);
-      const parts = url.hostname.split(".");
-      if (parts.length >= 2) {
-        const fallback = parts[0] ?? source;
-        const secondLevel = parts[parts.length - 2] ?? fallback;
-        const brand = parts.length === 3 ? secondLevel : fallback;
-        if (brand !== "www" && brand !== "api" && brand !== "mcp") {
-          return brand;
-        }
-        return secondLevel;
-      }
-      return parts[0] ?? source;
-    } catch {
-      return source;
-    }
-  }
-  if (type === "package") {
-    let name = source.replace(/^@[^/]+\//, "");
-    name = name.replace(/^mcp-server-/, "");
-    name = name.replace(/^server-/, "");
-    name = name.replace(/-mcp$/, "");
-    name = name.replace(/-server$/, "");
-    return name;
-  }
-  if (type === "github" || type === "gitlab") {
-    const match = source.match(/\/([^/]+?)(?:\.git)?$/);
-    return match?.[1] ?? source;
-  }
-  if (type === "local") {
-    const normalized = source.replace(/\\/g, "/").replace(/\/+$/, "");
-    const lastSegment = normalized.split("/").pop();
-    return lastSegment ?? source;
-  }
-  if (type === "command") {
-    const parts = source.split(/\s+/);
-    const command = parts.find(
-      (p) => !p.startsWith("-") && p !== "npx" && p !== "node" && p !== "python" && p !== "python3"
-    );
-    return command ?? parts[0] ?? source;
+// src/core/formats/index.ts
+async function readConfig(filePath, format) {
+  debug(`reading config: ${filePath} (format: ${format})`);
+  switch (format) {
+    case "json":
+    case "jsonc":
+      return readJsonConfig(filePath);
+    case "yaml":
+      return readYamlConfig(filePath);
+    case "toml":
+      return readTomlConfig(filePath);
+    default:
+      throw new Error(`Unsupported config format: ${format}`);
   }
-  return source;
 }
-function parseSource(input) {
-  const ghUrlMatch = input.match(GITHUB_URL);
-  if (ghUrlMatch) {
-    const owner = ghUrlMatch[1];
-    const repo = ghUrlMatch[2];
-    const path = ghUrlMatch[4];
-    if (!owner || !repo) {
-      return { type: "command", value: input, inferredName: inferName(input, "command") };
-    }
-    const inferredName = path ? path.split("/").pop() ?? repo : repo;
-    return {
-      type: "github",
-      value: input,
-      inferredName,
-      owner,
-      repo,
-      ref: ghUrlMatch[3],
-      path
-    };
-  }
-  const glUrlMatch = input.match(GITLAB_URL);
-  if (glUrlMatch) {
-    const owner = glUrlMatch[1];
-    const repo = glUrlMatch[2];
-    const path = glUrlMatch[4];
-    if (!owner || !repo) {
-      return { type: "command", value: input, inferredName: inferName(input, "command") };
-    }
-    const inferredName = path ? path.split("/").pop() ?? repo : repo;
-    return {
-      type: "gitlab",
-      value: input,
-      inferredName,
-      owner,
-      repo,
-      ref: glUrlMatch[3],
-      path
-    };
-  }
-  if (HTTP_URL.test(input)) {
-    return {
-      type: "remote",
-      value: input,
-      inferredName: inferName(input, "remote")
-    };
-  }
-  if (input.startsWith("/") || input.startsWith("./") || input.startsWith("../") || input.startsWith("~")) {
-    return {
-      type: "local",
-      value: input,
-      inferredName: inferName(input, "local")
-    };
-  }
-  const ghShorthand = input.match(GITHUB_SHORTHAND);
-  if (ghShorthand && !NPM_SCOPED.test(input)) {
-    const owner = ghShorthand[1];
-    const repo = ghShorthand[2];
-    const path = ghShorthand[3];
-    if (!owner || !repo) {
-      return { type: "command", value: input, inferredName: inferName(input, "command") };
-    }
-    const inferredName = path ? path.split("/").pop() ?? repo : repo;
-    return {
-      type: "github",
-      value: `https://github.com/${owner}/${repo}`,
-      inferredName,
-      owner,
-      repo,
-      path
-    };
-  }
-  const libraryMatch = input.match(LIBRARY_SKILL);
-  if (libraryMatch) {
-    return {
-      type: "library",
-      value: input,
-      inferredName: inferName(input, "library"),
-      owner: libraryMatch[1],
-      // This will be the package name, e.g. @cleocode/ct-skills
-      repo: libraryMatch[2]
-      // This will be the skill name, e.g. ct-research-agent
-    };
-  }
-  if (NPM_SCOPED.test(input)) {
-    return {
-      type: "package",
-      value: input,
-      inferredName: inferName(input, "package")
-    };
-  }
-  if (NPM_PACKAGE.test(input) && !input.includes(" ")) {
-    return {
-      type: "package",
-      value: input,
-      inferredName: inferName(input, "package")
-    };
+async function writeConfig(filePath, format, key, serverName, serverConfig) {
+  debug(`writing config: ${filePath} (format: ${format}, key: ${key}, server: ${serverName})`);
+  switch (format) {
+    case "json":
+    case "jsonc":
+      return writeJsonConfig(filePath, key, serverName, serverConfig);
+    case "yaml":
+      return writeYamlConfig(filePath, key, serverName, serverConfig);
+    case "toml":
+      return writeTomlConfig(filePath, key, serverName, serverConfig);
+    default:
+      throw new Error(`Unsupported config format: ${format}`);
   }
-  return {
-    type: "command",
-    value: input,
-    inferredName: inferName(input, "command")
-  };
 }
-function isMarketplaceScoped(input) {
-  return /^@[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(input);
+async function removeConfig(filePath, format, key, serverName) {
+  switch (format) {
+    case "json":
+    case "jsonc":
+      return removeJsonConfig(filePath, key, serverName);
+    case "yaml":
+      return removeYamlConfig(filePath, key, serverName);
+    case "toml":
+      return removeTomlConfig(filePath, key, serverName);
+    default:
+      throw new Error(`Unsupported config format: ${format}`);
+  }
 }
 
 // src/core/skills/audit/scanner.ts
-import { existsSync as existsSync10 } from "fs";
-import { readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
 
 // src/core/skills/audit/rules.ts
 function rule(id, name, description, severity, category, pattern) {
@@ -2146,10 +1122,10 @@ var SEVERITY_WEIGHTS = {
   info: 0
 };
 async function scanFile(filePath, rules) {
-  if (!existsSync10(filePath)) {
+  if (!existsSync7(filePath)) {
     return { file: filePath, findings: [], score: 100, passed: true };
   }
-  const content = await readFile6(filePath, "utf-8");
+  const content = await readFile4(filePath, "utf-8");
   const lines = content.split("\n");
   const activeRules = rules ?? AUDIT_RULES;
   const findings = [];
@@ -2181,13 +1157,13 @@ async function scanFile(filePath, rules) {
 async function scanDirectory(dirPath) {
   const { readdir: readdir2 } = await import("fs/promises");
   const { join: join7 } = await import("path");
-  if (!existsSync10(dirPath)) return [];
+  if (!existsSync7(dirPath)) return [];
   const entries = await readdir2(dirPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       const skillFile = join7(dirPath, entry.name, "SKILL.md");
-      if (existsSync10(skillFile)) {
+      if (existsSync7(skillFile)) {
         results.push(await scanFile(skillFile));
       }
     }
@@ -2238,10 +1214,246 @@ function toSarif(results) {
   };
 }
 
+// src/core/sources/parser.ts
+var GITHUB_SHORTHAND = /^([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)(?:\/(.+))?$/;
+var GITHUB_URL = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+)(?:\/(?:tree|blob)\/([^/]+)(?:\/(.+))?)?/;
+var GITLAB_URL = /^https?:\/\/(?:www\.)?gitlab\.com\/([^/]+)\/([^/]+)(?:\/-\/(?:tree|blob)\/([^/]+)(?:\/(.+))?)?/;
+var HTTP_URL = /^https?:\/\//;
+var NPM_SCOPED = /^@[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
+var NPM_PACKAGE = /^[a-zA-Z0-9_.-]+$/;
+var LIBRARY_SKILL = /^(@[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+|[a-zA-Z0-9_.-]+):([a-zA-Z0-9_.-]+)$/;
+function inferName(source, type) {
+  if (type === "library") {
+    const match = source.match(LIBRARY_SKILL);
+    return match?.[2] ?? source;
+  }
+  if (type === "remote") {
+    try {
+      const url = new URL(source);
+      const parts = url.hostname.split(".");
+      if (parts.length >= 2) {
+        const fallback = parts[0] ?? source;
+        const secondLevel = parts[parts.length - 2] ?? fallback;
+        const brand = parts.length === 3 ? secondLevel : fallback;
+        if (brand !== "www" && brand !== "api" && brand !== "mcp") {
+          return brand;
+        }
+        return secondLevel;
+      }
+      return parts[0] ?? source;
+    } catch {
+      return source;
+    }
+  }
+  if (type === "package") {
+    let name = source.replace(/^@[^/]+\//, "");
+    name = name.replace(/^mcp-server-/, "");
+    name = name.replace(/^server-/, "");
+    name = name.replace(/-mcp$/, "");
+    name = name.replace(/-server$/, "");
+    return name;
+  }
+  if (type === "github" || type === "gitlab") {
+    const match = source.match(/\/([^/]+?)(?:\.git)?$/);
+    return match?.[1] ?? source;
+  }
+  if (type === "local") {
+    const normalized = source.replace(/\\/g, "/").replace(/\/+$/, "");
+    const lastSegment = normalized.split("/").pop();
+    return lastSegment ?? source;
+  }
+  if (type === "command") {
+    const parts = source.split(/\s+/);
+    const command = parts.find(
+      (p) => !p.startsWith("-") && p !== "npx" && p !== "node" && p !== "python" && p !== "python3"
+    );
+    return command ?? parts[0] ?? source;
+  }
+  return source;
+}
+function parseSource(input) {
+  const ghUrlMatch = input.match(GITHUB_URL);
+  if (ghUrlMatch) {
+    const owner = ghUrlMatch[1];
+    const repo = ghUrlMatch[2];
+    const path = ghUrlMatch[4];
+    if (!owner || !repo) {
+      return { type: "command", value: input, inferredName: inferName(input, "command") };
+    }
+    const inferredName = path ? path.split("/").pop() ?? repo : repo;
+    return {
+      type: "github",
+      value: input,
+      inferredName,
+      owner,
+      repo,
+      ref: ghUrlMatch[3],
+      path
+    };
+  }
+  const glUrlMatch = input.match(GITLAB_URL);
+  if (glUrlMatch) {
+    const owner = glUrlMatch[1];
+    const repo = glUrlMatch[2];
+    const path = glUrlMatch[4];
+    if (!owner || !repo) {
+      return { type: "command", value: input, inferredName: inferName(input, "command") };
+    }
+    const inferredName = path ? path.split("/").pop() ?? repo : repo;
+    return {
+      type: "gitlab",
+      value: input,
+      inferredName,
+      owner,
+      repo,
+      ref: glUrlMatch[3],
+      path
+    };
+  }
+  if (HTTP_URL.test(input)) {
+    return {
+      type: "remote",
+      value: input,
+      inferredName: inferName(input, "remote")
+    };
+  }
+  if (input.startsWith("/") || input.startsWith("./") || input.startsWith("../") || input.startsWith("~")) {
+    return {
+      type: "local",
+      value: input,
+      inferredName: inferName(input, "local")
+    };
+  }
+  const ghShorthand = input.match(GITHUB_SHORTHAND);
+  if (ghShorthand && !NPM_SCOPED.test(input)) {
+    const owner = ghShorthand[1];
+    const repo = ghShorthand[2];
+    const path = ghShorthand[3];
+    if (!owner || !repo) {
+      return { type: "command", value: input, inferredName: inferName(input, "command") };
+    }
+    const inferredName = path ? path.split("/").pop() ?? repo : repo;
+    return {
+      type: "github",
+      value: `https://github.com/${owner}/${repo}`,
+      inferredName,
+      owner,
+      repo,
+      path
+    };
+  }
+  const libraryMatch = input.match(LIBRARY_SKILL);
+  if (libraryMatch) {
+    return {
+      type: "library",
+      value: input,
+      inferredName: inferName(input, "library"),
+      owner: libraryMatch[1],
+      // This will be the package name, e.g. @cleocode/ct-skills
+      repo: libraryMatch[2]
+      // This will be the skill name, e.g. ct-research-agent
+    };
+  }
+  if (NPM_SCOPED.test(input)) {
+    return {
+      type: "package",
+      value: input,
+      inferredName: inferName(input, "package")
+    };
+  }
+  if (NPM_PACKAGE.test(input) && !input.includes(" ")) {
+    return {
+      type: "package",
+      value: input,
+      inferredName: inferName(input, "package")
+    };
+  }
+  return {
+    type: "command",
+    value: input,
+    inferredName: inferName(input, "command")
+  };
+}
+function isMarketplaceScoped(input) {
+  return /^@[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(input);
+}
+
 // src/core/skills/lock.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { simpleGit } from "simple-git";
+
+// src/core/lock-utils.ts
+import { existsSync as existsSync8 } from "fs";
+import { mkdir as mkdir3, open, readFile as readFile5, rename, rm as rm3, stat, writeFile as writeFile4 } from "fs/promises";
+var LOCK_GUARD_PATH = `${LOCK_FILE_PATH}.lock`;
+var STALE_LOCK_MS = 5e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function removeStaleLock() {
+  try {
+    const info = await stat(LOCK_GUARD_PATH);
+    if (Date.now() - info.mtimeMs > STALE_LOCK_MS) {
+      await rm3(LOCK_GUARD_PATH, { force: true });
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+async function acquireLockGuard(retries = 40, delayMs = 25) {
+  await mkdir3(AGENTS_HOME, { recursive: true });
+  for (let attempt = 0; attempt < retries; attempt += 1) {
+    try {
+      const handle = await open(LOCK_GUARD_PATH, "wx");
+      await handle.close();
+      return;
+    } catch (error) {
+      if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
+        throw error;
+      }
+      if (attempt === 0) {
+        const removed = await removeStaleLock();
+        if (removed) continue;
+      }
+      await sleep(delayMs);
+    }
+  }
+  throw new Error("Timed out waiting for lock file guard");
+}
+async function releaseLockGuard() {
+  await rm3(LOCK_GUARD_PATH, { force: true });
+}
+async function writeLockFileUnsafe(lock) {
+  const tmpPath = `${LOCK_FILE_PATH}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile4(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+  await rename(tmpPath, LOCK_FILE_PATH);
+}
+async function readLockFile() {
+  try {
+    if (!existsSync8(LOCK_FILE_PATH)) {
+      return { version: 1, skills: {}, mcpServers: {} };
+    }
+    const content = await readFile5(LOCK_FILE_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, skills: {}, mcpServers: {} };
+  }
+}
+async function updateLockFile(updater) {
+  await acquireLockGuard();
+  try {
+    const lock = await readLockFile();
+    await updater(lock);
+    await writeLockFileUnsafe(lock);
+    return lock;
+  } finally {
+    await releaseLockGuard();
+  }
+}
+
+// src/core/skills/lock.ts
 var execFileAsync = promisify(execFile);
 async function recordSkillInstall(skillName, scopedName, source, sourceType, agents, canonicalPath, isGlobal, projectDir, version) {
   await updateLockFile((lock) => {
@@ -2951,7 +2163,7 @@ async function recommendSkills2(query, criteria, options = {}) {
 }
 
 // src/core/skills/library-loader.ts
-import { existsSync as existsSync11, readdirSync, readFileSync } from "fs";
+import { existsSync as existsSync9, readdirSync, readFileSync } from "fs";
 import { createRequire } from "module";
 import { basename as basename2, dirname as dirname2, join as join4 } from "path";
 var require2 = createRequire(import.meta.url);
@@ -3000,7 +2212,7 @@ function loadLibraryFromModule(root) {
 }
 function buildLibraryFromFiles(root) {
   const catalogPath = join4(root, "skills.json");
-  if (!existsSync11(catalogPath)) {
+  if (!existsSync9(catalogPath)) {
     throw new Error(`No skills.json found at ${root}`);
   }
   const catalogData = JSON.parse(readFileSync(catalogPath, "utf-8"));
@@ -3008,7 +2220,7 @@ function buildLibraryFromFiles(root) {
   const version = catalogData.version ?? "0.0.0";
   const manifestPath = join4(root, "skills", "manifest.json");
   let manifest;
-  if (existsSync11(manifestPath)) {
+  if (existsSync9(manifestPath)) {
     manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
   } else {
     manifest = {
@@ -3020,7 +2232,7 @@ function buildLibraryFromFiles(root) {
   }
   const profilesDir = join4(root, "profiles");
   const profiles = /* @__PURE__ */ new Map();
-  if (existsSync11(profilesDir)) {
+  if (existsSync9(profilesDir)) {
     for (const file of readdirSync(profilesDir)) {
       if (!file.endsWith(".json")) continue;
       try {
@@ -3069,7 +2281,7 @@ function buildLibraryFromFiles(root) {
     return resolveDeps([...new Set(skills)]);
   }
   function discoverFiles(dir, ext) {
-    if (!existsSync11(dir)) return [];
+    if (!existsSync9(dir)) return [];
     return readdirSync(dir).filter((f) => f.endsWith(ext)).map((f) => basename2(f, ext));
   }
   const library = {
@@ -3093,7 +2305,7 @@ function buildLibraryFromFiles(root) {
     getSkillDir: getSkillDir2,
     readSkillContent(name) {
       const skillPath = library.getSkillPath(name);
-      if (!existsSync11(skillPath)) {
+      if (!existsSync9(skillPath)) {
         throw new Error(`Skill content not found: ${skillPath}`);
       }
       return readFileSync(skillPath, "utf-8");
@@ -3124,7 +2336,7 @@ function buildLibraryFromFiles(root) {
     },
     getSharedResourcePath(name) {
       const resourcePath = join4(root, "skills", "_shared", `${name}.md`);
-      return existsSync11(resourcePath) ? resourcePath : void 0;
+      return existsSync9(resourcePath) ? resourcePath : void 0;
     },
     readSharedResource(name) {
       const resourcePath = library.getSharedResourcePath(name);
@@ -3138,9 +2350,9 @@ function buildLibraryFromFiles(root) {
     },
     getProtocolPath(name) {
       const rootPath = join4(root, "protocols", `${name}.md`);
-      if (existsSync11(rootPath)) return rootPath;
+      if (existsSync9(rootPath)) return rootPath;
       const skillsPath = join4(root, "skills", "protocols", `${name}.md`);
-      return existsSync11(skillsPath) ? skillsPath : void 0;
+      return existsSync9(skillsPath) ? skillsPath : void 0;
     },
     readProtocol(name) {
       const protocolPath = library.getProtocolPath(name);
@@ -3166,7 +2378,7 @@ function buildLibraryFromFiles(root) {
         issues.push({ level: "warn", field: "version", message: "Missing version" });
       }
       const skillPath = join4(root, entry.path);
-      if (!existsSync11(skillPath)) {
+      if (!existsSync9(skillPath)) {
         issues.push({
           level: "error",
           field: "path",
@@ -3225,7 +2437,7 @@ __export(catalog_exports, {
   validateAll: () => validateAll,
   validateSkillFrontmatter: () => validateSkillFrontmatter
 });
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { join as join5 } from "path";
 var _library = null;
 function registerSkillLibrary(library) {
@@ -3233,7 +2445,7 @@ function registerSkillLibrary(library) {
 }
 function registerSkillLibraryFromPath(root) {
   const indexPath = join5(root, "index.js");
-  if (existsSync12(indexPath)) {
+  if (existsSync10(indexPath)) {
     _library = loadLibraryFromModule(root);
     return;
   }
@@ -3244,13 +2456,13 @@ function clearRegisteredLibrary() {
 }
 function discoverLibrary() {
   const envPath = process.env["CAAMP_SKILL_LIBRARY"];
-  if (envPath && existsSync12(envPath)) {
+  if (envPath && existsSync10(envPath)) {
     try {
       const indexPath = join5(envPath, "index.js");
-      if (existsSync12(indexPath)) {
+      if (existsSync10(indexPath)) {
         return loadLibraryFromModule(envPath);
       }
-      if (existsSync12(join5(envPath, "skills.json"))) {
+      if (existsSync10(join5(envPath, "skills.json"))) {
         return buildLibraryFromFiles(envPath);
       }
     } catch {
@@ -3357,13 +2569,13 @@ function getLibraryRoot() {
 }
 
 // src/core/skills/discovery.ts
-import { existsSync as existsSync13 } from "fs";
-import { readdir, readFile as readFile7 } from "fs/promises";
+import { existsSync as existsSync11 } from "fs";
+import { readdir, readFile as readFile6 } from "fs/promises";
 import { join as join6 } from "path";
 import matter from "gray-matter";
 async function parseSkillFile(filePath) {
   try {
-    const content = await readFile7(filePath, "utf-8");
+    const content = await readFile6(filePath, "utf-8");
     const { data } = matter(content);
     if (!data.name || !data.description) {
       return null;
@@ -3384,7 +2596,7 @@ async function parseSkillFile(filePath) {
 }
 async function discoverSkill(skillDir) {
   const skillFile = join6(skillDir, "SKILL.md");
-  if (!existsSync13(skillFile)) return null;
+  if (!existsSync11(skillFile)) return null;
   const metadata = await parseSkillFile(skillFile);
   if (!metadata) return null;
   return {
@@ -3395,7 +2607,7 @@ async function discoverSkill(skillDir) {
   };
 }
 async function discoverSkills(rootDir) {
-  if (!existsSync13(rootDir)) return [];
+  if (!existsSync11(rootDir)) return [];
   const entries = await readdir(rootDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
@@ -3424,8 +2636,8 @@ async function discoverSkillsMulti(dirs) {
 }
 
 // src/core/skills/validator.ts
-import { existsSync as existsSync14 } from "fs";
-import { readFile as readFile8 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import { readFile as readFile7 } from "fs/promises";
 import matter2 from "gray-matter";
 var RESERVED_NAMES = [
   "anthropic",
@@ -3446,14 +2658,14 @@ var WARN_BODY_LINES = 500;
 var WARN_DESCRIPTION_LENGTH = 50;
 async function validateSkill(filePath) {
   const issues = [];
-  if (!existsSync14(filePath)) {
+  if (!existsSync12(filePath)) {
     return {
       valid: false,
       issues: [{ level: "error", field: "file", message: "File does not exist" }],
       metadata: null
     };
   }
-  const content = await readFile8(filePath, "utf-8");
+  const content = await readFile7(filePath, "utf-8");
   if (!content.startsWith("---")) {
     issues.push({
       level: "error",
@@ -3563,28 +2775,13 @@ async function validateSkill(filePath) {
 }
 
 export {
+  CANONICAL_SKILLS_DIR,
   setVerbose,
   setQuiet,
   isVerbose,
   isQuiet,
   setHuman,
   isHuman,
-  deepMerge,
-  getNestedValue,
-  ensureDir,
-  readConfig,
-  writeConfig,
-  removeConfig,
-  resolveConfigPath,
-  listMcpServers,
-  listAgentsMcpServers,
-  listAllMcpServers,
-  removeMcpServer,
-  getTransform,
-  installMcpServer,
-  installMcpServerToAll,
-  buildServerConfig,
-  CANONICAL_SKILLS_DIR,
   detectProvider,
   detectAllProviders,
   getInstalledProviders,
@@ -3595,31 +2792,19 @@ export {
   listCanonicalSkills,
   selectProvidersByMinimumPriority,
   installBatchWithRollback,
-  detectMcpConfigConflicts,
-  applyMcpInstallWithPolicy,
   updateInstructionsSingleOperation,
-  configureProviderGlobalAndProject,
-  normalizeCleoChannel,
-  resolveCleoServerName,
-  resolveChannelFromServerName,
-  buildCleoProfile,
-  checkCommandReachability,
-  parseEnvAssignments,
-  extractVersionTag,
-  isCleoSource,
+  deepMerge,
+  getNestedValue,
+  ensureDir,
+  readConfig,
+  writeConfig,
+  removeConfig,
   readLockFile,
-  recordMcpInstall,
-  removeMcpFromLock,
-  getTrackedMcpServers,
-  saveLastSelectedAgents,
-  getLastSelectedAgents,
-  inferCleoLockData,
-  reconcileCleoLock,
-  parseSource,
-  isMarketplaceScoped,
   scanFile,
   scanDirectory,
   toSarif,
+  parseSource,
+  isMarketplaceScoped,
   recordSkillInstall,
   removeSkillFromLock,
   getTrackedSkills,
@@ -3654,4 +2839,4 @@ export {
   discoverSkillsMulti,
   validateSkill
 };
-//# sourceMappingURL=chunk-3WKBFXLE.js.map
+//# sourceMappingURL=chunk-6NBM4CAF.js.map