@cleocode/caamp 0.3.0 → 0.4.1

package/dist/{chunk-PCWTRJV2.js → chunk-6HQDRJLS.js}

@@ -1,58 +1,158 @@
-// src/core/registry/providers.ts
-import { readFileSync, existsSync } from "fs";
+// src/core/paths/standard.ts
+import { existsSync } from "fs";
 import { homedir } from "os";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-function findRegistryPath() {
-  const thisDir = dirname(fileURLToPath(import.meta.url));
-  const devPath = join(thisDir, "..", "..", "..", "providers", "registry.json");
-  if (existsSync(devPath)) return devPath;
-  const distPath = join(thisDir, "..", "providers", "registry.json");
-  if (existsSync(distPath)) return distPath;
-  let dir = thisDir;
-  for (let i = 0; i < 5; i++) {
-    const candidate = join(dir, "providers", "registry.json");
-    if (existsSync(candidate)) return candidate;
-    dir = dirname(dir);
-  }
-  throw new Error(`Cannot find providers/registry.json (searched from ${thisDir})`);
-}
-var _registry = null;
-var _providers = null;
-var _aliasMap = null;
-function getPlatformPaths() {
+import { dirname, isAbsolute, join, resolve } from "path";
+function getPlatformLocations() {
   const home = homedir();
   const platform = process.platform;
   if (platform === "win32") {
     const appData = process.env["APPDATA"] ?? join(home, "AppData", "Roaming");
     return {
+      home,
       config: appData,
       vscodeConfig: join(appData, "Code", "User"),
       zedConfig: join(appData, "Zed"),
-      claudeDesktopConfig: join(appData, "Claude")
+      claudeDesktopConfig: join(appData, "Claude"),
+      applications: []
     };
-  } else if (platform === "darwin") {
+  }
+  if (platform === "darwin") {
+    const config2 = process.env["XDG_CONFIG_HOME"] ?? join(home, ".config");
     return {
-      config: process.env["XDG_CONFIG_HOME"] ?? join(home, ".config"),
+      home,
+      config: config2,
       vscodeConfig: join(home, "Library", "Application Support", "Code", "User"),
       zedConfig: join(home, "Library", "Application Support", "Zed"),
-      claudeDesktopConfig: join(home, "Library", "Application Support", "Claude")
-    };
-  } else {
-    const config = process.env["XDG_CONFIG_HOME"] ?? join(home, ".config");
-    return {
-      config,
-      vscodeConfig: join(config, "Code", "User"),
-      zedConfig: join(config, "zed"),
-      claudeDesktopConfig: join(config, "Claude")
+      claudeDesktopConfig: join(home, "Library", "Application Support", "Claude"),
+      applications: ["/Applications", join(home, "Applications")]
     };
   }
+  const config = process.env["XDG_CONFIG_HOME"] ?? join(home, ".config");
+  return {
+    home,
+    config,
+    vscodeConfig: join(config, "Code", "User"),
+    zedConfig: join(config, "zed"),
+    claudeDesktopConfig: join(config, "Claude"),
+    applications: []
+  };
 }
-function resolvePath(template) {
+function normalizeHomeOverride(value) {
   const home = homedir();
-  const paths = getPlatformPaths();
-  return template.replace(/\$HOME/g, home).replace(/\$CONFIG/g, paths.config).replace(/\$VSCODE_CONFIG/g, paths.vscodeConfig).replace(/\$ZED_CONFIG/g, paths.zedConfig).replace(/\$CLAUDE_DESKTOP_CONFIG/g, paths.claudeDesktopConfig);
+  const trimmed = value.trim();
+  if (trimmed.startsWith("~/")) {
+    return join(home, trimmed.slice(2));
+  }
+  if (trimmed === "~") {
+    return home;
+  }
+  if (isAbsolute(trimmed)) {
+    return resolve(trimmed);
+  }
+  return resolve(home, trimmed);
+}
+function getAgentsHome() {
+  const override = process.env["AGENTS_HOME"];
+  if (override && override.trim().length > 0) {
+    return normalizeHomeOverride(override);
+  }
+  return join(homedir(), ".agents");
+}
+function getProjectAgentsDir(projectRoot = process.cwd()) {
+  return join(projectRoot, ".agents");
+}
+function resolveProjectPath(relativePath, projectDir = process.cwd()) {
+  return join(projectDir, relativePath);
+}
+function getCanonicalSkillsDir() {
+  return join(getAgentsHome(), "skills");
+}
+function getLockFilePath() {
+  return join(getAgentsHome(), ".caamp-lock.json");
+}
+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 resolveProviderProjectPath(provider, projectDir = process.cwd()) {
+  return resolveProjectPath(provider.pathProject, projectDir);
+}
+function resolveProvidersRegistryPath(startDir) {
+  const candidates = [
+    join(startDir, "..", "..", "..", "providers", "registry.json"),
+    join(startDir, "..", "providers", "registry.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  let current = startDir;
+  for (let i = 0; i < 8; i += 1) {
+    const candidate = join(current, "providers", "registry.json");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    current = dirname(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/registry/providers.ts
+import { readFileSync } from "fs";
+import { dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+function findRegistryPath() {
+  const thisDir = dirname2(fileURLToPath(import.meta.url));
+  return resolveProvidersRegistryPath(thisDir);
 }
+var _registry = null;
+var _providers = null;
+var _aliasMap = null;
 function resolveProvider(raw) {
   return {
     id: raw.id,
@@ -60,19 +160,19 @@ function resolveProvider(raw) {
     vendor: raw.vendor,
     agentFlag: raw.agentFlag,
     aliases: raw.aliases,
-    pathGlobal: resolvePath(raw.pathGlobal),
+    pathGlobal: resolveRegistryTemplatePath(raw.pathGlobal),
     pathProject: raw.pathProject,
     instructFile: raw.instructFile,
     configKey: raw.configKey,
     configFormat: raw.configFormat,
-    configPathGlobal: resolvePath(raw.configPathGlobal),
+    configPathGlobal: resolveRegistryTemplatePath(raw.configPathGlobal),
     configPathProject: raw.configPathProject,
-    pathSkills: resolvePath(raw.pathSkills),
+    pathSkills: resolveRegistryTemplatePath(raw.pathSkills),
     pathProjectSkills: raw.pathProjectSkills,
     detection: {
       methods: raw.detection.methods,
       binary: raw.detection.binary,
-      directories: raw.detection.directories?.map(resolvePath),
+      directories: raw.detection.directories?.map(resolveRegistryTemplatePath),
       appBundle: raw.detection.appBundle,
       flatpakId: raw.detection.flatpakId
     },
@@ -163,6 +263,8 @@ function isQuiet() {
 import { existsSync as existsSync2 } from "fs";
 import { execFileSync } from "child_process";
 import { join as join2 } from "path";
+var DEFAULT_DETECTION_CACHE_TTL_MS = 3e4;
+var detectionCache = null;
 function checkBinary(binary) {
   try {
     const cmd = process.platform === "win32" ? "where" : "which";
@@ -177,7 +279,8 @@ function checkDirectory(dir) {
 }
 function checkAppBundle(appName) {
   if (process.platform !== "darwin") return false;
-  return existsSync2(join2("/Applications", appName));
+  const applications = getPlatformLocations().applications;
+  return applications.some((base) => existsSync2(join2(base, appName)));
 }
 function checkFlatpak(flatpakId) {
   if (process.platform !== "linux") return false;
@@ -229,24 +332,71 @@ function detectProvider(provider) {
     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) {
+  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)
+  };
+}
 function detectProjectProvider(provider, projectDir) {
   if (!provider.pathProject) return false;
-  return existsSync2(join2(projectDir, provider.pathProject));
+  return existsSync2(resolveProviderProjectPath(provider, projectDir));
 }
-function detectAllProviders() {
+function detectAllProviders(options = {}) {
   const providers = getAllProviders();
-  return providers.map(detectProvider);
+  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() {
-  return detectAllProviders().filter((r) => r.installed).map((r) => r.provider);
+function getInstalledProviders(options = {}) {
+  return detectAllProviders(options).filter((r) => r.installed).map((r) => r.provider);
 }
-function detectProjectProviders(projectDir) {
-  const results = detectAllProviders();
+function detectProjectProviders(projectDir, options = {}) {
+  const results = detectAllProviders(options);
   return results.map((r) => ({
     ...r,
     projectDetected: detectProjectProvider(r.provider, projectDir)
   }));
 }
+function resetDetectionCache() {
+  detectionCache = null;
+}
 
 // src/core/sources/parser.ts
 var GITHUB_SHORTHAND = /^([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)(?:\/(.+))?$/;
@@ -368,15 +518,20 @@ function isMarketplaceScoped(input) {
 // src/core/skills/installer.ts
 import { mkdir, symlink, rm, cp } from "fs/promises";
 import { existsSync as existsSync3, lstatSync } from "fs";
-import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
-var CANONICAL_DIR = join3(homedir2(), ".agents", "skills");
+
+// src/core/paths/agents.ts
+var AGENTS_HOME = getAgentsHome();
+var LOCK_FILE_PATH = getLockFilePath();
+var CANONICAL_SKILLS_DIR = getCanonicalSkillsDir();
+
+// src/core/skills/installer.ts
 async function ensureCanonicalDir() {
-  await mkdir(CANONICAL_DIR, { recursive: true });
+  await mkdir(CANONICAL_SKILLS_DIR, { recursive: true });
 }
 async function installToCanonical(sourcePath, skillName) {
   await ensureCanonicalDir();
-  const targetDir = join3(CANONICAL_DIR, skillName);
+  const targetDir = join3(CANONICAL_SKILLS_DIR, skillName);
   if (existsSync3(targetDir)) {
     await rm(targetDir, { recursive: true });
   }
@@ -384,7 +539,11 @@ async function installToCanonical(sourcePath, skillName) {
   return targetDir;
 }
 async function linkToAgent(canonicalPath, provider, skillName, isGlobal, projectDir) {
-  const targetSkillsDir = isGlobal ? provider.pathSkills : join3(projectDir ?? process.cwd(), provider.pathProjectSkills);
+  const targetSkillsDir = resolveProviderSkillsDir(
+    provider,
+    isGlobal ? "global" : "project",
+    projectDir
+  );
   if (!targetSkillsDir) {
     return { success: false, error: `Provider ${provider.id} has no skills directory` };
   }
@@ -437,7 +596,11 @@ async function removeSkill(skillName, providers, isGlobal, projectDir) {
   const removed = [];
   const errors = [];
   for (const provider of providers) {
-    const skillsDir = isGlobal ? provider.pathSkills : join3(projectDir ?? process.cwd(), provider.pathProjectSkills);
+    const skillsDir = resolveProviderSkillsDir(
+      provider,
+      isGlobal ? "global" : "project",
+      projectDir
+    );
     if (!skillsDir) continue;
     const linkPath = join3(skillsDir, skillName);
     if (existsSync3(linkPath)) {
@@ -449,7 +612,7 @@ async function removeSkill(skillName, providers, isGlobal, projectDir) {
       }
     }
   }
-  const canonicalPath = join3(CANONICAL_DIR, skillName);
+  const canonicalPath = join3(CANONICAL_SKILLS_DIR, skillName);
   if (existsSync3(canonicalPath)) {
     try {
       await rm(canonicalPath, { recursive: true });
@@ -460,62 +623,95 @@ async function removeSkill(skillName, providers, isGlobal, projectDir) {
   return { removed, errors };
 }
 async function listCanonicalSkills() {
-  if (!existsSync3(CANONICAL_DIR)) return [];
+  if (!existsSync3(CANONICAL_SKILLS_DIR)) return [];
   const { readdir: readdir2 } = await import("fs/promises");
-  const entries = await readdir2(CANONICAL_DIR, { withFileTypes: true });
+  const entries = await readdir2(CANONICAL_SKILLS_DIR, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
 }
 
 // src/core/lock-utils.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { open, readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, rm as rm2, rename } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
-var LOCK_DIR = join4(homedir3(), ".agents");
-var LOCK_FILE = join4(LOCK_DIR, ".caamp-lock.json");
+var LOCK_GUARD_PATH = `${LOCK_FILE_PATH}.lock`;
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+async function acquireLockGuard(retries = 40, delayMs = 25) {
+  await mkdir2(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;
+      }
+      await sleep(delayMs);
+    }
+  }
+  throw new Error("Timed out waiting for lock file guard");
+}
+async function releaseLockGuard() {
+  await rm2(LOCK_GUARD_PATH, { force: true });
+}
+async function writeLockFileUnsafe(lock) {
+  const tmpPath = `${LOCK_FILE_PATH}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile2(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+  await rename(tmpPath, LOCK_FILE_PATH);
+}
 async function readLockFile() {
   try {
-    if (!existsSync4(LOCK_FILE)) {
+    if (!existsSync4(LOCK_FILE_PATH)) {
       return { version: 1, skills: {}, mcpServers: {} };
     }
-    const content = await readFile2(LOCK_FILE, "utf-8");
+    const content = await readFile2(LOCK_FILE_PATH, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, skills: {}, mcpServers: {} };
   }
 }
-async function writeLockFile(lock) {
-  await mkdir2(LOCK_DIR, { recursive: true });
-  await writeFile2(LOCK_FILE, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+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
 import { simpleGit } from "simple-git";
 async function recordSkillInstall(skillName, scopedName, source, sourceType, agents, canonicalPath, isGlobal, projectDir, version) {
-  const lock = await readLockFile();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = lock.skills[skillName];
-  lock.skills[skillName] = {
-    name: skillName,
-    scopedName,
-    source,
-    sourceType,
-    version,
-    installedAt: existing?.installedAt ?? now,
-    updatedAt: now,
-    agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
-    canonicalPath,
-    isGlobal,
-    projectDir
-  };
-  await writeLockFile(lock);
+  await updateLockFile((lock) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = lock.skills[skillName];
+    lock.skills[skillName] = {
+      name: skillName,
+      scopedName,
+      source,
+      sourceType,
+      version,
+      installedAt: existing?.installedAt ?? now,
+      updatedAt: now,
+      agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
+      canonicalPath,
+      isGlobal,
+      projectDir
+    };
+  });
 }
 async function removeSkillFromLock(skillName) {
-  const lock = await readLockFile();
-  if (!(skillName in lock.skills)) return false;
-  delete lock.skills[skillName];
-  await writeLockFile(lock);
-  return true;
+  let removed = false;
+  await updateLockFile((lock) => {
+    if (!(skillName in lock.skills)) return;
+    delete lock.skills[skillName];
+    removed = true;
+  });
+  return removed;
 }
 async function getTrackedSkills() {
   const lock = await readLockFile();
@@ -576,8 +772,66 @@ async function checkSkillUpdate(skillName) {
   };
 }
 
+// src/core/network/fetch.ts
+var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+var NetworkError = class extends Error {
+  kind;
+  url;
+  status;
+  constructor(message, kind, url, status) {
+    super(message);
+    this.name = "NetworkError";
+    this.kind = kind;
+    this.url = url;
+    this.status = status;
+  }
+};
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+  try {
+    return await fetch(url, {
+      ...init,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw new NetworkError(`Request timed out after ${timeoutMs}ms`, "timeout", url);
+    }
+    throw new NetworkError("Network request failed", "network", url);
+  }
+}
+function ensureOkResponse(response, url) {
+  if (!response.ok) {
+    throw new NetworkError(`Request failed with status ${response.status}`, "http", url, response.status);
+  }
+  return response;
+}
+function formatNetworkError(error) {
+  if (error instanceof NetworkError) {
+    if (error.kind === "timeout") {
+      return "Network request timed out. Please check your connection and try again.";
+    }
+    if (error.kind === "http") {
+      return `Marketplace request failed with HTTP ${error.status ?? "unknown"}. Please try again shortly.`;
+    }
+    return "Network request failed. Please check your connection and try again.";
+  }
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
 // src/core/marketplace/skillsmp.ts
 var API_BASE = "https://www.agentskills.in/api/skills";
+function parseScopedName(value) {
+  const match = value.match(/^@([^/]+)\/([^/]+)$/);
+  if (!match) return null;
+  return {
+    author: match[1],
+    name: match[2]
+  };
+}
 function toResult(skill) {
   return {
     name: skill.name,
@@ -599,31 +853,34 @@ var SkillsMPAdapter = class {
       limit: String(limit),
       sortBy: "stars"
     });
-    try {
-      const response = await fetch(`${API_BASE}?${params}`);
-      if (!response.ok) return [];
-      const data = await response.json();
-      return data.skills.map(toResult);
-    } catch {
-      return [];
-    }
+    const url = `${API_BASE}?${params}`;
+    const response = ensureOkResponse(await fetchWithTimeout(url), url);
+    const data = await response.json();
+    return data.skills.map(toResult);
   }
   async getSkill(scopedName) {
-    const params = new URLSearchParams({
-      search: scopedName,
-      limit: "1"
-    });
-    try {
-      const response = await fetch(`${API_BASE}?${params}`);
-      if (!response.ok) return null;
+    const parts = parseScopedName(scopedName);
+    const searchTerms = parts ? [parts.name, `${parts.author} ${parts.name}`, scopedName] : [scopedName];
+    const seen = /* @__PURE__ */ new Set();
+    for (const term of searchTerms) {
+      if (seen.has(term)) continue;
+      seen.add(term);
+      const params = new URLSearchParams({
+        search: term,
+        limit: "50",
+        sortBy: "stars"
+      });
+      const url = `${API_BASE}?${params}`;
+      const response = ensureOkResponse(await fetchWithTimeout(url), url);
       const data = await response.json();
       const match = data.skills.find(
         (s) => s.scopedName === scopedName || `@${s.author}/${s.name}` === scopedName
       );
-      return match ? toResult(match) : null;
-    } catch {
-      return null;
+      if (match) {
+        return toResult(match);
+      }
     }
+    return null;
   }
 };
 
@@ -645,18 +902,14 @@ function toResult2(skill) {
 var SkillsShAdapter = class {
   name = "skills.sh";
   async search(query, limit = 20) {
-    try {
-      const params = new URLSearchParams({
-        q: query,
-        limit: String(limit)
-      });
-      const response = await fetch(`${API_BASE2}/search?${params}`);
-      if (!response.ok) return [];
-      const data = await response.json();
-      return data.results.map(toResult2);
-    } catch {
-      return [];
-    }
+    const params = new URLSearchParams({
+      q: query,
+      limit: String(limit)
+    });
+    const url = `${API_BASE2}/search?${params}`;
+    const response = ensureOkResponse(await fetchWithTimeout(url), url);
+    const data = await response.json();
+    return data.results.map(toResult2);
   }
   async getSkill(scopedName) {
     const results = await this.search(scopedName, 5);
@@ -665,6 +918,14 @@ var SkillsShAdapter = class {
 };
 
 // src/core/marketplace/client.ts
+var MarketplaceUnavailableError = class extends Error {
+  details;
+  constructor(message, details) {
+    super(message);
+    this.name = "MarketplaceUnavailableError";
+    this.details = details;
+  }
+};
 var MarketplaceClient = class {
   adapters;
   /**
@@ -704,11 +965,21 @@ var MarketplaceClient = class {
    * ```
    */
   async search(query, limit = 20) {
-    const promises = this.adapters.map(
-      (adapter) => adapter.search(query, limit).catch(() => [])
-    );
-    const allResults = await Promise.all(promises);
-    const flat = allResults.flat();
+    const settled = await Promise.allSettled(this.adapters.map((adapter) => adapter.search(query, limit)));
+    const flat = [];
+    const failures = [];
+    for (const [index, result] of settled.entries()) {
+      const adapterName = this.adapters[index]?.name ?? "unknown";
+      if (result.status === "fulfilled") {
+        flat.push(...result.value);
+      } else {
+        const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+        failures.push(`${adapterName}: ${reason}`);
+      }
+    }
+    if (flat.length === 0 && failures.length > 0) {
+      throw new MarketplaceUnavailableError("All marketplace sources failed.", failures);
+    }
     const seen = /* @__PURE__ */ new Map();
     for (const result of flat) {
       const existing = seen.get(result.scopedName);
@@ -734,9 +1005,18 @@ var MarketplaceClient = class {
    * ```
    */
   async getSkill(scopedName) {
+    const failures = [];
     for (const adapter of this.adapters) {
-      const result = await adapter.getSkill(scopedName).catch(() => null);
-      if (result) return result;
+      try {
+        const result = await adapter.getSkill(scopedName);
+        if (result) return result;
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        failures.push(`${adapter.name}: ${reason}`);
+      }
+    }
+    if (failures.length === this.adapters.length && this.adapters.length > 0) {
+      throw new MarketplaceUnavailableError("All marketplace sources failed.", failures);
     }
     return null;
   }
@@ -745,7 +1025,7 @@ var MarketplaceClient = class {
 // src/core/skills/discovery.ts
 import { readFile as readFile3, readdir } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 import matter from "gray-matter";
 async function parseSkillFile(filePath) {
   try {
@@ -769,7 +1049,7 @@ async function parseSkillFile(filePath) {
   }
 }
 async function discoverSkill(skillDir) {
-  const skillFile = join5(skillDir, "SKILL.md");
+  const skillFile = join4(skillDir, "SKILL.md");
   if (!existsSync5(skillFile)) return null;
   const metadata = await parseSkillFile(skillFile);
   if (!metadata) return null;
@@ -786,7 +1066,7 @@ async function discoverSkills(rootDir) {
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const skillDir = join5(rootDir, entry.name);
+    const skillDir = join4(rootDir, entry.name);
     const skill = await discoverSkill(skillDir);
     if (skill) {
       skills.push(skill);
@@ -809,6 +1089,273 @@ async function discoverSkillsMulti(dirs) {
   return all;
 }
 
+// src/core/skills/recommendation.ts
+var RECOMMENDATION_ERROR_CODES = {
+  QUERY_INVALID: "E_SKILLS_QUERY_INVALID",
+  NO_MATCHES: "E_SKILLS_NO_MATCHES",
+  SOURCE_UNAVAILABLE: "E_SKILLS_SOURCE_UNAVAILABLE",
+  CRITERIA_CONFLICT: "E_SKILLS_CRITERIA_CONFLICT"
+};
+var DEFAULT_WEIGHTS = {
+  mustHaveMatch: 10,
+  preferMatch: 4,
+  queryTokenMatch: 3,
+  starsFactor: 2,
+  metadataBoost: 2,
+  modernMarkerBoost: 3,
+  legacyMarkerPenalty: 3,
+  excludePenalty: 25,
+  missingMustHavePenalty: 20
+};
+var DEFAULT_MODERN_MARKERS = ["svelte 5", "runes", "lafs", "slsa", "drizzle", "better-auth"];
+var DEFAULT_LEGACY_MARKERS = ["svelte 3", "jquery", "bower", "legacy", "book.json", "gitbook-cli"];
+function tokenizeCriteriaValue(value) {
+  return value.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean);
+}
+function normalizeList(value) {
+  if (value === void 0) return [];
+  if (!(typeof value === "string" || Array.isArray(value))) return [];
+  const source = Array.isArray(value) ? value : [value];
+  const flattened = source.flatMap((item) => typeof item === "string" ? tokenizeCriteriaValue(item) : []);
+  return Array.from(new Set(flattened)).sort((a, b) => a.localeCompare(b));
+}
+function hasAnyCriteriaInput(input) {
+  const query = typeof input.query === "string" ? input.query.trim() : "";
+  if (query.length > 0) return true;
+  const lists = [input.mustHave, input.prefer, input.exclude];
+  return lists.some((list) => normalizeList(list).length > 0);
+}
+function validateRecommendationCriteria(input) {
+  const issues = [];
+  if (input.query !== void 0 && typeof input.query !== "string") {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.QUERY_INVALID,
+      field: "query",
+      message: "query must be a string"
+    });
+  }
+  if (input.mustHave !== void 0 && !(typeof input.mustHave === "string" || Array.isArray(input.mustHave))) {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.QUERY_INVALID,
+      field: "mustHave",
+      message: "mustHave must be a string or string[]"
+    });
+  }
+  if (input.prefer !== void 0 && !(typeof input.prefer === "string" || Array.isArray(input.prefer))) {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.QUERY_INVALID,
+      field: "prefer",
+      message: "prefer must be a string or string[]"
+    });
+  }
+  if (input.exclude !== void 0 && !(typeof input.exclude === "string" || Array.isArray(input.exclude))) {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.QUERY_INVALID,
+      field: "exclude",
+      message: "exclude must be a string or string[]"
+    });
+  }
+  const mustHave = normalizeList(input.mustHave);
+  const prefer = normalizeList(input.prefer);
+  const exclude = normalizeList(input.exclude);
+  const conflict = mustHave.some((term) => exclude.includes(term)) || prefer.some((term) => exclude.includes(term));
+  if (conflict) {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.CRITERIA_CONFLICT,
+      field: "exclude",
+      message: "criteria terms cannot appear in both prefer/must-have and exclude"
+    });
+  }
+  if (issues.length === 0 && !hasAnyCriteriaInput(input)) {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.QUERY_INVALID,
+      field: "query",
+      message: "at least one criteria value is required"
+    });
+  }
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+function normalizeRecommendationCriteria(input) {
+  const query = (input.query ?? "").trim().toLowerCase();
+  return {
+    query,
+    queryTokens: query ? Array.from(new Set(tokenizeCriteriaValue(query.replace(/\s+/g, ",")))).sort((a, b) => a.localeCompare(b)) : [],
+    mustHave: normalizeList(input.mustHave),
+    prefer: normalizeList(input.prefer),
+    exclude: normalizeList(input.exclude)
+  };
+}
+function countMatches(haystack, needles) {
+  let count = 0;
+  for (const needle of needles) {
+    if (haystack.includes(needle)) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function clampScore(value) {
+  return Number(value.toFixed(6));
+}
+function buildSearchText(skill) {
+  return `${skill.name} ${skill.scopedName} ${skill.description} ${skill.author}`.toLowerCase();
+}
+function scoreSkillRecommendation(skill, criteria, options = {}) {
+  const weights = { ...DEFAULT_WEIGHTS, ...options.weights };
+  const modernMarkers = (options.modernMarkers ?? DEFAULT_MODERN_MARKERS).map((marker) => marker.toLowerCase());
+  const legacyMarkers = (options.legacyMarkers ?? DEFAULT_LEGACY_MARKERS).map((marker) => marker.toLowerCase());
+  const text = buildSearchText(skill);
+  const reasons = [];
+  const tradeoffs = [];
+  const mustHaveMatches = countMatches(text, criteria.mustHave);
+  const missingMustHave = Math.max(criteria.mustHave.length - mustHaveMatches, 0);
+  const preferMatches = countMatches(text, criteria.prefer);
+  const queryMatches = countMatches(text, criteria.queryTokens);
+  const excludeMatches = countMatches(text, criteria.exclude);
+  const modernMatches = countMatches(text, modernMarkers);
+  const legacyMatches = countMatches(text, legacyMarkers);
+  const metadataSignal = skill.description.trim().length >= 80 ? 1 : 0;
+  const starsSignal = Math.log10(skill.stars + 1);
+  const sourceConfidence = skill.source === "agentskills.in" ? 1 : skill.source === "skills.sh" ? 0.8 : 0.6;
+  const mustHaveScore = mustHaveMatches * weights.mustHaveMatch - missingMustHave * weights.missingMustHavePenalty;
+  const preferScore = preferMatches * weights.preferMatch;
+  const queryScore = queryMatches * weights.queryTokenMatch;
+  const starsScore = starsSignal * weights.starsFactor;
+  const metadataScore = (metadataSignal + sourceConfidence) * weights.metadataBoost;
+  const modernityScore = modernMatches * weights.modernMarkerBoost - legacyMatches * weights.legacyMarkerPenalty;
+  const exclusionPenalty = excludeMatches * weights.excludePenalty;
+  const hasGitbookTopic = text.includes("gitbook");
+  const hasGitSync = text.includes("git sync") || text.includes("git") && text.includes("sync");
+  const hasApiWorkflow = text.includes("api") && (text.includes("workflow") || text.includes("sync"));
+  const hasLegacyCli = text.includes("gitbook-cli") || text.includes("book.json");
+  const topicScore = (hasGitbookTopic ? 3 : 0) + (hasGitSync ? 2 : 0) + (hasApiWorkflow ? 2 : 0) - (hasLegacyCli ? 4 : 0);
+  const total = clampScore(
+    mustHaveScore + preferScore + queryScore + starsScore + metadataScore + modernityScore + topicScore - exclusionPenalty
+  );
+  if (hasGitbookTopic) reasons.push({ code: "MATCH_TOPIC_GITBOOK" });
+  if (hasGitSync) reasons.push({ code: "HAS_GIT_SYNC" });
+  if (hasApiWorkflow) reasons.push({ code: "HAS_API_WORKFLOW" });
+  if (hasLegacyCli) reasons.push({ code: "PENALTY_LEGACY_CLI" });
+  if (mustHaveMatches > 0) reasons.push({ code: "MUST_HAVE_MATCH", detail: String(mustHaveMatches) });
+  if (missingMustHave > 0) reasons.push({ code: "MISSING_MUST_HAVE", detail: String(missingMustHave) });
+  if (preferMatches > 0) reasons.push({ code: "PREFER_MATCH", detail: String(preferMatches) });
+  if (queryMatches > 0) reasons.push({ code: "QUERY_MATCH", detail: String(queryMatches) });
+  if (starsSignal > 0) reasons.push({ code: "STAR_SIGNAL" });
+  if (metadataSignal > 0) reasons.push({ code: "METADATA_SIGNAL" });
+  if (modernMatches > 0) reasons.push({ code: "MODERN_MARKER", detail: String(modernMatches) });
+  if (legacyMatches > 0) reasons.push({ code: "LEGACY_MARKER", detail: String(legacyMatches) });
+  if (excludeMatches > 0) reasons.push({ code: "EXCLUDE_MATCH", detail: String(excludeMatches) });
+  if (missingMustHave > 0) tradeoffs.push("Missing one or more required criteria terms.");
+  if (excludeMatches > 0) tradeoffs.push("Matches one or more excluded terms.");
+  if (skill.stars < 10) tradeoffs.push("Low quality signal from repository stars.");
+  if (hasLegacyCli) tradeoffs.push("Contains legacy GitBook CLI markers.");
+  const result = {
+    skill,
+    score: total,
+    reasons,
+    tradeoffs,
+    excluded: excludeMatches > 0
+  };
+  if (options.includeDetails) {
+    result.breakdown = {
+      mustHave: clampScore(mustHaveScore),
+      prefer: clampScore(preferScore),
+      query: clampScore(queryScore),
+      stars: clampScore(starsScore),
+      metadata: clampScore(metadataScore),
+      modernity: clampScore(modernityScore),
+      exclusionPenalty: clampScore(exclusionPenalty),
+      total
+    };
+  }
+  return result;
+}
+function recommendSkills(skills, criteriaInput, options = {}) {
+  const validation = validateRecommendationCriteria(criteriaInput);
+  if (!validation.valid) {
+    const first = validation.issues[0];
+    const error = new Error(first?.message ?? "Invalid recommendation criteria");
+    error.code = first?.code;
+    error.issues = validation.issues;
+    throw error;
+  }
+  const criteria = normalizeRecommendationCriteria(criteriaInput);
+  const ranking = skills.map((skill) => scoreSkillRecommendation(skill, criteria, options)).sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    if (b.skill.stars !== a.skill.stars) return b.skill.stars - a.skill.stars;
+    return a.skill.scopedName.localeCompare(b.skill.scopedName);
+  });
+  return {
+    criteria,
+    ranking: typeof options.top === "number" ? ranking.slice(0, Math.max(0, options.top)) : ranking
+  };
+}
+var rankSkills = recommendSkills;
+
+// src/core/skills/recommendation-api.ts
+function formatSkillRecommendations(result, opts) {
+  const top = result.ranking;
+  if (opts.mode === "human") {
+    if (top.length === 0) return "No recommendations found.";
+    const lines = ["Recommended skills:", ""];
+    for (const [index, entry] of top.entries()) {
+      const marker = index === 0 ? " (Recommended)" : "";
+      lines.push(`${index + 1}) ${entry.skill.scopedName}${marker}`);
+      lines.push(`   why: ${entry.reasons.map((reason) => reason.code).join(", ") || "score-based match"}`);
+      lines.push(`   tradeoff: ${entry.tradeoffs[0] ?? "none"}`);
+    }
+    lines.push("");
+    lines.push(`CHOOSE: ${top.map((_, index) => index + 1).join(",")}`);
+    return lines.join("\n");
+  }
+  const options = top.map((entry, index) => ({
+    rank: index + 1,
+    scopedName: entry.skill.scopedName,
+    score: entry.score,
+    reasons: entry.reasons,
+    tradeoffs: entry.tradeoffs,
+    ...opts.details ? {
+      description: entry.skill.description,
+      source: entry.skill.source,
+      evidence: entry.breakdown ?? null
+    } : {}
+  }));
+  return {
+    query: result.criteria.query,
+    recommended: options[0] ?? null,
+    options
+  };
+}
+async function searchSkills(query, options = {}) {
+  const trimmed = query.trim();
+  if (!trimmed) {
+    const error = new Error("query must be non-empty");
+    error.code = RECOMMENDATION_ERROR_CODES.QUERY_INVALID;
+    throw error;
+  }
+  const client = new MarketplaceClient();
+  try {
+    return await client.search(trimmed, options.limit ?? 20);
+  } catch (error) {
+    const wrapped = new Error(error instanceof Error ? error.message : String(error));
+    wrapped.code = RECOMMENDATION_ERROR_CODES.SOURCE_UNAVAILABLE;
+    throw wrapped;
+  }
+}
+async function recommendSkills2(query, criteria, options = {}) {
+  const hits = await searchSkills(query, { limit: options.limit ?? Math.max((options.top ?? 3) * 5, 20) });
+  const ranked = recommendSkills(hits, { ...criteria, query }, options);
+  if (ranked.ranking.length === 0) {
+    const error = new Error("no matches found");
+    error.code = RECOMMENDATION_ERROR_CODES.NO_MATCHES;
+    throw error;
+  }
+  return ranked;
+}
+
 // src/core/skills/audit/scanner.ts
 import { readFile as readFile4 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
@@ -1222,13 +1769,13 @@ async function scanFile(filePath, rules) {
 }
 async function scanDirectory(dirPath) {
   const { readdir: readdir2 } = await import("fs/promises");
-  const { join: join8 } = await import("path");
+  const { join: join7 } = await import("path");
   if (!existsSync6(dirPath)) return [];
   const entries = await readdir2(dirPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const skillFile = join8(dirPath, entry.name, "SKILL.md");
+      const skillFile = join7(dirPath, entry.name, "SKILL.md");
       if (existsSync6(skillFile)) {
         results.push(await scanFile(skillFile));
       }
@@ -1442,9 +1989,9 @@ function getNestedValue(obj, keyPath) {
   return current;
 }
 async function ensureDir(filePath) {
-  const { mkdir: mkdir4 } = await import("fs/promises");
-  const { dirname: dirname4 } = await import("path");
-  await mkdir4(dirname4(filePath), { recursive: true });
+  const { mkdir: mkdir5 } = await import("fs/promises");
+  const { dirname: dirname6 } = await import("path");
+  await mkdir5(dirname6(filePath), { recursive: true });
 }
 
 // src/core/formats/json.ts
@@ -1756,14 +2303,9 @@ function getTransform(providerId) {
 }
 
 // src/core/mcp/reader.ts
-import { join as join6 } from "path";
 import { existsSync as existsSync11 } from "fs";
 function resolveConfigPath(provider, scope, projectDir) {
-  if (scope === "project") {
-    if (!provider.configPathProject) return null;
-    return join6(projectDir ?? process.cwd(), provider.configPathProject);
-  }
-  return provider.configPathGlobal;
+  return resolveProviderConfigPath(provider, scope, projectDir ?? process.cwd());
 }
 async function listMcpServers(provider, scope, projectDir) {
   const configPath = resolveConfigPath(provider, scope, projectDir);
@@ -1886,37 +2428,39 @@ function buildServerConfig(source, transport, headers) {
 
 // src/core/mcp/lock.ts
 async function recordMcpInstall(serverName, source, sourceType, agents, isGlobal) {
-  const lock = await readLockFile();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = lock.mcpServers[serverName];
-  lock.mcpServers[serverName] = {
-    name: serverName,
-    scopedName: serverName,
-    source,
-    sourceType,
-    installedAt: existing?.installedAt ?? now,
-    updatedAt: now,
-    agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
-    canonicalPath: "",
-    isGlobal
-  };
-  await writeLockFile(lock);
+  await updateLockFile((lock) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = lock.mcpServers[serverName];
+    lock.mcpServers[serverName] = {
+      name: serverName,
+      scopedName: serverName,
+      source,
+      sourceType,
+      installedAt: existing?.installedAt ?? now,
+      updatedAt: now,
+      agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
+      canonicalPath: "",
+      isGlobal
+    };
+  });
 }
 async function removeMcpFromLock(serverName) {
-  const lock = await readLockFile();
-  if (!(serverName in lock.mcpServers)) return false;
-  delete lock.mcpServers[serverName];
-  await writeLockFile(lock);
-  return true;
+  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) {
-  const lock = await readLockFile();
-  lock.lastSelectedAgents = agents;
-  await writeLockFile(lock);
+  await updateLockFile((lock) => {
+    lock.lastSelectedAgents = agents;
+  });
 }
 async function getLastSelectedAgents() {
   const lock = await readLockFile();
@@ -1926,7 +2470,7 @@ async function getLastSelectedAgents() {
 // src/core/instructions/injector.ts
 import { readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+import { join as join5, dirname as dirname4 } from "path";
 import { mkdir as mkdir3 } from "fs/promises";
 var MARKER_START = "<!-- CAAMP:START -->";
 var MARKER_END = "<!-- CAAMP:END -->";
@@ -1956,7 +2500,7 @@ ${MARKER_END}`;
 }
 async function inject(filePath, content) {
   const block = buildBlock(content);
-  await mkdir3(dirname3(filePath), { recursive: true });
+  await mkdir3(dirname4(filePath), { recursive: true });
   if (!existsSync12(filePath)) {
     await writeFile6(filePath, block + "\n", "utf-8");
     return "created";
@@ -1977,8 +2521,8 @@ async function removeInjection(filePath) {
   if (!MARKER_PATTERN.test(content)) return false;
   const cleaned = content.replace(MARKER_PATTERN, "").replace(/^\n{2,}/, "\n").trim();
   if (!cleaned) {
-    const { rm: rm2 } = await import("fs/promises");
-    await rm2(filePath);
+    const { rm: rm4 } = await import("fs/promises");
+    await rm4(filePath);
   } else {
     await writeFile6(filePath, cleaned + "\n", "utf-8");
   }
@@ -1988,7 +2532,7 @@ async function checkAllInjections(providers, projectDir, scope, expectedContent)
   const results = [];
   const checked = /* @__PURE__ */ new Set();
   for (const provider of providers) {
-    const filePath = scope === "global" ? join7(provider.pathGlobal, provider.instructFile) : join7(projectDir, provider.instructFile);
+    const filePath = scope === "global" ? join5(provider.pathGlobal, provider.instructFile) : join5(projectDir, provider.instructFile);
     if (checked.has(filePath)) continue;
     checked.add(filePath);
     const status = await checkInjection(filePath, expectedContent);
@@ -2005,7 +2549,7 @@ 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" ? join7(provider.pathGlobal, provider.instructFile) : join7(projectDir, provider.instructFile);
+    const filePath = scope === "global" ? join5(provider.pathGlobal, provider.instructFile) : join5(projectDir, provider.instructFile);
     if (injected.has(filePath)) continue;
     injected.add(filePath);
     const action = await inject(filePath, content);
@@ -2042,7 +2586,409 @@ function groupByInstructFile(providers) {
   return groups;
 }
 
+// src/core/advanced/orchestration.ts
+import { existsSync as existsSync13, lstatSync as lstatSync2 } from "fs";
+import {
+  cp as cp2,
+  mkdir as mkdir4,
+  readFile as readFile10,
+  readlink as readlink2,
+  rm as rm3,
+  symlink as symlink2,
+  writeFile as writeFile7
+} from "fs/promises";
+import { homedir as homedir2, tmpdir } from "os";
+import { basename as basename2, dirname as dirname5, join as join6 } from "path";
+var PRIORITY_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+var CANONICAL_SKILLS_DIR2 = join6(homedir2(), ".agents", "skills");
+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 : join6(projectDir, provider.pathProjectSkills);
+  return join6(skillDir, skillName);
+}
+async function snapshotConfigs(paths) {
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const path of paths) {
+    if (!path || snapshots.has(path)) continue;
+    if (!existsSync13(path)) {
+      snapshots.set(path, null);
+      continue;
+    }
+    snapshots.set(path, await readFile10(path, "utf-8"));
+  }
+  return snapshots;
+}
+async function restoreConfigSnapshots(snapshots) {
+  for (const [path, content] of snapshots) {
+    if (content === null) {
+      await rm3(path, { force: true });
+      continue;
+    }
+    await mkdir4(dirname5(path), { recursive: true });
+    await writeFile7(path, content, "utf-8");
+  }
+}
+async function snapshotSkillState(providerTargets, operation, projectDir, backupRoot) {
+  const skillName = operation.skillName;
+  const isGlobal = operation.isGlobal ?? true;
+  const canonicalPath = join6(CANONICAL_SKILLS_DIR2, skillName);
+  const canonicalExisted = existsSync13(canonicalPath);
+  const canonicalBackupPath = join6(backupRoot, "canonical", skillName);
+  if (canonicalExisted) {
+    await mkdir4(dirname5(canonicalBackupPath), { recursive: true });
+    await cp2(canonicalPath, canonicalBackupPath, { recursive: true });
+  }
+  const pathSnapshots = [];
+  for (const provider of providerTargets) {
+    const linkPath = resolveSkillLinkPath(provider, skillName, isGlobal, projectDir);
+    if (!existsSync13(linkPath)) {
+      pathSnapshots.push({ linkPath, state: "missing" });
+      continue;
+    }
+    const stat = lstatSync2(linkPath);
+    if (stat.isSymbolicLink()) {
+      pathSnapshots.push({
+        linkPath,
+        state: "symlink",
+        symlinkTarget: await readlink2(linkPath)
+      });
+      continue;
+    }
+    const backupPath = join6(backupRoot, "links", provider.id, `${skillName}-${basename2(linkPath)}`);
+    await mkdir4(dirname5(backupPath), { recursive: true });
+    if (stat.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 (existsSync13(snapshot.canonicalPath)) {
+    await rm3(snapshot.canonicalPath, { recursive: true, force: true });
+  }
+  if (snapshot.canonicalExisted && snapshot.canonicalBackupPath && existsSync13(snapshot.canonicalBackupPath)) {
+    await mkdir4(dirname5(snapshot.canonicalPath), { recursive: true });
+    await cp2(snapshot.canonicalBackupPath, snapshot.canonicalPath, { recursive: true });
+  }
+  for (const pathSnapshot of snapshot.pathSnapshots) {
+    await rm3(pathSnapshot.linkPath, { recursive: true, force: true });
+    if (pathSnapshot.state === "missing") continue;
+    await mkdir4(dirname5(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);
+      }
+    }
+  }
+}
+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 = join6(
+    tmpdir(),
+    `caamp-skill-backup-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+  );
+  const skillSnapshots = await Promise.all(
+    skillOps.map((operation) => snapshotSkillState(providers, operation, projectDir, backupRoot))
+  );
+  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(
+        operation.sourcePath,
+        operation.skillName,
+        providers,
+        isGlobal,
+        projectDir
+      );
+      const linkedProviders = providers.filter((provider) => result.linkedAgents.includes(provider.id));
+      appliedSkills.push({
+        skillName: operation.skillName,
+        isGlobal,
+        linkedProviders
+      });
+      if (result.errors.length > 0) {
+        throw new Error(result.errors.join("; "));
+      }
+      skillsApplied += 1;
+    }
+    await rm3(backupRoot, { recursive: true, force: true });
+    return {
+      success: true,
+      providerIds: providers.map((provider) => provider.id),
+      mcpApplied,
+      skillsApplied,
+      rollbackPerformed: false,
+      rollbackErrors: []
+    };
+  } catch (error) {
+    rollbackPerformed = true;
+    for (const applied of [...appliedSkills].reverse()) {
+      try {
+        await removeSkill(applied.skillName, applied.linkedProviders, applied.isGlobal, projectDir);
+      } catch (err) {
+        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);
+      } catch (err) {
+        rollbackErrors.push(err instanceof Error ? err.message : String(err));
+      }
+    }
+    await rm3(backupRoot, { recursive: true, force: true });
+    return {
+      success: false,
+      providerIds: providers.map((provider) => provider.id),
+      mcpApplied,
+      skillsApplied,
+      rollbackPerformed,
+      rollbackErrors,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+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);
+  const summary = {
+    scope,
+    updatedFiles: actions.size,
+    actions: []
+  };
+  for (const [filePath, action] of actions.entries()) {
+    const providersForFile = providers.filter((provider) => {
+      const expectedPath = scope === "global" ? join6(provider.pathGlobal, provider.instructFile) : join6(projectDir, provider.instructFile);
+      return expectedPath === filePath;
+    });
+    const fallback = groupedByFile.get(basename2(filePath)) ?? [];
+    const selected = providersForFile.length > 0 ? providersForFile : fallback;
+    summary.actions.push({
+      file: filePath,
+      action,
+      providers: selected.map((provider) => provider.id),
+      configFormats: Array.from(new Set(selected.map((provider) => provider.configFormat)))
+    });
+  }
+  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);
+    }
+  }
+  return {
+    providerId: provider.id,
+    configPaths: {
+      global: resolveConfigPath(provider, "global", projectDir),
+      project: resolveConfigPath(provider, "project", projectDir)
+    },
+    mcp: {
+      global: globalResults,
+      project: projectResults
+    },
+    instructions: instructionResults
+  };
+}
+
 export {
+  getPlatformLocations,
+  getAgentsHome,
+  getProjectAgentsDir,
+  getCanonicalSkillsDir,
+  getLockFilePath,
+  resolveRegistryTemplatePath,
+  resolveProviderConfigPath,
+  resolvePreferredConfigScope,
+  resolveProviderSkillsDir,
+  buildSkillSubPathCandidates,
   getAllProviders,
   getProvider,
   resolveAlias,
@@ -2060,6 +3006,7 @@ export {
   detectAllProviders,
   getInstalledProviders,
   detectProjectProviders,
+  resetDetectionCache,
   parseSource,
   isMarketplaceScoped,
   installSkill,
@@ -2070,11 +3017,21 @@ export {
   removeSkillFromLock,
   getTrackedSkills,
   checkSkillUpdate,
+  formatNetworkError,
   MarketplaceClient,
   parseSkillFile,
   discoverSkill,
   discoverSkills,
   discoverSkillsMulti,
+  RECOMMENDATION_ERROR_CODES,
+  tokenizeCriteriaValue,
+  validateRecommendationCriteria,
+  normalizeRecommendationCriteria,
+  scoreSkillRecommendation,
+  rankSkills,
+  formatSkillRecommendations,
+  searchSkills,
+  recommendSkills2 as recommendSkills,
   scanFile,
   scanDirectory,
   toSarif,
@@ -2104,6 +3061,12 @@ export {
   checkAllInjections,
   injectAll,
   generateInjectionContent,
-  groupByInstructFile
+  groupByInstructFile,
+  selectProvidersByMinimumPriority,
+  installBatchWithRollback,
+  detectMcpConfigConflicts,
+  applyMcpInstallWithPolicy,
+  updateInstructionsSingleOperation,
+  configureProviderGlobalAndProject
 };
-//# sourceMappingURL=chunk-PCWTRJV2.js.map
+//# sourceMappingURL=chunk-6HQDRJLS.js.map