@cleocode/caamp 1.7.1 → 1.8.1

package/dist/{chunk-6T3TJQFF.js → chunk-LDTYDQGR.js}

@@ -1,171 +1,19 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/core/instructions/injector.ts
-import { readFile, writeFile } from "fs/promises";
-import { existsSync } from "fs";
-import { join, dirname } from "path";
-import { mkdir } from "fs/promises";
-var MARKER_START = "<!-- CAAMP:START -->";
-var MARKER_END = "<!-- CAAMP:END -->";
-var MARKER_PATTERN = /<!-- CAAMP:START -->[\s\S]*?<!-- CAAMP:END -->/;
-async function checkInjection(filePath, expectedContent) {
-  if (!existsSync(filePath)) return "missing";
-  const content = await readFile(filePath, "utf-8");
-  if (!MARKER_PATTERN.test(content)) return "none";
-  if (expectedContent) {
-    const blockContent = extractBlock(content);
-    if (blockContent && blockContent.trim() === expectedContent.trim()) {
-      return "current";
-    }
-    return "outdated";
-  }
-  return "current";
-}
-function extractBlock(content) {
-  const match = content.match(MARKER_PATTERN);
-  if (!match) return null;
-  return match[0].replace(MARKER_START, "").replace(MARKER_END, "").trim();
-}
-function buildBlock(content) {
-  return `${MARKER_START}
-${content}
-${MARKER_END}`;
-}
-async function inject(filePath, content) {
-  const block = buildBlock(content);
-  await mkdir(dirname(filePath), { recursive: true });
-  if (!existsSync(filePath)) {
-    await writeFile(filePath, `${block}
-`, "utf-8");
-    return "created";
-  }
-  const existing = await readFile(filePath, "utf-8");
-  if (MARKER_PATTERN.test(existing)) {
-    const updated2 = existing.replace(MARKER_PATTERN, block);
-    await writeFile(filePath, updated2, "utf-8");
-    return "updated";
-  }
-  const updated = `${block}
-
-${existing}`;
-  await writeFile(filePath, updated, "utf-8");
-  return "added";
-}
-async function removeInjection(filePath) {
-  if (!existsSync(filePath)) return false;
-  const content = await readFile(filePath, "utf-8");
-  if (!MARKER_PATTERN.test(content)) return false;
-  const cleaned = content.replace(MARKER_PATTERN, "").replace(/^\n{2,}/, "\n").trim();
-  if (!cleaned) {
-    const { rm: rm4 } = await import("fs/promises");
-    await rm4(filePath);
-  } else {
-    await writeFile(filePath, `${cleaned}
-`, "utf-8");
-  }
-  return true;
-}
-async function checkAllInjections(providers, projectDir, scope, expectedContent) {
-  const results = [];
-  const checked = /* @__PURE__ */ new Set();
-  for (const provider of providers) {
-    const filePath = scope === "global" ? join(provider.pathGlobal, provider.instructFile) : join(projectDir, provider.instructFile);
-    if (checked.has(filePath)) continue;
-    checked.add(filePath);
-    const status = await checkInjection(filePath, expectedContent);
-    results.push({
-      file: filePath,
-      provider: provider.id,
-      status,
-      fileExists: existsSync(filePath)
-    });
-  }
-  return results;
-}
-async function injectAll(providers, projectDir, scope, content) {
-  const results = /* @__PURE__ */ new Map();
-  const injected = /* @__PURE__ */ new Set();
-  for (const provider of providers) {
-    const filePath = scope === "global" ? join(provider.pathGlobal, provider.instructFile) : join(projectDir, provider.instructFile);
-    if (injected.has(filePath)) continue;
-    injected.add(filePath);
-    const action = await inject(filePath, content);
-    results.set(filePath, action);
-  }
-  return results;
-}
-
-// src/core/instructions/templates.ts
-function buildInjectionContent(template) {
-  const lines = [];
-  for (const ref of template.references) {
-    lines.push(ref);
-  }
-  if (template.content && template.content.length > 0) {
-    if (lines.length > 0) {
-      lines.push("");
-    }
-    lines.push(...template.content);
-  }
-  return lines.join("\n");
-}
-function parseInjectionContent(content) {
-  const references = [];
-  const contentLines = [];
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    if (trimmed.startsWith("@")) {
-      references.push(trimmed);
-    } else {
-      contentLines.push(line);
-    }
-  }
-  return {
-    references,
-    content: contentLines.length > 0 ? contentLines : void 0
-  };
-}
-function generateInjectionContent(options) {
-  const lines = [];
-  lines.push("## CAAMP Managed Configuration");
-  lines.push("");
-  lines.push("This section is managed by [CAAMP](https://github.com/caamp/caamp).");
-  lines.push("Do not edit between the CAAMP markers manually.");
-  if (options?.mcpServerName) {
-    lines.push("");
-    lines.push(`### MCP Server: ${options.mcpServerName}`);
-    lines.push(`Configured via \`caamp mcp install\`.`);
-  }
-  if (options?.customContent) {
-    lines.push("");
-    lines.push(options.customContent);
-  }
-  return lines.join("\n");
-}
-function generateSkillsSection(skillNames) {
-  if (skillNames.length === 0) return "";
-  const lines = [];
-  lines.push("### Installed Skills");
-  lines.push("");
-  for (const name of skillNames) {
-    lines.push(`- \`${name}\` - Available via SKILL.md`);
-  }
-  return lines.join("\n");
-}
-function groupByInstructFile(providers) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const provider of providers) {
-    const existing = groups.get(provider.instructFile) ?? [];
-    existing.push(provider);
-    groups.set(provider.instructFile, existing);
-  }
-  return groups;
-}
+import {
+  __export,
+  getAgentsConfigPath,
+  getAgentsHome,
+  getAgentsMcpDir,
+  getAgentsMcpServersPath,
+  getAllProviders,
+  getCanonicalSkillsDir,
+  getLockFilePath,
+  getPlatformLocations,
+  groupByInstructFile,
+  injectAll,
+  resolveProviderConfigPath,
+  resolveProviderProjectPath,
+  resolveProviderSkillsDirs
+} from "./chunk-CPHF5IM4.js";
 
 // src/core/formats/utils.ts
 function deepMerge(target, source) {
@@ -194,9 +42,9 @@ function getNestedValue(obj, keyPath) {
   return current;
 }
 async function ensureDir(filePath) {
-  const { mkdir: mkdir5 } = await import("fs/promises");
-  const { dirname: dirname6 } = await import("path");
-  await mkdir5(dirname6(filePath), { recursive: true });
+  const { mkdir: mkdir4 } = await import("fs/promises");
+  const { dirname: dirname3 } = await import("path");
+  await mkdir4(dirname3(filePath), { recursive: true });
 }
 
 // src/core/logger.ts
@@ -226,12 +74,12 @@ function isHuman() {
 }
 
 // src/core/formats/json.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
 import * as jsonc from "jsonc-parser";
 async function readJsonConfig(filePath) {
-  if (!existsSync2(filePath)) return {};
-  const content = await readFile2(filePath, "utf-8");
+  if (!existsSync(filePath)) return {};
+  const content = await readFile(filePath, "utf-8");
   if (!content.trim()) return {};
   const errors = [];
   const result = jsonc.parse(content, errors);
@@ -257,8 +105,8 @@ function detectIndent(content) {
 async function writeJsonConfig(filePath, configKey, serverName, serverConfig) {
   await ensureDir(filePath);
   let content;
-  if (existsSync2(filePath)) {
-    content = await readFile2(filePath, "utf-8");
+  if (existsSync(filePath)) {
+    content = await readFile(filePath, "utf-8");
     if (!content.trim()) {
       content = "{}";
     }
@@ -280,11 +128,11 @@ async function writeJsonConfig(filePath, configKey, serverName, serverConfig) {
   if (!content.endsWith("\n")) {
     content += "\n";
   }
-  await writeFile2(filePath, content, "utf-8");
+  await writeFile(filePath, content, "utf-8");
 }
 async function removeJsonConfig(filePath, configKey, serverName) {
-  if (!existsSync2(filePath)) return false;
-  let content = await readFile2(filePath, "utf-8");
+  if (!existsSync(filePath)) return false;
+  let content = await readFile(filePath, "utf-8");
   if (!content.trim()) return false;
   const { tabSize, insertSpaces } = detectIndent(content);
   const formatOptions = {
@@ -300,17 +148,17 @@ async function removeJsonConfig(filePath, configKey, serverName) {
   if (!content.endsWith("\n")) {
     content += "\n";
   }
-  await writeFile2(filePath, content, "utf-8");
+  await writeFile(filePath, content, "utf-8");
   return true;
 }
 
 // src/core/formats/yaml.ts
-import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import yaml from "js-yaml";
 async function readYamlConfig(filePath) {
-  if (!existsSync3(filePath)) return {};
-  const content = await readFile3(filePath, "utf-8");
+  if (!existsSync2(filePath)) return {};
+  const content = await readFile2(filePath, "utf-8");
   if (!content.trim()) return {};
   const result = yaml.load(content);
   return result ?? {};
@@ -330,10 +178,10 @@ async function writeYamlConfig(filePath, configKey, serverName, serverConfig) {
     noRefs: true,
     sortKeys: false
   });
-  await writeFile3(filePath, content, "utf-8");
+  await writeFile2(filePath, content, "utf-8");
 }
 async function removeYamlConfig(filePath, configKey, serverName) {
-  if (!existsSync3(filePath)) return false;
+  if (!existsSync2(filePath)) return false;
   const existing = await readYamlConfig(filePath);
   const keyParts = configKey.split(".");
   let current = existing;
@@ -350,17 +198,17 @@ async function removeYamlConfig(filePath, configKey, serverName) {
     noRefs: true,
     sortKeys: false
   });
-  await writeFile3(filePath, content, "utf-8");
+  await writeFile2(filePath, content, "utf-8");
   return true;
 }
 
 // src/core/formats/toml.ts
-import { existsSync as existsSync4 } from "fs";
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import TOML from "@iarna/toml";
 async function readTomlConfig(filePath) {
-  if (!existsSync4(filePath)) return {};
-  const content = await readFile4(filePath, "utf-8");
+  if (!existsSync3(filePath)) return {};
+  const content = await readFile3(filePath, "utf-8");
   if (!content.trim()) return {};
   const result = TOML.parse(content);
   return result;
@@ -375,10 +223,10 @@ async function writeTomlConfig(filePath, configKey, serverName, serverConfig) {
   }
   const merged = deepMerge(existing, newEntry);
   const content = TOML.stringify(merged);
-  await writeFile4(filePath, content, "utf-8");
+  await writeFile3(filePath, content, "utf-8");
 }
 async function removeTomlConfig(filePath, configKey, serverName) {
-  if (!existsSync4(filePath)) return false;
+  if (!existsSync3(filePath)) return false;
   const existing = await readTomlConfig(filePath);
   const keyParts = configKey.split(".");
   let current = existing;
@@ -390,7 +238,7 @@ async function removeTomlConfig(filePath, configKey, serverName) {
   if (!(serverName in current)) return false;
   delete current[serverName];
   const content = TOML.stringify(existing);
-  await writeFile4(filePath, content, "utf-8");
+  await writeFile3(filePath, content, "utf-8");
   return true;
 }
 
@@ -437,258 +285,15 @@ async function removeConfig(filePath, format, key, serverName) {
   }
 }
 
-// src/core/platform-paths.ts
-import envPaths from "env-paths";
-import { arch, homedir, hostname, platform, release } from "os";
-import { isAbsolute, join as join2, resolve } from "path";
-var APP_NAME = "agents";
-function resolveAgentsHomeOverride(value) {
-  if (value === void 0) return void 0;
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return void 0;
-  if (trimmed === "~") return homedir();
-  if (trimmed.startsWith("~/")) return join2(homedir(), trimmed.slice(2));
-  if (isAbsolute(trimmed)) return resolve(trimmed);
-  return resolve(homedir(), trimmed);
-}
-var _paths = null;
-var _sysInfo = null;
-var _lastAgentsHome = void 0;
-function getPlatformPaths() {
-  const currentAgentsHome = process.env["AGENTS_HOME"];
-  if (_paths && currentAgentsHome !== _lastAgentsHome) {
-    _paths = null;
-    _sysInfo = null;
-  }
-  if (_paths) return _paths;
-  const ep = envPaths(APP_NAME, { suffix: "" });
-  _lastAgentsHome = currentAgentsHome;
-  _paths = {
-    data: resolveAgentsHomeOverride(currentAgentsHome) ?? ep.data,
-    config: ep.config,
-    cache: ep.cache,
-    log: ep.log,
-    temp: ep.temp
-  };
-  return _paths;
-}
-function getSystemInfo() {
-  if (_sysInfo) return _sysInfo;
-  const paths = getPlatformPaths();
-  _sysInfo = {
-    platform: platform(),
-    arch: arch(),
-    release: release(),
-    hostname: hostname(),
-    nodeVersion: process.version,
-    paths
-  };
-  return _sysInfo;
-}
-function _resetPlatformPathsCache() {
-  _paths = null;
-  _sysInfo = null;
-  _lastAgentsHome = void 0;
-}
-
-// src/core/paths/standard.ts
-import { existsSync as existsSync5 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join3 } from "path";
-function getPlatformLocations() {
-  const home = homedir2();
-  const platform2 = process.platform;
-  if (platform2 === "win32") {
-    const appData = process.env["APPDATA"] ?? join3(home, "AppData", "Roaming");
-    return {
-      home,
-      config: appData,
-      vscodeConfig: join3(appData, "Code", "User"),
-      zedConfig: join3(appData, "Zed"),
-      claudeDesktopConfig: join3(appData, "Claude"),
-      applications: []
-    };
-  }
-  if (platform2 === "darwin") {
-    const config2 = process.env["XDG_CONFIG_HOME"] ?? join3(home, ".config");
-    return {
-      home,
-      config: config2,
-      vscodeConfig: join3(home, "Library", "Application Support", "Code", "User"),
-      zedConfig: join3(home, "Library", "Application Support", "Zed"),
-      claudeDesktopConfig: join3(home, "Library", "Application Support", "Claude"),
-      applications: ["/Applications", join3(home, "Applications")]
-    };
-  }
-  const config = process.env["XDG_CONFIG_HOME"] ?? join3(home, ".config");
-  return {
-    home,
-    config,
-    vscodeConfig: join3(config, "Code", "User"),
-    zedConfig: join3(config, "zed"),
-    claudeDesktopConfig: join3(config, "Claude"),
-    applications: []
-  };
-}
-function getAgentsHome() {
-  return getPlatformPaths().data;
-}
-function getProjectAgentsDir(projectRoot = process.cwd()) {
-  return join3(projectRoot, ".agents");
-}
-function resolveProjectPath(relativePath, projectDir = process.cwd()) {
-  return join3(projectDir, relativePath);
-}
-function getCanonicalSkillsDir() {
-  return join3(getAgentsHome(), "skills");
-}
-function getLockFilePath() {
-  return join3(getAgentsHome(), ".caamp-lock.json");
-}
-function getAgentsMcpDir(scope = "global", projectDir) {
-  if (scope === "global") return join3(getAgentsHome(), "mcp");
-  return join3(projectDir ?? process.cwd(), ".agents", "mcp");
-}
-function getAgentsMcpServersPath(scope = "global", projectDir) {
-  return join3(getAgentsMcpDir(scope, projectDir), "servers.json");
-}
-function getAgentsInstructFile(scope = "global", projectDir) {
-  if (scope === "global") return join3(getAgentsHome(), "AGENTS.md");
-  return join3(projectDir ?? process.cwd(), ".agents", "AGENTS.md");
-}
-function getAgentsConfigPath(scope = "global", projectDir) {
-  if (scope === "global") return join3(getAgentsHome(), "config.toml");
-  return join3(projectDir ?? process.cwd(), ".agents", "config.toml");
-}
-function getAgentsWikiDir(scope = "global", projectDir) {
-  if (scope === "global") return join3(getAgentsHome(), "wiki");
-  return join3(projectDir ?? process.cwd(), ".agents", "wiki");
-}
-function getAgentsSpecDir(scope = "global", projectDir) {
-  if (scope === "global") return join3(getAgentsHome(), "spec");
-  return join3(projectDir ?? process.cwd(), ".agents", "spec");
-}
-function getAgentsLinksDir(scope = "global", projectDir) {
-  if (scope === "global") return join3(getAgentsHome(), "links");
-  return join3(projectDir ?? process.cwd(), ".agents", "links");
-}
-function resolveRegistryTemplatePath(template) {
-  const locations = getPlatformLocations();
-  return template.replace(/\$HOME/g, locations.home).replace(/\$CONFIG/g, locations.config).replace(/\$VSCODE_CONFIG/g, locations.vscodeConfig).replace(/\$ZED_CONFIG/g, locations.zedConfig).replace(/\$CLAUDE_DESKTOP_CONFIG/g, locations.claudeDesktopConfig).replace(/\$AGENTS_HOME/g, getAgentsHome());
-}
-function resolveProviderConfigPath(provider, scope, projectDir = process.cwd()) {
-  if (scope === "global") {
-    return provider.configPathGlobal;
-  }
-  if (!provider.configPathProject) {
-    return null;
-  }
-  return resolveProjectPath(provider.configPathProject, projectDir);
-}
-function resolvePreferredConfigScope(provider, useGlobalFlag) {
-  if (useGlobalFlag) {
-    return "global";
-  }
-  return provider.configPathProject ? "project" : "global";
-}
-function resolveProviderSkillsDir(provider, scope, projectDir = process.cwd()) {
-  if (scope === "global") {
-    return provider.pathSkills;
-  }
-  return resolveProjectPath(provider.pathProjectSkills, projectDir);
-}
-function resolveProviderSkillsDirs(provider, scope, projectDir = process.cwd()) {
-  const vendorPath = resolveProviderSkillsDir(provider, scope, projectDir);
-  const precedence = provider.capabilities?.skills?.precedence ?? "vendor-only";
-  const resolveAgentsPath = () => {
-    if (scope === "global") {
-      return provider.capabilities?.skills?.agentsGlobalPath ?? null;
-    }
-    const projectRelative = provider.capabilities?.skills?.agentsProjectPath ?? null;
-    return projectRelative ? join3(projectDir, projectRelative) : null;
-  };
-  switch (precedence) {
-    case "vendor-only":
-      return [vendorPath];
-    case "agents-canonical": {
-      const agentsPath = resolveAgentsPath();
-      return agentsPath ? [agentsPath] : [vendorPath];
-    }
-    case "agents-first": {
-      const agentsPath = resolveAgentsPath();
-      return agentsPath ? [agentsPath, vendorPath] : [vendorPath];
-    }
-    case "agents-supported": {
-      const agentsPath = resolveAgentsPath();
-      return agentsPath ? [vendorPath, agentsPath] : [vendorPath];
-    }
-    case "vendor-global-agents-project": {
-      if (scope === "global") {
-        return [vendorPath];
-      }
-      const agentsPath = resolveAgentsPath();
-      return agentsPath ? [agentsPath, vendorPath] : [vendorPath];
-    }
-    default:
-      return [vendorPath];
-  }
-}
-function resolveProviderProjectPath(provider, projectDir = process.cwd()) {
-  return resolveProjectPath(provider.pathProject, projectDir);
-}
-function resolveProvidersRegistryPath(startDir) {
-  const candidates = [
-    join3(startDir, "..", "..", "..", "providers", "registry.json"),
-    join3(startDir, "..", "providers", "registry.json")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync5(candidate)) {
-      return candidate;
-    }
-  }
-  let current = startDir;
-  for (let i = 0; i < 8; i += 1) {
-    const candidate = join3(current, "providers", "registry.json");
-    if (existsSync5(candidate)) {
-      return candidate;
-    }
-    current = dirname2(current);
-  }
-  throw new Error(`Cannot find providers/registry.json (searched from ${startDir})`);
-}
-function normalizeSkillSubPath(path) {
-  if (!path) return void 0;
-  const normalized = path.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/SKILL\.md$/i, "").trim();
-  return normalized.length > 0 ? normalized : void 0;
-}
-function buildSkillSubPathCandidates(marketplacePath, parsedPath) {
-  const candidates = [];
-  const base = normalizeSkillSubPath(marketplacePath);
-  const parsed = normalizeSkillSubPath(parsedPath);
-  if (base) candidates.push(base);
-  if (parsed) candidates.push(parsed);
-  const knownPrefixes = [".agents", ".claude"];
-  for (const value of [base, parsed]) {
-    if (!value || !value.startsWith("skills/")) continue;
-    for (const prefix of knownPrefixes) {
-      candidates.push(`${prefix}/${value}`);
-    }
-  }
-  if (candidates.length === 0) {
-    candidates.push(void 0);
-  }
-  return Array.from(new Set(candidates));
-}
-
 // src/core/mcp/reader.ts
-import { existsSync as existsSync6 } from "fs";
+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 || !existsSync6(configPath)) return [];
+  if (!configPath || !existsSync4(configPath)) return [];
   try {
     const config = await readConfig(configPath, provider.configFormat);
     const servers = getNestedValue(config, provider.configKey);
@@ -712,7 +317,7 @@ async function listMcpServers(provider, scope, projectDir) {
 async function listAgentsMcpServers(scope, projectDir) {
   const serversPath = getAgentsMcpServersPath(scope, projectDir);
   debug(`listing .agents/ MCP servers (${scope}) at ${serversPath}`);
-  if (!existsSync6(serversPath)) return [];
+  if (!existsSync4(serversPath)) return [];
   try {
     const config = await readConfig(serversPath, "json");
     const servers = config["servers"];
@@ -930,240 +535,10 @@ function buildServerConfig(source, transport, headers) {
   };
 }
 
-// src/core/registry/providers.ts
-import { readFileSync } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
-import { fileURLToPath } from "url";
-var DEFAULT_SKILLS_CAPABILITY = {
-  agentsGlobalPath: null,
-  agentsProjectPath: null,
-  precedence: "vendor-only"
-};
-var DEFAULT_HOOKS_CAPABILITY = {
-  supported: [],
-  hookConfigPath: null,
-  hookFormat: null
-};
-var DEFAULT_SPAWN_CAPABILITY = {
-  supportsSubagents: false,
-  supportsProgrammaticSpawn: false,
-  supportsInterAgentComms: false,
-  supportsParallelSpawn: false,
-  spawnMechanism: null
-};
-function resolveCapabilities(raw) {
-  const skills = raw?.skills ? {
-    agentsGlobalPath: raw.skills.agentsGlobalPath ? resolveRegistryTemplatePath(raw.skills.agentsGlobalPath) : null,
-    agentsProjectPath: raw.skills.agentsProjectPath,
-    precedence: raw.skills.precedence
-  } : { ...DEFAULT_SKILLS_CAPABILITY };
-  const hooks = raw?.hooks ? {
-    supported: raw.hooks.supported,
-    hookConfigPath: raw.hooks.hookConfigPath ? resolveRegistryTemplatePath(raw.hooks.hookConfigPath) : null,
-    hookFormat: raw.hooks.hookFormat
-  } : { ...DEFAULT_HOOKS_CAPABILITY, supported: [] };
-  const spawn = raw?.spawn ? {
-    supportsSubagents: raw.spawn.supportsSubagents,
-    supportsProgrammaticSpawn: raw.spawn.supportsProgrammaticSpawn,
-    supportsInterAgentComms: raw.spawn.supportsInterAgentComms,
-    supportsParallelSpawn: raw.spawn.supportsParallelSpawn,
-    spawnMechanism: raw.spawn.spawnMechanism
-  } : { ...DEFAULT_SPAWN_CAPABILITY };
-  return { skills, hooks, spawn };
-}
-function findRegistryPath() {
-  const thisDir = dirname3(fileURLToPath(import.meta.url));
-  return resolveProvidersRegistryPath(thisDir);
-}
-var _registry = null;
-var _providers = null;
-var _aliasMap = null;
-function resolveProvider(raw) {
-  return {
-    id: raw.id,
-    toolName: raw.toolName,
-    vendor: raw.vendor,
-    agentFlag: raw.agentFlag,
-    aliases: raw.aliases,
-    pathGlobal: resolveRegistryTemplatePath(raw.pathGlobal),
-    pathProject: raw.pathProject,
-    instructFile: raw.instructFile,
-    configKey: raw.configKey,
-    configFormat: raw.configFormat,
-    configPathGlobal: resolveRegistryTemplatePath(raw.configPathGlobal),
-    configPathProject: raw.configPathProject,
-    pathSkills: resolveRegistryTemplatePath(raw.pathSkills),
-    pathProjectSkills: raw.pathProjectSkills,
-    detection: {
-      methods: raw.detection.methods,
-      binary: raw.detection.binary,
-      directories: raw.detection.directories?.map(resolveRegistryTemplatePath),
-      appBundle: raw.detection.appBundle,
-      flatpakId: raw.detection.flatpakId
-    },
-    supportedTransports: raw.supportedTransports,
-    supportsHeaders: raw.supportsHeaders,
-    priority: raw.priority,
-    status: raw.status,
-    agentSkillsCompatible: raw.agentSkillsCompatible,
-    capabilities: resolveCapabilities(raw.capabilities)
-  };
-}
-function loadRegistry() {
-  if (_registry) return _registry;
-  const registryPath = findRegistryPath();
-  const raw = readFileSync(registryPath, "utf-8");
-  _registry = JSON.parse(raw);
-  return _registry;
-}
-function ensureProviders() {
-  if (_providers) return;
-  const registry = loadRegistry();
-  _providers = /* @__PURE__ */ new Map();
-  _aliasMap = /* @__PURE__ */ new Map();
-  for (const [id, raw] of Object.entries(registry.providers)) {
-    const provider = resolveProvider(raw);
-    _providers.set(id, provider);
-    for (const alias of provider.aliases) {
-      _aliasMap.set(alias, id);
-    }
-  }
-}
-function getAllProviders() {
-  ensureProviders();
-  if (!_providers) return [];
-  return Array.from(_providers.values());
-}
-function getProvider(idOrAlias) {
-  ensureProviders();
-  const resolved = _aliasMap?.get(idOrAlias) ?? idOrAlias;
-  return _providers?.get(resolved);
-}
-function resolveAlias(idOrAlias) {
-  ensureProviders();
-  return _aliasMap?.get(idOrAlias) ?? idOrAlias;
-}
-function getProvidersByPriority(priority) {
-  return getAllProviders().filter((p) => p.priority === priority);
-}
-function getProvidersByStatus(status) {
-  return getAllProviders().filter((p) => p.status === status);
-}
-function getProvidersByInstructFile(file) {
-  return getAllProviders().filter((p) => p.instructFile === file);
-}
-function getInstructionFiles() {
-  const files = /* @__PURE__ */ new Set();
-  for (const p of getAllProviders()) {
-    files.add(p.instructFile);
-  }
-  return Array.from(files);
-}
-function getProviderCount() {
-  ensureProviders();
-  return _providers?.size ?? 0;
-}
-function getRegistryVersion() {
-  return loadRegistry().version;
-}
-function getProvidersByHookEvent(event) {
-  return getAllProviders().filter((p) => p.capabilities.hooks.supported.includes(event));
-}
-function getCommonHookEvents(providerIds) {
-  const providers = providerIds && providerIds.length > 0 ? providerIds.map((id) => getProvider(id)).filter((p) => p !== void 0) : getAllProviders();
-  if (providers.length === 0) return [];
-  const first = providers[0].capabilities.hooks.supported;
-  return first.filter(
-    (event) => providers.every((p) => p.capabilities.hooks.supported.includes(event))
-  );
-}
-function providerSupports(provider, dotPath) {
-  const parts = dotPath.split(".");
-  let current = provider.capabilities;
-  for (const part of parts) {
-    if (current == null || typeof current !== "object") return false;
-    current = current[part];
-  }
-  if (typeof current === "boolean") return current;
-  if (Array.isArray(current)) return current.length > 0;
-  return current != null;
-}
-function getSpawnCapableProviders() {
-  return getAllProviders().filter((p) => p.capabilities.spawn.supportsSubagents);
-}
-function getProvidersBySpawnCapability(flag) {
-  return getAllProviders().filter((p) => p.capabilities.spawn[flag] === true);
-}
-function getProvidersBySkillsPrecedence(precedence) {
-  return getAllProviders().filter((p) => p.capabilities.skills.precedence === precedence);
-}
-function getEffectiveSkillsPaths(provider, scope, projectDir) {
-  const vendorPath = resolveProviderSkillsDir(provider, scope, projectDir);
-  const { precedence, agentsGlobalPath, agentsProjectPath } = provider.capabilities.skills;
-  const resolveAgentsPath = () => {
-    if (scope === "global" && agentsGlobalPath) return agentsGlobalPath;
-    if (scope === "project" && agentsProjectPath && projectDir) {
-      return join4(projectDir, agentsProjectPath);
-    }
-    return null;
-  };
-  const agentsPath = resolveAgentsPath();
-  const scopeLabel = scope === "global" ? "global" : "project";
-  switch (precedence) {
-    case "vendor-only":
-      return [{ path: vendorPath, source: "vendor", scope: scopeLabel }];
-    case "agents-canonical":
-      return agentsPath ? [{ path: agentsPath, source: "agents", scope: scopeLabel }] : [];
-    case "agents-first":
-      return [
-        ...agentsPath ? [{ path: agentsPath, source: "agents", scope: scopeLabel }] : [],
-        { path: vendorPath, source: "vendor", scope: scopeLabel }
-      ];
-    case "agents-supported":
-      return [
-        { path: vendorPath, source: "vendor", scope: scopeLabel },
-        ...agentsPath ? [{ path: agentsPath, source: "agents", scope: scopeLabel }] : []
-      ];
-    case "vendor-global-agents-project":
-      if (scope === "global") {
-        return [{ path: vendorPath, source: "vendor", scope: "global" }];
-      }
-      return [
-        ...agentsPath ? [{ path: agentsPath, source: "agents", scope: "project" }] : [],
-        { path: vendorPath, source: "vendor", scope: "project" }
-      ];
-    default:
-      return [{ path: vendorPath, source: "vendor", scope: scopeLabel }];
-  }
-}
-function buildSkillsMap() {
-  return getAllProviders().map((p) => {
-    const { precedence, agentsGlobalPath, agentsProjectPath } = p.capabilities.skills;
-    const isVendorOnly = precedence === "vendor-only";
-    return {
-      providerId: p.id,
-      toolName: p.toolName,
-      precedence,
-      paths: {
-        global: isVendorOnly ? p.pathSkills : agentsGlobalPath ?? null,
-        project: isVendorOnly ? p.pathProjectSkills : agentsProjectPath ?? null
-      }
-    };
-  });
-}
-function getProviderCapabilities(idOrAlias) {
-  return getProvider(idOrAlias)?.capabilities;
-}
-function providerSupportsById(idOrAlias, capabilityPath) {
-  const provider = getProvider(idOrAlias);
-  if (!provider) return false;
-  return providerSupports(provider, capabilityPath);
-}
-
 // src/core/registry/detection.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync7 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join } from "path";
 var DEFAULT_DETECTION_CACHE_TTL_MS = 3e4;
 var detectionCache = null;
 function checkBinary(binary) {
@@ -1176,12 +551,12 @@ function checkBinary(binary) {
   }
 }
 function checkDirectory(dir) {
-  return existsSync7(dir);
+  return existsSync5(dir);
 }
 function checkAppBundle(appName) {
   if (process.platform !== "darwin") return false;
   const applications = getPlatformLocations().applications;
-  return applications.some((base) => existsSync7(join5(base, appName)));
+  return applications.some((base) => existsSync5(join(base, appName)));
 }
 function checkFlatpak(flatpakId) {
   if (process.platform !== "linux") return false;
@@ -1272,7 +647,7 @@ function setCachedResults(signature, results) {
 }
 function detectProjectProvider(provider, projectDir) {
   if (!provider.pathProject) return false;
-  return existsSync7(resolveProviderProjectPath(provider, projectDir));
+  return existsSync5(resolveProviderProjectPath(provider, projectDir));
 }
 function detectAllProviders(options = {}) {
   const providers = getAllProviders() ?? [];
@@ -1301,15 +676,15 @@ function resetDetectionCache() {
 }
 
 // src/core/skills/installer.ts
-import { existsSync as existsSync8, lstatSync } from "fs";
-import { cp, mkdir as mkdir2, rm, symlink } from "fs/promises";
-import { join as join6 } from "path";
+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 mkdir2(getCanonicalSkillsDir(), { recursive: true });
+  await mkdir(getCanonicalSkillsDir(), { recursive: true });
 }
 async function installToCanonical(sourcePath, skillName) {
   await ensureCanonicalDir();
-  const targetDir = join6(getCanonicalSkillsDir(), skillName);
+  const targetDir = join2(getCanonicalSkillsDir(), skillName);
   await rm(targetDir, { recursive: true, force: true });
   try {
     await cp(sourcePath, targetDir, { recursive: true });
@@ -1334,9 +709,9 @@ async function linkToAgent(canonicalPath, provider, skillName, isGlobal, project
   for (const targetSkillsDir of targetDirs) {
     if (!targetSkillsDir) continue;
     try {
-      await mkdir2(targetSkillsDir, { recursive: true });
-      const linkPath = join6(targetSkillsDir, skillName);
-      if (existsSync8(linkPath)) {
+      await mkdir(targetSkillsDir, { recursive: true });
+      const linkPath = join2(targetSkillsDir, skillName);
+      if (existsSync6(linkPath)) {
         const stat2 = lstatSync(linkPath);
         if (stat2.isSymbolicLink()) {
           await rm(linkPath);
@@ -1392,8 +767,8 @@ async function removeSkill(skillName, providers, isGlobal, projectDir) {
     let providerRemoved = false;
     for (const skillsDir of targetDirs) {
       if (!skillsDir) continue;
-      const linkPath = join6(skillsDir, skillName);
-      if (existsSync8(linkPath)) {
+      const linkPath = join2(skillsDir, skillName);
+      if (existsSync6(linkPath)) {
         try {
           await rm(linkPath, { recursive: true });
           providerRemoved = true;
@@ -1406,8 +781,8 @@ async function removeSkill(skillName, providers, isGlobal, projectDir) {
       removed.push(provider.id);
     }
   }
-  const canonicalPath = join6(getCanonicalSkillsDir(), skillName);
-  if (existsSync8(canonicalPath)) {
+  const canonicalPath = join2(getCanonicalSkillsDir(), skillName);
+  if (existsSync6(canonicalPath)) {
     try {
       await rm(canonicalPath, { recursive: true });
     } catch (err) {
@@ -1417,25 +792,25 @@ async function removeSkill(skillName, providers, isGlobal, projectDir) {
   return { removed, errors };
 }
 async function listCanonicalSkills() {
-  if (!existsSync8(getCanonicalSkillsDir())) return [];
+  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 existsSync9, lstatSync as lstatSync2 } from "fs";
+import { existsSync as existsSync7, lstatSync as lstatSync2 } from "fs";
 import {
   cp as cp2,
-  mkdir as mkdir3,
-  readFile as readFile5,
+  mkdir as mkdir2,
+  readFile as readFile4,
   readlink,
   rm as rm2,
   symlink as symlink2,
-  writeFile as writeFile5
+  writeFile as writeFile4
 } from "fs/promises";
 import { tmpdir } from "os";
-import { basename, dirname as dirname4, join as join7 } from "path";
+import { basename, dirname, join as join3 } from "path";
 
 // src/core/paths/agents.ts
 var AGENTS_HOME = getAgentsHome();
@@ -1456,18 +831,18 @@ function selectProvidersByMinimumPriority(providers, minimumPriority = "low") {
   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 : join7(projectDir, provider.pathProjectSkills);
-  return join7(skillDir, skillName);
+  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 (!existsSync9(path)) {
+    if (!existsSync7(path)) {
       snapshots.set(path, null);
       continue;
     }
-    snapshots.set(path, await readFile5(path, "utf-8"));
+    snapshots.set(path, await readFile4(path, "utf-8"));
   }
   return snapshots;
 }
@@ -1477,24 +852,24 @@ async function restoreConfigSnapshots(snapshots) {
       await rm2(path, { force: true });
       continue;
     }
-    await mkdir3(dirname4(path), { recursive: true });
-    await writeFile5(path, content, "utf-8");
+    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 = join7(CANONICAL_SKILLS_DIR, skillName);
-  const canonicalExisted = existsSync9(canonicalPath);
-  const canonicalBackupPath = join7(backupRoot, "canonical", skillName);
+  const canonicalPath = join3(CANONICAL_SKILLS_DIR, skillName);
+  const canonicalExisted = existsSync7(canonicalPath);
+  const canonicalBackupPath = join3(backupRoot, "canonical", skillName);
   if (canonicalExisted) {
-    await mkdir3(dirname4(canonicalBackupPath), { recursive: true });
+    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 (!existsSync9(linkPath)) {
+    if (!existsSync7(linkPath)) {
       pathSnapshots.push({ linkPath, state: "missing" });
       continue;
     }
@@ -1507,8 +882,8 @@ async function snapshotSkillState(providerTargets, operation, projectDir, backup
       });
       continue;
     }
-    const backupPath = join7(backupRoot, "links", provider.id, `${skillName}-${basename(linkPath)}`);
-    await mkdir3(dirname4(backupPath), { recursive: true });
+    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 });
@@ -1527,17 +902,17 @@ async function snapshotSkillState(providerTargets, operation, projectDir, backup
   };
 }
 async function restoreSkillSnapshot(snapshot) {
-  if (existsSync9(snapshot.canonicalPath)) {
+  if (existsSync7(snapshot.canonicalPath)) {
     await rm2(snapshot.canonicalPath, { recursive: true, force: true });
   }
-  if (snapshot.canonicalExisted && snapshot.canonicalBackupPath && existsSync9(snapshot.canonicalBackupPath)) {
-    await mkdir3(dirname4(snapshot.canonicalPath), { recursive: 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 mkdir3(dirname4(pathSnapshot.linkPath), { recursive: true });
+    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);
@@ -1568,7 +943,7 @@ async function installBatchWithRollback(options) {
     return paths;
   });
   const configSnapshots = await snapshotConfigs(configPaths);
-  const backupRoot = join7(
+  const backupRoot = join3(
     tmpdir(),
     `caamp-skill-backup-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
   );
@@ -1759,7 +1134,7 @@ async function updateInstructionsSingleOperation(providers, content, scope = "pr
   };
   for (const [filePath, action] of actions.entries()) {
     const providersForFile = providers.filter((provider) => {
-      const expectedPath = scope === "global" ? join7(provider.pathGlobal, provider.instructFile) : join7(projectDir, provider.instructFile);
+      const expectedPath = scope === "global" ? join3(provider.pathGlobal, provider.instructFile) : join3(projectDir, provider.instructFile);
       return expectedPath === filePath;
     });
     const fallback = groupedByFile.get(basename(filePath)) ?? [];
@@ -1826,9 +1201,9 @@ async function configureProviderGlobalAndProject(provider, options) {
 
 // src/core/mcp/cleo.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync10 } from "fs";
-import { homedir as homedir3 } from "os";
-import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { homedir } from "os";
+import { isAbsolute, resolve as resolve2 } from "path";
 var CLEO_SERVER_NAMES = {
   stable: "cleo",
   beta: "cleo-beta",
@@ -1909,9 +1284,9 @@ function buildCleoProfile(options) {
   };
 }
 function expandHome(pathValue) {
-  if (pathValue === "~") return homedir3();
+  if (pathValue === "~") return homedir();
   if (pathValue.startsWith("~/")) {
-    return resolve3(homedir3(), pathValue.slice(2));
+    return resolve2(homedir(), pathValue.slice(2));
   }
   return pathValue;
 }
@@ -1919,8 +1294,8 @@ function checkCommandReachability(command) {
   const hasPathSeparator = command.includes("/") || command.includes("\\");
   if (hasPathSeparator || command.startsWith("~")) {
     const expanded = expandHome(command);
-    const candidate = isAbsolute2(expanded) ? expanded : resolve3(process.cwd(), expanded);
-    if (existsSync10(candidate)) {
+    const candidate = isAbsolute(expanded) ? expanded : resolve2(process.cwd(), expanded);
+    if (existsSync8(candidate)) {
       return { reachable: true, method: "path", detail: candidate };
     }
     return { reachable: false, method: "path", detail: candidate };
@@ -1960,12 +1335,12 @@ function isCleoSource(source) {
 }
 
 // src/core/lock-utils.ts
-import { open, readFile as readFile6, writeFile as writeFile6, mkdir as mkdir4, rm as rm3, rename, stat } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
+import { open, readFile as readFile5, writeFile as writeFile5, mkdir as mkdir3, rm as rm3, rename, stat } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
 var LOCK_GUARD_PATH = `${LOCK_FILE_PATH}.lock`;
 var STALE_LOCK_MS = 5e3;
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function removeStaleLock() {
   try {
@@ -1979,7 +1354,7 @@ async function removeStaleLock() {
   return false;
 }
 async function acquireLockGuard(retries = 40, delayMs = 25) {
-  await mkdir4(AGENTS_HOME, { recursive: true });
+  await mkdir3(AGENTS_HOME, { recursive: true });
   for (let attempt = 0; attempt < retries; attempt += 1) {
     try {
       const handle = await open(LOCK_GUARD_PATH, "wx");
@@ -2003,15 +1378,15 @@ async function releaseLockGuard() {
 }
 async function writeLockFileUnsafe(lock) {
   const tmpPath = `${LOCK_FILE_PATH}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile6(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+  await writeFile5(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
   await rename(tmpPath, LOCK_FILE_PATH);
 }
 async function readLockFile() {
   try {
-    if (!existsSync11(LOCK_FILE_PATH)) {
+    if (!existsSync9(LOCK_FILE_PATH)) {
       return { version: 1, skills: {}, mcpServers: {} };
     }
-    const content = await readFile6(LOCK_FILE_PATH, "utf-8");
+    const content = await readFile5(LOCK_FILE_PATH, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, skills: {}, mcpServers: {} };
@@ -2626,8 +2001,8 @@ var MarketplaceClient = class {
 
 // src/core/skills/library-loader.ts
 import { createRequire } from "module";
-import { existsSync as existsSync12, readdirSync, readFileSync as readFileSync2 } from "fs";
-import { basename as basename2, dirname as dirname5, join as join8 } from "path";
+import { existsSync as existsSync10, readdirSync, readFileSync } from "fs";
+import { basename as basename2, dirname as dirname2, join as join4 } from "path";
 var require2 = createRequire(import.meta.url);
 function loadLibraryFromModule(root) {
   let mod;
@@ -2675,17 +2050,17 @@ function loadLibraryFromModule(root) {
   return mod;
 }
 function buildLibraryFromFiles(root) {
-  const catalogPath = join8(root, "skills.json");
-  if (!existsSync12(catalogPath)) {
+  const catalogPath = join4(root, "skills.json");
+  if (!existsSync10(catalogPath)) {
     throw new Error(`No skills.json found at ${root}`);
   }
-  const catalogData = JSON.parse(readFileSync2(catalogPath, "utf-8"));
+  const catalogData = JSON.parse(readFileSync(catalogPath, "utf-8"));
   const entries = catalogData.skills ?? [];
   const version = catalogData.version ?? "0.0.0";
-  const manifestPath = join8(root, "skills", "manifest.json");
+  const manifestPath = join4(root, "skills", "manifest.json");
   let manifest;
-  if (existsSync12(manifestPath)) {
-    manifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
+  if (existsSync10(manifestPath)) {
+    manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
   } else {
     manifest = {
       $schema: "",
@@ -2694,14 +2069,14 @@ function buildLibraryFromFiles(root) {
       skills: []
     };
   }
-  const profilesDir = join8(root, "profiles");
+  const profilesDir = join4(root, "profiles");
   const profiles = /* @__PURE__ */ new Map();
-  if (existsSync12(profilesDir)) {
+  if (existsSync10(profilesDir)) {
     for (const file of readdirSync(profilesDir)) {
       if (!file.endsWith(".json")) continue;
       try {
         const profile = JSON.parse(
-          readFileSync2(join8(profilesDir, file), "utf-8")
+          readFileSync(join4(profilesDir, file), "utf-8")
         );
         profiles.set(profile.name, profile);
       } catch {
@@ -2715,9 +2090,9 @@ function buildLibraryFromFiles(root) {
   function getSkillDir2(name) {
     const entry = skillMap.get(name);
     if (entry) {
-      return dirname5(join8(root, entry.path));
+      return dirname2(join4(root, entry.path));
     }
-    return join8(root, "skills", name);
+    return join4(root, "skills", name);
   }
   function resolveDeps(names, visited = /* @__PURE__ */ new Set()) {
     const result = [];
@@ -2745,7 +2120,7 @@ function buildLibraryFromFiles(root) {
     return resolveDeps([...new Set(skills)]);
   }
   function discoverFiles(dir, ext) {
-    if (!existsSync12(dir)) return [];
+    if (!existsSync10(dir)) return [];
     return readdirSync(dir).filter((f) => f.endsWith(ext)).map((f) => basename2(f, ext));
   }
   const library = {
@@ -2762,17 +2137,17 @@ function buildLibraryFromFiles(root) {
     getSkillPath(name) {
       const entry = skillMap.get(name);
       if (entry) {
-        return join8(root, entry.path);
+        return join4(root, entry.path);
       }
-      return join8(root, "skills", name, "SKILL.md");
+      return join4(root, "skills", name, "SKILL.md");
     },
     getSkillDir: getSkillDir2,
     readSkillContent(name) {
       const skillPath = library.getSkillPath(name);
-      if (!existsSync12(skillPath)) {
+      if (!existsSync10(skillPath)) {
         throw new Error(`Skill content not found: ${skillPath}`);
       }
-      return readFileSync2(skillPath, "utf-8");
+      return readFileSync(skillPath, "utf-8");
     },
     getCoreSkills() {
       return entries.filter((e) => e.core);
@@ -2796,32 +2171,32 @@ function buildLibraryFromFiles(root) {
       return resolveProfileByName(name);
     },
     listSharedResources() {
-      return discoverFiles(join8(root, "skills", "_shared"), ".md");
+      return discoverFiles(join4(root, "skills", "_shared"), ".md");
     },
     getSharedResourcePath(name) {
-      const resourcePath = join8(root, "skills", "_shared", `${name}.md`);
-      return existsSync12(resourcePath) ? resourcePath : void 0;
+      const resourcePath = join4(root, "skills", "_shared", `${name}.md`);
+      return existsSync10(resourcePath) ? resourcePath : void 0;
     },
     readSharedResource(name) {
       const resourcePath = library.getSharedResourcePath(name);
       if (!resourcePath) return void 0;
-      return readFileSync2(resourcePath, "utf-8");
+      return readFileSync(resourcePath, "utf-8");
     },
     listProtocols() {
-      const rootProtocols = discoverFiles(join8(root, "protocols"), ".md");
+      const rootProtocols = discoverFiles(join4(root, "protocols"), ".md");
       if (rootProtocols.length > 0) return rootProtocols;
-      return discoverFiles(join8(root, "skills", "protocols"), ".md");
+      return discoverFiles(join4(root, "skills", "protocols"), ".md");
     },
     getProtocolPath(name) {
-      const rootPath = join8(root, "protocols", `${name}.md`);
-      if (existsSync12(rootPath)) return rootPath;
-      const skillsPath = join8(root, "skills", "protocols", `${name}.md`);
-      return existsSync12(skillsPath) ? skillsPath : void 0;
+      const rootPath = join4(root, "protocols", `${name}.md`);
+      if (existsSync10(rootPath)) return rootPath;
+      const skillsPath = join4(root, "skills", "protocols", `${name}.md`);
+      return existsSync10(skillsPath) ? skillsPath : void 0;
     },
     readProtocol(name) {
       const protocolPath = library.getProtocolPath(name);
       if (!protocolPath) return void 0;
-      return readFileSync2(protocolPath, "utf-8");
+      return readFileSync(protocolPath, "utf-8");
     },
     validateSkillFrontmatter(name) {
       const entry = skillMap.get(name);
@@ -2841,8 +2216,8 @@ function buildLibraryFromFiles(root) {
       if (!entry.version) {
         issues.push({ level: "warn", field: "version", message: "Missing version" });
       }
-      const skillPath = join8(root, entry.path);
-      if (!existsSync12(skillPath)) {
+      const skillPath = join4(root, entry.path);
+      if (!existsSync10(skillPath)) {
         issues.push({ level: "error", field: "path", message: `SKILL.md not found at ${entry.path}` });
       }
       return {
@@ -2897,15 +2272,15 @@ __export(catalog_exports, {
   validateAll: () => validateAll,
   validateSkillFrontmatter: () => validateSkillFrontmatter
 });
-import { existsSync as existsSync13 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { join as join5 } from "path";
 var _library = null;
 function registerSkillLibrary(library) {
   _library = library;
 }
 function registerSkillLibraryFromPath(root) {
-  const indexPath = join9(root, "index.js");
-  if (existsSync13(indexPath)) {
+  const indexPath = join5(root, "index.js");
+  if (existsSync11(indexPath)) {
     _library = loadLibraryFromModule(root);
     return;
   }
@@ -2916,13 +2291,13 @@ function clearRegisteredLibrary() {
 }
 function discoverLibrary() {
   const envPath = process.env["CAAMP_SKILL_LIBRARY"];
-  if (envPath && existsSync13(envPath)) {
+  if (envPath && existsSync11(envPath)) {
     try {
-      const indexPath = join9(envPath, "index.js");
-      if (existsSync13(indexPath)) {
+      const indexPath = join5(envPath, "index.js");
+      if (existsSync11(indexPath)) {
         return loadLibraryFromModule(envPath);
       }
-      if (existsSync13(join9(envPath, "skills.json"))) {
+      if (existsSync11(join5(envPath, "skills.json"))) {
         return buildLibraryFromFiles(envPath);
       }
     } catch {
@@ -3029,13 +2404,13 @@ function getLibraryRoot() {
 }
 
 // src/core/skills/discovery.ts
-import { readFile as readFile7, readdir } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
-import { join as join10 } from "path";
+import { readFile as readFile6, readdir } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+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;
@@ -3055,8 +2430,8 @@ async function parseSkillFile(filePath) {
   }
 }
 async function discoverSkill(skillDir) {
-  const skillFile = join10(skillDir, "SKILL.md");
-  if (!existsSync14(skillFile)) return null;
+  const skillFile = join6(skillDir, "SKILL.md");
+  if (!existsSync12(skillFile)) return null;
   const metadata = await parseSkillFile(skillFile);
   if (!metadata) return null;
   return {
@@ -3067,12 +2442,12 @@ async function discoverSkill(skillDir) {
   };
 }
 async function discoverSkills(rootDir) {
-  if (!existsSync14(rootDir)) return [];
+  if (!existsSync12(rootDir)) return [];
   const entries = await readdir(rootDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const skillDir = join10(rootDir, entry.name);
+    const skillDir = join6(rootDir, entry.name);
     const skill = await discoverSkill(skillDir);
     if (skill) {
       skills.push(skill);
@@ -3498,8 +2873,8 @@ async function recommendSkills2(query, criteria, options = {}) {
 }
 
 // src/core/skills/audit/scanner.ts
-import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile8 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import { readFile as readFile7 } from "fs/promises";
 
 // src/core/skills/audit/rules.ts
 function rule(id, name, description, severity, category, pattern) {
@@ -3878,10 +3253,10 @@ var SEVERITY_WEIGHTS = {
   info: 0
 };
 async function scanFile(filePath, rules) {
-  if (!existsSync15(filePath)) {
+  if (!existsSync13(filePath)) {
     return { file: filePath, findings: [], score: 100, passed: true };
   }
-  const content = await readFile8(filePath, "utf-8");
+  const content = await readFile7(filePath, "utf-8");
   const lines = content.split("\n");
   const activeRules = rules ?? AUDIT_RULES;
   const findings = [];
@@ -3910,14 +3285,14 @@ async function scanFile(filePath, rules) {
 }
 async function scanDirectory(dirPath) {
   const { readdir: readdir2 } = await import("fs/promises");
-  const { join: join11 } = await import("path");
-  if (!existsSync15(dirPath)) return [];
+  const { join: join7 } = await import("path");
+  if (!existsSync13(dirPath)) return [];
   const entries = await readdir2(dirPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const skillFile = join11(dirPath, entry.name, "SKILL.md");
-      if (existsSync15(skillFile)) {
+      const skillFile = join7(dirPath, entry.name, "SKILL.md");
+      if (existsSync13(skillFile)) {
         results.push(await scanFile(skillFile));
       }
     }
@@ -3969,8 +3344,8 @@ function toSarif(results) {
 }
 
 // src/core/skills/validator.ts
-import { readFile as readFile9 } from "fs/promises";
-import { existsSync as existsSync16 } from "fs";
+import { readFile as readFile8 } from "fs/promises";
+import { existsSync as existsSync14 } from "fs";
 import matter2 from "gray-matter";
 var RESERVED_NAMES = [
   "anthropic",
@@ -3991,14 +3366,14 @@ var WARN_BODY_LINES = 500;
 var WARN_DESCRIPTION_LENGTH = 50;
 async function validateSkill(filePath) {
   const issues = [];
-  if (!existsSync16(filePath)) {
+  if (!existsSync14(filePath)) {
     return {
       valid: false,
       issues: [{ level: "error", field: "file", message: "File does not exist" }],
       metadata: null
     };
   }
-  const content = await readFile9(filePath, "utf-8");
+  const content = await readFile8(filePath, "utf-8");
   if (!content.startsWith("---")) {
     issues.push({
       level: "error",
@@ -4104,16 +3479,6 @@ async function validateSkill(filePath) {
 }
 
 export {
-  checkInjection,
-  inject,
-  removeInjection,
-  checkAllInjections,
-  injectAll,
-  buildInjectionContent,
-  parseInjectionContent,
-  generateInjectionContent,
-  generateSkillsSection,
-  groupByInstructFile,
   deepMerge,
   getNestedValue,
   ensureDir,
@@ -4126,27 +3491,6 @@ export {
   readConfig,
   writeConfig,
   removeConfig,
-  getPlatformPaths,
-  getSystemInfo,
-  _resetPlatformPathsCache,
-  getPlatformLocations,
-  getAgentsHome,
-  getProjectAgentsDir,
-  getCanonicalSkillsDir,
-  getLockFilePath,
-  getAgentsMcpDir,
-  getAgentsMcpServersPath,
-  getAgentsInstructFile,
-  getAgentsConfigPath,
-  getAgentsWikiDir,
-  getAgentsSpecDir,
-  getAgentsLinksDir,
-  resolveRegistryTemplatePath,
-  resolveProviderConfigPath,
-  resolvePreferredConfigScope,
-  resolveProviderSkillsDir,
-  resolveProviderSkillsDirs,
-  buildSkillSubPathCandidates,
   resolveConfigPath,
   listMcpServers,
   listAgentsMcpServers,
@@ -4157,25 +3501,6 @@ export {
   installMcpServerToAll,
   buildServerConfig,
   CANONICAL_SKILLS_DIR,
-  getAllProviders,
-  getProvider,
-  resolveAlias,
-  getProvidersByPriority,
-  getProvidersByStatus,
-  getProvidersByInstructFile,
-  getInstructionFiles,
-  getProviderCount,
-  getRegistryVersion,
-  getProvidersByHookEvent,
-  getCommonHookEvents,
-  providerSupports,
-  getSpawnCapableProviders,
-  getProvidersBySpawnCapability,
-  getProvidersBySkillsPrecedence,
-  getEffectiveSkillsPaths,
-  buildSkillsMap,
-  getProviderCapabilities,
-  providerSupportsById,
   detectProvider,
   detectAllProviders,
   getInstalledProviders,
@@ -4245,4 +3570,4 @@ export {
   toSarif,
   validateSkill
 };
-//# sourceMappingURL=chunk-6T3TJQFF.js.map
+//# sourceMappingURL=chunk-LDTYDQGR.js.map