@cleocode/caamp 0.2.0 → 0.4.0

package/dist/{chunk-RW745KDU.js → chunk-ZYINKJDE.js}

@@ -140,13 +140,33 @@ function getRegistryVersion() {
   return loadRegistry().version;
 }
 
+// src/core/logger.ts
+var verboseMode = false;
+var quietMode = false;
+function setVerbose(v) {
+  verboseMode = v;
+}
+function setQuiet(q) {
+  quietMode = q;
+}
+function debug(...args) {
+  if (verboseMode) console.error("[debug]", ...args);
+}
+function isVerbose() {
+  return verboseMode;
+}
+function isQuiet() {
+  return quietMode;
+}
+
 // src/core/registry/detection.ts
 import { existsSync as existsSync2 } from "fs";
 import { execFileSync } from "child_process";
 import { join as join2 } from "path";
 function checkBinary(binary) {
   try {
-    execFileSync("which", [binary], { stdio: "pipe" });
+    const cmd = process.platform === "win32" ? "where" : "which";
+    execFileSync(cmd, [binary], { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -171,10 +191,12 @@ function checkFlatpak(flatpakId) {
 function detectProvider(provider) {
   const matchedMethods = [];
   const detection = provider.detection;
+  debug(`detecting provider ${provider.id} via methods: ${detection.methods.join(", ")}`);
   for (const method of detection.methods) {
     switch (method) {
       case "binary":
         if (detection.binary && checkBinary(detection.binary)) {
+          debug(`  ${provider.id}: binary "${detection.binary}" found`);
           matchedMethods.push("binary");
         }
         break;
@@ -444,7 +466,7 @@ async function listCanonicalSkills() {
   return entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
 }
 
-// src/core/mcp/lock.ts
+// src/core/lock-utils.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir3 } from "os";
@@ -466,55 +488,9 @@ async function writeLockFile(lock) {
   await mkdir2(LOCK_DIR, { recursive: true });
   await writeFile2(LOCK_FILE, JSON.stringify(lock, null, 2) + "\n", "utf-8");
 }
-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);
-}
-async function removeMcpFromLock(serverName) {
-  const lock = await readLockFile();
-  if (!(serverName in lock.mcpServers)) return false;
-  delete lock.mcpServers[serverName];
-  await writeLockFile(lock);
-  return true;
-}
-async function getTrackedMcpServers() {
-  const lock = await readLockFile();
-  return lock.mcpServers;
-}
-async function saveLastSelectedAgents(agents) {
-  const lock = await readLockFile();
-  lock.lastSelectedAgents = agents;
-  await writeLockFile(lock);
-}
-async function getLastSelectedAgents() {
-  const lock = await readLockFile();
-  return lock.lastSelectedAgents;
-}
 
 // src/core/skills/lock.ts
 import { simpleGit } from "simple-git";
-import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
-var LOCK_DIR2 = join5(homedir4(), ".agents");
-var LOCK_FILE2 = join5(LOCK_DIR2, ".caamp-lock.json");
-async function writeLockFile2(lock) {
-  await mkdir3(LOCK_DIR2, { recursive: true });
-  await writeFile3(LOCK_FILE2, JSON.stringify(lock, null, 2) + "\n", "utf-8");
-}
 async function recordSkillInstall(skillName, scopedName, source, sourceType, agents, canonicalPath, isGlobal, projectDir, version) {
   const lock = await readLockFile();
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -532,13 +508,13 @@ async function recordSkillInstall(skillName, scopedName, source, sourceType, age
     isGlobal,
     projectDir
   };
-  await writeLockFile2(lock);
+  await writeLockFile(lock);
 }
 async function removeSkillFromLock(skillName) {
   const lock = await readLockFile();
   if (!(skillName in lock.skills)) return false;
   delete lock.skills[skillName];
-  await writeLockFile2(lock);
+  await writeLockFile(lock);
   return true;
 }
 async function getTrackedSkills() {
@@ -600,8 +576,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,
@@ -623,31 +657,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;
   }
 };
 
@@ -669,18 +706,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);
@@ -689,21 +722,68 @@ 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;
+  /**
+   * Create a new marketplace client.
+   *
+   * @param adapters - Custom marketplace adapters (defaults to agentskills.in and skills.sh)
+   *
+   * @example
+   * ```typescript
+   * // Use default adapters
+   * const client = new MarketplaceClient();
+   *
+   * // Use custom adapters
+   * const client = new MarketplaceClient([myAdapter]);
+   * ```
+   */
   constructor(adapters) {
     this.adapters = adapters ?? [
       new SkillsMPAdapter(),
       new SkillsShAdapter()
     ];
   }
-  /** Search all marketplaces and deduplicate results */
+  /**
+   * Search all marketplaces and return deduplicated, sorted results.
+   *
+   * Queries all adapters in parallel and deduplicates by `scopedName`,
+   * keeping the entry with the highest star count. Results are sorted by
+   * stars descending.
+   *
+   * @param query - Search query string
+   * @param limit - Maximum number of results to return (default: 20)
+   * @returns Deduplicated and sorted marketplace results
+   *
+   * @example
+   * ```typescript
+   * const results = await client.search("code review", 10);
+   * ```
+   */
   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);
@@ -715,11 +795,32 @@ var MarketplaceClient = class {
     deduplicated.sort((a, b) => b.stars - a.stars);
     return deduplicated.slice(0, limit);
   }
-  /** Get a specific skill by scoped name */
+  /**
+   * Get a specific skill by its scoped name from any marketplace.
+   *
+   * Tries each adapter in order and returns the first match.
+   *
+   * @param scopedName - Scoped skill name (e.g. `"@author/my-skill"`)
+   * @returns The marketplace result, or `null` if not found in any marketplace
+   *
+   * @example
+   * ```typescript
+   * const skill = await client.getSkill("@anthropic/memory");
+   * ```
+   */
   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;
   }
@@ -728,7 +829,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 join6 } from "path";
+import { join as join5 } from "path";
 import matter from "gray-matter";
 async function parseSkillFile(filePath) {
   try {
@@ -752,7 +853,7 @@ async function parseSkillFile(filePath) {
   }
 }
 async function discoverSkill(skillDir) {
-  const skillFile = join6(skillDir, "SKILL.md");
+  const skillFile = join5(skillDir, "SKILL.md");
   if (!existsSync5(skillFile)) return null;
   const metadata = await parseSkillFile(skillFile);
   if (!metadata) return null;
@@ -769,7 +870,7 @@ async function discoverSkills(rootDir) {
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const skillDir = join6(rootDir, entry.name);
+    const skillDir = join5(rootDir, entry.name);
     const skill = await discoverSkill(skillDir);
     if (skill) {
       skills.push(skill);
@@ -792,6 +893,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";
@@ -1431,7 +1799,7 @@ async function ensureDir(filePath) {
 }
 
 // src/core/formats/json.ts
-import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 import * as jsonc from "jsonc-parser";
 async function readJsonConfig(filePath) {
@@ -1485,7 +1853,7 @@ async function writeJsonConfig(filePath, configKey, serverName, serverConfig) {
   if (!content.endsWith("\n")) {
     content += "\n";
   }
-  await writeFile4(filePath, content, "utf-8");
+  await writeFile3(filePath, content, "utf-8");
 }
 async function removeJsonConfig(filePath, configKey, serverName) {
   if (!existsSync8(filePath)) return false;
@@ -1505,12 +1873,12 @@ async function removeJsonConfig(filePath, configKey, serverName) {
   if (!content.endsWith("\n")) {
     content += "\n";
   }
-  await writeFile4(filePath, content, "utf-8");
+  await writeFile3(filePath, content, "utf-8");
   return true;
 }
 
 // src/core/formats/yaml.ts
-import { readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
 import yaml from "js-yaml";
 async function readYamlConfig(filePath) {
@@ -1535,7 +1903,7 @@ async function writeYamlConfig(filePath, configKey, serverName, serverConfig) {
     noRefs: true,
     sortKeys: false
   });
-  await writeFile5(filePath, content, "utf-8");
+  await writeFile4(filePath, content, "utf-8");
 }
 async function removeYamlConfig(filePath, configKey, serverName) {
   if (!existsSync9(filePath)) return false;
@@ -1555,12 +1923,12 @@ async function removeYamlConfig(filePath, configKey, serverName) {
     noRefs: true,
     sortKeys: false
   });
-  await writeFile5(filePath, content, "utf-8");
+  await writeFile4(filePath, content, "utf-8");
   return true;
 }
 
 // src/core/formats/toml.ts
-import { readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
 import TOML from "@iarna/toml";
 async function readTomlConfig(filePath) {
@@ -1580,7 +1948,7 @@ async function writeTomlConfig(filePath, configKey, serverName, serverConfig) {
   }
   const merged = deepMerge(existing, newEntry);
   const content = TOML.stringify(merged);
-  await writeFile6(filePath, content, "utf-8");
+  await writeFile5(filePath, content, "utf-8");
 }
 async function removeTomlConfig(filePath, configKey, serverName) {
   if (!existsSync10(filePath)) return false;
@@ -1595,12 +1963,13 @@ async function removeTomlConfig(filePath, configKey, serverName) {
   if (!(serverName in current)) return false;
   delete current[serverName];
   const content = TOML.stringify(existing);
-  await writeFile6(filePath, content, "utf-8");
+  await writeFile5(filePath, content, "utf-8");
   return true;
 }
 
 // src/core/formats/index.ts
 async function readConfig(filePath, format) {
+  debug(`reading config: ${filePath} (format: ${format})`);
   switch (format) {
     case "json":
     case "jsonc":
@@ -1614,6 +1983,7 @@ async function readConfig(filePath, format) {
   }
 }
 async function writeConfig(filePath, format, key, serverName, serverConfig) {
+  debug(`writing config: ${filePath} (format: ${format}, key: ${key}, server: ${serverName})`);
   switch (format) {
     case "json":
     case "jsonc":
@@ -1737,17 +2107,18 @@ function getTransform(providerId) {
 }
 
 // src/core/mcp/reader.ts
-import { join as join7 } from "path";
+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 join7(projectDir ?? process.cwd(), provider.configPathProject);
+    return join6(projectDir ?? process.cwd(), provider.configPathProject);
   }
   return provider.configPathGlobal;
 }
 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 || !existsSync11(configPath)) return [];
   try {
     const config = await readConfig(configPath, provider.configFormat);
@@ -1797,6 +2168,8 @@ function buildConfig(provider, serverName, config) {
 }
 async function installMcpServer(provider, serverName, config, scope = "project", projectDir) {
   const configPath = resolveConfigPath(provider, scope, projectDir);
+  debug(`installing MCP server "${serverName}" for ${provider.id} (${scope})`);
+  debug(`  config path: ${configPath ?? "(none)"}`);
   if (!configPath) {
     return {
       provider,
@@ -1808,6 +2181,8 @@ async function installMcpServer(provider, serverName, config, scope = "project",
   }
   try {
     const transformedConfig = buildConfig(provider, serverName, config);
+    const transform = getTransform(provider.id);
+    debug(`  transform applied: ${transform ? "yes" : "no"}`);
     await writeConfig(
       configPath,
       provider.configFormat,
@@ -1860,11 +2235,50 @@ 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);
+}
+async function removeMcpFromLock(serverName) {
+  const lock = await readLockFile();
+  if (!(serverName in lock.mcpServers)) return false;
+  delete lock.mcpServers[serverName];
+  await writeLockFile(lock);
+  return true;
+}
+async function getTrackedMcpServers() {
+  const lock = await readLockFile();
+  return lock.mcpServers;
+}
+async function saveLastSelectedAgents(agents) {
+  const lock = await readLockFile();
+  lock.lastSelectedAgents = agents;
+  await writeLockFile(lock);
+}
+async function getLastSelectedAgents() {
+  const lock = await readLockFile();
+  return lock.lastSelectedAgents;
+}
+
 // src/core/instructions/injector.ts
-import { readFile as readFile9, writeFile as writeFile7 } from "fs/promises";
+import { readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
-import { join as join8, dirname as dirname4 } from "path";
-import { mkdir as mkdir4 } from "fs/promises";
+import { join as join7, dirname as dirname3 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
 var MARKER_START = "<!-- CAAMP:START -->";
 var MARKER_END = "<!-- CAAMP:END -->";
 var MARKER_PATTERN = /<!-- CAAMP:START -->[\s\S]*?<!-- CAAMP:END -->/;
@@ -1893,19 +2307,19 @@ ${MARKER_END}`;
 }
 async function inject(filePath, content) {
   const block = buildBlock(content);
-  await mkdir4(dirname4(filePath), { recursive: true });
+  await mkdir3(dirname3(filePath), { recursive: true });
   if (!existsSync12(filePath)) {
-    await writeFile7(filePath, block + "\n", "utf-8");
+    await writeFile6(filePath, block + "\n", "utf-8");
     return "created";
   }
   const existing = await readFile9(filePath, "utf-8");
   if (MARKER_PATTERN.test(existing)) {
     const updated2 = existing.replace(MARKER_PATTERN, block);
-    await writeFile7(filePath, updated2, "utf-8");
+    await writeFile6(filePath, updated2, "utf-8");
     return "updated";
   }
   const updated = block + "\n\n" + existing;
-  await writeFile7(filePath, updated, "utf-8");
+  await writeFile6(filePath, updated, "utf-8");
   return "added";
 }
 async function removeInjection(filePath) {
@@ -1914,10 +2328,10 @@ 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: rm3 } = await import("fs/promises");
+    await rm3(filePath);
   } else {
-    await writeFile7(filePath, cleaned + "\n", "utf-8");
+    await writeFile6(filePath, cleaned + "\n", "utf-8");
   }
   return true;
 }
@@ -1925,7 +2339,7 @@ async function checkAllInjections(providers, projectDir, scope, expectedContent)
   const results = [];
   const checked = /* @__PURE__ */ new Set();
   for (const provider of providers) {
-    const filePath = scope === "global" ? join8(provider.pathGlobal, provider.instructFile) : join8(projectDir, provider.instructFile);
+    const filePath = scope === "global" ? join7(provider.pathGlobal, provider.instructFile) : join7(projectDir, provider.instructFile);
     if (checked.has(filePath)) continue;
     checked.add(filePath);
     const status = await checkInjection(filePath, expectedContent);
@@ -1942,7 +2356,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" ? join8(provider.pathGlobal, provider.instructFile) : join8(projectDir, provider.instructFile);
+    const filePath = scope === "global" ? join7(provider.pathGlobal, provider.instructFile) : join7(projectDir, provider.instructFile);
     if (injected.has(filePath)) continue;
     injected.add(filePath);
     const action = await inject(filePath, content);
@@ -1979,6 +2393,398 @@ 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 rm2,
+  symlink as symlink2,
+  writeFile as writeFile7
+} from "fs/promises";
+import { homedir as homedir4, tmpdir } from "os";
+import { basename as basename2, dirname as dirname4, join as join8 } from "path";
+var PRIORITY_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+var CANONICAL_SKILLS_DIR = join8(homedir4(), ".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 : join8(projectDir, provider.pathProjectSkills);
+  return join8(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 rm2(path, { force: true });
+      continue;
+    }
+    await mkdir4(dirname4(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 = join8(CANONICAL_SKILLS_DIR, skillName);
+  const canonicalExisted = existsSync13(canonicalPath);
+  const canonicalBackupPath = join8(backupRoot, "canonical", skillName);
+  if (canonicalExisted) {
+    await mkdir4(dirname4(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 = join8(backupRoot, "links", provider.id, `${skillName}-${basename2(linkPath)}`);
+    await mkdir4(dirname4(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 rm2(snapshot.canonicalPath, { recursive: true, force: true });
+  }
+  if (snapshot.canonicalExisted && snapshot.canonicalBackupPath && existsSync13(snapshot.canonicalBackupPath)) {
+    await mkdir4(dirname4(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 mkdir4(dirname4(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 = join8(
+    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 rm2(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 rm2(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" ? join8(provider.pathGlobal, provider.instructFile) : join8(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 {
   getAllProviders,
   getProvider,
@@ -1989,6 +2795,10 @@ export {
   getInstructionFiles,
   getProviderCount,
   getRegistryVersion,
+  setVerbose,
+  setQuiet,
+  isVerbose,
+  isQuiet,
   detectProvider,
   detectAllProviders,
   getInstalledProviders,
@@ -1999,20 +2809,25 @@ export {
   removeSkill,
   listCanonicalSkills,
   readLockFile,
-  recordMcpInstall,
-  removeMcpFromLock,
-  getTrackedMcpServers,
-  saveLastSelectedAgents,
-  getLastSelectedAgents,
   recordSkillInstall,
   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,
@@ -2031,12 +2846,23 @@ export {
   installMcpServer,
   installMcpServerToAll,
   buildServerConfig,
+  recordMcpInstall,
+  removeMcpFromLock,
+  getTrackedMcpServers,
+  saveLastSelectedAgents,
+  getLastSelectedAgents,
   checkInjection,
   inject,
   removeInjection,
   checkAllInjections,
   injectAll,
   generateInjectionContent,
-  groupByInstructFile
+  groupByInstructFile,
+  selectProvidersByMinimumPriority,
+  installBatchWithRollback,
+  detectMcpConfigConflicts,
+  applyMcpInstallWithPolicy,
+  updateInstructionsSingleOperation,
+  configureProviderGlobalAndProject
 };
-//# sourceMappingURL=chunk-RW745KDU.js.map
+//# sourceMappingURL=chunk-ZYINKJDE.js.map