@cleocode/caamp 1.5.1 → 1.6.0

package/README.md

@@ -65,6 +65,31 @@ const installed = getInstalledProviders();
 const servers = await listAllMcpServers(installed, "global");
 ```
 
+### Querying Provider Capabilities
+
+```typescript
+import {
+  getProviderCapabilities,
+  getSpawnCapableProviders,
+  getProvidersByHookEvent,
+  buildSkillsMap,
+} from "@cleocode/caamp";
+
+// Get capabilities for a specific provider
+const caps = getProviderCapabilities("claude-code");
+console.log(caps?.spawn.supportsSubagents); // true
+console.log(caps?.hooks.supported); // ["onSessionStart", ...]
+
+// Find all providers that support spawning subagents
+const spawnCapable = getSpawnCapableProviders();
+
+// Find providers supporting a specific hook event
+const hookProviders = getProvidersByHookEvent("onToolComplete");
+
+// Get full skills precedence map
+const skillsMap = buildSkillsMap();
+```
+
 See [API Reference](https://codluv.gitbook.io/caamp/api-and-reference/api-reference) for full programmatic API documentation.
 
 ## CLI Commands

package/dist/{chunk-ZEXRZTQX.js → chunk-N5E7BZM2.js}

@@ -561,6 +561,42 @@ function resolveProviderSkillsDir(provider, scope, projectDir = process.cwd()) {
   }
   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 ? join2(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);
 }
@@ -860,8 +896,45 @@ function buildServerConfig(source, transport, headers) {
 
 // src/core/registry/providers.ts
 import { readFileSync } from "fs";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname3, join as join3 } 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);
@@ -896,7 +969,8 @@ function resolveProvider(raw) {
     supportsHeaders: raw.supportsHeaders,
     priority: raw.priority,
     status: raw.status,
-    agentSkillsCompatible: raw.agentSkillsCompatible
+    agentSkillsCompatible: raw.agentSkillsCompatible,
+    capabilities: resolveCapabilities(raw.capabilities)
   };
 }
 function loadRegistry() {
@@ -956,11 +1030,104 @@ function getProviderCount() {
 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 join3(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 join3 } from "path";
+import { join as join4 } from "path";
 var DEFAULT_DETECTION_CACHE_TTL_MS = 3e4;
 var detectionCache = null;
 function checkBinary(binary) {
@@ -978,7 +1145,7 @@ function checkDirectory(dir) {
 function checkAppBundle(appName) {
   if (process.platform !== "darwin") return false;
   const applications = getPlatformLocations().applications;
-  return applications.some((base) => existsSync7(join3(base, appName)));
+  return applications.some((base) => existsSync7(join4(base, appName)));
 }
 function checkFlatpak(flatpakId) {
   if (process.platform !== "linux") return false;
@@ -1100,13 +1267,13 @@ 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 join4 } from "path";
+import { join as join5 } from "path";
 async function ensureCanonicalDir() {
   await mkdir2(getCanonicalSkillsDir(), { recursive: true });
 }
 async function installToCanonical(sourcePath, skillName) {
   await ensureCanonicalDir();
-  const targetDir = join4(getCanonicalSkillsDir(), skillName);
+  const targetDir = join5(getCanonicalSkillsDir(), skillName);
   await rm(targetDir, { recursive: true, force: true });
   try {
     await cp(sourcePath, targetDir, { recursive: true });
@@ -1121,38 +1288,44 @@ async function installToCanonical(sourcePath, skillName) {
   return targetDir;
 }
 async function linkToAgent(canonicalPath, provider, skillName, isGlobal, projectDir) {
-  const targetSkillsDir = resolveProviderSkillsDir(
-    provider,
-    isGlobal ? "global" : "project",
-    projectDir
-  );
-  if (!targetSkillsDir) {
+  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` };
   }
