@agents-inc/cli 0.42.0 → 0.45.0

package/dist/{chunk-SYHRJG5G.js → chunk-ZECXM7LP.js}

@@ -42,7 +42,7 @@ import {
   warn,
   warnUnknownFields,
   writeFile
-} from "./chunk-UXNHU7Y7.js";
+} from "./chunk-473YHDYQ.js";
 import {
   ARCHIVED_SKILLS_DIR_NAME,
   CACHE_DIR,
@@ -76,7 +76,7 @@ import {
   STANDARD_FILES,
   YAML_FORMATTING,
   yamlSchemaComment
-} from "./chunk-PP7NDFFE.js";
+} from "./chunk-FVN5PFFY.js";
 import {
   init_esm_shims
 } from "./chunk-DHET7RCE.js";
@@ -415,7 +415,7 @@ init_esm_shims();
 import { createHash as createHash2 } from "crypto";
 import { downloadTemplate } from "giget";
 import os2 from "os";
-import path25 from "path";
+import path23 from "path";
 
 // src/cli/lib/configuration/index.ts
 init_esm_shims();
@@ -600,7 +600,7 @@ async function loadPluginSkills(pluginDir) {
 
 // src/cli/lib/loading/source-loader.ts
 init_esm_shims();
-import path22 from "path";
+import path20 from "path";
 
 // src/cli/lib/metadata-keys.ts
 init_esm_shims();
@@ -914,7 +914,7 @@ async function copySkillsToLocalFlattened(selectedSkillIds, localSkillsDir, matr
 
 // src/cli/lib/skills/skill-plugin-compiler.ts
 init_esm_shims();
-import path17 from "path";
+import path15 from "path";
 import { parse as parseYaml6 } from "yaml";
 
 // src/cli/lib/plugins/index.ts
@@ -998,35 +998,19 @@ async function writePluginManifest(outputDir, manifest) {
   return manifestPath;
 }
 
-// src/cli/lib/plugins/plugin-manifest-finder.ts
-init_esm_shims();
-import path7 from "path";
-async function findPluginManifest(startDir) {
-  let currentDir = startDir;
-  const root = path7.parse(currentDir).root;
-  while (currentDir !== root) {
-    const manifestPath = path7.join(currentDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
-    if (await fileExists(manifestPath)) {
-      return manifestPath;
-    }
-    currentDir = path7.dirname(currentDir);
-  }
-  return null;
-}
-
 // src/cli/lib/plugins/plugin-finder.ts
 init_esm_shims();
-import path8 from "path";
+import path7 from "path";
 import { last, zip } from "remeda";
 function getProjectPluginsDir(projectDir) {
   const dir = projectDir ?? process.cwd();
-  return path8.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR);
+  return path7.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR);
 }
 function getPluginAgentsDir(pluginDir) {
-  return path8.join(pluginDir, "agents");
+  return path7.join(pluginDir, "agents");
 }
 function getPluginManifestPath(pluginDir) {
-  return path8.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+  return path7.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
 }
 
 // src/cli/lib/plugins/plugin-info.ts
@@ -1038,10 +1022,10 @@ init_esm_shims();
 
 // src/cli/lib/installation/installation.ts
 init_esm_shims();
-import path9 from "path";
+import path8 from "path";
 async function detectInstallation(projectDir = process.cwd()) {
-  const srcConfigPath = path9.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_YAML);
-  const legacyConfigPath = path9.join(projectDir, CLAUDE_DIR, STANDARD_FILES.CONFIG_YAML);
+  const srcConfigPath = path8.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_YAML);
+  const legacyConfigPath = path8.join(projectDir, CLAUDE_DIR, STANDARD_FILES.CONFIG_YAML);
   const localConfigPath = await fileExists(srcConfigPath) ? srcConfigPath : await fileExists(legacyConfigPath) ? legacyConfigPath : null;
   if (!localConfigPath) {
     return null;
@@ -1052,23 +1036,23 @@ async function detectInstallation(projectDir = process.cwd()) {
     return {
       mode: "local",
       configPath: localConfigPath,
-      agentsDir: path9.join(projectDir, CLAUDE_DIR, "agents"),
-      skillsDir: path9.join(projectDir, CLAUDE_DIR, "skills"),
+      agentsDir: path8.join(projectDir, CLAUDE_DIR, "agents"),
+      skillsDir: path8.join(projectDir, CLAUDE_DIR, "skills"),
       projectDir
     };
   }
   return {
     mode: "plugin",
     configPath: localConfigPath,
-    agentsDir: path9.join(projectDir, CLAUDE_DIR, "agents"),
-    skillsDir: path9.join(projectDir, CLAUDE_DIR, PLUGINS_SUBDIR),
+    agentsDir: path8.join(projectDir, CLAUDE_DIR, "agents"),
+    skillsDir: path8.join(projectDir, CLAUDE_DIR, PLUGINS_SUBDIR),
     projectDir
   };
 }
 
 // src/cli/lib/installation/local-installer.ts
 init_esm_shims();
-import path13 from "path";
+import path12 from "path";
 import { stringify as stringifyYaml3 } from "yaml";
 
 // src/cli/lib/stacks/index.ts
@@ -1077,7 +1061,7 @@ init_esm_shims();
 // src/cli/lib/stacks/stacks-loader.ts
 init_esm_shims();
 import { parse as parseYaml4 } from "yaml";
