@cleocode/caamp 0.4.0 → 0.5.1

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

@@ -1,58 +1,191 @@
-// src/core/registry/providers.ts
-import { readFileSync, existsSync } from "fs";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// 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 getAgentsMcpDir(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "mcp");
+  return join(projectDir ?? process.cwd(), ".agents", "mcp");
+}
+function getAgentsMcpServersPath(scope = "global", projectDir) {
+  return join(getAgentsMcpDir(scope, projectDir), "servers.json");
+}
+function getAgentsInstructFile(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "AGENTS.md");
+  return join(projectDir ?? process.cwd(), ".agents", "AGENTS.md");
+}
+function getAgentsConfigPath(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "config.toml");
+  return join(projectDir ?? process.cwd(), ".agents", "config.toml");
+}
+function getAgentsWikiDir(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "wiki");
+  return join(projectDir ?? process.cwd(), ".agents", "wiki");
+}
+function getAgentsSpecDir(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "spec");
+  return join(projectDir ?? process.cwd(), ".agents", "spec");
+}
+function getAgentsLinksDir(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "links");
+  return join(projectDir ?? process.cwd(), ".agents", "links");
+}
+function resolveRegistryTemplatePath(template) {
+  const locations = getPlatformLocations();
+  return template.replace(/\$HOME/g, locations.home).replace(/\$CONFIG/g, locations.config).replace(/\$VSCODE_CONFIG/g, locations.vscodeConfig).replace(/\$ZED_CONFIG/g, locations.zedConfig).replace(/\$CLAUDE_DESKTOP_CONFIG/g, locations.claudeDesktopConfig).replace(/\$AGENTS_HOME/g, getAgentsHome());
+}
+function resolveProviderConfigPath(provider, scope, projectDir = process.cwd()) {
+  if (scope === "global") {
+    return provider.configPathGlobal;
+  }
+  if (!provider.configPathProject) {
+    return null;
+  }
+  return resolveProjectPath(provider.configPathProject, projectDir);
+}
+function resolvePreferredConfigScope(provider, useGlobalFlag) {
+  if (useGlobalFlag) {
+    return "global";
+  }
+  return provider.configPathProject ? "project" : "global";
+}
+function resolveProviderSkillsDir(provider, scope, projectDir = process.cwd()) {
+  if (scope === "global") {
+    return provider.pathSkills;
+  }
+  return resolveProjectPath(provider.pathProjectSkills, projectDir);
+}
+function 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 +193,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
     },
@@ -105,16 +238,17 @@ function ensureProviders() {
 }
 function getAllProviders() {
   ensureProviders();
+  if (!_providers) return [];
   return Array.from(_providers.values());
 }
 function getProvider(idOrAlias) {
   ensureProviders();
-  const resolved = _aliasMap.get(idOrAlias) ?? idOrAlias;
-  return _providers.get(resolved);
+  const resolved = _aliasMap?.get(idOrAlias) ?? idOrAlias;
+  return _providers?.get(resolved);
 }
 function resolveAlias(idOrAlias) {
   ensureProviders();
-  return _aliasMap.get(idOrAlias) ?? idOrAlias;
+  return _aliasMap?.get(idOrAlias) ?? idOrAlias;
 }
 function getProvidersByPriority(priority) {
   return getAllProviders().filter((p) => p.priority === priority);
@@ -134,7 +268,7 @@ function getInstructionFiles() {
 }
 function getProviderCount() {
   ensureProviders();
-  return _providers.size;
+  return _providers?.size ?? 0;
 }
 function getRegistryVersion() {
   return loadRegistry().version;
@@ -163,6 +297,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 +313,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 +366,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_.-]+)(?:\/(.+))?$/;
@@ -261,13 +445,15 @@ function inferName(source, type) {
       const url = new URL(source);
       const parts = url.hostname.split(".");
       if (parts.length >= 2) {
-        const brand = parts.length === 3 ? parts[parts.length - 2] : parts[0];
+        const fallback = parts[0] ?? source;
+        const secondLevel = parts[parts.length - 2] ?? fallback;
+        const brand = parts.length === 3 ? secondLevel : fallback;
         if (brand !== "www" && brand !== "api" && brand !== "mcp") {
           return brand;
         }
-        return parts[parts.length - 2] ?? parts[0];
+        return secondLevel;
       }
-      return parts[0];
+      return parts[0] ?? source;
     } catch {
       return source;
     }
@@ -284,6 +470,11 @@ function inferName(source, type) {
     const match = source.match(/\/([^/]+?)(?:\.git)?$/);
     return match?.[1] ?? source;
   }