-  try {
-    await mkdir2(targetSkillsDir, { recursive: true });
-    const linkPath = join4(targetSkillsDir, skillName);
-    if (existsSync8(linkPath)) {
-      const stat2 = lstatSync(linkPath);
-      if (stat2.isSymbolicLink()) {
-        await rm(linkPath);
-      } else {
-        await rm(linkPath, { recursive: true });
-      }
-    }
-    const symlinkType = process.platform === "win32" ? "junction" : "dir";
+  const errors = [];
+  let anySuccess = false;
+  for (const targetSkillsDir of targetDirs) {
+    if (!targetSkillsDir) continue;
     try {
-      await symlink(canonicalPath, linkPath, symlinkType);
-    } catch {
-      await cp(canonicalPath, linkPath, { recursive: true });
+      await mkdir2(targetSkillsDir, { recursive: true });
+      const linkPath = join5(targetSkillsDir, skillName);
+      if (existsSync8(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 };
-  } catch (err) {
-    return {
-      success: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
   }
+  return {
+    success: false,
+    error: errors.join("; ") || `Provider ${provider.id} has no skills directory`
+  };
 }
 async function installSkill(sourcePath, skillName, providers, isGlobal, projectDir) {
   const errors = [];
@@ -1178,23 +1351,26 @@ async function removeSkill(skillName, providers, isGlobal, projectDir) {
   const removed = [];
   const errors = [];
   for (const provider of providers) {
-    const skillsDir = resolveProviderSkillsDir(
-      provider,
-      isGlobal ? "global" : "project",
-      projectDir
-    );
-    if (!skillsDir) continue;
-    const linkPath = join4(skillsDir, skillName);
-    if (existsSync8(linkPath)) {
-      try {
-        await rm(linkPath, { recursive: true });
-        removed.push(provider.id);
-      } catch (err) {
-        errors.push(`${provider.id}: ${err instanceof Error ? err.message : String(err)}`);
+    const scope = isGlobal ? "global" : "project";
+    const targetDirs = resolveProviderSkillsDirs(provider, scope, projectDir);
+    let providerRemoved = false;
+    for (const skillsDir of targetDirs) {
+      if (!skillsDir) continue;
+      const linkPath = join5(skillsDir, skillName);
+      if (existsSync8(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 = join4(getCanonicalSkillsDir(), skillName);
+  const canonicalPath = join5(getCanonicalSkillsDir(), skillName);
   if (existsSync8(canonicalPath)) {
     try {
       await rm(canonicalPath, { recursive: true });
@@ -1223,7 +1399,7 @@ import {
   writeFile as writeFile5
 } from "fs/promises";
 import { tmpdir } from "os";
-import { basename, dirname as dirname4, join as join5 } from "path";
+import { basename, dirname as dirname4, join as join6 } from "path";
 
 // src/core/paths/agents.ts
 var AGENTS_HOME = getAgentsHome();
@@ -1244,8 +1420,8 @@ 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 : join5(projectDir, provider.pathProjectSkills);
-  return join5(skillDir, skillName);
+  const skillDir = isGlobal ? provider.pathSkills : join6(projectDir, provider.pathProjectSkills);
+  return join6(skillDir, skillName);
 }
 async function snapshotConfigs(paths) {
   const snapshots = /* @__PURE__ */ new Map();
@@ -1272,9 +1448,9 @@ async function restoreConfigSnapshots(snapshots) {
 async function snapshotSkillState(providerTargets, operation, projectDir, backupRoot) {
   const skillName = operation.skillName;
   const isGlobal = operation.isGlobal ?? true;
-  const canonicalPath = join5(CANONICAL_SKILLS_DIR, skillName);
+  const canonicalPath = join6(CANONICAL_SKILLS_DIR, skillName);
   const canonicalExisted = existsSync9(canonicalPath);
-  const canonicalBackupPath = join5(backupRoot, "canonical", skillName);
+  const canonicalBackupPath = join6(backupRoot, "canonical", skillName);
   if (canonicalExisted) {
     await mkdir3(dirname4(canonicalBackupPath), { recursive: true });
     await cp2(canonicalPath, canonicalBackupPath, { recursive: true });
@@ -1295,7 +1471,7 @@ async function snapshotSkillState(providerTargets, operation, projectDir, backup
       });
       continue;
     }
-    const backupPath = join5(backupRoot, "links", provider.id, `${skillName}-${basename(linkPath)}`);
+    const backupPath = join6(backupRoot, "links", provider.id, `${skillName}-${basename(linkPath)}`);
     await mkdir3(dirname4(backupPath), { recursive: true });
     if (stat2.isDirectory()) {
       await cp2(linkPath, backupPath, { recursive: true });
@@ -1356,7 +1532,7 @@ async function installBatchWithRollback(options) {
     return paths;
   });
   const configSnapshots = await snapshotConfigs(configPaths);
-  const backupRoot = join5(
+  const backupRoot = join6(
     tmpdir(),
     `caamp-skill-backup-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
   );
@@ -1547,7 +1723,7 @@ async function updateInstructionsSingleOperation(providers, content, scope = "pr
   };
   for (const [filePath, action] of actions.entries()) {
     const providersForFile = providers.filter((provider) => {
-      const expectedPath = scope === "global" ? join5(provider.pathGlobal, provider.instructFile) : join5(projectDir, provider.instructFile);
+      const expectedPath = scope === "global" ? join6(provider.pathGlobal, provider.instructFile) : join6(projectDir, provider.instructFile);
       return expectedPath === filePath;
     });
     const fallback = groupedByFile.get(basename(filePath)) ?? [];
@@ -2415,7 +2591,7 @@ 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 join6 } from "path";
+import { basename as basename2, dirname as dirname5, join as join7 } from "path";
 var require2 = createRequire(import.meta.url);
 function loadLibraryFromModule(root) {
   let mod;
@@ -2463,14 +2639,14 @@ function loadLibraryFromModule(root) {
   return mod;
 }
 function buildLibraryFromFiles(root) {
-  const catalogPath = join6(root, "skills.json");
+  const catalogPath = join7(root, "skills.json");
   if (!existsSync12(catalogPath)) {
     throw new Error(`No skills.json found at ${root}`);
   }
   const catalogData = JSON.parse(readFileSync2(catalogPath, "utf-8"));
   const entries = catalogData.skills ?? [];
   const version = catalogData.version ?? "0.0.0";
-  const manifestPath = join6(root, "skills", "manifest.json");
+  const manifestPath = join7(root, "skills", "manifest.json");
   let manifest;
   if (existsSync12(manifestPath)) {
     manifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
@@ -2482,14 +2658,14 @@ function buildLibraryFromFiles(root) {
       skills: []
     };
   }
-  const profilesDir = join6(root, "profiles");
+  const profilesDir = join7(root, "profiles");
   const profiles = /* @__PURE__ */ new Map();
   if (existsSync12(profilesDir)) {
     for (const file of readdirSync(profilesDir)) {
       if (!file.endsWith(".json")) continue;
       try {
         const profile = JSON.parse(
-          readFileSync2(join6(profilesDir, file), "utf-8")
+          readFileSync2(join7(profilesDir, file), "utf-8")
         );
         profiles.set(profile.name, profile);
       } catch {
@@ -2503,9 +2679,9 @@ function buildLibraryFromFiles(root) {
   function getSkillDir2(name) {
     const entry = skillMap.get(name);
     if (entry) {
-      return dirname5(join6(root, entry.path));
+      return dirname5(join7(root, entry.path));
     }
-    return join6(root, "skills", name);
+    return join7(root, "skills", name);
   }
   function resolveDeps(names, visited = /* @__PURE__ */ new Set()) {
     const result = [];
@@ -2550,9 +2726,9 @@ function buildLibraryFromFiles(root) {
     getSkillPath(name) {
       const entry = skillMap.get(name);
       if (entry) {
-        return join6(root, entry.path);
+        return join7(root, entry.path);
       }
-      return join6(root, "skills", name, "SKILL.md");
+      return join7(root, "skills", name, "SKILL.md");
     },
     getSkillDir: getSkillDir2,
     readSkillContent(name) {
@@ -2584,10 +2760,10 @@ function buildLibraryFromFiles(root) {
       return resolveProfileByName(name);
     },
     listSharedResources() {
-      return discoverFiles(join6(root, "skills", "_shared"), ".md");
+      return discoverFiles(join7(root, "skills", "_shared"), ".md");
     },
     getSharedResourcePath(name) {
-      const resourcePath = join6(root, "skills", "_shared", `${name}.md`);
+      const resourcePath = join7(root, "skills", "_shared", `${name}.md`);
       return existsSync12(resourcePath) ? resourcePath : void 0;
     },
     readSharedResource(name) {
@@ -2596,14 +2772,14 @@ function buildLibraryFromFiles(root) {
       return readFileSync2(resourcePath, "utf-8");
     },
     listProtocols() {
-      const rootProtocols = discoverFiles(join6(root, "protocols"), ".md");
+      const rootProtocols = discoverFiles(join7(root, "protocols"), ".md");
       if (rootProtocols.length > 0) return rootProtocols;
-      return discoverFiles(join6(root, "skills", "protocols"), ".md");
+      return discoverFiles(join7(root, "skills", "protocols"), ".md");
     },
     getProtocolPath(name) {
-      const rootPath = join6(root, "protocols", `${name}.md`);
+      const rootPath = join7(root, "protocols", `${name}.md`);
       if (existsSync12(rootPath)) return rootPath;
-      const skillsPath = join6(root, "skills", "protocols", `${name}.md`);
+      const skillsPath = join7(root, "skills", "protocols", `${name}.md`);
       return existsSync12(skillsPath) ? skillsPath : void 0;
     },
     readProtocol(name) {
@@ -2629,7 +2805,7 @@ function buildLibraryFromFiles(root) {
       if (!entry.version) {
         issues.push({ level: "warn", field: "version", message: "Missing version" });
       }
-      const skillPath = join6(root, entry.path);
+      const skillPath = join7(root, entry.path);
       if (!existsSync12(skillPath)) {
         issues.push({ level: "error", field: "path", message: `SKILL.md not found at ${entry.path}` });
       }
@@ -2686,13 +2862,13 @@ __export(catalog_exports, {
   validateSkillFrontmatter: () => validateSkillFrontmatter
 });
 import { existsSync as existsSync13 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var _library = null;
 function registerSkillLibrary(library) {
   _library = library;
 }
 function registerSkillLibraryFromPath(root) {
-  const indexPath = join7(root, "index.js");
+  const indexPath = join8(root, "index.js");
   if (existsSync13(indexPath)) {
     _library = loadLibraryFromModule(root);
     return;
@@ -2706,11 +2882,11 @@ function discoverLibrary() {
   const envPath = process.env["CAAMP_SKILL_LIBRARY"];
   if (envPath && existsSync13(envPath)) {
     try {
-      const indexPath = join7(envPath, "index.js");
+      const indexPath = join8(envPath, "index.js");
       if (existsSync13(indexPath)) {
         return loadLibraryFromModule(envPath);
       }
-      if (existsSync13(join7(envPath, "skills.json"))) {
+      if (existsSync13(join8(envPath, "skills.json"))) {
         return buildLibraryFromFiles(envPath);
       }
     } catch {
@@ -2819,7 +2995,7 @@ function getLibraryRoot() {
 // src/core/skills/discovery.ts
 import { readFile as readFile7, readdir } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import matter from "gray-matter";
 async function parseSkillFile(filePath) {
   try {
@@ -2843,7 +3019,7 @@ async function parseSkillFile(filePath) {
   }
 }
 async function discoverSkill(skillDir) {
-  const skillFile = join8(skillDir, "SKILL.md");
+  const skillFile = join9(skillDir, "SKILL.md");
   if (!existsSync14(skillFile)) return null;
   const metadata = await parseSkillFile(skillFile);
   if (!metadata) return null;
@@ -2860,7 +3036,7 @@ async function discoverSkills(rootDir) {
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const skillDir = join8(rootDir, entry.name);
+    const skillDir = join9(rootDir, entry.name);
     const skill = await discoverSkill(skillDir);
     if (skill) {
       skills.push(skill);
@@ -3698,13 +3874,13 @@ async function scanFile(filePath, rules) {
 }
 async function scanDirectory(dirPath) {
   const { readdir: readdir2 } = await import("fs/promises");
-  const { join: join9 } = await import("path");
+  const { join: join10 } = await import("path");
   if (!existsSync15(dirPath)) return [];
   const entries = await readdir2(dirPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const skillFile = join9(dirPath, entry.name, "SKILL.md");
+      const skillFile = join10(dirPath, entry.name, "SKILL.md");
       if (existsSync15(skillFile)) {
         results.push(await scanFile(skillFile));
       }
@@ -3930,6 +4106,7 @@ export {
   resolveProviderConfigPath,
   resolvePreferredConfigScope,
   resolveProviderSkillsDir,
+  resolveProviderSkillsDirs,
   buildSkillSubPathCandidates,
   resolveConfigPath,
   listMcpServers,
@@ -3950,6 +4127,16 @@ export {
   getInstructionFiles,
   getProviderCount,
   getRegistryVersion,
+  getProvidersByHookEvent,
+  getCommonHookEvents,
+  providerSupports,
+  getSpawnCapableProviders,
+  getProvidersBySpawnCapability,
+  getProvidersBySkillsPrecedence,
+  getEffectiveSkillsPaths,
+  buildSkillsMap,
+  getProviderCapabilities,
+  providerSupportsById,
   detectProvider,
   detectAllProviders,
   getInstalledProviders,
@@ -4019,4 +4206,4 @@ export {
   toSarif,
   validateSkill
 };
-//# sourceMappingURL=chunk-ZEXRZTQX.js.map
+//# sourceMappingURL=chunk-N5E7BZM2.js.map