-import path10 from "path";
+import path9 from "path";
 import { mapValues, pipe, flatMap, unique as unique2 } from "remeda";
 var stacksCache = /* @__PURE__ */ new Map();
 function normalizeAgentConfig(agentConfig) {
@@ -1096,7 +1080,7 @@ async function loadStacks(configDir, stacksFile) {
   const cacheKey = `${configDir}:${resolvedStacksFile}`;
   const cached = stacksCache.get(cacheKey);
   if (cached) return cached;
-  const stacksPath = path10.join(configDir, resolvedStacksFile);
+  const stacksPath = path9.join(configDir, resolvedStacksFile);
   if (!await fileExists(stacksPath)) {
     verbose(`No stacks file found at ${stacksPath}`);
     return [];
@@ -1167,12 +1151,12 @@ function getStackSkillIds(stack) {
 
 // src/cli/lib/stacks/stack-plugin-compiler.ts
 init_esm_shims();
-import path12 from "path";
+import path11 from "path";
 
 // src/cli/lib/compiler.ts
 init_esm_shims();
 import { Liquid } from "liquidjs";
-import path11 from "path";
+import path10 from "path";
 import { pipe as pipe2, flatMap as flatMap2, filter, uniqueBy } from "remeda";
 
 // src/cli/lib/resolver.ts
@@ -1346,18 +1330,18 @@ function sanitizeCompiledAgentData(data) {
 async function createLiquidEngine(projectDir) {
   const roots = [];
   if (projectDir) {
-    const srcTemplatesDir = path11.join(projectDir, CLAUDE_SRC_DIR, "agents", "_templates");
+    const srcTemplatesDir = path10.join(projectDir, CLAUDE_SRC_DIR, "agents", "_templates");
     if (await directoryExists(srcTemplatesDir)) {
       roots.push(srcTemplatesDir);
       verbose(`Using local templates from: ${srcTemplatesDir}`);
     }
-    const legacyTemplatesDir = path11.join(projectDir, CLAUDE_DIR, "templates");
+    const legacyTemplatesDir = path10.join(projectDir, CLAUDE_DIR, "templates");
     if (await directoryExists(legacyTemplatesDir)) {
       roots.push(legacyTemplatesDir);
       verbose(`Using legacy templates from: ${legacyTemplatesDir}`);
     }
   }
-  roots.push(path11.join(PROJECT_ROOT, DIRS.templates));
+  roots.push(path10.join(PROJECT_ROOT, DIRS.templates));
   return new Liquid({
     root: roots,
     extname: ".liquid",
@@ -1382,31 +1366,31 @@ async function compileAgentForPlugin(name, agent, fallbackRoot, engine, installM
   verbose(`Compiling agent: ${name}`);
   const agentSourceRoot = agent.sourceRoot || fallbackRoot;
   const agentBaseDir = agent.agentBaseDir || DIRS.agents;
-  const agentDir = path12.join(agentSourceRoot, agentBaseDir, agent.path || name);
-  const intro = await readFile(path12.join(agentDir, STANDARD_FILES.INTRO_MD));
-  const workflow = await readFile(path12.join(agentDir, STANDARD_FILES.WORKFLOW_MD));
+  const agentDir = path11.join(agentSourceRoot, agentBaseDir, agent.path || name);
+  const intro = await readFile(path11.join(agentDir, STANDARD_FILES.INTRO_MD));
+  const workflow = await readFile(path11.join(agentDir, STANDARD_FILES.WORKFLOW_MD));
   const examples = await readFileOptional(
-    path12.join(agentDir, STANDARD_FILES.EXAMPLES_MD),
+    path11.join(agentDir, STANDARD_FILES.EXAMPLES_MD),
     "## Examples\n\n_No examples defined._"
   );
   const criticalRequirementsTop = await readFileOptional(
-    path12.join(agentDir, STANDARD_FILES.CRITICAL_REQUIREMENTS_MD),
+    path11.join(agentDir, STANDARD_FILES.CRITICAL_REQUIREMENTS_MD),
     ""
   );
   const criticalReminders = await readFileOptional(
-    path12.join(agentDir, STANDARD_FILES.CRITICAL_REMINDERS_MD),
+    path11.join(agentDir, STANDARD_FILES.CRITICAL_REMINDERS_MD),
     ""
   );
   const agentPath = agent.path || name;
   const category = agentPath.split("/")[0];
-  const categoryDir = path12.join(agentSourceRoot, agentBaseDir, category);
+  const categoryDir = path11.join(agentSourceRoot, agentBaseDir, category);
   let outputFormat = await readFileOptional(
-    path12.join(agentDir, STANDARD_FILES.OUTPUT_FORMAT_MD),
+    path11.join(agentDir, STANDARD_FILES.OUTPUT_FORMAT_MD),
     ""
   );
   if (!outputFormat) {
     outputFormat = await readFileOptional(
-      path12.join(categoryDir, STANDARD_FILES.OUTPUT_FORMAT_MD),
+      path11.join(categoryDir, STANDARD_FILES.OUTPUT_FORMAT_MD),
       ""
     );
   }
@@ -1519,19 +1503,19 @@ async function compileStackPlugin(options) {
   );
   const compileConfig = convertStackToCompileConfig(stackId, stack);
   const resolvedAgents = await resolveAgents(agents, skills, compileConfig, projectRoot, newStack);
-  const pluginDir = path12.join(outputDir, stackId);
-  const agentsDir = path12.join(pluginDir, "agents");
+  const pluginDir = path11.join(outputDir, stackId);
+  const agentsDir = path11.join(pluginDir, "agents");
   await ensureDir(pluginDir);
   await ensureDir(agentsDir);
-  const pluginSkillsDir = path12.join(pluginDir, "skills");
+  const pluginSkillsDir = path11.join(pluginDir, "skills");
   await ensureDir(pluginSkillsDir);
   const copiedSourcePaths = /* @__PURE__ */ new Set();
   for (const resolvedSkill of Object.values(skills)) {
-    const sourceSkillDir = path12.join(projectRoot, resolvedSkill.path);
+    const sourceSkillDir = path11.join(projectRoot, resolvedSkill.path);
     if (copiedSourcePaths.has(resolvedSkill.path)) {
       continue;
     }
-    const destSkillDir = path12.join(pluginSkillsDir, resolvedSkill.id);
+    const destSkillDir = path11.join(pluginSkillsDir, resolvedSkill.id);
     if (await directoryExists(sourceSkillDir)) {
       await copy(sourceSkillDir, destSkillDir);
       copiedSourcePaths.add(resolvedSkill.path);
@@ -1545,18 +1529,18 @@ async function compileStackPlugin(options) {
   const allSkillPlugins = [];
   for (const [name, agent] of typedEntries(resolvedAgents)) {
     const output = await compileAgentForPlugin(name, agent, PROJECT_ROOT, engine);
-    await writeFile(path12.join(agentsDir, `${name}.md`), output);
+    await writeFile(path11.join(agentsDir, `${name}.md`), output);
     compiledAgentNames.push(name);
     for (const skill of agent.skills) {
       allSkillPlugins.push(skill.id);
     }
     verbose(`  Compiled agent: ${name}`);
   }
-  const stackDir = path12.join(projectRoot, DIRS.stacks, stackId);
-  const claudeMdPath = path12.join(stackDir, STANDARD_FILES.CLAUDE_MD);
+  const stackDir = path11.join(projectRoot, DIRS.stacks, stackId);
+  const claudeMdPath = path11.join(stackDir, STANDARD_FILES.CLAUDE_MD);
   if (await fileExists(claudeMdPath)) {
     const claudeContent = await readFile(claudeMdPath);
-    await writeFile(path12.join(pluginDir, STANDARD_FILES.CLAUDE_MD), claudeContent);
+    await writeFile(path11.join(pluginDir, STANDARD_FILES.CLAUDE_MD), claudeContent);
     verbose(`  Copied ${STANDARD_FILES.CLAUDE_MD}`);
   }
   const newHash = hashStackConfig(stack);
@@ -1580,7 +1564,7 @@ async function compileStackPlugin(options) {
   await writeContentHash(pluginDir, contentHash, getPluginManifestPath);
   verbose(`  Wrote plugin.json (v${version})`);
   const readme = generateStackReadme(stackId, stack, compiledAgentNames, uniqueSkillPlugins);
-  await writeFile(path12.join(pluginDir, "README.md"), readme);
+  await writeFile(path11.join(pluginDir, "README.md"), readme);
   verbose("  Generated README.md");
   return {
     pluginPath: pluginDir,
@@ -1613,15 +1597,15 @@ Stack plugin compiled: ${result.stackName}`);
 // src/cli/lib/installation/local-installer.ts
 function resolveInstallPaths(projectDir) {
   return {
-    skillsDir: path13.join(projectDir, LOCAL_SKILLS_PATH),
-    agentsDir: path13.join(projectDir, CLAUDE_DIR, "agents"),
-    configPath: path13.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_YAML)
+    skillsDir: path12.join(projectDir, LOCAL_SKILLS_PATH),
+    agentsDir: path12.join(projectDir, CLAUDE_DIR, "agents"),
+    configPath: path12.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_YAML)
   };
 }
 async function prepareDirectories(paths) {
   await ensureDir(paths.skillsDir);
   await ensureDir(paths.agentsDir);
-  await ensureDir(path13.dirname(paths.configPath));
+  await ensureDir(path12.dirname(paths.configPath));
 }
 async function archiveAndCopySkills(wizardResult, sourceResult, projectDir, skillsDir) {
   for (const skillId of wizardResult.selectedSkills) {
@@ -1734,6 +1718,9 @@ function setConfigMetadata(config, wizardResult, sourceResult, sourceFlag) {
   if (wizardResult.selectedDomains && wizardResult.selectedDomains.length > 0) {
     config.domains = wizardResult.selectedDomains;
   }
+  if (wizardResult.selectedAgents && wizardResult.selectedAgents.length > 0) {
+    config.selectedAgents = wizardResult.selectedAgents;
+  }
   if (sourceFlag) {
     config.source = sourceFlag;
   } else if (sourceResult.sourceConfig.source) {
@@ -1812,7 +1799,7 @@ async function compileAndWriteAgents(compileConfig, agents, localSkills, sourceR
       engine,
       installMode
     );
-    await writeFile(path13.join(agentsDir, `${name}.md`), output);
+    await writeFile(path12.join(agentsDir, `${name}.md`), output);
     compiledAgentNames.push(name);
   }
   return compiledAgentNames;
@@ -1821,7 +1808,7 @@ async function installPluginConfig(options) {
   const { wizardResult, sourceResult, projectDir, sourceFlag } = options;
   const paths = resolveInstallPaths(projectDir);
   await ensureDir(paths.agentsDir);
-  await ensureDir(path13.dirname(paths.configPath));
+  await ensureDir(path12.dirname(paths.configPath));
   const agents = await loadMergedAgents(sourceResult.sourcePath);
   const mergeResult = await buildAndMergeConfig(wizardResult, sourceResult, projectDir, sourceFlag);
   const finalConfig = mergeResult.config;
@@ -1902,7 +1889,7 @@ init_esm_shims();
 
 // src/cli/lib/plugins/plugin-settings.ts
 init_esm_shims();
-import path14 from "path";
+import path13 from "path";
 import os from "os";
 import { z } from "zod";
 var pluginSettingsSchema = z.object({
@@ -1924,7 +1911,7 @@ var installedPluginsSchema = z.object({
 var SETTINGS_FILE = "settings.json";
 var INSTALLED_PLUGINS_FILE = "installed_plugins.json";
 async function getEnabledPluginKeys(projectDir) {
-  const settingsPath = path14.join(projectDir, CLAUDE_DIR, SETTINGS_FILE);
+  const settingsPath = path13.join(projectDir, CLAUDE_DIR, SETTINGS_FILE);
   if (!await fileExists(settingsPath)) {
     verbose(`No settings.json found at '${settingsPath}'`);
     return [];
@@ -1954,7 +1941,7 @@ async function resolvePluginInstallPaths(pluginKeys, projectDir) {
   if (pluginKeys.length === 0) {
     return [];
   }
-  const registryPath = path14.join(os.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR, INSTALLED_PLUGINS_FILE);
+  const registryPath = path13.join(os.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR, INSTALLED_PLUGINS_FILE);
   if (!await fileExists(registryPath)) {
     verbose(`Plugin registry not found at '${registryPath}'`);
     return [];
@@ -2008,7 +1995,7 @@ async function getVerifiedPluginInstallPaths(projectDir) {
   const resolvedPaths = await resolvePluginInstallPaths(enabledKeys, projectDir);
   const verified = [];
   for (const { pluginKey, installPath } of resolvedPaths) {
-    const pluginJsonPath = path14.join(installPath, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+    const pluginJsonPath = path13.join(installPath, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
     if (await fileExists(pluginJsonPath)) {
       verified.push({ pluginKey, installPath });
     } else {
@@ -2126,49 +2113,10 @@ function formatInstallationDisplay(info) {
   Agents:  ${info.agentsDir}`;
 }
 
-// src/cli/lib/plugins/plugin-version.ts
-init_esm_shims();
-import path15 from "path";
-function parseVersion(version) {
-  const parts = version.split(".").map(Number);
-  return [parts[0] || 1, parts[1] || 0, parts[2] || 0];
-}
-async function bumpPluginVersion(pluginDir, type) {
-  const manifestPath = path15.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
-  const content = await readFileSafe(manifestPath, MAX_PLUGIN_FILE_SIZE);
-  const manifest = pluginManifestSchema.parse(JSON.parse(content));
-  const [major, minor, patch] = parseVersion(manifest.version || DEFAULT_VERSION);
-  let newVersion;
-  switch (type) {
-    case "major":
-      newVersion = `${major + 1}.0.0`;
-      break;
-    case "minor":
-      newVersion = `${major}.${minor + 1}.0`;
-      break;
-    case "patch":
-      newVersion = `${major}.${minor}.${patch + 1}`;
-      break;
-    default: {
-      const exhaustiveCheck = type;
-      throw new Error(`Unknown version bump type: ${exhaustiveCheck}`);
-    }
-  }
-  manifest.version = newVersion;
-  await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
-  return newVersion;
-}
-async function getPluginVersion(pluginDir) {
-  const manifestPath = path15.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
-  const content = await readFileSafe(manifestPath, MAX_PLUGIN_FILE_SIZE);
-  const manifest = pluginManifestSchema.parse(JSON.parse(content));
-  return manifest.version || DEFAULT_VERSION;
-}
-
 // src/cli/lib/plugins/plugin-validator.ts
 init_esm_shims();
 import { z as z2 } from "zod";
-import path16 from "path";
+import path14 from "path";
 import fg from "fast-glob";
 import { countBy } from "remeda";
 var PLUGIN_DIR = PLUGIN_MANIFEST_DIR;
@@ -2188,11 +2136,11 @@ var pluginManifestValidationSchema = z2.object({
 }).strict();
 function formatZodErrors2(error) {
   return error.issues.map((issue) => {
-    const path26 = issue.path.join(".");
+    const path24 = issue.path.join(".");
     if (issue.code === "unrecognized_keys") {
       return `Unrecognized key: "${issue.keys.join('", "')}"`;
     }
-    return path26 ? `${path26}: ${issue.message}` : issue.message;
+    return path24 ? `${path24}: ${issue.message}` : issue.message;
   });
 }
 function isKebabCase(str) {
@@ -2211,15 +2159,15 @@ async function validatePluginStructure(pluginPath) {
       warnings: []
     };
   }
-  const pluginDir = path16.join(pluginPath, PLUGIN_DIR);
+  const pluginDir = path14.join(pluginPath, PLUGIN_DIR);
   if (!await directoryExists(pluginDir)) {
     errors.push(`Missing ${PLUGIN_DIR}/ directory`);
   }
-  const manifestPath = path16.join(pluginDir, PLUGIN_MANIFEST);
+  const manifestPath = path14.join(pluginDir, PLUGIN_MANIFEST);
   if (!await fileExists(manifestPath)) {
     errors.push(`Missing ${PLUGIN_DIR}/${PLUGIN_MANIFEST}`);
   }
-  const readmePath = path16.join(pluginPath, "README.md");
+  const readmePath = path14.join(pluginPath, "README.md");
   if (!await fileExists(readmePath)) {
     warnings.push("Missing README.md (recommended for documentation)");
   }
@@ -2269,15 +2217,15 @@ async function validatePluginManifest(manifestPath) {
   if (!manifest.description) {
     warnings.push("Missing description field (recommended for discoverability)");
   }
-  const pluginDir = path16.dirname(path16.dirname(manifestPath));
+  const pluginDir = path14.dirname(path14.dirname(manifestPath));
   if (manifest.skills && typeof manifest.skills === "string") {
-    const skillsPath = path16.join(pluginDir, manifest.skills);
+    const skillsPath = path14.join(pluginDir, manifest.skills);
     if (!await directoryExists(skillsPath)) {
       errors.push(`Skills path does not exist: ${manifest.skills}`);
     }
   }
   if (manifest.agents && typeof manifest.agents === "string") {
-    const agentsPath = path16.join(pluginDir, manifest.agents);
+    const agentsPath = path14.join(pluginDir, manifest.agents);
     if (!await directoryExists(agentsPath)) {
       errors.push(`Agents path does not exist: ${manifest.agents}`);
     }
@@ -2366,7 +2314,7 @@ function prefixResult(result, prefix) {
   };
 }
 async function validatePluginSkillFiles(pluginPath, skillsRelPath) {
-  const skillsDir = path16.join(pluginPath, skillsRelPath);
+  const skillsDir = path14.join(pluginPath, skillsRelPath);
   if (!await directoryExists(skillsDir)) return EMPTY_RESULT;
   const files = await fg("**/SKILL.md", { cwd: skillsDir, absolute: true });
   if (files.length === 0) {
@@ -2378,13 +2326,13 @@ async function validatePluginSkillFiles(pluginPath, skillsRelPath) {
   }
   const results = await Promise.all(
     files.map(
-      async (f) => prefixResult(await validateSkillFrontmatter(f), path16.relative(pluginPath, f))
+      async (f) => prefixResult(await validateSkillFrontmatter(f), path14.relative(pluginPath, f))
     )
   );
   return mergeResults(results);
 }
 async function validatePluginAgentFiles(pluginPath, agentsRelPath) {
-  const agentsDir = path16.join(pluginPath, agentsRelPath);
+  const agentsDir = path14.join(pluginPath, agentsRelPath);
   if (!await directoryExists(agentsDir)) return EMPTY_RESULT;
   const files = await fg("*.md", { cwd: agentsDir, absolute: true });
   if (files.length === 0) {
@@ -2396,7 +2344,7 @@ async function validatePluginAgentFiles(pluginPath, agentsRelPath) {
   }
   const results = await Promise.all(
     files.map(
-      async (f) => prefixResult(await validateAgentFrontmatter(f), path16.relative(pluginPath, f))
+      async (f) => prefixResult(await validateAgentFrontmatter(f), path14.relative(pluginPath, f))
     )
   );
   return mergeResults(results);
@@ -2412,7 +2360,7 @@ async function loadManifestForValidation(manifestPath) {
 async function validatePlugin(pluginPath) {
   const structureResult = await validatePluginStructure(pluginPath);
   if (!structureResult.valid) return structureResult;
-  const manifestPath = path16.join(pluginPath, PLUGIN_DIR, PLUGIN_MANIFEST);
+  const manifestPath = path14.join(pluginPath, PLUGIN_DIR, PLUGIN_MANIFEST);
   const manifestResult = await validatePluginManifest(manifestPath);
   const manifest = await loadManifestForValidation(manifestPath);
   const skillsResult = manifest?.skills && typeof manifest.skills === "string" ? await validatePluginSkillFiles(pluginPath, manifest.skills) : EMPTY_RESULT;
@@ -2440,7 +2388,7 @@ async function validateAllPlugins(pluginsDir) {
   const allDirs = await listDirectories(pluginsDir);
   const pluginDirs = [];
   for (const dirName of allDirs) {
-    const potentialPluginDir = path16.join(pluginsDir, dirName, PLUGIN_DIR);
+    const potentialPluginDir = path14.join(pluginsDir, dirName, PLUGIN_DIR);
     if (await directoryExists(potentialPluginDir)) {
       pluginDirs.push(dirName);
     }
@@ -2464,7 +2412,7 @@ async function validateAllPlugins(pluginsDir) {
     };
   }
   for (const pluginName of pluginDirs) {
-    const pluginPath = path16.join(pluginsDir, pluginName);
+    const pluginPath = path14.join(pluginsDir, pluginName);
     const result = await validatePlugin(pluginPath);
     results.push({ name: pluginName, result });
   }
@@ -2502,7 +2450,7 @@ function sanitizeSkillName(name) {
   return name.replace(/\+/g, "-");
 }
 async function readSkillMetadata(skillPath) {
-  const metadataPath = path17.join(skillPath, STANDARD_FILES.METADATA_YAML);
+  const metadataPath = path15.join(skillPath, STANDARD_FILES.METADATA_YAML);
   if (!await fileExists(metadataPath)) {
     return null;
   }
@@ -2559,8 +2507,8 @@ function generateReadme(skillName, frontmatter, metadata) {
 }
 async function compileSkillPlugin(options) {
   const { skillPath, outputDir, skillName: overrideName } = options;
-  const dirBasename = path17.basename(skillPath);
-  const skillMdPath = path17.join(skillPath, STANDARD_FILES.SKILL_MD);
+  const dirBasename = path15.basename(skillPath);
+  const skillMdPath = path15.join(skillPath, STANDARD_FILES.SKILL_MD);
   if (!await fileExists(skillMdPath)) {
     throw new Error(
       `Skill '${dirBasename}' is missing required ${STANDARD_FILES.SKILL_MD} file. Expected at: ${skillMdPath}`
@@ -2576,8 +2524,8 @@ async function compileSkillPlugin(options) {
   const skillName = overrideName ?? sanitizeSkillName(frontmatter.name);
   verbose(`Compiling skill plugin: ${skillName} from ${skillPath}`);
   const metadata = await readSkillMetadata(skillPath);
-  const pluginDir = path17.join(outputDir, skillName);
-  const skillsDir = path17.join(pluginDir, "skills", skillName);
+  const pluginDir = path15.join(outputDir, skillName);
+  const skillsDir = path15.join(pluginDir, "skills", skillName);
   await ensureDir(pluginDir);
   await ensureDir(skillsDir);
   const newHash = await computeSkillFolderHash(skillPath);
@@ -2596,26 +2544,26 @@ async function compileSkillPlugin(options) {
   await writePluginManifest(pluginDir, manifest);
   await writeContentHash(pluginDir, contentHash, getPluginManifestPath);
   verbose(`  Wrote plugin.json for ${skillName} (v${version})`);
-  await writeFile(path17.join(skillsDir, STANDARD_FILES.SKILL_MD), skillMdContent);
+  await writeFile(path15.join(skillsDir, STANDARD_FILES.SKILL_MD), skillMdContent);
   verbose(`  Copied ${STANDARD_FILES.SKILL_MD}`);
   for (const fileName of SKILL_CONTENT_FILES) {
     if (fileName === STANDARD_FILES.SKILL_MD) continue;
-    const sourcePath = path17.join(skillPath, fileName);
+    const sourcePath = path15.join(skillPath, fileName);
     if (await fileExists(sourcePath)) {
       const content = await readFile(sourcePath);
-      await writeFile(path17.join(skillsDir, fileName), content);
+      await writeFile(path15.join(skillsDir, fileName), content);
       verbose(`  Copied ${fileName}`);
     }
   }
   for (const dirName of SKILL_CONTENT_DIRS) {
-    const sourceDir = path17.join(skillPath, dirName);
+    const sourceDir = path15.join(skillPath, dirName);
     if (await fileExists(sourceDir)) {
-      await copy(sourceDir, path17.join(skillsDir, dirName));
+      await copy(sourceDir, path15.join(skillsDir, dirName));
       verbose(`  Copied ${dirName}/`);
     }
   }
   const readme = generateReadme(skillName, frontmatter, metadata);
-  await writeFile(path17.join(pluginDir, "README.md"), readme);
+  await writeFile(path15.join(pluginDir, "README.md"), readme);
   verbose("  Generated README.md");
   return {
     pluginPath: pluginDir,
@@ -2627,7 +2575,7 @@ async function compileAllSkillPlugins(skillsDir, outputDir) {
   const results = [];
   const skillMdFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir);
   for (const skillMdFile of skillMdFiles) {
-    const skillPath = path17.join(skillsDir, path17.dirname(skillMdFile));
+    const skillPath = path15.join(skillsDir, path15.dirname(skillMdFile));
     try {
       const result = await compileSkillPlugin({
         skillPath,
@@ -2637,7 +2585,7 @@ async function compileAllSkillPlugins(skillsDir, outputDir) {
       log(`  [OK] ${result.skillName}`);
     } catch (error) {
       const errorMessage = getErrorMessage(error);
-      const dirBasename = path17.basename(skillPath);
+      const dirBasename = path15.basename(skillPath);
       warn(`Failed to compile skill from '${dirBasename}': ${errorMessage}`);
     }
   }
@@ -2654,9 +2602,9 @@ Compiled ${results.length} skill plugins:`);
 // src/cli/lib/skills/local-skill-loader.ts
 init_esm_shims();
 import { parse as parseYaml7 } from "yaml";
-import path18 from "path";
+import path16 from "path";
 async function discoverLocalSkills(projectDir) {
-  const localSkillsPath = path18.join(projectDir, LOCAL_SKILLS_PATH);
+  const localSkillsPath = path16.join(projectDir, LOCAL_SKILLS_PATH);
   if (!await directoryExists(localSkillsPath)) {
     verbose(`Local skills directory not found: ${localSkillsPath}`);
     return null;
@@ -2676,9 +2624,9 @@ async function discoverLocalSkills(projectDir) {
   };
 }
 async function extractLocalSkill(localSkillsPath, skillDirName) {
-  const skillDir = path18.join(localSkillsPath, skillDirName);
-  const metadataPath = path18.join(skillDir, STANDARD_FILES.METADATA_YAML);
-  const skillMdPath = path18.join(skillDir, STANDARD_FILES.SKILL_MD);
+  const skillDir = path16.join(localSkillsPath, skillDirName);
+  const metadataPath = path16.join(skillDir, STANDARD_FILES.METADATA_YAML);
+  const skillMdPath = path16.join(skillDir, STANDARD_FILES.SKILL_MD);
   if (!await fileExists(metadataPath)) {
     verbose(`Skipping local skill '${skillDirName}': No metadata.yaml found`);
     return null;
@@ -2740,7 +2688,7 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
 
 // src/cli/lib/skills/source-switcher.ts
 init_esm_shims();
-import path19 from "path";
+import path17 from "path";
 function validateSkillId(skillId) {
   if (!SKILL_ID_PATTERN.test(skillId)) {
     return false;
@@ -2748,19 +2696,19 @@ function validateSkillId(skillId) {
   return !(skillId.includes("\0") || skillId.includes("..") || skillId.includes("/") || skillId.includes("\\"));
 }
 function validatePathBoundary(resolvedPath, expectedParent) {
-  const normalizedPath = path19.resolve(resolvedPath);
-  const normalizedParent = path19.resolve(expectedParent);
-  return normalizedPath.startsWith(normalizedParent + path19.sep);
+  const normalizedPath = path17.resolve(resolvedPath);
+  const normalizedParent = path17.resolve(expectedParent);
+  return normalizedPath.startsWith(normalizedParent + path17.sep);
 }
 async function archiveLocalSkill(projectDir, skillId) {
   if (!validateSkillId(skillId)) {
     warn(`Invalid skill ID for archiving: '${skillId}'`);
     return;
   }
-  const skillsDir = path19.resolve(path19.join(projectDir, LOCAL_SKILLS_PATH));
-  const skillPath = path19.resolve(path19.join(skillsDir, skillId));
-  const archivedDir = path19.resolve(path19.join(skillsDir, ARCHIVED_SKILLS_DIR_NAME));
-  const archivedSkillPath = path19.resolve(path19.join(archivedDir, skillId));
+  const skillsDir = path17.resolve(path17.join(projectDir, LOCAL_SKILLS_PATH));
+  const skillPath = path17.resolve(path17.join(skillsDir, skillId));
+  const archivedDir = path17.resolve(path17.join(skillsDir, ARCHIVED_SKILLS_DIR_NAME));
+  const archivedSkillPath = path17.resolve(path17.join(archivedDir, skillId));
   if (!validatePathBoundary(skillPath, skillsDir) || !validatePathBoundary(archivedSkillPath, archivedDir)) {
     warn(`Skill ID '${skillId}' resolves outside the skills directory.`);
     return;
@@ -2780,10 +2728,10 @@ async function restoreArchivedSkill(projectDir, skillId) {
     warn(`Invalid skill ID for restoring: '${skillId}'`);
     return false;
   }
-  const skillsDir = path19.resolve(path19.join(projectDir, LOCAL_SKILLS_PATH));
-  const skillPath = path19.resolve(path19.join(skillsDir, skillId));
-  const archivedDir = path19.resolve(path19.join(skillsDir, ARCHIVED_SKILLS_DIR_NAME));
-  const archivedSkillPath = path19.resolve(path19.join(archivedDir, skillId));
+  const skillsDir = path17.resolve(path17.join(projectDir, LOCAL_SKILLS_PATH));
+  const skillPath = path17.resolve(path17.join(skillsDir, skillId));
+  const archivedDir = path17.resolve(path17.join(skillsDir, ARCHIVED_SKILLS_DIR_NAME));
+  const archivedSkillPath = path17.resolve(path17.join(archivedDir, skillId));
   if (!validatePathBoundary(skillPath, skillsDir) || !validatePathBoundary(archivedSkillPath, archivedDir)) {
     warn(`Skill ID '${skillId}' resolves outside the skills directory.`);
     return false;
@@ -2804,13 +2752,12 @@ init_esm_shims();
 // src/cli/lib/matrix/matrix-loader.ts
 init_esm_shims();
 import { parse as parseYaml8 } from "yaml";
-import path20 from "path";
+import path18 from "path";
 import { z as z3 } from "zod";
 var rawMetadataSchema = z3.object({
   category: categoryPathSchema,
   categoryExclusive: z3.boolean().optional(),
   author: z3.string(),
-  version: z3.coerce.string(),
   cliName: z3.string().optional(),
   cliDescription: z3.string().optional(),
   usageGuidance: z3.string().optional(),
@@ -2838,9 +2785,9 @@ async function extractAllSkills(skillsDir) {
   const skills = [];
   const metadataFiles = await glob(`**/${STANDARD_FILES.METADATA_YAML}`, skillsDir);
   for (const metadataFile of metadataFiles) {
-    const skillDir = path20.dirname(metadataFile);
-    const skillMdPath = path20.join(skillsDir, skillDir, STANDARD_FILES.SKILL_MD);
-    const metadataPath = path20.join(skillsDir, metadataFile);
+    const skillDir = path18.dirname(metadataFile);
+    const skillMdPath = path18.join(skillsDir, skillDir, STANDARD_FILES.SKILL_MD);
+    const metadataPath = path18.join(skillsDir, metadataFile);
     if (!await fileExists(skillMdPath)) {
       verbose(`Skipping ${metadataFile}: No ${STANDARD_FILES.SKILL_MD} found`);
       continue;
@@ -3430,87 +3377,14 @@ function getAvailableSkills(categoryId, currentSelections, matrix, options) {
 init_esm_shims();
 function checkMatrixHealth(matrix) {
   const issues = [];
-  const skillIds = new Set(typedKeys(matrix.skills));
-  checkRelationshipTargets(matrix, skillIds, issues);
   checkSubcategoryDomains(matrix, issues);
   checkSkillCategories(matrix, issues);
-  checkCompatibleWithTargets(matrix, skillIds, issues);
-  checkStackSkillIds(matrix, skillIds, issues);
+  checkSkillRelationRefs(matrix, issues);
   for (const issue of issues) {
     warn(`[matrix] ${issue.details}`);
   }
   return issues;
 }
-function checkRelationshipTargets(matrix, skillIds, issues) {
-  for (const [skillId, skill] of typedEntries(matrix.skills)) {
-    if (!skill) continue;
-    for (const conflict of skill.conflictsWith) {
-      if (!skillIds.has(conflict.skillId)) {
-        issues.push({
-          severity: "warning",
-          finding: "ghost-relationship-target",
-          details: `Skill '${skillId}' conflicts with '${conflict.skillId}' which does not exist in the matrix`
-        });
-      }
-    }
-    for (const recommend of skill.recommends) {
-      if (!skillIds.has(recommend.skillId)) {
-        issues.push({
-          severity: "warning",
-          finding: "ghost-relationship-target",
-          details: `Skill '${skillId}' recommends '${recommend.skillId}' which does not exist in the matrix`
-        });
-      }
-    }
-    for (const requirement of skill.requires) {
-      for (const reqId of requirement.skillIds) {
-        if (!skillIds.has(reqId)) {
-          issues.push({
-            severity: "error",
-            finding: "ghost-requirement-target",
-            details: `Skill '${skillId}' requires '${reqId}' which does not exist in the matrix`
-          });
-        }
-      }
-    }
-    for (const alt of skill.alternatives) {
-      if (!skillIds.has(alt.skillId)) {
-        issues.push({
-          severity: "warning",
-          finding: "ghost-alternative-target",
-          details: `Skill '${skillId}' lists alternative '${alt.skillId}' which does not exist in the matrix`
-        });
-      }
-    }
-    for (const discourage of skill.discourages) {
-      if (!skillIds.has(discourage.skillId)) {
-        issues.push({
-          severity: "warning",
-          finding: "ghost-relationship-target",
-          details: `Skill '${skillId}' discourages '${discourage.skillId}' which does not exist in the matrix`
-        });
-      }
-    }
-    for (const setupId of skill.requiresSetup) {
-      if (!skillIds.has(setupId)) {
-        issues.push({
-          severity: "warning",
-          finding: "ghost-setup-target",
-          details: `Skill '${skillId}' requiresSetup '${setupId}' which does not exist in the matrix`
-        });
-      }
-    }
-    for (const providesId of skill.providesSetupFor) {
-      if (!skillIds.has(providesId)) {
-        issues.push({
-          severity: "warning",
-          finding: "ghost-setup-target",
-          details: `Skill '${skillId}' providesSetupFor '${providesId}' which does not exist in the matrix`
-        });
-      }
-    }
-  }
-}
 function checkSubcategoryDomains(matrix, issues) {
   for (const [catId, cat] of typedEntries(matrix.categories)) {
     if (!cat) continue;
@@ -3535,37 +3409,51 @@ function checkSkillCategories(matrix, issues) {
     }
   }
 }
-function checkCompatibleWithTargets(matrix, skillIds, issues) {
+var RELATION_FIELDS_SKILL_ID_ARRAY = [
+  "compatibleWith",
+  "requiresSetup",
+  "providesSetupFor"
+];
+function checkSkillRelationRefs(matrix, issues) {
   for (const [skillId, skill] of typedEntries(matrix.skills)) {
     if (!skill) continue;
-    for (const compatId of skill.compatibleWith) {
-      if (!skillIds.has(compatId)) {
-        issues.push({
-          severity: "warning",
-          finding: "ghost-compatible-with-target",
-          details: `Skill '${skillId}' has compatibleWith '${compatId}' which does not exist in the matrix`
-        });
+    for (const field of RELATION_FIELDS_SKILL_ID_ARRAY) {
+      for (const ref of skill[field]) {
+        if (!matrix.skills[ref]) {
+          issues.push({
+            severity: "warning",
+            finding: "skill-unresolved-relation-ref",
+            details: `Skill '${skillId}' has unresolved reference '${ref}' in '${field}'`
+          });
+        }
       }
     }
-  }
-}
-function checkStackSkillIds(matrix, skillIds, issues) {
-  for (const stack of matrix.suggestedStacks) {
-    for (const stackSkillId of stack.allSkillIds) {
-      if (!skillIds.has(stackSkillId)) {
+    for (const relation of skill.conflictsWith) {
+      if (!matrix.skills[relation.skillId]) {
         issues.push({
           severity: "warning",
-          finding: "stack-ghost-skill",
-          details: `Stack '${stack.id}' references skill '${stackSkillId}' which does not exist in the matrix`
+          finding: "skill-unresolved-relation-ref",
+          details: `Skill '${skillId}' has unresolved reference '${relation.skillId}' in 'conflictsWith'`
         });
       }
     }
+    for (const requirement of skill.requires) {
+      for (const ref of requirement.skillIds) {
+        if (!matrix.skills[ref]) {
+          issues.push({
+            severity: "warning",
+            finding: "skill-unresolved-relation-ref",
+            details: `Skill '${skillId}' has unresolved reference '${ref}' in 'requires'`
+          });
+        }
+      }
+    }
   }
 }
 
 // src/cli/lib/loading/multi-source-loader.ts
 init_esm_shims();
-import path21 from "path";
+import path19 from "path";
 async function loadSkillsFromAllSources(primaryMatrix, sourceConfig, projectDir, forceRefresh = false, marketplace) {
   const resolvedMarketplace = marketplace ?? sourceConfig.marketplace;
   const isDefaultPublicSource = sourceConfig.source === DEFAULT_SOURCE;
@@ -3586,7 +3474,6 @@ function tagPrimarySourceSkills(matrix, sourceName, sourceType) {
     const source = {
       name: sourceName,
       type: sourceType,
-      version: skill.version,
       installed: false,
       primary: true
     };
@@ -3628,7 +3515,6 @@ async function tagPluginSkills(matrix, projectDir, primarySourceName, primarySou
       skill.availableSources.push({
         name: primarySourceName,
         type: primarySourceType,
-        version: skill.version,
         installed: true,
         installMode: "plugin",
         primary: true
@@ -3656,7 +3542,7 @@ async function tagPublicSourceSkills(matrix, forceRefresh) {
   }
   try {
     const fetchResult = await fetchFromSource(DEFAULT_SOURCE, { forceRefresh });
-    const skillsDir = path21.join(fetchResult.path, SKILLS_DIR_PATH);
+    const skillsDir = path19.join(fetchResult.path, SKILLS_DIR_PATH);
     const publicSkills = await extractAllSkills(skillsDir);
     let matchCount = 0;
     for (const publicSkill of publicSkills) {
@@ -3694,7 +3580,7 @@ async function tagExtraSources(matrix, projectDir, forceRefresh) {
     verbose(`Loading extra source: ${extraSource.name} (${extraSource.url})`);
     try {
       const fetchResult = await fetchFromSource(extraSource.url, { forceRefresh });
-      const skillsDir = path21.join(fetchResult.path, SKILLS_DIR_PATH);
+      const skillsDir = path19.join(fetchResult.path, SKILLS_DIR_PATH);
       const skills = await extractAllSkills(skillsDir);
       let matchCount = 0;
       for (const extractedSkill of skills) {
@@ -3737,7 +3623,7 @@ async function searchExtraSources(alias, configuredSources) {
   for (const source of configuredSources) {
     try {
       const fetchResult = await fetchFromSource(source.url, { forceRefresh: false });
-      const skillsDir = path21.join(fetchResult.path, SKILLS_DIR_PATH);
+      const skillsDir = path19.join(fetchResult.path, SKILLS_DIR_PATH);
       const skills = await extractAllSkills(skillsDir);
       for (const skill of skills) {
         const segments = skill.directoryPath.split("/");
@@ -3795,7 +3681,7 @@ async function loadSkillsMatrixFromSource(options = {}) {
 async function loadFromLocal(source, sourceConfig) {
   let skillsPath;
   if (isLocalSource(source)) {
-    skillsPath = path22.isAbsolute(source) ? source : path22.resolve(process.cwd(), source);
+    skillsPath = path20.isAbsolute(source) ? source : path20.resolve(process.cwd(), source);
   } else {
     skillsPath = PROJECT_ROOT;
   }
@@ -3837,8 +3723,8 @@ async function loadAndMergeFromBasePath(basePath) {
   const matrixRelPath = sourceProjectConfig?.matrixFile ?? SKILLS_MATRIX_PATH;
   const skillsDirRelPath = sourceProjectConfig?.skillsDir ?? SKILLS_DIR_PATH;
   const stacksRelFile = sourceProjectConfig?.stacksFile;
-  const sourceMatrixPath = path22.join(basePath, matrixRelPath);
-  const cliMatrixPath = path22.join(PROJECT_ROOT, SKILLS_MATRIX_PATH);
+  const sourceMatrixPath = path20.join(basePath, matrixRelPath);
+  const cliMatrixPath = path20.join(PROJECT_ROOT, SKILLS_MATRIX_PATH);
   let matrixPath;
   if (await fileExists(sourceMatrixPath)) {
     matrixPath = sourceMatrixPath;
@@ -3847,7 +3733,7 @@ async function loadAndMergeFromBasePath(basePath) {
     matrixPath = cliMatrixPath;
     verbose(`Matrix from CLI (source has no matrix): ${matrixPath}`);
   }
-  const skillsDir = path22.join(basePath, skillsDirRelPath);
+  const skillsDir = path20.join(basePath, skillsDirRelPath);
   verbose(`Skills from source: ${skillsDir}`);
   const matrix = await loadSkillsMatrix(matrixPath);
   const skills = await extractAllSkills(skillsDir);
@@ -3943,13 +3829,13 @@ function mergeLocalSkillsIntoMatrix(matrix, localResult) {
 
 // src/cli/lib/loading/defaults-loader.ts
 init_esm_shims();
-import path23 from "path";
+import path21 from "path";
 import { fileURLToPath } from "url";
 var cachedDefaults = null;
 function getDefaultsPath() {
-  const currentDir = path23.dirname(fileURLToPath(import.meta.url));
+  const currentDir = path21.dirname(fileURLToPath(import.meta.url));
   const isInDist = currentDir.includes("/dist");
-  return isInDist ? path23.join(currentDir, "cli", "defaults", "agent-mappings.yaml") : path23.join(currentDir, "../..", "defaults", "agent-mappings.yaml");
+  return isInDist ? path21.join(currentDir, "cli", "defaults", "agent-mappings.yaml") : path21.join(currentDir, "../..", "defaults", "agent-mappings.yaml");
 }
 async function loadDefaultMappings() {
   if (cachedDefaults !== null) {
@@ -4123,12 +4009,12 @@ import { difference } from "remeda";
 
 // src/cli/lib/configuration/project-config.ts
 init_esm_shims();
-import path24 from "path";
+import path22 from "path";
 var CONFIG_PATH = `${CLAUDE_SRC_DIR}/config.yaml`;
 var LEGACY_CONFIG_PATH = `${CLAUDE_DIR}/config.yaml`;
 async function loadProjectConfig(projectDir) {
-  const srcConfigPath = path24.join(projectDir, CONFIG_PATH);
-  const legacyConfigPath = path24.join(projectDir, LEGACY_CONFIG_PATH);
+  const srcConfigPath = path22.join(projectDir, CONFIG_PATH);
+  const legacyConfigPath = path22.join(projectDir, LEGACY_CONFIG_PATH);
   let configPath = srcConfigPath;
   if (!await fileExists(srcConfigPath)) {
     if (await fileExists(legacyConfigPath)) {
@@ -4151,7 +4037,7 @@ async function loadProjectConfig(projectDir) {
     warn(
       `Project config at '${configPath}' is missing required 'name' field \u2014 defaulting to directory name`
     );
-    config.name = path24.basename(projectDir);
+    config.name = path22.basename(projectDir);
   }
   if (!config.skills) {
     warn(`Project config at '${configPath}' is missing 'skills' array \u2014 defaulting to empty`);
@@ -4262,7 +4148,7 @@ function sanitizeSourceForCache(source) {
 }
 function getCacheDir(source) {
   const sanitized = sanitizeSourceForCache(source) || "unknown";
-  return path25.join(CACHE_DIR, "sources", sanitized);
+  return path23.join(CACHE_DIR, "sources", sanitized);
 }
 async function fetchFromSource(source, options = {}) {
   const { forceRefresh = false, subdir } = options;
@@ -4272,8 +4158,8 @@ async function fetchFromSource(source, options = {}) {
   return fetchFromRemoteSource(source, { forceRefresh, subdir });
 }
 async function fetchFromLocalSource(source, subdir) {
-  const fullPath = subdir ? path25.join(source, subdir) : source;
-  const absolutePath = path25.isAbsolute(fullPath) ? fullPath : path25.resolve(process.cwd(), fullPath);
+  const fullPath = subdir ? path23.join(source, subdir) : source;
+  const absolutePath = path23.isAbsolute(fullPath) ? fullPath : path23.resolve(process.cwd(), fullPath);
   if (!await directoryExists(absolutePath)) {
     throw new Error(`Local source not found: '${absolutePath}'`);
   }
@@ -4300,8 +4186,8 @@ function getGigetCacheDir(source) {
     return void 0;
   }
   const templateName = uriMatch.groups.repo.replace("/", "-").replace(/[^\da-z-]/gi, "-");
-  const gigetCacheRoot = process.env.XDG_CACHE_HOME ? path25.resolve(process.env.XDG_CACHE_HOME, "giget") : path25.resolve(os2.homedir(), ".cache", "giget");
-  return path25.join(gigetCacheRoot, providerName, templateName);
+  const gigetCacheRoot = process.env.XDG_CACHE_HOME ? path23.resolve(process.env.XDG_CACHE_HOME, "giget") : path23.resolve(os2.homedir(), ".cache", "giget");
+  return path23.join(gigetCacheRoot, providerName, templateName);
 }
 async function clearGigetCache(source) {
   const gigetDir = getGigetCacheDir(source);
@@ -4327,8 +4213,9 @@ async function fetchFromRemoteSource(source, options) {
   }
   if (forceRefresh) {
     await clearGigetCache(source);
+    await remove(cacheDir);
   }
-  await ensureDir(path25.dirname(cacheDir));
+  await ensureDir(path23.dirname(cacheDir));
   try {
     const result = await downloadTemplate(fullSource, {
       dir: cacheDir,
@@ -4398,8 +4285,8 @@ async function fetchMarketplace(source, options = {}) {
     subdir: ""
     // Root of repo
   });
-  const marketplacePath = path25.join(result.path, PLUGIN_MANIFEST_DIR, "marketplace.json");
-  if (!await directoryExists(path25.dirname(marketplacePath))) {
+  const marketplacePath = path23.join(result.path, PLUGIN_MANIFEST_DIR, "marketplace.json");
+  if (!await directoryExists(path23.dirname(marketplacePath))) {
     throw new Error(
       `Marketplace not found for source: ${source}
 
@@ -4539,7 +4426,6 @@ async function getSourceSummary(projectDir) {
 export {
   generateAgentPluginManifest,
   writePluginManifest,
-  findPluginManifest,
   getProjectPluginsDir,
   getPluginAgentsDir,
   getPluginManifestPath,
@@ -4605,10 +4491,8 @@ export {
   installLocal,
   getInstallationInfo,
   formatInstallationDisplay,
-  bumpPluginVersion,
-  getPluginVersion,
   validatePlugin,
   validateAllPlugins,
   printPluginValidationResult
 };
-//# sourceMappingURL=chunk-SYHRJG5G.js.map
+//# sourceMappingURL=chunk-ZECXM7LP.js.map