@cleocode/caamp 0.4.0 → 0.4.1

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

@@ -1,58 +1,158 @@
-// src/core/registry/providers.ts
-import { readFileSync, existsSync } from "fs";
+// src/core/paths/standard.ts
+import { existsSync } from "fs";
 import { homedir } from "os";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-function findRegistryPath() {
-  const thisDir = dirname(fileURLToPath(import.meta.url));
-  const devPath = join(thisDir, "..", "..", "..", "providers", "registry.json");
-  if (existsSync(devPath)) return devPath;
-  const distPath = join(thisDir, "..", "providers", "registry.json");
-  if (existsSync(distPath)) return distPath;
-  let dir = thisDir;
-  for (let i = 0; i < 5; i++) {
-    const candidate = join(dir, "providers", "registry.json");
-    if (existsSync(candidate)) return candidate;
-    dir = dirname(dir);
-  }
-  throw new Error(`Cannot find providers/registry.json (searched from ${thisDir})`);
-}
-var _registry = null;
-var _providers = null;
-var _aliasMap = null;
-function getPlatformPaths() {
+import { dirname, isAbsolute, join, resolve } from "path";
+function getPlatformLocations() {
   const home = homedir();
   const platform = process.platform;
   if (platform === "win32") {
     const appData = process.env["APPDATA"] ?? join(home, "AppData", "Roaming");
     return {
+      home,
       config: appData,
       vscodeConfig: join(appData, "Code", "User"),
       zedConfig: join(appData, "Zed"),
-      claudeDesktopConfig: join(appData, "Claude")
+      claudeDesktopConfig: join(appData, "Claude"),
+      applications: []
     };
-  } else if (platform === "darwin") {
+  }
+  if (platform === "darwin") {
+    const config2 = process.env["XDG_CONFIG_HOME"] ?? join(home, ".config");
     return {
-      config: process.env["XDG_CONFIG_HOME"] ?? join(home, ".config"),
+      home,
+      config: config2,
       vscodeConfig: join(home, "Library", "Application Support", "Code", "User"),
       zedConfig: join(home, "Library", "Application Support", "Zed"),
-      claudeDesktopConfig: join(home, "Library", "Application Support", "Claude")
-    };
-  } else {
-    const config = process.env["XDG_CONFIG_HOME"] ?? join(home, ".config");
-    return {
-      config,
-      vscodeConfig: join(config, "Code", "User"),
-      zedConfig: join(config, "zed"),
-      claudeDesktopConfig: join(config, "Claude")
+      claudeDesktopConfig: join(home, "Library", "Application Support", "Claude"),
+      applications: ["/Applications", join(home, "Applications")]
     };
   }
+  const config = process.env["XDG_CONFIG_HOME"] ?? join(home, ".config");
+  return {
+    home,
+    config,
+    vscodeConfig: join(config, "Code", "User"),
+    zedConfig: join(config, "zed"),
+    claudeDesktopConfig: join(config, "Claude"),
+    applications: []
+  };
 }
-function resolvePath(template) {
+function normalizeHomeOverride(value) {
   const home = homedir();
-  const paths = getPlatformPaths();
-  return template.replace(/\$HOME/g, home).replace(/\$CONFIG/g, paths.config).replace(/\$VSCODE_CONFIG/g, paths.vscodeConfig).replace(/\$ZED_CONFIG/g, paths.zedConfig).replace(/\$CLAUDE_DESKTOP_CONFIG/g, paths.claudeDesktopConfig);
+  const trimmed = value.trim();
+  if (trimmed.startsWith("~/")) {
+    return join(home, trimmed.slice(2));
+  }
+  if (trimmed === "~") {
+    return home;
+  }
+  if (isAbsolute(trimmed)) {
+    return resolve(trimmed);
+  }
+  return resolve(home, trimmed);
+}
+function getAgentsHome() {
+  const override = process.env["AGENTS_HOME"];
+  if (override && override.trim().length > 0) {
+    return normalizeHomeOverride(override);
+  }
+  return join(homedir(), ".agents");
+}
+function getProjectAgentsDir(projectRoot = process.cwd()) {
+  return join(projectRoot, ".agents");
+}
+function resolveProjectPath(relativePath, projectDir = process.cwd()) {
+  return join(projectDir, relativePath);
 }
+function getCanonicalSkillsDir() {
+  return join(getAgentsHome(), "skills");
+}
+function getLockFilePath() {
+  return join(getAgentsHome(), ".caamp-lock.json");
+}
+function resolveRegistryTemplatePath(template) {
+  const locations = getPlatformLocations();
+  return template.replace(/\$HOME/g, locations.home).replace(/\$CONFIG/g, locations.config).replace(/\$VSCODE_CONFIG/g, locations.vscodeConfig).replace(/\$ZED_CONFIG/g, locations.zedConfig).replace(/\$CLAUDE_DESKTOP_CONFIG/g, locations.claudeDesktopConfig).replace(/\$AGENTS_HOME/g, getAgentsHome());
+}
+function resolveProviderConfigPath(provider, scope, projectDir = process.cwd()) {
+  if (scope === "global") {
+    return provider.configPathGlobal;
+  }
+  if (!provider.configPathProject) {
+    return null;
+  }
+  return resolveProjectPath(provider.configPathProject, projectDir);
+}
+function resolvePreferredConfigScope(provider, useGlobalFlag) {
+  if (useGlobalFlag) {
+    return "global";
+  }
+  return provider.configPathProject ? "project" : "global";
+}
+function resolveProviderSkillsDir(provider, scope, projectDir = process.cwd()) {
+  if (scope === "global") {
+    return provider.pathSkills;
+  }
+  return resolveProjectPath(provider.pathProjectSkills, projectDir);
+}
+function resolveProviderProjectPath(provider, projectDir = process.cwd()) {
+  return resolveProjectPath(provider.pathProject, projectDir);
+}
+function resolveProvidersRegistryPath(startDir) {
+  const candidates = [
+    join(startDir, "..", "..", "..", "providers", "registry.json"),
+    join(startDir, "..", "providers", "registry.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  let current = startDir;
+  for (let i = 0; i < 8; i += 1) {
+    const candidate = join(current, "providers", "registry.json");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    current = dirname(current);
+  }
+  throw new Error(`Cannot find providers/registry.json (searched from ${startDir})`);
+}
+function normalizeSkillSubPath(path) {
+  if (!path) return void 0;
+  const normalized = path.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/SKILL\.md$/i, "").trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function buildSkillSubPathCandidates(marketplacePath, parsedPath) {
+  const candidates = [];
+  const base = normalizeSkillSubPath(marketplacePath);
+  const parsed = normalizeSkillSubPath(parsedPath);
+  if (base) candidates.push(base);
+  if (parsed) candidates.push(parsed);
+  const knownPrefixes = [".agents", ".claude"];
+  for (const value of [base, parsed]) {
+    if (!value || !value.startsWith("skills/")) continue;
+    for (const prefix of knownPrefixes) {
+      candidates.push(`${prefix}/${value}`);
+    }
+  }
+  if (candidates.length === 0) {
+    candidates.push(void 0);
+  }
+  return Array.from(new Set(candidates));
+}
+
+// src/core/registry/providers.ts
+import { readFileSync } from "fs";
+import { dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+function findRegistryPath() {
+  const thisDir = dirname2(fileURLToPath(import.meta.url));
+  return resolveProvidersRegistryPath(thisDir);
+}
+var _registry = null;
+var _providers = null;
+var _aliasMap = null;
 function resolveProvider(raw) {
   return {
     id: raw.id,
@@ -60,19 +160,19 @@ function resolveProvider(raw) {
     vendor: raw.vendor,
     agentFlag: raw.agentFlag,
     aliases: raw.aliases,
-    pathGlobal: resolvePath(raw.pathGlobal),
+    pathGlobal: resolveRegistryTemplatePath(raw.pathGlobal),
     pathProject: raw.pathProject,
     instructFile: raw.instructFile,
     configKey: raw.configKey,
     configFormat: raw.configFormat,
-    configPathGlobal: resolvePath(raw.configPathGlobal),
+    configPathGlobal: resolveRegistryTemplatePath(raw.configPathGlobal),
     configPathProject: raw.configPathProject,
-    pathSkills: resolvePath(raw.pathSkills),
+    pathSkills: resolveRegistryTemplatePath(raw.pathSkills),
     pathProjectSkills: raw.pathProjectSkills,
     detection: {
       methods: raw.detection.methods,
       binary: raw.detection.binary,
-      directories: raw.detection.directories?.map(resolvePath),
+      directories: raw.detection.directories?.map(resolveRegistryTemplatePath),
       appBundle: raw.detection.appBundle,
       flatpakId: raw.detection.flatpakId
     },
@@ -163,6 +263,8 @@ function isQuiet() {
 import { existsSync as existsSync2 } from "fs";
 import { execFileSync } from "child_process";
 import { join as join2 } from "path";
+var DEFAULT_DETECTION_CACHE_TTL_MS = 3e4;
+var detectionCache = null;
 function checkBinary(binary) {
   try {
     const cmd = process.platform === "win32" ? "where" : "which";
@@ -177,7 +279,8 @@ function checkDirectory(dir) {
 }
 function checkAppBundle(appName) {
   if (process.platform !== "darwin") return false;
-  return existsSync2(join2("/Applications", appName));
+  const applications = getPlatformLocations().applications;
+  return applications.some((base) => existsSync2(join2(base, appName)));
 }
 function checkFlatpak(flatpakId) {
   if (process.platform !== "linux") return false;
@@ -229,24 +332,71 @@ function detectProvider(provider) {
     projectDetected: false
   };
 }
+function providerSignature(provider) {
+  return JSON.stringify({
+    id: provider.id,
+    methods: provider.detection.methods,
+    binary: provider.detection.binary,
+    directories: provider.detection.directories,
+    appBundle: provider.detection.appBundle,
+    flatpakId: provider.detection.flatpakId
+  });
+}
+function buildProvidersSignature(providers) {
+  return providers.map(providerSignature).join("|");
+}
+function cloneDetectionResults(results) {
+  return results.map((result) => ({
+    provider: result.provider,
+    installed: result.installed,
+    methods: [...result.methods],
+    projectDetected: result.projectDetected
+  }));
+}
+function getCachedResults(signature, options) {
+  if (!detectionCache || options.forceRefresh) return null;
+  if (detectionCache.signature !== signature) return null;
+  const ttlMs = options.ttlMs ?? DEFAULT_DETECTION_CACHE_TTL_MS;
+  if (ttlMs <= 0) return null;
+  if (Date.now() - detectionCache.createdAt > ttlMs) return null;
+  return cloneDetectionResults(detectionCache.results);
+}
+function setCachedResults(signature, results) {
+  detectionCache = {
+    createdAt: Date.now(),
+    signature,
+    results: cloneDetectionResults(results)
+  };
+}
 function detectProjectProvider(provider, projectDir) {
   if (!provider.pathProject) return false;
-  return existsSync2(join2(projectDir, provider.pathProject));
+  return existsSync2(resolveProviderProjectPath(provider, projectDir));
 }
-function detectAllProviders() {
+function detectAllProviders(options = {}) {
   const providers = getAllProviders();
-  return providers.map(detectProvider);
+  const signature = buildProvidersSignature(providers);
+  const cached = getCachedResults(signature, options);
+  if (cached) {
+    debug(`detection cache hit for ${providers.length} providers`);
+    return cached;
+  }
+  const results = providers.map(detectProvider);
+  setCachedResults(signature, results);
+  return cloneDetectionResults(results);
 }
-function getInstalledProviders() {
-  return detectAllProviders().filter((r) => r.installed).map((r) => r.provider);
+function getInstalledProviders(options = {}) {
+  return detectAllProviders(options).filter((r) => r.installed).map((r) => r.provider);
 }
-function detectProjectProviders(projectDir) {
-  const results = detectAllProviders();
+function detectProjectProviders(projectDir, options = {}) {
+  const results = detectAllProviders(options);
   return results.map((r) => ({
     ...r,
     projectDetected: detectProjectProvider(r.provider, projectDir)
   }));
 }
+function resetDetectionCache() {
+  detectionCache = null;
+}
 
 // src/core/sources/parser.ts
 var GITHUB_SHORTHAND = /^([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)(?:\/(.+))?$/;
@@ -368,15 +518,20 @@ function isMarketplaceScoped(input) {
 // src/core/skills/installer.ts
 import { mkdir, symlink, rm, cp } from "fs/promises";
 import { existsSync as existsSync3, lstatSync } from "fs";
-import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
-var CANONICAL_DIR = join3(homedir2(), ".agents", "skills");
+
+// src/core/paths/agents.ts
+var AGENTS_HOME = getAgentsHome();
+var LOCK_FILE_PATH = getLockFilePath();
+var CANONICAL_SKILLS_DIR = getCanonicalSkillsDir();
+
+// src/core/skills/installer.ts
 async function ensureCanonicalDir() {
-  await mkdir(CANONICAL_DIR, { recursive: true });
+  await mkdir(CANONICAL_SKILLS_DIR, { recursive: true });
 }
 async function installToCanonical(sourcePath, skillName) {
   await ensureCanonicalDir();
-  const targetDir = join3(CANONICAL_DIR, skillName);
+  const targetDir = join3(CANONICAL_SKILLS_DIR, skillName);
   if (existsSync3(targetDir)) {
     await rm(targetDir, { recursive: true });
   }
@@ -384,7 +539,11 @@ async function installToCanonical(sourcePath, skillName) {
   return targetDir;
 }
 async function linkToAgent(canonicalPath, provider, skillName, isGlobal, projectDir) {
-  const targetSkillsDir = isGlobal ? provider.pathSkills : join3(projectDir ?? process.cwd(), provider.pathProjectSkills);
+  const targetSkillsDir = resolveProviderSkillsDir(
+    provider,
+    isGlobal ? "global" : "project",
+    projectDir
+  );
   if (!targetSkillsDir) {
     return { success: false, error: `Provider ${provider.id} has no skills directory` };
   }
@@ -437,7 +596,11 @@ async function removeSkill(skillName, providers, isGlobal, projectDir) {
   const removed = [];
   const errors = [];
   for (const provider of providers) {
-    const skillsDir = isGlobal ? provider.pathSkills : join3(projectDir ?? process.cwd(), provider.pathProjectSkills);
+    const skillsDir = resolveProviderSkillsDir(
+      provider,
+      isGlobal ? "global" : "project",
+      projectDir
+    );
     if (!skillsDir) continue;
     const linkPath = join3(skillsDir, skillName);
     if (existsSync3(linkPath)) {
@@ -449,7 +612,7 @@ async function removeSkill(skillName, providers, isGlobal, projectDir) {
       }
     }
   }
-  const canonicalPath = join3(CANONICAL_DIR, skillName);
+  const canonicalPath = join3(CANONICAL_SKILLS_DIR, skillName);
   if (existsSync3(canonicalPath)) {
     try {
       await rm(canonicalPath, { recursive: true });
@@ -460,62 +623,95 @@ async function removeSkill(skillName, providers, isGlobal, projectDir) {
   return { removed, errors };
 }
 async function listCanonicalSkills() {
-  if (!existsSync3(CANONICAL_DIR)) return [];
+  if (!existsSync3(CANONICAL_SKILLS_DIR)) return [];
   const { readdir: readdir2 } = await import("fs/promises");
-  const entries = await readdir2(CANONICAL_DIR, { withFileTypes: true });
+  const entries = await readdir2(CANONICAL_SKILLS_DIR, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
 }
 
 // src/core/lock-utils.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { open, readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, rm as rm2, rename } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
-var LOCK_DIR = join4(homedir3(), ".agents");
-var LOCK_FILE = join4(LOCK_DIR, ".caamp-lock.json");
+var LOCK_GUARD_PATH = `${LOCK_FILE_PATH}.lock`;
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+async function acquireLockGuard(retries = 40, delayMs = 25) {
+  await mkdir2(AGENTS_HOME, { recursive: true });
+  for (let attempt = 0; attempt < retries; attempt += 1) {
+    try {
+      const handle = await open(LOCK_GUARD_PATH, "wx");
+      await handle.close();
+      return;
+    } catch (error) {
+      if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
+        throw error;
+      }
+      await sleep(delayMs);
+    }
+  }
+  throw new Error("Timed out waiting for lock file guard");
+}
+async function releaseLockGuard() {
+  await rm2(LOCK_GUARD_PATH, { force: true });
+}
+async function writeLockFileUnsafe(lock) {
+  const tmpPath = `${LOCK_FILE_PATH}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile2(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+  await rename(tmpPath, LOCK_FILE_PATH);
+}
 async function readLockFile() {
   try {
-    if (!existsSync4(LOCK_FILE)) {
+    if (!existsSync4(LOCK_FILE_PATH)) {
       return { version: 1, skills: {}, mcpServers: {} };
     }
-    const content = await readFile2(LOCK_FILE, "utf-8");
+    const content = await readFile2(LOCK_FILE_PATH, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, skills: {}, mcpServers: {} };
   }
 }
-async function writeLockFile(lock) {
-  await mkdir2(LOCK_DIR, { recursive: true });
-  await writeFile2(LOCK_FILE, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+async function updateLockFile(updater) {
+  await acquireLockGuard();
+  try {
+    const lock = await readLockFile();
+    await updater(lock);
+    await writeLockFileUnsafe(lock);
+    return lock;
+  } finally {
+    await releaseLockGuard();
+  }
 }
 
 // src/core/skills/lock.ts
 import { simpleGit } from "simple-git";
 async function recordSkillInstall(skillName, scopedName, source, sourceType, agents, canonicalPath, isGlobal, projectDir, version) {
-  const lock = await readLockFile();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = lock.skills[skillName];
-  lock.skills[skillName] = {
-    name: skillName,
-    scopedName,
-    source,
-    sourceType,
-    version,
-    installedAt: existing?.installedAt ?? now,
-    updatedAt: now,
-    agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
-    canonicalPath,
-    isGlobal,
-    projectDir
-  };
-  await writeLockFile(lock);
+  await updateLockFile((lock) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = lock.skills[skillName];
+    lock.skills[skillName] = {
+      name: skillName,
+      scopedName,
+      source,
+      sourceType,
+      version,
+      installedAt: existing?.installedAt ?? now,
+      updatedAt: now,
+      agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
+      canonicalPath,
+      isGlobal,
+      projectDir
+    };
+  });
 }
 async function removeSkillFromLock(skillName) {
-  const lock = await readLockFile();
-  if (!(skillName in lock.skills)) return false;
-  delete lock.skills[skillName];
-  await writeLockFile(lock);
-  return true;
+  let removed = false;
+  await updateLockFile((lock) => {
+    if (!(skillName in lock.skills)) return;
+    delete lock.skills[skillName];
+    removed = true;
+  });
+  return removed;
 }
 async function getTrackedSkills() {
   const lock = await readLockFile();
@@ -829,7 +1025,7 @@ var MarketplaceClient = class {
 // src/core/skills/discovery.ts
 import { readFile as readFile3, readdir } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 import matter from "gray-matter";
 async function parseSkillFile(filePath) {
   try {
@@ -853,7 +1049,7 @@ async function parseSkillFile(filePath) {
   }
 }
 async function discoverSkill(skillDir) {
-  const skillFile = join5(skillDir, "SKILL.md");
+  const skillFile = join4(skillDir, "SKILL.md");
   if (!existsSync5(skillFile)) return null;
   const metadata = await parseSkillFile(skillFile);
   if (!metadata) return null;
@@ -870,7 +1066,7 @@ async function discoverSkills(rootDir) {
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const skillDir = join5(rootDir, entry.name);
+    const skillDir = join4(rootDir, entry.name);
     const skill = await discoverSkill(skillDir);
     if (skill) {
       skills.push(skill);
@@ -1573,13 +1769,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));
       }
@@ -1794,8 +1990,8 @@ function getNestedValue(obj, keyPath) {
 }
 async function ensureDir(filePath) {
   const { mkdir: mkdir5 } = await import("fs/promises");
-  const { dirname: dirname5 } = await import("path");
-  await mkdir5(dirname5(filePath), { recursive: true });
+  const { dirname: dirname6 } = await import("path");
+  await mkdir5(dirname6(filePath), { recursive: true });
 }
 
 // src/core/formats/json.ts
@@ -2107,14 +2303,9 @@ function getTransform(providerId) {
 }
 
 // src/core/mcp/reader.ts
-import { join as join6 } from "path";
 import { existsSync as existsSync11 } from "fs";
 function resolveConfigPath(provider, scope, projectDir) {
-  if (scope === "project") {
-    if (!provider.configPathProject) return null;
-    return join6(projectDir ?? process.cwd(), provider.configPathProject);
-  }
-  return provider.configPathGlobal;
+  return resolveProviderConfigPath(provider, scope, projectDir ?? process.cwd());
 }
 async function listMcpServers(provider, scope, projectDir) {
   const configPath = resolveConfigPath(provider, scope, projectDir);
@@ -2237,37 +2428,39 @@ function buildServerConfig(source, transport, headers) {
 
 // src/core/mcp/lock.ts
 async function recordMcpInstall(serverName, source, sourceType, agents, isGlobal) {
-  const lock = await readLockFile();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = lock.mcpServers[serverName];
-  lock.mcpServers[serverName] = {
-    name: serverName,
-    scopedName: serverName,
-    source,
-    sourceType,
-    installedAt: existing?.installedAt ?? now,
-    updatedAt: now,
-    agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
-    canonicalPath: "",
-    isGlobal
-  };
-  await writeLockFile(lock);
+  await updateLockFile((lock) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = lock.mcpServers[serverName];
+    lock.mcpServers[serverName] = {
+      name: serverName,
+      scopedName: serverName,
+      source,
+      sourceType,
+      installedAt: existing?.installedAt ?? now,
+      updatedAt: now,
+      agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
+      canonicalPath: "",
+      isGlobal
+    };
+  });
 }
 async function removeMcpFromLock(serverName) {
-  const lock = await readLockFile();
-  if (!(serverName in lock.mcpServers)) return false;
-  delete lock.mcpServers[serverName];
-  await writeLockFile(lock);
-  return true;
+  let removed = false;
+  await updateLockFile((lock) => {
+    if (!(serverName in lock.mcpServers)) return;
+    delete lock.mcpServers[serverName];
+    removed = true;
+  });
+  return removed;
 }
 async function getTrackedMcpServers() {
   const lock = await readLockFile();
   return lock.mcpServers;
 }
 async function saveLastSelectedAgents(agents) {
-  const lock = await readLockFile();
-  lock.lastSelectedAgents = agents;
-  await writeLockFile(lock);
+  await updateLockFile((lock) => {
+    lock.lastSelectedAgents = agents;
+  });
 }
 async function getLastSelectedAgents() {
   const lock = await readLockFile();
@@ -2277,7 +2470,7 @@ async function getLastSelectedAgents() {
 // src/core/instructions/injector.ts
 import { readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+import { join as join5, dirname as dirname4 } from "path";
 import { mkdir as mkdir3 } from "fs/promises";
 var MARKER_START = "<!-- CAAMP:START -->";
 var MARKER_END = "<!-- CAAMP:END -->";
@@ -2307,7 +2500,7 @@ ${MARKER_END}`;
 }
 async function inject(filePath, content) {
   const block = buildBlock(content);
-  await mkdir3(dirname3(filePath), { recursive: true });
+  await mkdir3(dirname4(filePath), { recursive: true });
   if (!existsSync12(filePath)) {
     await writeFile6(filePath, block + "\n", "utf-8");
     return "created";
@@ -2328,8 +2521,8 @@ async function removeInjection(filePath) {
   if (!MARKER_PATTERN.test(content)) return false;
   const cleaned = content.replace(MARKER_PATTERN, "").replace(/^\n{2,}/, "\n").trim();
   if (!cleaned) {
-    const { rm: 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");
   }
@@ -2339,7 +2532,7 @@ async function checkAllInjections(providers, projectDir, scope, expectedContent)
   const results = [];
   const checked = /* @__PURE__ */ new Set();
   for (const provider of providers) {
-    const filePath = scope === "global" ? join7(provider.pathGlobal, provider.instructFile) : join7(projectDir, provider.instructFile);
+    const filePath = scope === "global" ? join5(provider.pathGlobal, provider.instructFile) : join5(projectDir, provider.instructFile);
     if (checked.has(filePath)) continue;
     checked.add(filePath);
     const status = await checkInjection(filePath, expectedContent);
@@ -2356,7 +2549,7 @@ async function injectAll(providers, projectDir, scope, content) {
   const results = /* @__PURE__ */ new Map();
   const injected = /* @__PURE__ */ new Set();
   for (const provider of providers) {
-    const filePath = scope === "global" ? join7(provider.pathGlobal, provider.instructFile) : join7(projectDir, provider.instructFile);
+    const filePath = scope === "global" ? join5(provider.pathGlobal, provider.instructFile) : join5(projectDir, provider.instructFile);
     if (injected.has(filePath)) continue;
     injected.add(filePath);
     const action = await inject(filePath, content);
@@ -2400,25 +2593,25 @@ import {
   mkdir as mkdir4,
   readFile as readFile10,
   readlink as readlink2,
-  rm as rm2,
+  rm as rm3,
   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";
+import { homedir as homedir2, tmpdir } from "os";
+import { basename as basename2, dirname as dirname5, join as join6 } from "path";
 var PRIORITY_ORDER = {
   high: 0,
   medium: 1,
   low: 2
 };
-var CANONICAL_SKILLS_DIR = join8(homedir4(), ".agents", "skills");
+var CANONICAL_SKILLS_DIR2 = join6(homedir2(), ".agents", "skills");
 function selectProvidersByMinimumPriority(providers, minimumPriority = "low") {
   const maxRank = PRIORITY_ORDER[minimumPriority];
   return [...providers].filter((provider) => PRIORITY_ORDER[provider.priority] <= maxRank).sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
 }
 function resolveSkillLinkPath(provider, skillName, isGlobal, projectDir) {
-  const skillDir = isGlobal ? provider.pathSkills : 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();
@@ -2435,21 +2628,21 @@ async function snapshotConfigs(paths) {
 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 mkdir4(dirname5(path), { recursive: true });
     await writeFile7(path, content, "utf-8");
   }
 }
 async function snapshotSkillState(providerTargets, operation, projectDir, backupRoot) {
   const skillName = operation.skillName;
   const isGlobal = operation.isGlobal ?? true;
-  const canonicalPath = join8(CANONICAL_SKILLS_DIR, skillName);
+  const canonicalPath = join6(CANONICAL_SKILLS_DIR2, 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 mkdir4(dirname5(canonicalBackupPath), { recursive: true });
     await cp2(canonicalPath, canonicalBackupPath, { recursive: true });
   }
   const pathSnapshots = [];
@@ -2468,8 +2661,8 @@ async function snapshotSkillState(providerTargets, operation, projectDir, backup
       });
       continue;
     }
-    const backupPath = join8(backupRoot, "links", provider.id, `${skillName}-${basename2(linkPath)}`);
-    await mkdir4(dirname4(backupPath), { recursive: true });
+    const backupPath = join6(backupRoot, "links", provider.id, `${skillName}-${basename2(linkPath)}`);
+    await mkdir4(dirname5(backupPath), { recursive: true });
     if (stat.isDirectory()) {
       await cp2(linkPath, backupPath, { recursive: true });
       pathSnapshots.push({ linkPath, state: "directory", backupPath });
@@ -2489,16 +2682,16 @@ 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 mkdir4(dirname5(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 });
+    await mkdir4(dirname5(pathSnapshot.linkPath), { recursive: true });
     if (pathSnapshot.state === "symlink" && pathSnapshot.symlinkTarget) {
       const linkType = process.platform === "win32" ? "junction" : "dir";
       await symlink2(pathSnapshot.symlinkTarget, pathSnapshot.linkPath, linkType);
@@ -2529,7 +2722,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 +2771,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 +2801,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,7 +2913,7 @@ 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)) ?? [];
@@ -2786,6 +2979,16 @@ async function configureProviderGlobalAndProject(provider, options) {
 }
 
 export {
+  getPlatformLocations,
+  getAgentsHome,
+  getProjectAgentsDir,
+  getCanonicalSkillsDir,
+  getLockFilePath,
+  resolveRegistryTemplatePath,
+  resolveProviderConfigPath,
+  resolvePreferredConfigScope,
+  resolveProviderSkillsDir,
+  buildSkillSubPathCandidates,
   getAllProviders,
   getProvider,
   resolveAlias,
@@ -2803,6 +3006,7 @@ export {
   detectAllProviders,
   getInstalledProviders,
   detectProjectProviders,
+  resetDetectionCache,
   parseSource,
   isMarketplaceScoped,
   installSkill,
@@ -2865,4 +3069,4 @@ export {
   updateInstructionsSingleOperation,
   configureProviderGlobalAndProject
 };
-//# sourceMappingURL=chunk-ZYINKJDE.js.map
+//# sourceMappingURL=chunk-6HQDRJLS.js.map