+  if (type === "local") {
+    const normalized = source.replace(/\\/g, "/").replace(/\/+$/, "");
+    const lastSegment = normalized.split("/").pop();
+    return lastSegment ?? source;
+  }
   if (type === "command") {
     const parts = source.split(/\s+/);
     const command = parts.find((p) => !p.startsWith("-") && p !== "npx" && p !== "node" && p !== "python" && p !== "python3");
@@ -294,24 +485,34 @@ function inferName(source, type) {
 function parseSource(input) {
   const ghUrlMatch = input.match(GITHUB_URL);
   if (ghUrlMatch) {
+    const owner = ghUrlMatch[1];
+    const repo = ghUrlMatch[2];
+    if (!owner || !repo) {
+      return { type: "command", value: input, inferredName: inferName(input, "command") };
+    }
     return {
       type: "github",
       value: input,
-      inferredName: ghUrlMatch[2],
-      owner: ghUrlMatch[1],
-      repo: ghUrlMatch[2],
+      inferredName: repo,
+      owner,
+      repo,
       ref: ghUrlMatch[3],
       path: ghUrlMatch[4]
     };
   }
   const glUrlMatch = input.match(GITLAB_URL);
   if (glUrlMatch) {
+    const owner = glUrlMatch[1];
+    const repo = glUrlMatch[2];
+    if (!owner || !repo) {
+      return { type: "command", value: input, inferredName: inferName(input, "command") };
+    }
     return {
       type: "gitlab",
       value: input,
-      inferredName: glUrlMatch[2],
-      owner: glUrlMatch[1],
-      repo: glUrlMatch[2],
+      inferredName: repo,
+      owner,
+      repo,
       ref: glUrlMatch[3],
       path: glUrlMatch[4]
     };
@@ -332,12 +533,17 @@ function parseSource(input) {
   }
   const ghShorthand = input.match(GITHUB_SHORTHAND);
   if (ghShorthand && !NPM_SCOPED.test(input)) {
+    const owner = ghShorthand[1];
+    const repo = ghShorthand[2];
+    if (!owner || !repo) {
+      return { type: "command", value: input, inferredName: inferName(input, "command") };
+    }
     return {
       type: "github",
-      value: `https://github.com/${ghShorthand[1]}/${ghShorthand[2]}`,
-      inferredName: ghShorthand[2],
-      owner: ghShorthand[1],
-      repo: ghShorthand[2],
+      value: `https://github.com/${owner}/${repo}`,
+      inferredName: repo,
+      owner,
+      repo,
       path: ghShorthand[3]
     };
   }
@@ -368,15 +574,23 @@ 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();
+var AGENTS_MCP_DIR = getAgentsMcpDir();
+var AGENTS_MCP_SERVERS_PATH = getAgentsMcpServersPath();
+var AGENTS_CONFIG_PATH = getAgentsConfigPath();
+
+// 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 +598,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 +655,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 +671,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 +682,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, writeFile, 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 writeFile(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 readFile(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: existing?.scopedName ?? scopedName,
+      source: existing?.source ?? source,
+      sourceType: existing?.sourceType ?? sourceType,
+      version: version ?? existing?.version,
+      installedAt: existing?.installedAt ?? now,
+      updatedAt: now,
+      agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
+      canonicalPath,
+      isGlobal: existing?.isGlobal ?? isGlobal,
+      projectDir: existing?.projectDir ?? 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();
@@ -827,33 +1082,33 @@ var MarketplaceClient = class {
 };
 
 // src/core/skills/discovery.ts
-import { readFile as readFile3, readdir } from "fs/promises";
+import { readFile as readFile2, 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 {
-    const content = await readFile3(filePath, "utf-8");
+    const content = await readFile2(filePath, "utf-8");
     const { data } = matter(content);
-    if (!data["name"] || !data["description"]) {
+    if (!data.name || !data.description) {
       return null;
     }
-    const allowedTools = data["allowed-tools"] ?? data["allowedTools"];
+    const allowedTools = data["allowed-tools"] ?? data.allowedTools;
     return {
-      name: String(data["name"]),
-      description: String(data["description"]),
-      license: data["license"] ? String(data["license"]) : void 0,
-      compatibility: data["compatibility"] ? String(data["compatibility"]) : void 0,
-      metadata: data["metadata"],
+      name: String(data.name),
+      description: String(data.description),
+      license: data.license ? String(data.license) : void 0,
+      compatibility: data.compatibility ? String(data.compatibility) : void 0,
+      metadata: data.metadata,
       allowedTools: typeof allowedTools === "string" ? allowedTools.split(/\s+/) : Array.isArray(allowedTools) ? allowedTools.map(String) : void 0,
-      version: data["version"] ? String(data["version"]) : void 0
+      version: data.version ? String(data.version) : void 0
     };
   } catch {
     return null;
   }
 }
 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;
@@ -870,7 +1125,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);
@@ -893,6 +1148,135 @@ async function discoverSkillsMulti(dirs) {
   return all;
 }
 
+// src/core/skills/catalog.ts
+var catalog_exports = {};
+__export(catalog_exports, {
+  getCoreSkills: () => getCoreSkills,
+  getDispatchMatrix: () => getDispatchMatrix,
+  getLibraryRoot: () => getLibraryRoot,
+  getManifest: () => getManifest,
+  getProfile: () => getProfile,
+  getProtocolPath: () => getProtocolPath,
+  getSharedResourcePath: () => getSharedResourcePath,
+  getSkill: () => getSkill,
+  getSkillDependencies: () => getSkillDependencies,
+  getSkillDir: () => getSkillDir,
+  getSkillPath: () => getSkillPath,
+  getSkills: () => getSkills,
+  getSkillsByCategory: () => getSkillsByCategory,
+  getVersion: () => getVersion,
+  isCatalogAvailable: () => isCatalogAvailable,
+  listProfiles: () => listProfiles,
+  listProtocols: () => listProtocols,
+  listSharedResources: () => listSharedResources,
+  listSkills: () => listSkills,
+  readProtocol: () => readProtocol,
+  readSharedResource: () => readSharedResource,
+  readSkillContent: () => readSkillContent,
+  resolveDependencyTree: () => resolveDependencyTree,
+  resolveProfile: () => resolveProfile,
+  validateAll: () => validateAll,
+  validateSkillFrontmatter: () => validateSkillFrontmatter
+});
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var _ctSkills;
+function getCtSkills() {
+  if (!_ctSkills) {
+    try {
+      _ctSkills = require2("@cleocode/ct-skills");
+    } catch {
+      throw new Error(
+        "@cleocode/ct-skills is not installed. Run: npm install @cleocode/ct-skills"
+      );
+    }
+  }
+  return _ctSkills;
+}
+function getSkills() {
+  return getCtSkills().skills;
+}
+function getManifest() {
+  return getCtSkills().manifest;
+}
+function listSkills() {
+  return getCtSkills().listSkills();
+}
+function getSkill(name) {
+  return getCtSkills().getSkill(name);
+}
+function getSkillPath(name) {
+  return getCtSkills().getSkillPath(name);
+}
+function getSkillDir(name) {
+  return getCtSkills().getSkillDir(name);
+}
+function readSkillContent(name) {
+  return getCtSkills().readSkillContent(name);
+}
+function getCoreSkills() {
+  return getCtSkills().getCoreSkills();
+}
+function getSkillsByCategory(category) {
+  return getCtSkills().getSkillsByCategory(category);
+}
+function getSkillDependencies(name) {
+  return getCtSkills().getSkillDependencies(name);
+}
+function resolveDependencyTree(names) {
+  return getCtSkills().resolveDependencyTree(names);
+}
+function listProfiles() {
+  return getCtSkills().listProfiles();
+}
+function getProfile(name) {
+  return getCtSkills().getProfile(name);
+}
+function resolveProfile(name) {
+  return getCtSkills().resolveProfile(name);
+}
+function listSharedResources() {
+  return getCtSkills().listSharedResources();
+}
+function getSharedResourcePath(name) {
+  return getCtSkills().getSharedResourcePath(name);
+}
+function readSharedResource(name) {
+  return getCtSkills().readSharedResource(name);
+}
+function listProtocols() {
+  return getCtSkills().listProtocols();
+}
+function getProtocolPath(name) {
+  return getCtSkills().getProtocolPath(name);
+}
+function readProtocol(name) {
+  return getCtSkills().readProtocol(name);
+}
+function validateSkillFrontmatter(name) {
+  return getCtSkills().validateSkillFrontmatter(name);
+}
+function validateAll() {
+  return getCtSkills().validateAll();
+}
+function getDispatchMatrix() {
+  return getCtSkills().getDispatchMatrix();
+}
+function getVersion() {
+  return getCtSkills().version;
+}
+function getLibraryRoot() {
+  return getCtSkills().libraryRoot;
+}
+function isCatalogAvailable() {
+  try {
+    getCtSkills();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/core/skills/recommendation.ts
 var RECOMMENDATION_ERROR_CODES = {
   QUERY_INVALID: "E_SKILLS_QUERY_INVALID",
@@ -1161,8 +1545,8 @@ async function recommendSkills2(query, criteria, options = {}) {
 }
 
 // src/core/skills/audit/scanner.ts
-import { readFile as readFile4 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
 
 // src/core/skills/audit/rules.ts
 function rule(id, name, description, severity, category, pattern) {
@@ -1232,7 +1616,7 @@ var AUDIT_RULES = [
     "Invisible characters or zero-width spaces",
     "medium",
     "prompt-injection",
-    /[\u200B\u200C\u200D\u2060\uFEFF]/
+    /(?:\u200B|\u200C|\u200D|\u2060|\uFEFF)/
   ),
   // ── Command Injection ───────────────────────────────────────
   rule(
@@ -1544,13 +1928,13 @@ async function scanFile(filePath, rules) {
   if (!existsSync6(filePath)) {
     return { file: filePath, findings: [], score: 100, passed: true };
   }
-  const content = await readFile4(filePath, "utf-8");
+  const content = await readFile3(filePath, "utf-8");
   const lines = content.split("\n");
   const activeRules = rules ?? AUDIT_RULES;
   const findings = [];
   for (const rule2 of activeRules) {
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
+      const line = lines[i] ?? "";
       const match = line.match(rule2.pattern);
       if (match) {
         findings.push({
@@ -1573,13 +1957,13 @@ async function scanFile(filePath, rules) {
 }
 async function scanDirectory(dirPath) {
   const { readdir: readdir2 } = await import("fs/promises");
-  const { join: join9 } = await import("path");
+  const { join: 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 = join9(dirPath, entry.name, "SKILL.md");
+      const skillFile = join7(dirPath, entry.name, "SKILL.md");
       if (existsSync6(skillFile)) {
         results.push(await scanFile(skillFile));
       }
@@ -1632,7 +2016,7 @@ function toSarif(results) {
 }
 
 // src/core/skills/validator.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 import matter2 from "gray-matter";
 var RESERVED_NAMES = [
@@ -1661,7 +2045,7 @@ async function validateSkill(filePath) {
       metadata: null
     };
   }
-  const content = await readFile5(filePath, "utf-8");
+  const content = await readFile4(filePath, "utf-8");
   if (!content.startsWith("---")) {
     issues.push({
       level: "error",
@@ -1684,10 +2068,10 @@ async function validateSkill(filePath) {
     });
     return { valid: false, issues, metadata: null };
   }
-  if (!data["name"]) {
+  if (!data.name) {
     issues.push({ level: "error", field: "name", message: "Missing required field: name" });
   } else {
-    const name = String(data["name"]);
+    const name = String(data.name);
     if (name.length > MAX_NAME_LENGTH) {
       issues.push({
         level: "error",
@@ -1717,10 +2101,10 @@ async function validateSkill(filePath) {
       });
     }
   }
-  if (!data["description"]) {
+  if (!data.description) {
     issues.push({ level: "error", field: "description", message: "Missing required field: description" });
   } else {
-    const desc = String(data["description"]);
+    const desc = String(data.description);
     if (desc.length > MAX_DESCRIPTION_LENGTH) {
       issues.push({
         level: "error",
@@ -1799,12 +2183,12 @@ async function ensureDir(filePath) {
 }
 
 // src/core/formats/json.ts
-import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 import * as jsonc from "jsonc-parser";
 async function readJsonConfig(filePath) {
   if (!existsSync8(filePath)) return {};
-  const content = await readFile6(filePath, "utf-8");
+  const content = await readFile5(filePath, "utf-8");
   if (!content.trim()) return {};
   const errors = [];
   const result = jsonc.parse(content, errors);
@@ -1831,7 +2215,7 @@ async function writeJsonConfig(filePath, configKey, serverName, serverConfig) {
   await ensureDir(filePath);
   let content;
   if (existsSync8(filePath)) {
-    content = await readFile6(filePath, "utf-8");
+    content = await readFile5(filePath, "utf-8");
     if (!content.trim()) {
       content = "{}";
     }
@@ -1853,11 +2237,11 @@ async function writeJsonConfig(filePath, configKey, serverName, serverConfig) {
   if (!content.endsWith("\n")) {
     content += "\n";
   }
-  await writeFile3(filePath, content, "utf-8");
+  await writeFile2(filePath, content, "utf-8");
 }
 async function removeJsonConfig(filePath, configKey, serverName) {
   if (!existsSync8(filePath)) return false;
-  let content = await readFile6(filePath, "utf-8");
+  let content = await readFile5(filePath, "utf-8");
   if (!content.trim()) return false;
   const { tabSize, insertSpaces } = detectIndent(content);
   const formatOptions = {
@@ -1873,17 +2257,17 @@ async function removeJsonConfig(filePath, configKey, serverName) {
   if (!content.endsWith("\n")) {
     content += "\n";
   }
-  await writeFile3(filePath, content, "utf-8");
+  await writeFile2(filePath, content, "utf-8");
   return true;
 }
 
 // src/core/formats/yaml.ts
-import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
 import yaml from "js-yaml";
 async function readYamlConfig(filePath) {
   if (!existsSync9(filePath)) return {};
-  const content = await readFile7(filePath, "utf-8");
+  const content = await readFile6(filePath, "utf-8");
   if (!content.trim()) return {};
   const result = yaml.load(content);
   return result ?? {};
@@ -1893,8 +2277,8 @@ async function writeYamlConfig(filePath, configKey, serverName, serverConfig) {
   const existing = await readYamlConfig(filePath);
   const keyParts = configKey.split(".");
   let newEntry = { [serverName]: serverConfig };
-  for (let i = keyParts.length - 1; i >= 0; i--) {
-    newEntry = { [keyParts[i]]: newEntry };
+  for (const part of [...keyParts].reverse()) {
+    newEntry = { [part]: newEntry };
   }
   const merged = deepMerge(existing, newEntry);
   const content = yaml.dump(merged, {
@@ -1903,7 +2287,7 @@ async function writeYamlConfig(filePath, configKey, serverName, serverConfig) {
     noRefs: true,
     sortKeys: false
   });
-  await writeFile4(filePath, content, "utf-8");
+  await writeFile3(filePath, content, "utf-8");
 }
 async function removeYamlConfig(filePath, configKey, serverName) {
   if (!existsSync9(filePath)) return false;
@@ -1923,17 +2307,17 @@ async function removeYamlConfig(filePath, configKey, serverName) {
     noRefs: true,
     sortKeys: false
   });
-  await writeFile4(filePath, content, "utf-8");
+  await writeFile3(filePath, content, "utf-8");
   return true;
 }
 
 // src/core/formats/toml.ts
-import { readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
 import TOML from "@iarna/toml";
 async function readTomlConfig(filePath) {
   if (!existsSync10(filePath)) return {};
-  const content = await readFile8(filePath, "utf-8");
+  const content = await readFile7(filePath, "utf-8");
   if (!content.trim()) return {};
   const result = TOML.parse(content);
   return result;
@@ -1943,12 +2327,12 @@ async function writeTomlConfig(filePath, configKey, serverName, serverConfig) {
   const existing = await readTomlConfig(filePath);
   const keyParts = configKey.split(".");
   let newEntry = { [serverName]: serverConfig };
-  for (let i = keyParts.length - 1; i >= 0; i--) {
-    newEntry = { [keyParts[i]]: newEntry };
+  for (const part of [...keyParts].reverse()) {
+    newEntry = { [part]: newEntry };
   }
   const merged = deepMerge(existing, newEntry);
   const content = TOML.stringify(merged);
-  await writeFile5(filePath, content, "utf-8");
+  await writeFile4(filePath, content, "utf-8");
 }
 async function removeTomlConfig(filePath, configKey, serverName) {
   if (!existsSync10(filePath)) return false;
@@ -1963,7 +2347,7 @@ async function removeTomlConfig(filePath, configKey, serverName) {
   if (!(serverName in current)) return false;
   delete current[serverName];
   const content = TOML.stringify(existing);
-  await writeFile5(filePath, content, "utf-8");
+  await writeFile4(filePath, content, "utf-8");
   return true;
 }
 
@@ -2010,6 +2394,83 @@ async function removeConfig(filePath, format, key, serverName) {
   }
 }
 
+// src/core/mcp/reader.ts
+import { existsSync as existsSync11 } from "fs";
+function resolveConfigPath(provider, scope, projectDir) {
+  return resolveProviderConfigPath(provider, scope, projectDir ?? process.cwd());
+}
+async function listMcpServers(provider, scope, projectDir) {
+  const configPath = resolveConfigPath(provider, scope, projectDir);
+  debug(`listing MCP servers for ${provider.id} (${scope}) at ${configPath ?? "(none)"}`);
+  if (!configPath || !existsSync11(configPath)) return [];
+  try {
+    const config = await readConfig(configPath, provider.configFormat);
+    const servers = getNestedValue(config, provider.configKey);
+    if (!servers || typeof servers !== "object") return [];
+    const entries = [];
+    for (const [name, cfg] of Object.entries(servers)) {
+      entries.push({
+        name,
+        providerId: provider.id,
+        providerName: provider.toolName,
+        scope,
+        configPath,
+        config: cfg ?? {}
+      });
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+async function listAgentsMcpServers(scope, projectDir) {
+  const serversPath = getAgentsMcpServersPath(scope, projectDir);
+  debug(`listing .agents/ MCP servers (${scope}) at ${serversPath}`);
+  if (!existsSync11(serversPath)) return [];
+  try {
+    const config = await readConfig(serversPath, "json");
+    const servers = config["servers"];
+    if (!servers || typeof servers !== "object") return [];
+    const entries = [];
+    for (const [name, cfg] of Object.entries(servers)) {
+      entries.push({
+        name,
+        providerId: ".agents",
+        providerName: ".agents/ standard",
+        scope,
+        configPath: serversPath,
+        config: cfg ?? {}
+      });
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+async function listAllMcpServers(providers, scope, projectDir) {
+  const seen = /* @__PURE__ */ new Set();
+  const allEntries = [];
+  const agentsServersPath = getAgentsMcpServersPath(scope, projectDir);
+  const agentsEntries = await listAgentsMcpServers(scope, projectDir);
+  if (agentsEntries.length > 0) {
+    allEntries.push(...agentsEntries);
+    seen.add(agentsServersPath);
+  }
+  for (const provider of providers) {
+    const configPath = resolveConfigPath(provider, scope, projectDir);
+    if (!configPath || seen.has(configPath)) continue;
+    seen.add(configPath);
+    const entries = await listMcpServers(provider, scope, projectDir);
+    allEntries.push(...entries);
+  }
+  return allEntries;
+}
+async function removeMcpServer(provider, serverName, scope, projectDir) {
+  const configPath = resolveConfigPath(provider, scope, projectDir);
+  if (!configPath) return false;
+  return removeConfig(configPath, provider.configFormat, provider.configKey, serverName);
+}
+
 // src/core/mcp/transforms.ts
 function transformGoose(serverName, config) {
   if (config.url) {
@@ -2033,7 +2494,7 @@ function transformGoose(serverName, config) {
     timeout: 300
   };
 }
-function transformZed(serverName, config) {
+function transformZed(_serverName, config) {
   if (config.url) {
     return {
       source: "custom",
@@ -2049,7 +2510,7 @@ function transformZed(serverName, config) {
     ...config.env ? { env: config.env } : {}
   };
 }
-function transformOpenCode(serverName, config) {
+function transformOpenCode(_serverName, config) {
   if (config.url) {
     return {
       type: "remote",
@@ -2066,7 +2527,7 @@ function transformOpenCode(serverName, config) {
     ...config.env ? { environment: config.env } : {}
   };
 }
-function transformCodex(serverName, config) {
+function transformCodex(_serverName, config) {
   if (config.url) {
     return {
       type: config.type ?? "http",
@@ -2080,7 +2541,7 @@ function transformCodex(serverName, config) {
     ...config.env ? { env: config.env } : {}
   };
 }
-function transformCursor(serverName, config) {
+function transformCursor(_serverName, config) {
   if (config.url) {
     return {
       url: config.url,
@@ -2106,58 +2567,6 @@ 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;
-}
-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);
-    const servers = getNestedValue(config, provider.configKey);
-    if (!servers || typeof servers !== "object") return [];
-    const entries = [];
-    for (const [name, cfg] of Object.entries(servers)) {
-      entries.push({
-        name,
-        providerId: provider.id,
-        providerName: provider.toolName,
-        scope,
-        configPath,
-        config: cfg ?? {}
-      });
-    }
-    return entries;
-  } catch {
-    return [];
-  }
-}
-async function listAllMcpServers(providers, scope, projectDir) {
-  const seen = /* @__PURE__ */ new Set();
-  const allEntries = [];
-  for (const provider of providers) {
-    const configPath = resolveConfigPath(provider, scope, projectDir);
-    if (!configPath || seen.has(configPath)) continue;
-    seen.add(configPath);
-    const entries = await listMcpServers(provider, scope, projectDir);
-    allEntries.push(...entries);
-  }
-  return allEntries;
-}
-async function removeMcpServer(provider, serverName, scope, projectDir) {
-  const configPath = resolveConfigPath(provider, scope, projectDir);
-  if (!configPath) return false;
-  return removeConfig(configPath, provider.configFormat, provider.configKey, serverName);
-}
-
 // src/core/mcp/installer.ts
 function buildConfig(provider, serverName, config) {
   const transform = getTransform(provider.id);
@@ -2228,46 +2637,49 @@ function buildServerConfig(source, transport, headers) {
       args: ["-y", source.value]
     };
   }
-  const parts = source.value.split(/\s+/);
+  const parts = source.value.trim().split(/\s+/);
+  const command = parts[0] ?? source.value;
   return {
-    command: parts[0],
+    command,
     args: parts.slice(1)
   };
 }
 
 // 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();
@@ -2275,16 +2687,16 @@ async function getLastSelectedAgents() {
 }
 
 // src/core/instructions/injector.ts
-import { readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+import { join as join5, 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 -->/;
 async function checkInjection(filePath, expectedContent) {
   if (!existsSync12(filePath)) return "missing";
-  const content = await readFile9(filePath, "utf-8");
+  const content = await readFile8(filePath, "utf-8");
   if (!MARKER_PATTERN.test(content)) return "none";
   if (expectedContent) {
     const blockContent = extractBlock(content);
@@ -2309,29 +2721,33 @@ async function inject(filePath, content) {
   const block = buildBlock(content);
   await mkdir3(dirname3(filePath), { recursive: true });
   if (!existsSync12(filePath)) {
-    await writeFile6(filePath, block + "\n", "utf-8");
+    await writeFile5(filePath, `${block}
+`, "utf-8");
     return "created";
   }
-  const existing = await readFile9(filePath, "utf-8");
+  const existing = await readFile8(filePath, "utf-8");
   if (MARKER_PATTERN.test(existing)) {
     const updated2 = existing.replace(MARKER_PATTERN, block);
-    await writeFile6(filePath, updated2, "utf-8");
+    await writeFile5(filePath, updated2, "utf-8");
     return "updated";
   }
-  const updated = block + "\n\n" + existing;
-  await writeFile6(filePath, updated, "utf-8");
+  const updated = `${block}
+
+${existing}`;
+  await writeFile5(filePath, updated, "utf-8");
   return "added";
 }
 async function removeInjection(filePath) {
   if (!existsSync12(filePath)) return false;
-  const content = await readFile9(filePath, "utf-8");
+  const content = await readFile8(filePath, "utf-8");
   if (!MARKER_PATTERN.test(content)) return false;
   const cleaned = content.replace(MARKER_PATTERN, "").replace(/^\n{2,}/, "\n").trim();
   if (!cleaned) {
-    const { rm: rm3 } = await import("fs/promises");
-    await rm3(filePath);
+    const { rm: rm4 } = await import("fs/promises");
+    await rm4(filePath);
   } else {
-    await writeFile6(filePath, cleaned + "\n", "utf-8");
+    await writeFile5(filePath, `${cleaned}
+`, "utf-8");
   }
   return true;
 }
@@ -2339,7 +2755,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);
@@ -2356,7 +2772,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);
@@ -2398,27 +2814,26 @@ 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,
+  readFile as readFile9,
+  readlink,
+  rm as rm3,
   symlink as symlink2,
-  writeFile as writeFile7
+  writeFile as writeFile6
 } from "fs/promises";
-import { homedir as homedir4, tmpdir } from "os";
-import { basename as basename2, dirname as dirname4, join as join8 } from "path";
+import { tmpdir } from "os";
+import { basename, dirname as dirname4, join as join6 } 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);
+  const skillDir = isGlobal ? provider.pathSkills : join6(projectDir, provider.pathProjectSkills);
+  return join6(skillDir, skillName);
 }
 async function snapshotConfigs(paths) {
   const snapshots = /* @__PURE__ */ new Map();
@@ -2428,26 +2843,26 @@ async function snapshotConfigs(paths) {
       snapshots.set(path, null);
       continue;
     }
-    snapshots.set(path, await readFile10(path, "utf-8"));
+    snapshots.set(path, await readFile9(path, "utf-8"));
   }
   return snapshots;
 }
 async function restoreConfigSnapshots(snapshots) {
   for (const [path, content] of snapshots) {
     if (content === null) {
-      await rm2(path, { force: true });
+      await rm3(path, { force: true });
       continue;
     }
     await mkdir4(dirname4(path), { recursive: true });
-    await writeFile7(path, content, "utf-8");
+    await writeFile6(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 canonicalPath = join6(CANONICAL_SKILLS_DIR, skillName);
   const canonicalExisted = existsSync13(canonicalPath);
-  const canonicalBackupPath = join8(backupRoot, "canonical", skillName);
+  const canonicalBackupPath = join6(backupRoot, "canonical", skillName);
   if (canonicalExisted) {
     await mkdir4(dirname4(canonicalBackupPath), { recursive: true });
     await cp2(canonicalPath, canonicalBackupPath, { recursive: true });
@@ -2464,11 +2879,11 @@ async function snapshotSkillState(providerTargets, operation, projectDir, backup
       pathSnapshots.push({
         linkPath,
         state: "symlink",
-        symlinkTarget: await readlink2(linkPath)
+        symlinkTarget: await readlink(linkPath)
       });
       continue;
     }
-    const backupPath = join8(backupRoot, "links", provider.id, `${skillName}-${basename2(linkPath)}`);
+    const backupPath = join6(backupRoot, "links", provider.id, `${skillName}-${basename(linkPath)}`);
     await mkdir4(dirname4(backupPath), { recursive: true });
     if (stat.isDirectory()) {
       await cp2(linkPath, backupPath, { recursive: true });
@@ -2489,14 +2904,14 @@ async function snapshotSkillState(providerTargets, operation, projectDir, backup
 }
 async function restoreSkillSnapshot(snapshot) {
   if (existsSync13(snapshot.canonicalPath)) {
-    await rm2(snapshot.canonicalPath, { recursive: true, force: true });
+    await rm3(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 });
+    await rm3(pathSnapshot.linkPath, { recursive: true, force: true });
     if (pathSnapshot.state === "missing") continue;
     await mkdir4(dirname4(pathSnapshot.linkPath), { recursive: true });
     if (pathSnapshot.state === "symlink" && pathSnapshot.symlinkTarget) {
@@ -2529,7 +2944,7 @@ async function installBatchWithRollback(options) {
     return paths;
   });
   const configSnapshots = await snapshotConfigs(configPaths);
-  const backupRoot = join8(
+  const backupRoot = join6(
     tmpdir(),
     `caamp-skill-backup-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
   );
@@ -2578,7 +2993,7 @@ async function installBatchWithRollback(options) {
       }
       skillsApplied += 1;
     }
-    await rm2(backupRoot, { recursive: true, force: true });
+    await rm3(backupRoot, { recursive: true, force: true });
     return {
       success: true,
       providerIds: providers.map((provider) => provider.id),
@@ -2608,7 +3023,7 @@ async function installBatchWithRollback(options) {
         rollbackErrors.push(err instanceof Error ? err.message : String(err));
       }
     }
-    await rm2(backupRoot, { recursive: true, force: true });
+    await rm3(backupRoot, { recursive: true, force: true });
     return {
       success: false,
       providerIds: providers.map((provider) => provider.id),
@@ -2720,10 +3135,10 @@ async function updateInstructionsSingleOperation(providers, content, scope = "pr
   };
   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);
+      const expectedPath = scope === "global" ? join6(provider.pathGlobal, provider.instructFile) : join6(projectDir, provider.instructFile);
       return expectedPath === filePath;
     });
-    const fallback = groupedByFile.get(basename2(filePath)) ?? [];
+    const fallback = groupedByFile.get(basename(filePath)) ?? [];
     const selected = providersForFile.length > 0 ? providersForFile : fallback;
     summary.actions.push({
       file: filePath,
@@ -2786,6 +3201,23 @@ async function configureProviderGlobalAndProject(provider, options) {
 }
 
 export {
+  getPlatformLocations,
+  getAgentsHome,
+  getProjectAgentsDir,
+  getCanonicalSkillsDir,
+  getLockFilePath,
+  getAgentsMcpDir,
+  getAgentsMcpServersPath,
+  getAgentsInstructFile,
+  getAgentsConfigPath,
+  getAgentsWikiDir,
+  getAgentsSpecDir,
+  getAgentsLinksDir,
+  resolveRegistryTemplatePath,
+  resolveProviderConfigPath,
+  resolvePreferredConfigScope,
+  resolveProviderSkillsDir,
+  buildSkillSubPathCandidates,
   getAllProviders,
   getProvider,
   resolveAlias,
@@ -2803,8 +3235,10 @@ export {
   detectAllProviders,
   getInstalledProviders,
   detectProjectProviders,
+  resetDetectionCache,
   parseSource,
   isMarketplaceScoped,
+  CANONICAL_SKILLS_DIR,
   installSkill,
   removeSkill,
   listCanonicalSkills,
@@ -2819,6 +3253,13 @@ export {
   discoverSkill,
   discoverSkills,
   discoverSkillsMulti,
+  listSkills,
+  getSkill,
+  getSkillDir,
+  listProfiles,
+  resolveProfile,
+  isCatalogAvailable,
+  catalog_exports,
   RECOMMENDATION_ERROR_CODES,
   tokenizeCriteriaValue,
   validateRecommendationCriteria,
@@ -2838,11 +3279,12 @@ export {
   readConfig,
   writeConfig,
   removeConfig,
-  getTransform,
   resolveConfigPath,
   listMcpServers,
+  listAgentsMcpServers,
   listAllMcpServers,
   removeMcpServer,
+  getTransform,
   installMcpServer,
   installMcpServerToAll,
   buildServerConfig,
@@ -2865,4 +3307,4 @@ export {
   updateInstructionsSingleOperation,
   configureProviderGlobalAndProject
 };
-//# sourceMappingURL=chunk-ZYINKJDE.js.map
+//# sourceMappingURL=chunk-YCSZGZ5W.js.map