@claude-collective/cli 0.21.0 → 0.26.0

package/dist/chunk-ETQ3BPGU.js

@@ -0,0 +1,4204 @@
+#!/usr/bin/env node
+import {
+  agentFrontmatterValidationSchema,
+  agentYamlConfigSchema,
+  categoryPathSchema,
+  copy,
+  directoryExists,
+  ensureDir,
+  fileExists,
+  glob,
+  hooksRecordSchema,
+  listDirectories,
+  localRawMetadataSchema,
+  localSkillMetadataSchema,
+  marketplaceSchema,
+  pluginAuthorSchema,
+  pluginManifestSchema,
+  projectConfigLoaderSchema,
+  projectSourceConfigSchema,
+  readFile,
+  readFileOptional,
+  remove,
+  skillDisplayNameSchema,
+  skillFrontmatterLoaderSchema,
+  skillFrontmatterValidationSchema,
+  skillIdSchema,
+  skillMetadataConfigSchema,
+  skillsMatrixConfigSchema,
+  stacksConfigSchema,
+  verbose,
+  warn,
+  writeFile
+} from "./chunk-ZDREFYD2.js";
+import {
+  typedEntries,
+  typedKeys
+} from "./chunk-HWD32NP7.js";
+import {
+  ARCHIVED_SKILLS_DIR_NAME,
+  CACHE_DIR,
+  CLAUDE_DIR,
+  CLAUDE_SRC_DIR,
+  DEFAULT_DISPLAY_VERSION,
+  DEFAULT_VERSION,
+  DIRS,
+  KEY_SUBCATEGORIES,
+  LOCAL_SKILLS_PATH,
+  PLUGINS_SUBDIR,
+  PLUGIN_MANIFEST_DIR,
+  PLUGIN_MANIFEST_FILE,
+  PROJECT_ROOT,
+  SKILLS_DIR_PATH,
+  SKILLS_MATRIX_PATH
+} from "./chunk-O6ZTD7ZI.js";
+import {
+  init_esm_shims
+} from "./chunk-AWKZ5BDL.js";
+
+// src/cli/lib/configuration/source-manager.ts
+init_esm_shims();
+
+// src/cli/lib/configuration/config.ts
+init_esm_shims();
+import path from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var DEFAULT_SOURCE = "github:claude-collective/skills";
+var SOURCE_ENV_VAR = "CC_SOURCE";
+var PROJECT_CONFIG_FILE = "config.yaml";
+function getProjectConfigPath(projectDir) {
+  return path.join(projectDir, CLAUDE_SRC_DIR, PROJECT_CONFIG_FILE);
+}
+async function loadProjectSourceConfig(projectDir) {
+  const srcConfigPath = getProjectConfigPath(projectDir);
+  const legacyConfigPath = path.join(projectDir, CLAUDE_DIR, "config.yaml");
+  let configPath = srcConfigPath;
+  if (!await fileExists(srcConfigPath)) {
+    if (await fileExists(legacyConfigPath)) {
+      configPath = legacyConfigPath;
+      verbose(`Using legacy config location: ${legacyConfigPath}`);
+    } else {
+      verbose(`Project config not found at ${srcConfigPath} or ${legacyConfigPath}`);
+      return null;
+    }
+  }
+  try {
+    const content = await readFile(configPath);
+    const parsed = parseYaml(content);
+    const result = projectSourceConfigSchema.safeParse(parsed);
+    if (!result.success) {
+      warn(`Invalid project config at ${configPath}: ${result.error.message}`);
+      return null;
+    }
+    verbose(`Loaded project config from ${configPath}`);
+    return result.data;
+  } catch (error) {
+    warn(`Failed to parse project config at ${configPath}: ${error}`);
+    return null;
+  }
+}
+async function saveProjectConfig(projectDir, config) {
+  const configPath = getProjectConfigPath(projectDir);
+  await ensureDir(path.join(projectDir, CLAUDE_SRC_DIR));
+  const content = stringifyYaml(config, { lineWidth: 0 });
+  await writeFile(configPath, content);
+  verbose(`Saved project config to ${configPath}`);
+}
+async function resolveSource(flagValue, projectDir) {
+  const projectConfig = projectDir ? await loadProjectSourceConfig(projectDir) : null;
+  const marketplace = projectConfig?.marketplace;
+  if (flagValue !== void 0) {
+    if (flagValue === "" || flagValue.trim() === "") {
+      throw new Error("--source flag cannot be empty");
+    }
+    verbose(`Source from --source flag: ${flagValue}`);
+    return { source: flagValue, sourceOrigin: "flag", marketplace };
+  }
+  const envValue = process.env[SOURCE_ENV_VAR];
+  if (envValue) {
+    verbose(`Source from ${SOURCE_ENV_VAR} env var: ${envValue}`);
+    return { source: envValue, sourceOrigin: "env", marketplace };
+  }
+  if (projectConfig?.source) {
+    verbose(`Source from project config: ${projectConfig.source}`);
+    return {
+      source: projectConfig.source,
+      sourceOrigin: "project",
+      marketplace
+    };
+  }
+  verbose(`Using default source: ${DEFAULT_SOURCE}`);
+  return { source: DEFAULT_SOURCE, sourceOrigin: "default", marketplace };
+}
+async function resolveAgentsSource(flagValue, projectDir) {
+  if (flagValue !== void 0) {
+    if (flagValue === "" || flagValue.trim() === "") {
+      throw new Error("--agent-source flag cannot be empty");
+    }
+    verbose(`Agents source from --agent-source flag: ${flagValue}`);
+    return { agentsSource: flagValue, agentsSourceOrigin: "flag" };
+  }
+  const projectConfig = projectDir ? await loadProjectSourceConfig(projectDir) : null;
+  if (projectConfig?.agents_source) {
+    verbose(`Agents source from project config: ${projectConfig.agents_source}`);
+    return {
+      agentsSource: projectConfig.agents_source,
+      agentsSourceOrigin: "project"
+    };
+  }
+  verbose("Using default agents source (local CLI)");
+  return { agentsSource: void 0, agentsSourceOrigin: "default" };
+}
+var PROJECT_ORIGIN_LABEL = "project config (.claude-src/config.yaml)";
+function formatOrigin(type, origin) {
+  if (origin === "project") return PROJECT_ORIGIN_LABEL;
+  if (type === "source") {
+    switch (origin) {
+      case "flag":
+        return "--source flag";
+      case "env":
+        return `${SOURCE_ENV_VAR} environment variable`;
+      case "default":
+        return "default";
+    }
+  }
+  switch (origin) {
+    case "flag":
+      return "--agent-source flag";
+    case "default":
+      return "default (local CLI)";
+  }
+  return origin;
+}
+async function resolveAuthor(projectDir) {
+  const projectConfig = projectDir ? await loadProjectSourceConfig(projectDir) : null;
+  return projectConfig?.author;
+}
+async function resolveAllSources(projectDir) {
+  const projectConfig = projectDir ? await loadProjectSourceConfig(projectDir) : null;
+  const resolvedConfig = await resolveSource(void 0, projectDir);
+  const primary = {
+    name: "marketplace",
+    url: resolvedConfig.source,
+    description: "Primary skills marketplace"
+  };
+  const extras = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  if (projectConfig?.sources) {
+    for (const source of projectConfig.sources) {
+      if (!seenNames.has(source.name)) {
+        seenNames.add(source.name);
+        extras.push(source);
+      }
+    }
+  }
+  return { primary, extras };
+}
+function isLocalSource(source) {
+  if (source.startsWith("/") || source.startsWith(".")) {
+    return true;
+  }
+  const remoteProtocols = [
+    "github:",
+    "gh:",
+    "gitlab:",
+    "bitbucket:",
+    "sourcehut:",
+    "https://",
+    "http://"
+  ];
+  const hasRemoteProtocol = remoteProtocols.some((prefix) => source.startsWith(prefix));
+  if (!hasRemoteProtocol) {
+    if (source.includes("..") || source.includes("~")) {
+      throw new Error(`Invalid source path: ${source}. Path traversal patterns are not allowed.`);
+    }
+  }
+  return !hasRemoteProtocol;
+}
+
+// src/cli/lib/loading/source-fetcher.ts
+init_esm_shims();
+import path25 from "path";
+import { downloadTemplate } from "giget";
+
+// src/cli/lib/configuration/index.ts
+init_esm_shims();
+
+// src/cli/lib/configuration/config-generator.ts
+init_esm_shims();
+
+// src/cli/lib/skills/index.ts
+init_esm_shims();
+
+// src/cli/lib/skills/skill-metadata.ts
+init_esm_shims();
+import path3 from "path";
+import { parse as parseYaml3, stringify as stringifyYaml3 } from "yaml";
+import { sortBy } from "remeda";
+
+// src/cli/lib/versioning.ts
+init_esm_shims();
+import { createHash } from "crypto";
+import path2 from "path";
+import { stringify as stringifyYaml2, parse as parseYaml2 } from "yaml";
+var HASH_PREFIX_LENGTH = 7;
+var HASHABLE_FILES = ["SKILL.md", "reference.md"];
+var HASHABLE_DIRS = ["examples", "scripts"];
+function getCurrentDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+function hashString(content) {
+  const hash = createHash("sha256");
+  hash.update(content);
+  return hash.digest("hex").slice(0, HASH_PREFIX_LENGTH);
+}
+async function hashFile(filePath) {
+  const content = await readFile(filePath);
+  return hashString(content);
+}
+async function hashSkillFolder(skillPath) {
+  const contents = [];
+  for (const fileName of HASHABLE_FILES) {
+    const filePath = path2.join(skillPath, fileName);
+    if (await fileExists(filePath)) {
+      const content = await readFile(filePath);
+      contents.push(`${fileName}:${content}`);
+    }
+  }
+  for (const dirName of HASHABLE_DIRS) {
+    const dirPath = path2.join(skillPath, dirName);
+    if (await fileExists(dirPath)) {
+      const files = await glob("**/*", dirPath);
+      for (const file of files.sort()) {
+        const filePath = path2.join(dirPath, file);
+        const content = await readFile(filePath);
+        contents.push(`${dirName}/${file}:${content}`);
+      }
+    }
+  }
+  const combined = contents.join("\n---\n");
+  return hashString(combined);
+}
+var CONTENT_HASH_FILE = ".content-hash";
+function parseMajorVersion(version) {
+  const match = version.match(/^(\d+)\./);
+  return match ? parseInt(match[1], 10) : 1;
+}
+function bumpMajorVersion(version) {
+  const major = parseMajorVersion(version);
+  return `${major + 1}.0.0`;
+}
+async function readExistingPluginManifest(pluginDir, getManifestPath) {
+  const manifestPath = getManifestPath(pluginDir);
+  if (!await fileExists(manifestPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(manifestPath);
+    const manifest = pluginManifestSchema.parse(JSON.parse(content));
+    const hashFilePath = manifestPath.replace("plugin.json", CONTENT_HASH_FILE);
+    let contentHash;
+    if (await fileExists(hashFilePath)) {
+      contentHash = (await readFile(hashFilePath)).trim();
+    }
+    return {
+      version: manifest.version ?? DEFAULT_VERSION,
+      contentHash
+    };
+  } catch {
+    return null;
+  }
+}
+async function determinePluginVersion(newHash, pluginDir, getManifestPath) {
+  const existing = await readExistingPluginManifest(pluginDir, getManifestPath);
+  if (!existing) {
+    return {
+      version: DEFAULT_VERSION,
+      contentHash: newHash
+    };
+  }
+  if (existing.contentHash !== newHash) {
+    return {
+      version: bumpMajorVersion(existing.version),
+      contentHash: newHash
+    };
+  }
+  return {
+    version: existing.version,
+    contentHash: newHash
+  };
+}
+async function writeContentHash(pluginDir, contentHash, getManifestPath) {
+  const hashFilePath = getManifestPath(pluginDir).replace("plugin.json", CONTENT_HASH_FILE);
+  await writeFile(hashFilePath, contentHash);
+}
+
+// src/cli/lib/skills/skill-metadata.ts
+async function readForkedFromMetadata(skillDir) {
+  const metadataPath = path3.join(skillDir, "metadata.yaml");
+  if (!await fileExists(metadataPath)) {
+    return null;
+  }
+  const content = await readFile(metadataPath);
+  const result = localSkillMetadataSchema.safeParse(parseYaml3(content));
+  if (!result.success) {
+    warn(
+      `Invalid metadata.yaml at ${metadataPath}: ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+    return null;
+  }
+  return result.data.forked_from ?? null;
+}
+async function getLocalSkillsWithMetadata(projectDir) {
+  const localSkillsPath = path3.join(projectDir, LOCAL_SKILLS_PATH);
+  const result = /* @__PURE__ */ new Map();
+  if (!await fileExists(localSkillsPath)) {
+    return result;
+  }
+  const skillDirs = await listDirectories(localSkillsPath);
+  for (const dirName of skillDirs) {
+    const skillDir = path3.join(localSkillsPath, dirName);
+    const forkedFrom = await readForkedFromMetadata(skillDir);
+    const skillId = forkedFrom?.skill_id ?? dirName;
+    result.set(skillId, { dirName, forkedFrom });
+  }
+  return result;
+}
+async function computeSourceHash(sourcePath, skillPath) {
+  const skillMdPath = path3.join(sourcePath, "src", skillPath, "SKILL.md");
+  if (!await fileExists(skillMdPath)) {
+    return null;
+  }
+  return hashFile(skillMdPath);
+}
+async function compareSkills(projectDir, sourcePath, sourceSkills) {
+  const results = [];
+  const localSkills = await getLocalSkillsWithMetadata(projectDir);
+  for (const [skillId, { dirName, forkedFrom }] of localSkills) {
+    if (!forkedFrom) {
+      results.push({
+        id: skillId,
+        localHash: null,
+        sourceHash: null,
+        status: "local-only",
+        dirName
+      });
+      continue;
+    }
+    const localHash = forkedFrom.content_hash;
+    const sourceSkill = sourceSkills[forkedFrom.skill_id];
+    if (!sourceSkill) {
+      results.push({
+        id: forkedFrom.skill_id,
+        localHash,
+        sourceHash: null,
+        status: "local-only",
+        dirName
+      });
+      continue;
+    }
+    const sourceHash = await computeSourceHash(sourcePath, sourceSkill.path);
+    if (sourceHash === null) {
+      results.push({
+        id: forkedFrom.skill_id,
+        localHash,
+        sourceHash: null,
+        status: "local-only",
+        dirName
+      });
+      continue;
+    }
+    const status = localHash === sourceHash ? "current" : "outdated";
+    results.push({
+      id: forkedFrom.skill_id,
+      localHash,
+      sourceHash,
+      status,
+      dirName,
+      sourcePath: sourceSkill.path
+    });
+  }
+  return sortBy(results, (r) => r.id);
+}
+async function injectForkedFromMetadata(destPath, skillId, contentHash) {
+  const metadataPath = path3.join(destPath, "metadata.yaml");
+  const rawContent = await readFile(metadataPath);
+  const lines = rawContent.split("\n");
+  let yamlContent = rawContent;
+  if (lines[0]?.startsWith("# yaml-language-server:")) {
+    yamlContent = lines.slice(1).join("\n");
+  }
+  const parseResult = localSkillMetadataSchema.safeParse(parseYaml3(yamlContent));
+  if (!parseResult.success) {
+    warn(`Malformed metadata.yaml at ${metadataPath} \u2014 existing fields may be lost`);
+  }
+  const metadata = parseResult.success ? parseResult.data : { forked_from: void 0 };
+  metadata.forked_from = {
+    skill_id: skillId,
+    content_hash: contentHash,
+    date: getCurrentDate()
+  };
+  const newYamlContent = stringifyYaml3(metadata, { lineWidth: 0 });
+  await writeFile(metadataPath, newYamlContent);
+}
+
+// src/cli/lib/skills/skill-copier.ts
+init_esm_shims();
+import path4 from "path";
+function getSkillDestPath(skill, stackDir) {
+  const skillRelativePath = skill.path.replace(/^skills\//, "");
+  return path4.join(stackDir, "skills", skillRelativePath);
+}
+async function generateSkillHash(skillSourcePath) {
+  const skillMdPath = path4.join(skillSourcePath, "SKILL.md");
+  return hashFile(skillMdPath);
+}
+function getSkillSourcePathFromSource(skill, sourceResult) {
+  return path4.join(sourceResult.sourcePath, "src", skill.path);
+}
+async function copySkillFromSource(skill, stackDir, sourceResult) {
+  const sourcePath = getSkillSourcePathFromSource(skill, sourceResult);
+  const destPath = getSkillDestPath(skill, stackDir);
+  const contentHash = await generateSkillHash(sourcePath);
+  await ensureDir(path4.dirname(destPath));
+  await copy(sourcePath, destPath);
+  await injectForkedFromMetadata(destPath, skill.id, contentHash);
+  return {
+    skillId: skill.id,
+    contentHash,
+    sourcePath,
+    destPath
+  };
+}
+async function copySkillsToPluginFromSource(selectedSkillIds, pluginDir, matrix, sourceResult, sourceSelections) {
+  const copiedSkills = [];
+  for (const skillId of selectedSkillIds) {
+    const skill = matrix.skills[skillId];
+    if (!skill) {
+      console.warn(`Warning: Skill not found in matrix: ${skillId}`);
+      continue;
+    }
+    const selectedSource = sourceSelections?.[skillId];
+    const userSelectedRemote = selectedSource && selectedSource !== "local";
+    if (skill.local && skill.localPath && !userSelectedRemote) {
+      const localSkillPath = path4.join(process.cwd(), skill.localPath);
+      const contentHash = await generateSkillHash(localSkillPath);
+      copiedSkills.push({
+        skillId: skill.id,
+        sourcePath: skill.localPath,
+        destPath: skill.localPath,
+        contentHash,
+        local: true
+      });
+      continue;
+    }
+    const copied = await copySkillFromSource(skill, pluginDir, sourceResult);
+    copiedSkills.push(copied);
+  }
+  return copiedSkills;
+}
+function getFlattenedSkillDestPath(skill, localSkillsDir) {
+  return path4.join(localSkillsDir, skill.id);
+}
+async function copySkillToLocalFlattened(skill, localSkillsDir, sourceResult) {
+  const sourcePath = getSkillSourcePathFromSource(skill, sourceResult);
+  const destPath = getFlattenedSkillDestPath(skill, localSkillsDir);
+  const contentHash = await generateSkillHash(sourcePath);
+  await ensureDir(path4.dirname(destPath));
+  await copy(sourcePath, destPath);
+  await injectForkedFromMetadata(destPath, skill.id, contentHash);
+  return {
+    skillId: skill.id,
+    contentHash,
+    sourcePath,
+    destPath
+  };
+}
+async function copySkillsToLocalFlattened(selectedSkillIds, localSkillsDir, matrix, sourceResult, sourceSelections) {
+  const copiedSkills = [];
+  for (const skillId of selectedSkillIds) {
+    const skill = matrix.skills[skillId];
+    if (!skill) {
+      console.warn(`Warning: Skill not found in matrix: ${skillId}`);
+      continue;
+    }
+    const selectedSource = sourceSelections?.[skillId];
+    const userSelectedRemote = selectedSource && selectedSource !== "local";
+    if (skill.local && skill.localPath && !userSelectedRemote) {
+      const localSkillPath = path4.join(process.cwd(), skill.localPath);
+      const contentHash = await generateSkillHash(localSkillPath);
+      copiedSkills.push({
+        skillId: skill.id,
+        sourcePath: skill.localPath,
+        destPath: skill.localPath,
+        contentHash,
+        local: true
+      });
+      continue;
+    }
+    const copied = await copySkillToLocalFlattened(skill, localSkillsDir, sourceResult);
+    copiedSkills.push(copied);
+  }
+  return copiedSkills;
+}
+
+// src/cli/lib/skills/skill-agent-mappings.ts
+init_esm_shims();
+
+// src/cli/lib/loading/index.ts
+init_esm_shims();
+
+// src/cli/lib/loading/loader.ts
+init_esm_shims();
+import { parse as parseYaml4 } from "yaml";
+import path5 from "path";
+import { unique } from "remeda";
+var FRONTMATTER_REGEX = /^---\n([\s\S]*?)\n---/;
+function parseFrontmatter(content, filePath) {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match) return null;
+  const yamlContent = match[1];
+  const parsed = skillFrontmatterLoaderSchema.safeParse(parseYaml4(yamlContent));
+  if (!parsed.success) {
+    const location = filePath ?? "unknown file";
+    warn(
+      `Invalid SKILL.md frontmatter in ${location}: ${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+    return null;
+  }
+  return parsed.data;
+}
+async function loadAllAgents(projectRoot) {
+  const agents = {};
+  const agentSourcesDir = path5.join(projectRoot, DIRS.agents);
+  const files = await glob("**/agent.yaml", agentSourcesDir);
+  for (const file of files) {
+    const fullPath = path5.join(agentSourcesDir, file);
+    try {
+      const content = await readFile(fullPath);
+      const config = agentYamlConfigSchema.parse(parseYaml4(content));
+      const agentPath = path5.dirname(file);
+      agents[config.id] = {
+        title: config.title,
+        description: config.description,
+        model: config.model,
+        tools: config.tools,
+        path: agentPath,
+        sourceRoot: projectRoot
+      };
+      verbose(`Loaded agent: ${config.id} from ${file}`);
+    } catch (error) {
+      warn(
+        `Skipping invalid agent.yaml at ${fullPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return agents;
+}
+async function loadProjectAgents(projectRoot) {
+  const agents = {};
+  const projectAgentsDir = path5.join(projectRoot, CLAUDE_SRC_DIR, "agents");
+  if (!await directoryExists(projectAgentsDir)) {
+    verbose(`No project agents directory at ${projectAgentsDir}`);
+    return agents;
+  }
+  const files = await glob("**/agent.yaml", projectAgentsDir);
+  for (const file of files) {
+    const fullPath = path5.join(projectAgentsDir, file);
+    try {
+      const content = await readFile(fullPath);
+      const config = agentYamlConfigSchema.parse(parseYaml4(content));
+      const agentPath = path5.dirname(file);
+      agents[config.id] = {
+        title: config.title,
+        description: config.description,
+        model: config.model,
+        tools: config.tools,
+        path: agentPath,
+        sourceRoot: projectRoot,
+        agentBaseDir: `${CLAUDE_SRC_DIR}/agents`
+        // Project agents are in .claude-src/agents/
+      };
+      verbose(`Loaded project agent: ${config.id} from ${file}`);
+    } catch (error) {
+      warn(
+        `Skipping invalid agent.yaml at ${fullPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return agents;
+}
+async function buildIdToDirectoryPathMap(skillsDir) {
+  const map = {};
+  const files = await glob("**/SKILL.md", skillsDir);
+  for (const file of files) {
+    const fullPath = path5.join(skillsDir, file);
+    const content = await readFile(fullPath);
+    const frontmatter = parseFrontmatter(content, fullPath);
+    if (frontmatter?.name) {
+      const directoryPath = file.replace("/SKILL.md", "");
+      map[frontmatter.name] = directoryPath;
+      map[directoryPath] = directoryPath;
+    }
+  }
+  return map;
+}
+async function loadSkillsByIds(skillIds, projectRoot) {
+  const skills = {};
+  const skillsDir = path5.join(projectRoot, DIRS.skills);
+  const idToDirectoryPath = await buildIdToDirectoryPathMap(skillsDir);
+  const allSkillIds = Object.keys(idToDirectoryPath);
+  const expandedSkillIds = [];
+  for (const { id: skillId } of skillIds) {
+    if (idToDirectoryPath[skillId]) {
+      expandedSkillIds.push(skillId);
+    } else {
+      const childSkills = allSkillIds.filter((id) => {
+        const dirPath = idToDirectoryPath[id];
+        return dirPath.startsWith(skillId + "/");
+      });
+      if (childSkills.length > 0) {
+        expandedSkillIds.push(...childSkills);
+        verbose(`Expanded directory '${skillId}' to ${childSkills.length} skills`);
+      } else {
+        console.warn(`  Warning: Unknown skill reference '${skillId}'`);
+      }
+    }
+  }
+  const uniqueSkillIds = unique(expandedSkillIds);
+  for (const skillId of uniqueSkillIds) {
+    const directoryPath = idToDirectoryPath[skillId];
+    if (!directoryPath) {
+      console.warn(`  Warning: Could not find skill ${skillId}: No matching skill found`);
+      continue;
+    }
+    const skillPath = path5.join(skillsDir, directoryPath);
+    const skillMdPath = path5.join(skillPath, "SKILL.md");
+    try {
+      const content = await readFile(skillMdPath);
+      const frontmatter = parseFrontmatter(content, skillMdPath);
+      if (!frontmatter) {
+        warn(`Skipping ${skillId}: Missing or invalid frontmatter`);
+        continue;
+      }
+      const canonicalId = frontmatter.name;
+      const skillDef = {
+        id: canonicalId,
+        path: `${DIRS.skills}/${directoryPath}/`,
+        description: frontmatter.description
+      };
+      skills[canonicalId] = skillDef;
+      if (directoryPath !== canonicalId) {
+        skills[directoryPath] = skillDef;
+      }
+      verbose(`Loaded skill: ${canonicalId} (from ${directoryPath})`);
+    } catch (error) {
+      console.warn(`  Warning: Could not load skill ${skillId}: ${error}`);
+    }
+  }
+  return skills;
+}
+async function loadPluginSkills(pluginDir) {
+  const skills = {};
+  const pluginSkillsDir = path5.join(pluginDir, "skills");
+  if (!await directoryExists(pluginSkillsDir)) {
+    return skills;
+  }
+  const files = await glob("**/SKILL.md", pluginSkillsDir);
+  for (const file of files) {
+    const fullPath = path5.join(pluginSkillsDir, file);
+    const content = await readFile(fullPath);
+    const frontmatter = parseFrontmatter(content, fullPath);
+    if (!frontmatter) {
+      warn(`Skipping ${file}: Missing or invalid frontmatter`);
+      continue;
+    }
+    const folderPath = file.replace("/SKILL.md", "");
+    const skillPath = `skills/${folderPath}/`;
+    const skillId = frontmatter.name;
+    skills[skillId] = {
+      id: skillId,
+      path: skillPath,
+      description: frontmatter.description
+    };
+    verbose(`Loaded plugin skill: ${skillId} from ${file}`);
+  }
+  return skills;
+}
+
+// src/cli/lib/loading/source-loader.ts
+init_esm_shims();
+import path19 from "path";
+
+// src/cli/lib/matrix/index.ts
+init_esm_shims();
+
+// src/cli/lib/matrix/matrix-loader.ts
+init_esm_shims();
+import { parse as parseYaml5 } from "yaml";
+import path6 from "path";
+import { z } from "zod";
+var rawMetadataSchema = z.object({
+  category: categoryPathSchema,
+  category_exclusive: z.boolean().optional(),
+  author: z.string(),
+  version: z.coerce.string(),
+  cli_name: z.string().optional(),
+  cli_description: z.string().optional(),
+  usage_guidance: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  // Lenient: accepts display names and skill IDs from YAML, resolved to canonical IDs during matrix merge
+  compatible_with: z.array(z.string()).optional(),
+  conflicts_with: z.array(z.string()).optional(),
+  requires: z.array(z.string()).optional(),
+  requires_setup: z.array(z.string()).optional(),
+  provides_setup_for: z.array(z.string()).optional()
+});
+async function loadSkillsMatrix(configPath) {
+  const content = await readFile(configPath);
+  const raw = parseYaml5(content);
+  const result = skillsMatrixConfigSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(
+      `Invalid skills matrix at ${configPath}: ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  verbose(`Loaded skills matrix: ${configPath}`);
+  return result.data;
+}
+async function extractAllSkills(skillsDir) {
+  const skills = [];
+  const metadataFiles = await glob("**/metadata.yaml", skillsDir);
+  for (const metadataFile of metadataFiles) {
+    const skillDir = path6.dirname(metadataFile);
+    const skillMdPath = path6.join(skillsDir, skillDir, "SKILL.md");
+    const metadataPath = path6.join(skillsDir, metadataFile);
+    if (!await fileExists(skillMdPath)) {
+      verbose(`Skipping ${metadataFile}: No SKILL.md found`);
+      continue;
+    }
+    const metadataContent = await readFile(metadataPath);
+    const rawMetadata = parseYaml5(metadataContent);
+    const metadataResult = rawMetadataSchema.safeParse(rawMetadata);
+    if (!metadataResult.success) {
+      warn(
+        `Skipping ${metadataFile}: Invalid metadata.yaml \u2014 ${metadataResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+      );
+      continue;
+    }
+    const metadata = metadataResult.data;
+    const skillMdContent = await readFile(skillMdPath);
+    const frontmatter = parseFrontmatter(skillMdContent, skillMdPath);
+    if (!frontmatter) {
+      verbose(`Skipping ${metadataFile}: Invalid SKILL.md frontmatter`);
+      continue;
+    }
+    if (!metadata.cli_name) {
+      throw new Error(
+        `Skill at ${metadataFile} is missing required 'cli_name' field in metadata.yaml`
+      );
+    }
+    const skillId = frontmatter.name;
+    const extracted = {
+      id: skillId,
+      directoryPath: skillDir,
+      description: metadata.cli_description || frontmatter.description,
+      usageGuidance: metadata.usage_guidance,
+      category: metadata.category,
+      categoryExclusive: metadata.category_exclusive ?? true,
+      author: metadata.author,
+      tags: metadata.tags ?? [],
+      compatibleWith: metadata.compatible_with ?? [],
+      conflictsWith: metadata.conflicts_with ?? [],
+      requires: metadata.requires ?? [],
+      requiresSetup: metadata.requires_setup ?? [],
+      providesSetupFor: metadata.provides_setup_for ?? [],
+      path: `skills/${skillDir}/`
+    };
+    skills.push(extracted);
+    verbose(`Extracted skill: ${skillId}`);
+  }
+  return skills;
+}
+function buildReverseDisplayNames(displayNameToId) {
+  const reverse = {};
+  for (const [name, fullId] of Object.entries(displayNameToId)) {
+    const nameResult = skillDisplayNameSchema.safeParse(name);
+    const idResult = skillIdSchema.safeParse(fullId);
+    if (nameResult.success && idResult.success) {
+      reverse[idResult.data] = nameResult.data;
+    } else {
+      warn(
+        `Invalid skill alias mapping: '${name}' -> '${fullId}'${!nameResult.success ? ` (invalid display name: ${nameResult.error.message})` : ""}${!idResult.success ? ` (invalid skill ID: ${idResult.error.message})` : ""}`
+      );
+    }
+  }
+  return reverse;
+}
+function buildAliasTargetToSkillIdMap(displayNameToId, skills) {
+  const map = {};
+  for (const skill of skills) {
+    const parts = skill.id.split("/");
+    const shortForm = parts[parts.length - 1];
+    if (shortForm && shortForm !== skill.id) {
+      map[shortForm] = skill.id;
+    }
+    if (skill.directoryPath && skill.directoryPath !== skill.id) {
+      map[skill.directoryPath] = skill.id;
+    }
+  }
+  const aliasTargets = new Set(Object.values(displayNameToId));
+  for (const skill of skills) {
+    for (const aliasTarget of aliasTargets) {
+      if (aliasTarget !== skill.id && (skill.id.endsWith(`/${aliasTarget}`) || skill.id === aliasTarget)) {
+        map[aliasTarget] = skill.id;
+      }
+    }
+  }
+  return map;
+}
+function buildDirectoryPathToIdMap(skills) {
+  const map = {};
+  for (const skill of skills) {
+    if (skill.directoryPath && skill.directoryPath !== skill.id) {
+      map[skill.directoryPath] = skill.id;
+    }
+  }
+  return map;
+}
+function resolveToCanonicalId(nameOrId, displayNameToId, directoryPathToId = {}, aliasTargetToSkillId = {}, context) {
+  const displayNameResult = displayNameToId[nameOrId];
+  if (displayNameResult) {
+    return displayNameResult;
+  }
+  if (directoryPathToId[nameOrId]) {
+    return directoryPathToId[nameOrId];
+  }
+  if (aliasTargetToSkillId[nameOrId]) {
+    return aliasTargetToSkillId[nameOrId];
+  }
+  if (context) {
+    verbose(`Unresolved ID '${nameOrId}' in ${context} \u2014 passing through as-is`);
+  }
+  return nameOrId;
+}
+async function mergeMatrixWithSkills(matrix, skills) {
+  const displayNameToId = matrix.skill_aliases;
+  const displayNames = buildReverseDisplayNames(displayNameToId);
+  const directoryPathToId = buildDirectoryPathToIdMap(skills);
+  const aliasTargetToSkillId = buildAliasTargetToSkillIdMap(displayNameToId, skills);
+  const resolvedSkills = {};
+  for (const skill of skills) {
+    const resolved = buildResolvedSkill(
+      skill,
+      matrix,
+      displayNameToId,
+      displayNames,
+      directoryPathToId,
+      aliasTargetToSkillId
+    );
+    resolvedSkills[skill.id] = resolved;
+  }
+  const suggestedStacks = resolveSuggestedStacks();
+  const merged = {
+    version: matrix.version,
+    categories: matrix.categories,
+    skills: resolvedSkills,
+    suggestedStacks,
+    displayNameToId,
+    displayNames,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return merged;
+}
+function buildResolvedSkill(skill, matrix, displayNameToId, displayNames, directoryPathToId, aliasTargetToSkillId) {
+  const conflictsWith = [];
+  const recommends = [];
+  const requires = [];
+  const alternatives = [];
+  const discourages = [];
+  const resolve = (id, relationContext) => resolveToCanonicalId(
+    id,
+    displayNameToId,
+    directoryPathToId,
+    aliasTargetToSkillId,
+    relationContext ? `${skill.id} ${relationContext}` : void 0
+  );
+  for (const conflictRef of skill.conflictsWith) {
+    const canonicalId = resolve(conflictRef, "conflictsWith");
+    conflictsWith.push({
+      skillId: canonicalId,
+      reason: "Defined in skill metadata"
+    });
+  }
+  for (const conflictRule of matrix.relationships.conflicts) {
+    const resolvedSkills = conflictRule.skills.map((id) => resolve(id, "conflicts"));
+    if (resolvedSkills.includes(skill.id)) {
+      for (const otherSkill of resolvedSkills) {
+        if (otherSkill !== skill.id) {
+          if (!conflictsWith.some((c) => c.skillId === otherSkill)) {
+            conflictsWith.push({
+              skillId: otherSkill,
+              reason: conflictRule.reason
+            });
+          }
+        }
+      }
+    }
+  }
+  for (const compatRef of skill.compatibleWith) {
+    const canonicalId = resolve(compatRef, "compatibleWith");
+    recommends.push({
+      skillId: canonicalId,
+      reason: "Compatible with this skill"
+    });
+  }
+  for (const recommendRule of matrix.relationships.recommends) {
+    const whenCanonicalId = resolve(recommendRule.when, "recommends.when");
+    if (whenCanonicalId === skill.id) {
+      for (const suggested of recommendRule.suggest) {
+        const canonicalId = resolve(suggested, "recommends.suggest");
+        if (!recommends.some((r) => r.skillId === canonicalId)) {
+          recommends.push({
+            skillId: canonicalId,
+            reason: recommendRule.reason
+          });
+        }
+      }
+    }
+  }
+  if (skill.requires.length > 0) {
+    requires.push({
+      skillIds: skill.requires.map((id) => resolve(id, "requires")),
+      needsAny: false,
+      reason: "Defined in skill metadata"
+    });
+  }
+  for (const requireRule of matrix.relationships.requires) {
+    const skillCanonicalId = resolve(requireRule.skill, "requires.skill");
+    if (skillCanonicalId === skill.id) {
+      requires.push({
+        skillIds: requireRule.needs.map((id) => resolve(id, "requires.needs")),
+        needsAny: requireRule.needs_any ?? false,
+        reason: requireRule.reason
+      });
+    }
+  }
+  for (const altGroup of matrix.relationships.alternatives) {
+    const resolvedAlts = altGroup.skills.map((id) => resolve(id, "alternatives"));
+    if (resolvedAlts.includes(skill.id)) {
+      for (const altSkill of resolvedAlts) {
+        if (altSkill !== skill.id) {
+          alternatives.push({
+            skillId: altSkill,
+            purpose: altGroup.purpose
+          });
+        }
+      }
+    }
+  }
+  if (matrix.relationships.discourages) {
+    for (const discourageRule of matrix.relationships.discourages) {
+      const resolvedSkills = discourageRule.skills.map((id) => resolve(id, "discourages"));
+      if (resolvedSkills.includes(skill.id)) {
+        for (const otherSkill of resolvedSkills) {
+          if (otherSkill !== skill.id) {
+            if (!discourages.some((d) => d.skillId === otherSkill)) {
+              discourages.push({
+                skillId: otherSkill,
+                reason: discourageRule.reason
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  const compatibleWith = skill.compatibleWith.map((id) => resolve(id, "compatibleWith"));
+  return {
+    id: skill.id,
+    displayName: displayNames[skill.id],
+    description: skill.description,
+    usageGuidance: skill.usageGuidance,
+    category: skill.category,
+    categoryExclusive: skill.categoryExclusive,
+    tags: skill.tags,
+    author: skill.author,
+    conflictsWith,
+    recommends,
+    requires,
+    alternatives,
+    discourages,
+    compatibleWith,
+    requiresSetup: skill.requiresSetup.map((id) => resolve(id, "requiresSetup")),
+    providesSetupFor: skill.providesSetupFor.map((id) => resolve(id, "providesSetupFor")),
+    path: skill.path
+  };
+}
+function resolveSuggestedStacks() {
+  return [];
+}
+
+// src/cli/lib/matrix/matrix-resolver.ts
+init_esm_shims();
+import { groupBy } from "remeda";
+function getLabel(skill, fallback) {
+  return skill?.displayName || skill?.id || fallback;
+}
+function resolveAlias(aliasOrId, matrix) {
+  return matrix.displayNameToId[aliasOrId] || aliasOrId;
+}
+function isDisabled(skillId, currentSelections, matrix, options) {
+  if (options?.expertMode) {
+    return false;
+  }
+  const fullId = resolveAlias(skillId, matrix);
+  const skill = matrix.skills[fullId];
+  if (!skill) {
+    return false;
+  }
+  for (const selectedId of currentSelections) {
+    const selectedFullId = resolveAlias(selectedId, matrix);
+    if (skill.conflictsWith.some((c) => c.skillId === selectedFullId)) {
+      return true;
+    }
+    const selectedSkill = matrix.skills[selectedFullId];
+    if (selectedSkill && selectedSkill.conflictsWith.some((c) => c.skillId === fullId)) {
+      return true;
+    }
+  }
+  const resolvedSelections = currentSelections.map((s) => resolveAlias(s, matrix));
+  for (const requirement of skill.requires) {
+    if (requirement.needsAny) {
+      const hasAny = requirement.skillIds.some((reqId) => resolvedSelections.includes(reqId));
+      if (!hasAny) {
+        return true;
+      }
+    } else {
+      const hasAll = requirement.skillIds.every((reqId) => resolvedSelections.includes(reqId));
+      if (!hasAll) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function getDisableReason(skillId, currentSelections, matrix) {
+  const fullId = resolveAlias(skillId, matrix);
+  const skill = matrix.skills[fullId];
+  if (!skill) {
+    return void 0;
+  }
+  const resolvedSelections = currentSelections.map((s) => resolveAlias(s, matrix));
+  for (const selectedId of resolvedSelections) {
+    const conflict = skill.conflictsWith.find((c) => c.skillId === selectedId);
+    if (conflict) {
+      const selectedSkill2 = matrix.skills[selectedId];
+      return `${conflict.reason} (conflicts with ${getLabel(selectedSkill2, selectedId)})`;
+    }
+    const selectedSkill = matrix.skills[selectedId];
+    if (selectedSkill) {
+      const reverseConflict = selectedSkill.conflictsWith.find((c) => c.skillId === fullId);
+      if (reverseConflict) {
+        return `${reverseConflict.reason} (conflicts with ${getLabel(selectedSkill, selectedId)})`;
+      }
+    }
+  }
+  for (const requirement of skill.requires) {
+    if (requirement.needsAny) {
+      const hasAny = requirement.skillIds.some((reqId) => resolvedSelections.includes(reqId));
+      if (!hasAny) {
+        const requiredNames = requirement.skillIds.map((id) => getLabel(matrix.skills[id], id)).join(" or ");
+        return `${requirement.reason} (requires ${requiredNames})`;
+      }
+    } else {
+      const missingIds = requirement.skillIds.filter(
+        (reqId) => !resolvedSelections.includes(reqId)
+      );
+      if (missingIds.length > 0) {
+        const missingNames = missingIds.map((id) => getLabel(matrix.skills[id], id)).join(", ");
+        return `${requirement.reason} (requires ${missingNames})`;
+      }
+    }
+  }
+  return void 0;
+}
+function isDiscouraged(skillId, currentSelections, matrix) {
+  const fullId = resolveAlias(skillId, matrix);
+  const skill = matrix.skills[fullId];
+  if (!skill) {
+    return false;
+  }
+  const resolvedSelections = currentSelections.map((s) => resolveAlias(s, matrix));
+  for (const selectedId of resolvedSelections) {
+    const selectedSkill = matrix.skills[selectedId];
+    if (selectedSkill && selectedSkill.discourages.some((d) => d.skillId === fullId)) {
+      return true;
+    }
+    if (skill.discourages.some((d) => d.skillId === selectedId)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getDiscourageReason(skillId, currentSelections, matrix) {
+  const fullId = resolveAlias(skillId, matrix);
+  const skill = matrix.skills[fullId];
+  if (!skill) {
+    return void 0;
+  }
+  const resolvedSelections = currentSelections.map((s) => resolveAlias(s, matrix));
+  for (const selectedId of resolvedSelections) {
+    const selectedSkill = matrix.skills[selectedId];
+    if (selectedSkill) {
+      const discourage = selectedSkill.discourages.find((d) => d.skillId === fullId);
+      if (discourage) {
+        return discourage.reason;
+      }
+    }
+    const reverseDiscourage = skill.discourages.find((d) => d.skillId === selectedId);
+    if (reverseDiscourage) {
+      return reverseDiscourage.reason;
+    }
+  }
+  return void 0;
+}
+function isRecommended(skillId, currentSelections, matrix) {
+  const fullId = resolveAlias(skillId, matrix);
+  const skill = matrix.skills[fullId];
+  if (!skill) {
+    return false;
+  }
+  const resolvedSelections = currentSelections.map((s) => resolveAlias(s, matrix));
+  for (const selectedId of resolvedSelections) {
+    const selectedSkill = matrix.skills[selectedId];
+    if (selectedSkill && selectedSkill.recommends.some((r) => r.skillId === fullId)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getRecommendReason(skillId, currentSelections, matrix) {
+  const fullId = resolveAlias(skillId, matrix);
+  const skill = matrix.skills[fullId];
+  if (!skill) {
+    return void 0;
+  }
+  const resolvedSelections = currentSelections.map((s) => resolveAlias(s, matrix));
+  for (const selectedId of resolvedSelections) {
+    const selectedSkill = matrix.skills[selectedId];
+    if (selectedSkill) {
+      const recommendation = selectedSkill.recommends.find((r) => r.skillId === fullId);
+      if (recommendation) {
+        return `${recommendation.reason} (recommended by ${getLabel(selectedSkill, selectedId)})`;
+      }
+    }
+  }
+  return void 0;
+}
+function validateSelection(selections, matrix) {
+  const errors = [];
+  const warnings = [];
+  const resolvedSelections = selections.map((s) => resolveAlias(s, matrix));
+  for (let i = 0; i < resolvedSelections.length; i++) {
+    const skillA = matrix.skills[resolvedSelections[i]];
+    if (!skillA) continue;
+    for (let j = i + 1; j < resolvedSelections.length; j++) {
+      const skillBId = resolvedSelections[j];
+      const conflict = skillA.conflictsWith.find((c) => c.skillId === skillBId);
+      if (conflict) {
+        errors.push({
+          type: "conflict",
+          message: `${getLabel(skillA, skillA.id)} conflicts with ${getLabel(matrix.skills[skillBId], skillBId)}: ${conflict.reason}`,
+          skills: [skillA.id, skillBId]
+        });
+      }
+    }
+  }
+  for (const skillId of resolvedSelections) {
+    const skill = matrix.skills[skillId];
+    if (!skill) continue;
+    for (const requirement of skill.requires) {
+      if (requirement.needsAny) {
+        const hasAny = requirement.skillIds.some((reqId) => resolvedSelections.includes(reqId));
+        if (!hasAny) {
+          errors.push({
+            type: "missing_requirement",
+            message: `${getLabel(skill, skillId)} requires one of: ${requirement.skillIds.map((id) => getLabel(matrix.skills[id], id)).join(", ")}`,
+            skills: [skillId, ...requirement.skillIds]
+          });
+        }
+      } else {
+        const missingIds = requirement.skillIds.filter(
+          (reqId) => !resolvedSelections.includes(reqId)
+        );
+        if (missingIds.length > 0) {
+          errors.push({
+            type: "missing_requirement",
+            message: `${getLabel(skill, skillId)} requires: ${missingIds.map((id) => getLabel(matrix.skills[id], id)).join(", ")}`,
+            skills: [skillId, ...missingIds]
+          });
+        }
+      }
+    }
+  }
+  const validSkills = resolvedSelections.map((skillId) => ({ skillId, skill: matrix.skills[skillId] })).filter((entry) => entry.skill != null);
+  const categorySelections = groupBy(validSkills, (entry) => entry.skill.category);
+  for (const [categoryId, entries] of typedEntries(categorySelections)) {
+    if (entries.length > 1) {
+      const skillIds = entries.map((e) => e.skillId);
+      const category = matrix.categories[categoryId];
+      if (category?.exclusive) {
+        errors.push({
+          type: "category_exclusive",
+          message: `Category "${category.displayName}" only allows one selection, but multiple selected: ${skillIds.map((id) => getLabel(matrix.skills[id], id)).join(", ")}`,
+          skills: skillIds
+        });
+      }
+    }
+  }
+  for (const skillId of resolvedSelections) {
+    const skill = matrix.skills[skillId];
+    if (!skill) continue;
+    for (const recommendation of skill.recommends) {
+      if (!resolvedSelections.includes(recommendation.skillId)) {
+        const recommendedSkill = matrix.skills[recommendation.skillId];
+        if (recommendedSkill) {
+          const hasConflict = recommendedSkill.conflictsWith.some(
+            (c) => resolvedSelections.includes(c.skillId)
+          );
+          if (!hasConflict) {
+            warnings.push({
+              type: "missing_recommendation",
+              message: `${getLabel(skill, skillId)} recommends ${getLabel(recommendedSkill, recommendation.skillId)}: ${recommendation.reason}`,
+              skills: [skillId, recommendation.skillId]
+            });
+          }
+        }
+      }
+    }
+  }
+  for (const skillId of resolvedSelections) {
+    const skill = matrix.skills[skillId];
+    if (!skill || skill.providesSetupFor.length === 0) continue;
+    const hasUsageSkill = skill.providesSetupFor.some(
+      (usageId) => resolvedSelections.includes(usageId)
+    );
+    if (!hasUsageSkill) {
+      warnings.push({
+        type: "unused_setup",
+        message: `Setup skill "${getLabel(skill, skillId)}" selected but no corresponding usage skills: ${skill.providesSetupFor.map((id) => getLabel(matrix.skills[id], id)).join(", ")}`,
+        skills: [skillId, ...skill.providesSetupFor]
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function getAvailableSkills(categoryId, currentSelections, matrix, options) {
+  const skillOptions = [];
+  const resolvedSelections = currentSelections.map((s) => resolveAlias(s, matrix));
+  for (const skill of Object.values(matrix.skills)) {
+    if (!skill) continue;
+    if (skill.category !== categoryId) {
+      continue;
+    }
+    const disabled = isDisabled(skill.id, currentSelections, matrix, options);
+    const discouraged = !disabled && isDiscouraged(skill.id, currentSelections, matrix);
+    const recommended = !disabled && !discouraged && isRecommended(skill.id, currentSelections, matrix);
+    skillOptions.push({
+      id: skill.id,
+      displayName: skill.displayName,
+      description: skill.description,
+      disabled,
+      disabledReason: disabled ? getDisableReason(skill.id, currentSelections, matrix) : void 0,
+      discouraged,
+      discouragedReason: discouraged ? getDiscourageReason(skill.id, currentSelections, matrix) : void 0,
+      recommended,
+      recommendedReason: recommended ? getRecommendReason(skill.id, currentSelections, matrix) : void 0,
+      selected: resolvedSelections.includes(skill.id),
+      alternatives: skill.alternatives.map((a) => a.skillId)
+    });
+  }
+  return skillOptions;
+}
+
+// src/cli/lib/matrix/matrix-health-check.ts
+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);
+  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;
+    if (!cat.domain) {
+      issues.push({
+        severity: "warning",
+        finding: "category-missing-domain",
+        details: `Category '${catId}' has no domain \u2014 it won't appear in any wizard domain view`
+      });
+    }
+  }
+}
+function checkSkillCategories(matrix, issues) {
+  for (const [skillId, skill] of typedEntries(matrix.skills)) {
+    if (!skill) continue;
+    if (!matrix.categories[skill.category]) {
+      issues.push({
+        severity: "warning",
+        finding: "skill-unknown-category",
+        details: `Skill '${skillId}' references category '${skill.category}' which does not exist in the matrix`
+      });
+    }
+  }
+}
+function checkCompatibleWithTargets(matrix, skillIds, 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`
+        });
+      }
+    }
+  }
+}
+function checkStackSkillIds(matrix, skillIds, issues) {
+  for (const stack of matrix.suggestedStacks) {
+    for (const stackSkillId of stack.allSkillIds) {
+      if (!skillIds.has(stackSkillId)) {
+        issues.push({
+          severity: "warning",
+          finding: "stack-ghost-skill",
+          details: `Stack '${stack.id}' references skill '${stackSkillId}' which does not exist in the matrix`
+        });
+      }
+    }
+  }
+}
+
+// src/cli/lib/loading/multi-source-loader.ts
+init_esm_shims();
+import path18 from "path";
+
+// src/cli/lib/plugins/index.ts
+init_esm_shims();
+
+// src/cli/lib/plugins/plugin-manifest.ts
+init_esm_shims();
+import path7 from "path";
+var PLUGIN_DIR_NAME = ".claude-plugin";
+var PLUGIN_MANIFEST_FILE2 = "plugin.json";
+var SKILL_PLUGIN_PREFIX = "";
+var AGENT_PLUGIN_PREFIX = "agent-";
+function buildAuthor(name, email) {
+  if (!name) {
+    return void 0;
+  }
+  const author = { name };
+  if (email) {
+    author.email = email;
+  }
+  return author;
+}
+function generateSkillPluginManifest(options) {
+  const manifest = {
+    name: `${SKILL_PLUGIN_PREFIX}${options.skillName}`,
+    version: options.version ?? DEFAULT_VERSION,
+    skills: "./skills/"
+  };
+  if (options.description) {
+    manifest.description = options.description;
+  }
+  const author = buildAuthor(options.author, options.authorEmail);
+  if (author) {
+    manifest.author = author;
+  }
+  if (options.keywords && options.keywords.length > 0) {
+    manifest.keywords = options.keywords;
+  }
+  return manifest;
+}
+function generateAgentPluginManifest(options) {
+  const manifest = {
+    name: `${AGENT_PLUGIN_PREFIX}${options.agentName}`,
+    version: options.version ?? DEFAULT_VERSION,
+    agents: "./agents/"
+  };
+  if (options.description) {
+    manifest.description = options.description;
+  }
+  return manifest;
+}
+function generateStackPluginManifest(options) {
+  const manifest = {
+    name: options.stackName,
+    version: options.version ?? DEFAULT_VERSION
+  };
+  if (options.hasSkills) {
+    manifest.skills = "./skills/";
+  }
+  if (options.description) {
+    manifest.description = options.description;
+  }
+  const author = buildAuthor(options.author, options.authorEmail);
+  if (author) {
+    manifest.author = author;
+  }
+  if (options.keywords && options.keywords.length > 0) {
+    manifest.keywords = options.keywords;
+  }
+  if (options.hasHooks) {
+    manifest.hooks = "./hooks/hooks.json";
+  }
+  return manifest;
+}
+async function writePluginManifest(outputDir, manifest) {
+  const pluginDir = path7.join(outputDir, PLUGIN_DIR_NAME);
+  const manifestPath = path7.join(pluginDir, PLUGIN_MANIFEST_FILE2);
+  await ensureDir(pluginDir);
+  const content = JSON.stringify(manifest, null, 2);
+  await writeFile(manifestPath, content);
+  return manifestPath;
+}
+
+// src/cli/lib/plugins/plugin-manifest-finder.ts
+init_esm_shims();
+import path8 from "path";
+async function findPluginManifest(startDir) {
+  let currentDir = startDir;
+  const root = path8.parse(currentDir).root;
+  while (currentDir !== root) {
+    const manifestPath = path8.join(currentDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+    if (await fileExists(manifestPath)) {
+      return manifestPath;
+    }
+    currentDir = path8.dirname(currentDir);
+  }
+  return null;
+}
+
+// src/cli/lib/plugins/plugin-finder.ts
+init_esm_shims();
+import path9 from "path";
+function getCollectivePluginDir(projectDir) {
+  const dir = projectDir ?? process.cwd();
+  return path9.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR, "claude-collective");
+}
+function getProjectPluginsDir(projectDir) {
+  const dir = projectDir ?? process.cwd();
+  return path9.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR);
+}
+function getPluginSkillsDir(pluginDir) {
+  return path9.join(pluginDir, "skills");
+}
+function getPluginAgentsDir(pluginDir) {
+  return path9.join(pluginDir, "agents");
+}
+function getPluginManifestPath(pluginDir) {
+  return path9.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+}
+async function readPluginManifest(pluginDir) {
+  const manifestPath = getPluginManifestPath(pluginDir);
+  if (!await fileExists(manifestPath)) {
+    verbose(`  No manifest at ${manifestPath}`);
+    return null;
+  }
+  try {
+    const content = await readFile(manifestPath);
+    const manifest = pluginManifestSchema.parse(JSON.parse(content));
+    if (!manifest.name || typeof manifest.name !== "string") {
+      verbose(`  Invalid manifest at ${manifestPath}: missing name`);
+      return null;
+    }
+    return manifest;
+  } catch (error) {
+    verbose(`  Failed to parse manifest at ${manifestPath}: ${error}`);
+    return null;
+  }
+}
+async function getPluginSkillIds(pluginSkillsDir, matrix) {
+  const skillFiles = await glob("**/SKILL.md", pluginSkillsDir);
+  const skillIds = [];
+  const aliasToId = /* @__PURE__ */ new Map();
+  for (const [id, skill] of Object.entries(matrix.skills)) {
+    if (!skill) continue;
+    if (skill.displayName) {
+      aliasToId.set(skill.displayName.toLowerCase(), id);
+    }
+  }
+  const dirToId = /* @__PURE__ */ new Map();
+  for (const [id] of Object.entries(matrix.skills)) {
+    const idParts = id.split("/");
+    const lastPart = idParts[idParts.length - 1];
+    if (lastPart) {
+      dirToId.set(lastPart.toLowerCase(), id);
+    }
+  }
+  for (const skillFile of skillFiles) {
+    const fullPath = path9.join(pluginSkillsDir, skillFile);
+    const content = await readFile(fullPath);
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+      const frontmatter = frontmatterMatch[1];
+      const nameMatch = frontmatter.match(/^name:\s*["']?(.+?)["']?\s*$/m);
+      if (nameMatch) {
+        const skillName = nameMatch[1].trim();
+        if (matrix.skills[skillName]) {
+          skillIds.push(skillName);
+          continue;
+        }
+        const skillId2 = aliasToId.get(skillName.toLowerCase());
+        if (skillId2) {
+          skillIds.push(skillId2);
+          continue;
+        }
+      }
+    }
+    const dirPath = path9.dirname(skillFile);
+    const dirName = path9.basename(dirPath);
+    const skillId = dirToId.get(dirName.toLowerCase());
+    if (skillId) {
+      skillIds.push(skillId);
+    }
+  }
+  return skillIds;
+}
+
+// src/cli/lib/plugins/plugin-info.ts
+init_esm_shims();
+import { readdir } from "fs/promises";
+import { countBy } from "remeda";
+
+// src/cli/lib/installation/index.ts
+init_esm_shims();
+
+// src/cli/lib/installation/installation.ts
+init_esm_shims();
+import path10 from "path";
+async function detectInstallation(projectDir = process.cwd()) {
+  const srcConfigPath = path10.join(projectDir, CLAUDE_SRC_DIR, "config.yaml");
+  const legacyConfigPath = path10.join(projectDir, CLAUDE_DIR, "config.yaml");
+  const localConfigPath = await fileExists(srcConfigPath) ? srcConfigPath : await fileExists(legacyConfigPath) ? legacyConfigPath : null;
+  if (localConfigPath) {
+    const loaded = await loadProjectConfig(projectDir);
+    const mode = loaded?.config?.installMode ?? "local";
+    if (mode === "local") {
+      return {
+        mode: "local",
+        configPath: localConfigPath,
+        agentsDir: path10.join(projectDir, CLAUDE_DIR, "agents"),
+        skillsDir: path10.join(projectDir, CLAUDE_DIR, "skills"),
+        projectDir
+      };
+    }
+  }
+  const pluginDir = getCollectivePluginDir(projectDir);
+  const pluginConfigPath = path10.join(pluginDir, "config.yaml");
+  if (await directoryExists(pluginDir)) {
+    return {
+      mode: "plugin",
+      configPath: pluginConfigPath,
+      agentsDir: path10.join(pluginDir, "agents"),
+      skillsDir: path10.join(pluginDir, "skills"),
+      projectDir
+    };
+  }
+  return null;
+}
+
+// src/cli/lib/installation/local-installer.ts
+init_esm_shims();
+import path15 from "path";
+import { stringify as stringifyYaml4 } from "yaml";
+
+// src/cli/lib/stacks/index.ts
+init_esm_shims();
+
+// src/cli/lib/stacks/stacks-loader.ts
+init_esm_shims();
+import { parse as parseYaml6 } from "yaml";
+import path11 from "path";
+import { mapValues } from "remeda";
+var STACKS_FILE = "config/stacks.yaml";
+var stacksCache = /* @__PURE__ */ new Map();
+async function loadStacks(configDir) {
+  const cacheKey = configDir;
+  const cached = stacksCache.get(cacheKey);
+  if (cached) return cached;
+  const stacksPath = path11.join(configDir, STACKS_FILE);
+  if (!await fileExists(stacksPath)) {
+    verbose(`No stacks file found at ${stacksPath}`);
+    return [];
+  }
+  try {
+    const content = await readFile(stacksPath);
+    const result = stacksConfigSchema.safeParse(parseYaml6(content));
+    if (!result.success) {
+      throw new Error(
+        `Invalid stacks.yaml at ${stacksPath}: ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+      );
+    }
+    const config = result.data;
+    stacksCache.set(cacheKey, config.stacks);
+    verbose(`Loaded ${config.stacks.length} stacks from ${stacksPath}`);
+    return config.stacks;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load stacks from '${stacksPath}': ${errorMessage}`);
+  }
+}
+async function loadStackById(stackId, configDir) {
+  const stacks = await loadStacks(configDir);
+  const stack = stacks.find((s) => s.id === stackId);
+  if (!stack) {
+    verbose(`Stack '${stackId}' not found`);
+    return null;
+  }
+  verbose(`Found stack: ${stack.name} (${stackId})`);
+  return stack;
+}
+function resolveAgentConfigToSkills(agentConfig, displayNameToId) {
+  const skillRefs = [];
+  for (const [subcategory, technologyDisplayName] of Object.entries(agentConfig)) {
+    const fullSkillId = displayNameToId[technologyDisplayName];
+    if (!fullSkillId) {
+      warn(
+        `No skill found for display name '${technologyDisplayName}' (subcategory: ${subcategory}) in stack config. Skipping.`
+      );
+      continue;
+    }
+    const isKeySkill = KEY_SUBCATEGORIES.has(subcategory);
+    skillRefs.push({
+      id: fullSkillId,
+      usage: `when working with ${subcategory}`,
+      preloaded: isKeySkill
+    });
+  }
+  return skillRefs;
+}
+
+// src/cli/lib/stacks/stack-installer.ts
+init_esm_shims();
+import os from "os";
+import path14 from "path";
+
+// src/cli/lib/stacks/stack-plugin-compiler.ts
+init_esm_shims();
+import path13 from "path";
+
+// src/cli/lib/compiler.ts
+init_esm_shims();
+import { Liquid } from "liquidjs";
+import path12 from "path";
+import { pipe, flatMap, filter, uniqueBy } from "remeda";
+
+// src/cli/lib/resolver.ts
+init_esm_shims();
+function resolveSkillReference(ref, skills) {
+  const definition = skills[ref.id];
+  if (!definition) {
+    verbose(`Skill '${ref.id}' not found in available skills, skipping`);
+    return null;
+  }
+  return {
+    ...definition,
+    usage: ref.usage,
+    preloaded: ref.preloaded ?? false
+  };
+}
+function resolveSkillReferences(skillRefs, skills) {
+  return skillRefs.map((ref) => resolveSkillReference(ref, skills)).filter((skill) => skill !== null);
+}
+function buildSkillRefsFromConfig(agentStack) {
+  const skillRefs = [];
+  for (const [subcategory, skillId] of typedEntries(agentStack)) {
+    skillRefs.push({
+      id: skillId,
+      usage: `when working with ${subcategory}`,
+      preloaded: KEY_SUBCATEGORIES.has(subcategory)
+    });
+  }
+  return skillRefs;
+}
+function resolveAgentSkillsFromStack(agentName, stack, displayNameToId) {
+  const agentConfig = stack.agents[agentName];
+  if (!agentConfig) {
+    verbose(`Agent '${agentName}' not found in stack '${stack.id}'`);
+    return [];
+  }
+  if (typedKeys(agentConfig).length === 0) {
+    verbose(`Agent '${agentName}' has no technology config in stack '${stack.id}'`);
+    return [];
+  }
+  const skillRefs = [];
+  for (const [subcategory, technologyDisplayName] of typedEntries(
+    agentConfig
+  )) {
+    const fullSkillId = displayNameToId[technologyDisplayName];
+    if (!fullSkillId) {
+      verbose(
+        `Warning: No skill found for display name '${technologyDisplayName}' (agent: ${agentName}, subcategory: ${subcategory}). Skipping.`
+      );
+      continue;
+    }
+    const isKeySkill = KEY_SUBCATEGORIES.has(subcategory);
+    skillRefs.push({
+      id: fullSkillId,
+      usage: `when working with ${subcategory}`,
+      preloaded: isKeySkill
+    });
+  }
+  verbose(`Resolved ${skillRefs.length} skills for agent '${agentName}' from stack '${stack.id}'`);
+  return skillRefs;
+}
+async function getAgentSkills(agentName, agentConfig, stack, displayNameToId) {
+  if (agentConfig.skills && agentConfig.skills.length > 0) {
+    return agentConfig.skills;
+  }
+  if (stack && displayNameToId) {
+    const stackSkills = resolveAgentSkillsFromStack(agentName, stack, displayNameToId);
+    if (stackSkills.length > 0) {
+      verbose(`Resolved ${stackSkills.length} skills from stack for ${agentName}`);
+      return stackSkills;
+    }
+  }
+  return [];
+}
+async function resolveAgents(agents, skills, compileConfig, _projectRoot, stack, displayNameToId) {
+  const resolved = {};
+  const agentNames = typedKeys(compileConfig.agents);
+  for (const agentName of agentNames) {
+    const definition = agents[agentName];
+    if (!definition) {
+      const availableAgents = typedKeys(agents);
+      const agentList = availableAgents.length > 0 ? `Available agents: ${availableAgents.slice(0, 5).join(", ")}${availableAgents.length > 5 ? ` (and ${availableAgents.length - 5} more)` : ""}` : "No agents found in scanned directories";
+      throw new Error(
+        `Agent '${agentName}' referenced in compile config but not found in scanned agents. ${agentList}. Check that src/agents/${agentName}/agent.yaml exists.`
+      );
+    }
+    const agentConfig = compileConfig.agents[agentName];
+    const skillRefs = await getAgentSkills(agentName, agentConfig, stack, displayNameToId);
+    const resolvedSkills = resolveSkillReferences(skillRefs, skills);
+    resolved[agentName] = {
+      name: agentName,
+      title: definition.title,
+      description: definition.description,
+      model: definition.model,
+      tools: definition.tools,
+      skills: resolvedSkills,
+      path: definition.path,
+      sourceRoot: definition.sourceRoot,
+      agentBaseDir: definition.agentBaseDir
+    };
+  }
+  return resolved;
+}
+function stackToCompileConfig(stackId, stack) {
+  const agents = {};
+  for (const agentId of stack.agents) {
+    agents[agentId] = {};
+  }
+  return {
+    name: stack.name,
+    description: stack.description || "",
+    stack: stackId,
+    agents
+  };
+}
+
+// src/cli/utils/frontmatter.ts
+init_esm_shims();
+import { parse as parseYaml7 } from "yaml";
+function extractFrontmatter(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/;
+  const match = content.match(frontmatterRegex);
+  if (!match || !match[1]) {
+    return null;
+  }
+  try {
+    return parseYaml7(match[1]);
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/lib/compiler.ts
+async function createLiquidEngine(projectDir) {
+  const roots = [];
+  if (projectDir) {
+    const srcTemplatesDir = path12.join(projectDir, CLAUDE_SRC_DIR, "agents", "_templates");
+    if (await directoryExists(srcTemplatesDir)) {
+      roots.push(srcTemplatesDir);
+      verbose(`Using local templates from: ${srcTemplatesDir}`);
+    }
+    const legacyTemplatesDir = path12.join(projectDir, CLAUDE_DIR, "templates");
+    if (await directoryExists(legacyTemplatesDir)) {
+      roots.push(legacyTemplatesDir);
+      verbose(`Using legacy templates from: ${legacyTemplatesDir}`);
+    }
+  }
+  roots.push(path12.join(PROJECT_ROOT, DIRS.templates));
+  return new Liquid({
+    root: roots,
+    extname: ".liquid",
+    strictVariables: false,
+    strictFilters: true
+  });
+}
+
+// src/cli/lib/stacks/stack-plugin-compiler.ts
+import { unique as unique2 } from "remeda";
+function hashStackConfig(stack) {
+  const stackSkillIds = stack.stack ? [...new Set(Object.values(stack.stack).flatMap((a) => Object.values(a)))].sort() : [];
+  const parts = [
+    `name:${stack.name}`,
+    `description:${stack.description ?? ""}`,
+    `skills:${stackSkillIds.join(",")}`,
+    `agents:${(stack.agents || []).sort().join(",")}`
+  ];
+  return hashString(parts.join("\n"));
+}
+async function compileAgentForPlugin(name, agent, fallbackRoot, engine, installMode) {
+  verbose(`Compiling agent: ${name}`);
+  const agentSourceRoot = agent.sourceRoot || fallbackRoot;
+  const agentBaseDir = agent.agentBaseDir || DIRS.agents;
+  const agentDir = path13.join(agentSourceRoot, agentBaseDir, agent.path || name);
+  const intro = await readFile(path13.join(agentDir, "intro.md"));
+  const workflow = await readFile(path13.join(agentDir, "workflow.md"));
+  const examples = await readFileOptional(
+    path13.join(agentDir, "examples.md"),
+    "## Examples\n\n_No examples defined._"
+  );
+  const criticalRequirementsTop = await readFileOptional(
+    path13.join(agentDir, "critical-requirements.md"),
+    ""
+  );
+  const criticalReminders = await readFileOptional(
+    path13.join(agentDir, "critical-reminders.md"),
+    ""
+  );
+  const agentPath = agent.path || name;
+  const category = agentPath.split("/")[0];
+  const categoryDir = path13.join(agentSourceRoot, agentBaseDir, category);
+  let outputFormat = await readFileOptional(path13.join(agentDir, "output-format.md"), "");
+  if (!outputFormat) {
+    outputFormat = await readFileOptional(path13.join(categoryDir, "output-format.md"), "");
+  }
+  const skills = installMode === "plugin" ? agent.skills.map((s) => ({ ...s, pluginRef: `${s.id}:${s.id}` })) : agent.skills;
+  const preloadedSkills = skills.filter((s) => s.preloaded);
+  const dynamicSkills = skills.filter((s) => !s.preloaded);
+  const preloadedSkillIds = preloadedSkills.map((s) => s.pluginRef ?? s.id);
+  verbose(
+    `Skills for ${name}: ${preloadedSkills.length} preloaded, ${dynamicSkills.length} dynamic`
+  );
+  const data = {
+    agent,
+    intro,
+    workflow,
+    examples,
+    criticalRequirementsTop,
+    criticalReminders,
+    outputFormat,
+    skills,
+    preloadedSkills,
+    dynamicSkills,
+    preloadedSkillIds
+  };
+  return engine.renderFile("agent", data);
+}
+function generateStackReadme(stackId, stack, agents, skillPlugins) {
+  const lines = [];
+  lines.push(`# ${stack.name}`);
+  lines.push("");
+  lines.push(stack.description || "A Claude Code stack plugin.");
+  lines.push("");
+  lines.push("## Installation");
+  lines.push("");
+  lines.push("Add this plugin to your Claude Code configuration:");
+  lines.push("");
+  lines.push("```json");
+  lines.push(`{`);
+  lines.push(`  "plugins": ["${stackId}"]`);
+  lines.push(`}`);
+  lines.push("```");
+  lines.push("");
+  lines.push("## Agents");
+  lines.push("");
+  lines.push("This stack includes the following agents:");
+  lines.push("");
+  for (const agent of agents) {
+    lines.push(`- \`${agent}\``);
+  }
+  lines.push("");
+  if (skillPlugins.length > 0) {
+    lines.push("## Included Skills");
+    lines.push("");
+    lines.push("This stack includes the following skills:");
+    lines.push("");
+    const uniqueSkills = unique2(skillPlugins).sort();
+    for (const skill of uniqueSkills) {
+      lines.push(`- \`${skill}\``);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Generated by Claude Collective stack-plugin-compiler*");
+  lines.push("");
+  return lines.join("\n");
+}
+async function compileStackPlugin(options) {
+  const { stackId, outputDir, projectRoot, agentSourcePath } = options;
+  const localAgentRoot = agentSourcePath || projectRoot;
+  verbose(`Compiling stack plugin: ${stackId}`);
+  verbose(`  Stack/skills source: ${projectRoot}`);
+  verbose(`  Local agent source: ${localAgentRoot}`);
+  verbose(`  CLI agent source: ${PROJECT_ROOT}`);
+  const cliAgents = await loadAllAgents(PROJECT_ROOT);
+  const localAgents = await loadAllAgents(localAgentRoot);
+  const agents = { ...cliAgents, ...localAgents };
+  verbose(
+    `  Loaded ${Object.keys(localAgents).length} local agents, ${Object.keys(cliAgents).length} CLI agents`
+  );
+  const newStack = options.stack || await loadStackById(stackId, PROJECT_ROOT);
+  const matrixPath = path13.join(PROJECT_ROOT, SKILLS_MATRIX_PATH);
+  const matrix = await loadSkillsMatrix(matrixPath);
+  const skillAliases = matrix.skill_aliases || {};
+  let stack;
+  if (newStack) {
+    verbose(`  Found stack: ${newStack.name}`);
+    const agentSkillIds = /* @__PURE__ */ new Set();
+    for (const agentName of typedKeys(newStack.agents)) {
+      const agentConfig = newStack.agents[agentName];
+      if (!agentConfig) continue;
+      const skillRefs = resolveAgentConfigToSkills(agentConfig, skillAliases);
+      for (const ref of skillRefs) {
+        agentSkillIds.add(ref.id);
+      }
+    }
+    stack = {
+      name: newStack.name,
+      description: newStack.description,
+      agents: typedKeys(newStack.agents),
+      skills: [...agentSkillIds],
+      stack: buildStackProperty(newStack, skillAliases)
+    };
+  } else {
+    throw new Error(`Stack '${stackId}' not found in config/stacks.yaml`);
+  }
+  const stackSkillIds = stack.stack ? [...new Set(Object.values(stack.stack).flatMap((a) => Object.values(a)))] : [];
+  const skills = await loadSkillsByIds(
+    stackSkillIds.map((id) => ({ id })),
+    projectRoot
+  );
+  const compileConfig = stackToCompileConfig(stackId, stack);
+  const resolvedAgents = await resolveAgents(
+    agents,
+    skills,
+    compileConfig,
+    projectRoot,
+    newStack,
+    skillAliases
+  );
+  const pluginDir = path13.join(outputDir, stackId);
+  const agentsDir = path13.join(pluginDir, "agents");
+  await ensureDir(pluginDir);
+  await ensureDir(agentsDir);
+  const pluginSkillsDir = path13.join(pluginDir, "skills");
+  await ensureDir(pluginSkillsDir);
+  const copiedSourcePaths = /* @__PURE__ */ new Set();
+  for (const resolvedSkill of Object.values(skills)) {
+    const sourceSkillDir = path13.join(projectRoot, resolvedSkill.path);
+    if (copiedSourcePaths.has(resolvedSkill.path)) {
+      continue;
+    }
+    const destSkillDir = path13.join(pluginSkillsDir, resolvedSkill.id);
+    if (await directoryExists(sourceSkillDir)) {
+      await copy(sourceSkillDir, destSkillDir);
+      copiedSourcePaths.add(resolvedSkill.path);
+      verbose(`  Copied skill: ${resolvedSkill.id}`);
+    } else {
+      verbose(`  Warning: Skill directory not found: ${sourceSkillDir}`);
+    }
+  }
+  const engine = await createLiquidEngine();
+  const compiledAgentNames = [];
+  const allSkillPlugins = [];
+  for (const [name, agent] of typedEntries(resolvedAgents)) {
+    const output = await compileAgentForPlugin(name, agent, PROJECT_ROOT, engine);
+    await writeFile(path13.join(agentsDir, `${name}.md`), output);
+    compiledAgentNames.push(name);
+    for (const skill of agent.skills) {
+      allSkillPlugins.push(skill.id);
+    }
+    verbose(`  Compiled agent: ${name}`);
+  }
+  const stackDir = path13.join(projectRoot, DIRS.stacks, stackId);
+  const claudeMdPath = path13.join(stackDir, "CLAUDE.md");
+  if (await fileExists(claudeMdPath)) {
+    const claudeContent = await readFile(claudeMdPath);
+    await writeFile(path13.join(pluginDir, "CLAUDE.md"), claudeContent);
+    verbose(`  Copied CLAUDE.md`);
+  }
+  const newHash = hashStackConfig(stack);
+  const { version, contentHash } = await determinePluginVersion(
+    newHash,
+    pluginDir,
+    getPluginManifestPath
+  );
+  const uniqueSkillPlugins = unique2(allSkillPlugins);
+  const manifest = generateStackPluginManifest({
+    stackName: stackId,
+    description: stack.description,
+    author: stack.author,
+    version,
+    keywords: void 0,
+    hasAgents: true,
+    hasHooks: false,
+    hasSkills: true
+  });
+  await writePluginManifest(pluginDir, manifest);
+  await writeContentHash(pluginDir, contentHash, getPluginManifestPath);
+  verbose(`  Wrote plugin.json (v${version})`);
+  const readme = generateStackReadme(stackId, stack, compiledAgentNames, uniqueSkillPlugins);
+  await writeFile(path13.join(pluginDir, "README.md"), readme);
+  verbose(`  Generated README.md`);
+  return {
+    pluginPath: pluginDir,
+    manifest,
+    stackName: stack.name,
+    agents: compiledAgentNames,
+    skillPlugins: uniqueSkillPlugins,
+    hasHooks: false
+  };
+}
+function printStackCompilationSummary(result) {
+  console.log(`
+Stack plugin compiled: ${result.stackName}`);
+  console.log(`  Path: ${result.pluginPath}`);
+  console.log(`  Agents: ${result.agents.length}`);
+  for (const agent of result.agents) {
+    console.log(`    - ${agent}`);
+  }
+  if (result.skillPlugins.length > 0) {
+    console.log(`  Skills included: ${result.skillPlugins.length}`);
+    for (const skill of result.skillPlugins) {
+      console.log(`    - ${skill}`);
+    }
+  }
+  if (result.hasHooks) {
+    console.log(`  Hooks: enabled`);
+  }
+}
+
+// src/cli/utils/exec.ts
+init_esm_shims();
+import { spawn } from "child_process";
+async function execCommand(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      cwd: options?.cwd,
+      env: { ...process.env, ...options?.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code ?? 1
+      });
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function claudePluginInstall(pluginPath, scope, projectDir) {
+  const args = ["plugin", "install", pluginPath, "--scope", scope];
+  const result = await execCommand("claude", args, { cwd: projectDir });
+  if (result.exitCode !== 0) {
+    const errorMessage = result.stderr || result.stdout || "Unknown error";
+    throw new Error(`Plugin installation failed: ${errorMessage.trim()}`);
+  }
+}
+async function isClaudeCLIAvailable() {
+  try {
+    const result = await execCommand("claude", ["--version"], {});
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function claudePluginMarketplaceList() {
+  try {
+    const result = await execCommand("claude", ["plugin", "marketplace", "list", "--json"], {});
+    if (result.exitCode !== 0) {
+      return [];
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(result.stdout);
+    } catch {
+      warn("Failed to parse marketplace list output as JSON");
+      return [];
+    }
+    if (!Array.isArray(parsed)) {
+      warn("Unexpected marketplace list format \u2014 expected an array");
+      return [];
+    }
+    return parsed;
+  } catch {
+    return [];
+  }
+}
+async function claudePluginMarketplaceExists(name) {
+  const marketplaces = await claudePluginMarketplaceList();
+  return marketplaces.some((m) => m.name === name);
+}
+async function claudePluginMarketplaceAdd(githubRepo, name) {
+  const args = ["plugin", "marketplace", "add", githubRepo, "--name", name];
+  let result;
+  try {
+    result = await execCommand("claude", args, {});
+  } catch (err) {
+    throw new Error(
+      `Failed to add marketplace: ${err instanceof Error ? err.message : "Unknown error"}`
+    );
+  }
+  if (result.exitCode !== 0) {
+    const errorMessage = result.stderr || result.stdout || "Unknown error";
+    if (errorMessage.includes("already installed")) {
+      return;
+    }
+    throw new Error(`Failed to add marketplace: ${errorMessage.trim()}`);
+  }
+}
+async function claudePluginUninstall(pluginName, scope, projectDir) {
+  const args = ["plugin", "uninstall", pluginName, "--scope", scope];
+  const result = await execCommand("claude", args, { cwd: projectDir });
+  if (result.exitCode !== 0) {
+    const errorMessage = result.stderr || result.stdout || "Unknown error";
+    if (errorMessage.includes("not installed") || errorMessage.includes("not found")) {
+      return;
+    }
+    throw new Error(`Plugin uninstall failed: ${errorMessage.trim()}`);
+  }
+}
+
+// src/cli/lib/stacks/stack-installer.ts
+async function compileStackToTemp(options) {
+  const tempDir = path14.join(os.tmpdir(), `cc-stack-${Date.now()}`);
+  await ensureDir(tempDir);
+  const result = await compileStackPlugin({
+    stackId: options.stackId,
+    outputDir: tempDir,
+    projectRoot: options.projectRoot,
+    agentSourcePath: options.agentSourcePath
+  });
+  return {
+    result,
+    cleanup: async () => {
+      await remove(tempDir);
+    }
+  };
+}
+async function installStackAsPlugin(options) {
+  const { stackId, projectDir, sourcePath, agentSourcePath, marketplace } = options;
+  const claudeAvailable = await isClaudeCLIAvailable();
+  if (!claudeAvailable) {
+    throw new Error(
+      "Claude CLI not found. Please install Claude Code first: https://claude.ai/code"
+    );
+  }
+  if (marketplace) {
+    verbose(`Installing from marketplace: ${stackId}@${marketplace}`);
+    const pluginRef = `${stackId}@${marketplace}`;
+    await claudePluginInstall(pluginRef, "project", projectDir);
+    return {
+      pluginName: stackId,
+      stackName: stackId,
+      agents: [],
+      skills: [],
+      pluginPath: pluginRef,
+      fromMarketplace: true
+    };
+  }
+  verbose(`Compiling stack locally: ${stackId}`);
+  const { result, cleanup } = await compileStackToTemp({
+    stackId,
+    projectRoot: sourcePath,
+    agentSourcePath
+  });
+  try {
+    await claudePluginInstall(result.pluginPath, "project", projectDir);
+    return {
+      pluginName: `stack-${stackId}`,
+      stackName: result.stackName,
+      agents: result.agents,
+      skills: result.skillPlugins,
+      pluginPath: result.pluginPath,
+      fromMarketplace: false
+    };
+  } finally {
+    await cleanup();
+  }
+}
+
+// src/cli/lib/installation/local-installer.ts
+var PLUGIN_NAME = "claude-collective";
+var YAML_INDENT = 2;
+var YAML_LINE_WIDTH = 120;
+function buildLocalSkillsMap(copiedSkills, matrix) {
+  const localSkillsForResolution = {};
+  for (const copiedSkill of copiedSkills) {
+    const skill = matrix.skills[copiedSkill.skillId];
+    if (skill) {
+      localSkillsForResolution[copiedSkill.skillId] = {
+        id: copiedSkill.skillId,
+        description: skill.description || "",
+        path: copiedSkill.destPath,
+        content: ""
+        // Content not needed for skill references
+      };
+    }
+  }
+  return localSkillsForResolution;
+}
+async function buildLocalConfig(wizardResult, sourceResult) {
+  let loadedStack = null;
+  if (wizardResult.selectedStackId) {
+    loadedStack = await loadStackById(wizardResult.selectedStackId, sourceResult.sourcePath);
+    if (!loadedStack) {
+      loadedStack = await loadStackById(wizardResult.selectedStackId, PROJECT_ROOT);
+    }
+  }
+  let localConfig;
+  if (wizardResult.selectedStackId) {
+    if (loadedStack) {
+      localConfig = generateProjectConfigFromSkills(
+        PLUGIN_NAME,
+        wizardResult.selectedSkills,
+        sourceResult.matrix
+      );
+      localConfig.description = loadedStack.description;
+      const stackAgentIds = typedKeys(loadedStack.agents);
+      for (const agentId of stackAgentIds) {
+        if (!localConfig.agents.includes(agentId)) {
+          localConfig.agents.push(agentId);
+        }
+      }
+      localConfig.agents.sort();
+    } else {
+      throw new Error(
+        `Stack '${wizardResult.selectedStackId}' not found in config/stacks.yaml. Available stacks are defined in the CLI's config/stacks.yaml file.`
+      );
+    }
+  } else {
+    localConfig = generateProjectConfigFromSkills(
+      PLUGIN_NAME,
+      wizardResult.selectedSkills,
+      sourceResult.matrix
+    );
+  }
+  return { config: localConfig, loadedStack };
+}
+function setConfigMetadata(config, wizardResult, sourceResult, sourceFlag) {
+  config.installMode = wizardResult.installMode;
+  if (sourceFlag) {
+    config.source = sourceFlag;
+  } else if (sourceResult.sourceConfig.source) {
+    config.source = sourceResult.sourceConfig.source;
+  }
+  if (sourceResult.marketplace) {
+    config.marketplace = sourceResult.marketplace;
+  }
+}
+function buildCompileAgents(config, agents) {
+  const compileAgents = {};
+  for (const agentId of config.agents) {
+    if (agents[agentId]) {
+      const agentStack = config.stack?.[agentId];
+      compileAgents[agentId] = agentStack ? { skills: buildSkillRefsFromConfig(agentStack) } : {};
+    }
+  }
+  return compileAgents;
+}
+async function compileAndWriteAgents(compileConfig, agents, localSkills, sourceResult, projectDir, agentsDir, installMode) {
+  const engine = await createLiquidEngine(projectDir);
+  const resolvedAgents = await resolveAgents(
+    agents,
+    localSkills,
+    compileConfig,
+    sourceResult.sourcePath
+  );
+  const compiledAgentNames = [];
+  for (const [name, agent] of typedEntries(resolvedAgents)) {
+    const output = await compileAgentForPlugin(
+      name,
+      agent,
+      sourceResult.sourcePath,
+      engine,
+      installMode
+    );
+    await writeFile(path15.join(agentsDir, `${name}.md`), output);
+    compiledAgentNames.push(name);
+  }
+  return compiledAgentNames;
+}
+async function installLocal(options) {
+  const { wizardResult, sourceResult, projectDir, sourceFlag } = options;
+  const matrix = sourceResult.matrix;
+  const localSkillsDir = path15.join(projectDir, LOCAL_SKILLS_PATH);
+  const localAgentsDir = path15.join(projectDir, CLAUDE_DIR, "agents");
+  const localConfigPath = path15.join(projectDir, CLAUDE_SRC_DIR, "config.yaml");
+  await ensureDir(localSkillsDir);
+  await ensureDir(localAgentsDir);
+  await ensureDir(path15.dirname(localConfigPath));
+  for (const skillId of wizardResult.selectedSkills) {
+    const selectedSource = wizardResult.sourceSelections?.[skillId];
+    if (selectedSource && selectedSource !== "public") {
+      verbose(`Using alternate source '${selectedSource}' for ${skillId}`);
+      await archiveLocalSkill(projectDir, skillId);
+    }
+  }
+  const copiedSkills = await copySkillsToLocalFlattened(
+    wizardResult.selectedSkills,
+    localSkillsDir,
+    matrix,
+    sourceResult
+  );
+  const localSkillsForResolution = buildLocalSkillsMap(copiedSkills, matrix);
+  const cliAgents = await loadAllAgents(PROJECT_ROOT);
+  const localAgents = await loadAllAgents(sourceResult.sourcePath);
+  const agents = { ...cliAgents, ...localAgents };
+  const { config: builtConfig } = await buildLocalConfig(wizardResult, sourceResult);
+  setConfigMetadata(builtConfig, wizardResult, sourceResult, sourceFlag);
+  const mergeResult = await mergeWithExistingConfig(builtConfig, { projectDir });
+  const finalConfig = mergeResult.config;
+  const configYaml = stringifyYaml4(finalConfig, {
+    indent: YAML_INDENT,
+    lineWidth: YAML_LINE_WIDTH
+  });
+  await writeFile(localConfigPath, configYaml);
+  const compileAgentsConfig = buildCompileAgents(finalConfig, agents);
+  const compileConfig = {
+    name: PLUGIN_NAME,
+    description: finalConfig.description || `Local setup with ${wizardResult.selectedSkills.length} skills`,
+    agents: compileAgentsConfig
+  };
+  const compiledAgentNames = await compileAndWriteAgents(
+    compileConfig,
+    agents,
+    localSkillsForResolution,
+    sourceResult,
+    projectDir,
+    localAgentsDir,
+    wizardResult.installMode
+  );
+  return {
+    copiedSkills,
+    config: finalConfig,
+    configPath: localConfigPath,
+    compiledAgents: compiledAgentNames,
+    wasMerged: mergeResult.merged,
+    mergedConfigPath: mergeResult.existingConfigPath,
+    skillsDir: localSkillsDir,
+    agentsDir: localAgentsDir
+  };
+}
+
+// src/cli/lib/plugins/plugin-info.ts
+var DEFAULT_NAME = "claude-collective";
+async function getInstallationInfo() {
+  const installation = await detectInstallation();
+  if (!installation) {
+    return null;
+  }
+  let skillCount = 0;
+  let agentCount = 0;
+  let name = DEFAULT_NAME;
+  let version = DEFAULT_DISPLAY_VERSION;
+  if (await directoryExists(installation.skillsDir)) {
+    try {
+      const skills = await readdir(installation.skillsDir, {
+        withFileTypes: true
+      });
+      skillCount = skills.filter((s) => s.isDirectory()).length;
+    } catch {
+    }
+  }
+  if (await directoryExists(installation.agentsDir)) {
+    try {
+      const agents = await readdir(installation.agentsDir, {
+        withFileTypes: true
+      });
+      agentCount = agents.filter((a) => a.isFile() && a.name.endsWith(".md")).length;
+    } catch {
+    }
+  }
+  if (installation.mode === "local") {
+    const loaded = await loadProjectConfig(installation.projectDir);
+    if (loaded?.config) {
+      name = loaded.config.name || DEFAULT_NAME;
+      version = "local";
+    }
+  } else {
+    const pluginDir = getCollectivePluginDir(installation.projectDir);
+    const manifest = await readPluginManifest(pluginDir);
+    if (manifest) {
+      name = manifest.name || DEFAULT_NAME;
+      version = manifest.version || DEFAULT_DISPLAY_VERSION;
+    }
+  }
+  return {
+    mode: installation.mode,
+    name,
+    version,
+    skillCount,
+    agentCount,
+    configPath: installation.configPath,
+    agentsDir: installation.agentsDir,
+    skillsDir: installation.skillsDir
+  };
+}
+function formatInstallationDisplay(info) {
+  const modeLabel = info.mode === "local" ? "Local" : "Plugin";
+  const versionDisplay = info.mode === "local" ? "(local mode)" : `v${info.version}`;
+  return `Installation: ${info.name} ${versionDisplay}
+  Mode:    ${modeLabel}
+  Skills:  ${info.skillCount}
+  Agents:  ${info.agentCount}
+  Config:  ${info.configPath}
+  Agents:  ${info.agentsDir}`;
+}
+
+// src/cli/lib/plugins/plugin-version.ts
+init_esm_shims();
+import path16 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 = path16.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+  const content = await readFile(manifestPath);
+  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;
+  }
+  manifest.version = newVersion;
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  return newVersion;
+}
+async function getPluginVersion(pluginDir) {
+  const manifestPath = path16.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+  const content = await readFile(manifestPath);
+  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 path17 from "path";
+import fg from "fast-glob";
+import { countBy as countBy2 } from "remeda";
+var PLUGIN_DIR = ".claude-plugin";
+var PLUGIN_MANIFEST = "plugin.json";
+var KEBAB_CASE_REGEX = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+var pluginManifestValidationSchema = z2.object({
+  name: z2.string(),
+  version: z2.string().optional(),
+  description: z2.string().optional(),
+  author: pluginAuthorSchema.optional(),
+  keywords: z2.array(z2.string()).optional(),
+  commands: z2.union([z2.string(), z2.array(z2.string())]).optional(),
+  agents: z2.union([z2.string(), z2.array(z2.string())]).optional(),
+  skills: z2.union([z2.string(), z2.array(z2.string())]).optional(),
+  hooks: z2.union([z2.string(), hooksRecordSchema]).optional()
+}).strict();
+function formatZodErrors(error) {
+  return error.issues.map((issue) => {
+    const path26 = issue.path.join(".");
+    if (issue.code === "unrecognized_keys") {
+      return `Unrecognized key: "${issue.keys.join('", "')}"`;
+    }
+    return path26 ? `${path26}: ${issue.message}` : issue.message;
+  });
+}
+function isKebabCase(str) {
+  return KEBAB_CASE_REGEX.test(str);
+}
+function isValidSemver(str) {
+  return SEMVER_REGEX.test(str);
+}
+async function validatePluginStructure(pluginPath) {
+  const errors = [];
+  const warnings = [];
+  if (!await directoryExists(pluginPath)) {
+    return {
+      valid: false,
+      errors: [`Plugin directory does not exist: ${pluginPath}`],
+      warnings: []
+    };
+  }
+  const pluginDir = path17.join(pluginPath, PLUGIN_DIR);
+  if (!await directoryExists(pluginDir)) {
+    errors.push(`Missing ${PLUGIN_DIR}/ directory`);
+  }
+  const manifestPath = path17.join(pluginDir, PLUGIN_MANIFEST);
+  if (!await fileExists(manifestPath)) {
+    errors.push(`Missing ${PLUGIN_DIR}/${PLUGIN_MANIFEST}`);
+  }
+  const readmePath = path17.join(pluginPath, "README.md");
+  if (!await fileExists(readmePath)) {
+    warnings.push("Missing README.md (recommended for documentation)");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+async function validatePluginManifest(manifestPath) {
+  const errors = [];
+  const warnings = [];
+  if (!await fileExists(manifestPath)) {
+    return {
+      valid: false,
+      errors: [`Manifest file not found: ${manifestPath}`],
+      warnings: []
+    };
+  }
+  let manifest;
+  try {
+    const content = await readFile(manifestPath);
+    manifest = JSON.parse(content);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      valid: false,
+      errors: [`Invalid JSON in ${PLUGIN_MANIFEST}: ${message}`],
+      warnings: []
+    };
+  }
+  const result = pluginManifestValidationSchema.safeParse(manifest);
+  if (!result.success) {
+    errors.push(...formatZodErrors(result.error));
+  }
+  if (manifest.name && typeof manifest.name === "string") {
+    if (!isKebabCase(manifest.name)) {
+      errors.push(`name must be kebab-case: "${manifest.name}"`);
+    }
+  }
+  if (manifest.version && typeof manifest.version === "string") {
+    if (!isValidSemver(manifest.version)) {
+      errors.push(
+        `version "${manifest.version}" is not valid semver (expected: major.minor.patch)`
+      );
+    }
+  }
+  if (!manifest.description) {
+    warnings.push("Missing description field (recommended for discoverability)");
+  }
+  const pluginDir = path17.dirname(path17.dirname(manifestPath));
+  if (manifest.skills && typeof manifest.skills === "string") {
+    const skillsPath = path17.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 = path17.join(pluginDir, manifest.agents);
+    if (!await directoryExists(agentsPath)) {
+      errors.push(`Agents path does not exist: ${manifest.agents}`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+async function validateSkillFrontmatter(skillPath) {
+  const errors = [];
+  const warnings = [];
+  if (!await fileExists(skillPath)) {
+    return {
+      valid: false,
+      errors: [`Skill file not found: ${skillPath}`],
+      warnings: []
+    };
+  }
+  const content = await readFile(skillPath);
+  const frontmatter = extractFrontmatter(content);
+  if (frontmatter === null) {
+    return {
+      valid: false,
+      errors: ["Missing or invalid YAML frontmatter"],
+      warnings: []
+    };
+  }
+  const result = skillFrontmatterValidationSchema.safeParse(frontmatter);
+  if (!result.success) {
+    errors.push(...formatZodErrors(result.error));
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+async function validateAgentFrontmatter(agentPath) {
+  const errors = [];
+  const warnings = [];
+  if (!await fileExists(agentPath)) {
+    return {
+      valid: false,
+      errors: [`Agent file not found: ${agentPath}`],
+      warnings: []
+    };
+  }
+  const content = await readFile(agentPath);
+  const frontmatter = extractFrontmatter(content);
+  if (frontmatter === null) {
+    return {
+      valid: false,
+      errors: ["Missing or invalid YAML frontmatter"],
+      warnings: []
+    };
+  }
+  const result = agentFrontmatterValidationSchema.safeParse(frontmatter);
+  if (!result.success) {
+    errors.push(...formatZodErrors(result.error));
+  }
+  const fm = frontmatter;
+  if (fm.name && typeof fm.name === "string") {
+    if (!isKebabCase(fm.name)) {
+      errors.push(`name must be kebab-case: "${fm.name}"`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+async function validatePlugin(pluginPath) {
+  const errors = [];
+  const warnings = [];
+  const structureResult = await validatePluginStructure(pluginPath);
+  errors.push(...structureResult.errors);
+  warnings.push(...structureResult.warnings);
+  if (!structureResult.valid) {
+    return { valid: false, errors, warnings };
+  }
+  const manifestPath = path17.join(pluginPath, PLUGIN_DIR, PLUGIN_MANIFEST);
+  const manifestResult = await validatePluginManifest(manifestPath);
+  errors.push(...manifestResult.errors);
+  warnings.push(...manifestResult.warnings);
+  let manifest = null;
+  try {
+    const content = await readFile(manifestPath);
+    manifest = JSON.parse(content);
+  } catch {
+  }
+  if (manifest) {
+    if (manifest.skills && typeof manifest.skills === "string") {
+      const skillsDir = path17.join(pluginPath, manifest.skills);
+      if (await directoryExists(skillsDir)) {
+        const skillFiles = await fg("**/SKILL.md", {
+          cwd: skillsDir,
+          absolute: true
+        });
+        if (skillFiles.length === 0) {
+          warnings.push(
+            `Skills directory exists but contains no SKILL.md files: ${manifest.skills}`
+          );
+        }
+        for (const skillFile of skillFiles) {
+          const relativePath = path17.relative(pluginPath, skillFile);
+          const skillResult = await validateSkillFrontmatter(skillFile);
+          if (!skillResult.valid) {
+            errors.push(...skillResult.errors.map((e) => `${relativePath}: ${e}`));
+          }
+          warnings.push(...skillResult.warnings.map((w) => `${relativePath}: ${w}`));
+        }
+      }
+    }
+    if (manifest.agents && typeof manifest.agents === "string") {
+      const agentsDir = path17.join(pluginPath, manifest.agents);
+      if (await directoryExists(agentsDir)) {
+        const agentFiles = await fg("*.md", {
+          cwd: agentsDir,
+          absolute: true
+        });
+        if (agentFiles.length === 0) {
+          warnings.push(`Agents directory exists but contains no .md files: ${manifest.agents}`);
+        }
+        for (const agentFile of agentFiles) {
+          const relativePath = path17.relative(pluginPath, agentFile);
+          const agentResult = await validateAgentFrontmatter(agentFile);
+          if (!agentResult.valid) {
+            errors.push(...agentResult.errors.map((e) => `${relativePath}: ${e}`));
+          }
+          warnings.push(...agentResult.warnings.map((w) => `${relativePath}: ${w}`));
+        }
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+async function validateAllPlugins(pluginsDir) {
+  const results = [];
+  if (!await directoryExists(pluginsDir)) {
+    return {
+      valid: false,
+      results: [
+        {
+          name: pluginsDir,
+          result: {
+            valid: false,
+            errors: [`Directory does not exist: ${pluginsDir}`],
+            warnings: []
+          }
+        }
+      ],
+      summary: { total: 0, valid: 0, invalid: 1, withWarnings: 0 }
+    };
+  }
+  const allDirs = await listDirectories(pluginsDir);
+  const pluginDirs = [];
+  for (const dirName of allDirs) {
+    const potentialPluginDir = path17.join(pluginsDir, dirName, PLUGIN_DIR);
+    if (await directoryExists(potentialPluginDir)) {
+      pluginDirs.push(dirName);
+    }
+  }
+  if (pluginDirs.length === 0) {
+    return {
+      valid: false,
+      results: [
+        {
+          name: pluginsDir,
+          result: {
+            valid: false,
+            errors: [
+              `No plugins found in directory: ${pluginsDir}. Plugins must contain a ${PLUGIN_DIR}/ directory.`
+            ],
+            warnings: []
+          }
+        }
+      ],
+      summary: { total: 0, valid: 0, invalid: 1, withWarnings: 0 }
+    };
+  }
+  for (const pluginName of pluginDirs) {
+    const pluginPath = path17.join(pluginsDir, pluginName);
+    const result = await validatePlugin(pluginPath);
+    results.push({ name: pluginName, result });
+  }
+  const summary = {
+    total: results.length,
+    valid: countBy2(results, (r) => String(r.result.valid))["true"] ?? 0,
+    invalid: countBy2(results, (r) => String(r.result.valid))["false"] ?? 0,
+    withWarnings: countBy2(results, (r) => String(r.result.warnings.length > 0))["true"] ?? 0
+  };
+  return {
+    valid: summary.invalid === 0,
+    results,
+    summary
+  };
+}
+function printPluginValidationResult(name, result, verbose2 = false) {
+  const status = result.valid ? "\u2713" : "\u2717";
+  if (result.valid && result.warnings.length === 0 && !verbose2) {
+    return;
+  }
+  console.log(`
+  ${status} ${name}`);
+  if (result.errors.length > 0) {
+    console.log("    Errors:");
+    result.errors.forEach((e) => console.log(`      - ${e}`));
+  }
+  if (result.warnings.length > 0) {
+    console.log("    Warnings:");
+    result.warnings.forEach((w) => console.log(`      - ${w}`));
+  }
+}
+
+// src/cli/lib/loading/multi-source-loader.ts
+var PUBLIC_SOURCE_NAME = "public";
+async function loadSkillsFromAllSources(primaryMatrix, sourceConfig, projectDir) {
+  tagPrimarySourceSkills(primaryMatrix);
+  tagLocalSkills(primaryMatrix);
+  await tagPluginSkills(primaryMatrix, projectDir);
+  await tagExtraSources(primaryMatrix, projectDir);
+  setActiveSources(primaryMatrix);
+}
+function tagPrimarySourceSkills(matrix) {
+  for (const [, skill] of typedEntries(
+    matrix.skills
+  )) {
+    if (!skill) continue;
+    const source = {
+      name: PUBLIC_SOURCE_NAME,
+      type: "public",
+      version: skill.version,
+      installed: false
+    };
+    skill.availableSources = skill.availableSources ?? [];
+    skill.availableSources.push(source);
+  }
+}
+function tagLocalSkills(matrix) {
+  let count = 0;
+  for (const [, skill] of typedEntries(
+    matrix.skills
+  )) {
+    if (!skill) continue;
+    if (!skill.local) continue;
+    const source = {
+      name: "local",
+      type: "local",
+      installed: true,
+      installMode: "local"
+    };
+    skill.availableSources = skill.availableSources ?? [];
+    skill.availableSources.push(source);
+    count++;
+  }
+  verbose(`Tagged ${count} local skills with local source`);
+}
+async function tagPluginSkills(matrix, projectDir) {
+  const pluginDir = getCollectivePluginDir(projectDir);
+  if (!await directoryExists(pluginDir)) {
+    verbose("No plugin directory found, skipping plugin skill tagging");
+    return;
+  }
+  const pluginSkillsDir = getPluginSkillsDir(pluginDir);
+  if (!await directoryExists(pluginSkillsDir)) {
+    verbose("No plugin skills directory found, skipping plugin skill tagging");
+    return;
+  }
+  try {
+    const pluginSkillIds = await getPluginSkillIds(pluginSkillsDir, matrix);
+    for (const skillId of pluginSkillIds) {
+      const skill = matrix.skills[skillId];
+      if (!skill) continue;
+      skill.availableSources = skill.availableSources ?? [];
+      const existingSource = skill.availableSources.find((s) => s.type === "public");
+      if (existingSource && !existingSource.installMode) {
+        existingSource.installed = true;
+        existingSource.installMode = "plugin";
+      } else if (!skill.availableSources.some((s) => s.installMode === "plugin")) {
+        skill.availableSources.push({
+          name: PUBLIC_SOURCE_NAME,
+          type: "public",
+          version: skill.version,
+          installed: true,
+          installMode: "plugin"
+        });
+      }
+    }
+    verbose(`Tagged ${pluginSkillIds.length} plugin-installed skills`);
+  } catch (error) {
+    verbose(`Failed to detect plugin skills: ${error}`);
+  }
+}
+async function tagExtraSources(matrix, projectDir) {
+  let allSources;
+  try {
+    allSources = await resolveAllSources(projectDir);
+  } catch (error) {
+    verbose(`Failed to resolve extra sources: ${error}`);
+    return;
+  }
+  if (allSources.extras.length === 0) {
+    verbose("No extra sources configured");
+    return;
+  }
+  for (const extraSource of allSources.extras) {
+    verbose(`Loading extra source: ${extraSource.name} (${extraSource.url})`);
+    try {
+      const fetchResult = await fetchFromSource(extraSource.url, { forceRefresh: false });
+      const skillsDir = path18.join(fetchResult.path, SKILLS_DIR_PATH);
+      const skills = await extractAllSkills(skillsDir);
+      let matchCount = 0;
+      for (const extractedSkill of skills) {
+        const matrixSkill = matrix.skills[extractedSkill.id];
+        if (!matrixSkill) continue;
+        const source = {
+          name: extraSource.name,
+          type: "private",
+          url: extraSource.url,
+          installed: false
+        };
+        matrixSkill.availableSources = matrixSkill.availableSources ?? [];
+        matrixSkill.availableSources.push(source);
+        matchCount++;
+      }
+      verbose(
+        `Extra source '${extraSource.name}': ${skills.length} skills found, ${matchCount} matching`
+      );
+    } catch (error) {
+      warn(`Failed to load extra source '${extraSource.name}' (${extraSource.url}): ${error}`);
+    }
+  }
+}
+function setActiveSources(matrix) {
+  for (const [, skill] of typedEntries(
+    matrix.skills
+  )) {
+    if (!skill) continue;
+    if (!skill.availableSources || skill.availableSources.length === 0) continue;
+    const installedSource = skill.availableSources.find((s) => s.installed);
+    skill.activeSource = installedSource ?? skill.availableSources[0];
+  }
+}
+async function searchExtraSources(alias, configuredSources) {
+  const candidates = [];
+  if (configuredSources.length === 0) {
+    return candidates;
+  }
+  const lowerAlias = alias.toLowerCase();
+  for (const source of configuredSources) {
+    try {
+      const fetchResult = await fetchFromSource(source.url, { forceRefresh: false });
+      const skillsDir = path18.join(fetchResult.path, SKILLS_DIR_PATH);
+      const skills = await extractAllSkills(skillsDir);
+      for (const skill of skills) {
+        const segments = skill.directoryPath.split("/");
+        const lastSegment = segments[segments.length - 1]?.toLowerCase();
+        if (lastSegment === lowerAlias) {
+          candidates.push({
+            id: skill.id,
+            sourceUrl: source.url,
+            sourceName: source.name,
+            alias,
+            description: skill.description
+          });
+        }
+      }
+    } catch (error) {
+      warn(`Failed to search extra source '${source.name}' (${source.url}): ${error}`);
+    }
+  }
+  return candidates;
+}
+
+// src/cli/lib/loading/source-loader.ts
+async function loadSkillsMatrixFromSource(options = {}) {
+  const { sourceFlag, projectDir, forceRefresh = false, devMode = false } = options;
+  const sourceConfig = await resolveSource(sourceFlag, projectDir);
+  const { source } = sourceConfig;
+  verbose(`Loading skills from source: ${source}`);
+  const isLocal = isLocalSource(source) || devMode === true;
+  let result;
+  if (isLocal) {
+    result = await loadFromLocal(source, sourceConfig);
+  } else {
+    result = await loadFromRemote(source, sourceConfig, forceRefresh);
+  }
+  const resolvedProjectDir = projectDir || process.cwd();
+  const localSkillsResult = await discoverLocalSkills(resolvedProjectDir);
+  if (localSkillsResult && localSkillsResult.skills.length > 0) {
+    verbose(
+      `Found ${localSkillsResult.skills.length} local skill(s) in ${localSkillsResult.localSkillsPath}`
+    );
+    result.matrix = mergeLocalSkillsIntoMatrix(result.matrix, localSkillsResult);
+  }
+  await loadSkillsFromAllSources(result.matrix, sourceConfig, resolvedProjectDir);
+  checkMatrixHealth(result.matrix);
+  return result;
+}
+async function loadFromLocal(source, sourceConfig) {
+  let skillsPath;
+  if (isLocalSource(source)) {
+    skillsPath = path19.isAbsolute(source) ? source : path19.resolve(process.cwd(), source);
+  } else {
+    skillsPath = PROJECT_ROOT;
+  }
+  verbose(`Loading skills from local path: ${skillsPath}`);
+  const sourceMatrixPath = path19.join(skillsPath, SKILLS_MATRIX_PATH);
+  const cliMatrixPath = path19.join(PROJECT_ROOT, SKILLS_MATRIX_PATH);
+  let matrixPath;
+  if (await fileExists(sourceMatrixPath)) {
+    matrixPath = sourceMatrixPath;
+    verbose(`Matrix from source: ${matrixPath}`);
+  } else {
+    matrixPath = cliMatrixPath;
+    verbose(`Matrix from CLI (source has no matrix): ${matrixPath}`);
+  }
+  const skillsDir = path19.join(skillsPath, SKILLS_DIR_PATH);
+  verbose(`Skills from source: ${skillsDir}`);
+  const matrix = await loadSkillsMatrix(matrixPath);
+  const skills = await extractAllSkills(skillsDir);
+  const mergedMatrix = await mergeMatrixWithSkills(matrix, skills);
+  const sourceStacks = await loadStacks(skillsPath);
+  const stacks = sourceStacks.length > 0 ? sourceStacks : await loadStacks(PROJECT_ROOT);
+  if (stacks.length > 0) {
+    mergedMatrix.suggestedStacks = stacks.map(
+      (stack) => stackToResolvedStack(stack, mergedMatrix.displayNameToId)
+    );
+    const stackSource = sourceStacks.length > 0 ? "source" : "CLI";
+    verbose(`Loaded ${stacks.length} stacks from ${stackSource}`);
+  }
+  return {
+    matrix: mergedMatrix,
+    sourceConfig,
+    sourcePath: skillsPath,
+    isLocal: true,
+    marketplace: sourceConfig.marketplace
+  };
+}
+async function loadFromRemote(source, sourceConfig, forceRefresh) {
+  verbose(`Fetching skills from remote source: ${source}`);
+  const fetchResult = await fetchFromSource(source, { forceRefresh });
+  verbose(`Fetched to: ${fetchResult.path}`);
+  const sourceMatrixPath = path19.join(fetchResult.path, SKILLS_MATRIX_PATH);
+  const cliMatrixPath = path19.join(PROJECT_ROOT, SKILLS_MATRIX_PATH);
+  let matrixPath;
+  if (await fileExists(sourceMatrixPath)) {
+    matrixPath = sourceMatrixPath;
+    verbose(`Matrix from source: ${matrixPath}`);
+  } else {
+    matrixPath = cliMatrixPath;
+    verbose(`Matrix from CLI (source has no matrix): ${matrixPath}`);
+  }
+  const skillsDir = path19.join(fetchResult.path, SKILLS_DIR_PATH);
+  verbose(`Skills from source: ${skillsDir}`);
+  const matrix = await loadSkillsMatrix(matrixPath);
+  const skills = await extractAllSkills(skillsDir);
+  const mergedMatrix = await mergeMatrixWithSkills(matrix, skills);
+  const sourceStacks = await loadStacks(fetchResult.path);
+  const stacks = sourceStacks.length > 0 ? sourceStacks : await loadStacks(PROJECT_ROOT);
+  if (stacks.length > 0) {
+    mergedMatrix.suggestedStacks = stacks.map(
+      (stack) => stackToResolvedStack(stack, mergedMatrix.displayNameToId)
+    );
+    const stackSource = sourceStacks.length > 0 ? "source" : "CLI";
+    verbose(`Loaded ${stacks.length} stacks from ${stackSource}`);
+  }
+  return {
+    matrix: mergedMatrix,
+    sourceConfig,
+    sourcePath: fetchResult.path,
+    isLocal: false,
+    marketplace: sourceConfig.marketplace
+  };
+}
+function stackToResolvedStack(stack, displayNameToId) {
+  const allSkillIds = [];
+  const seenSkillIds = /* @__PURE__ */ new Set();
+  for (const agentId of typedKeys(stack.agents)) {
+    const agentConfig = stack.agents[agentId];
+    if (!agentConfig) continue;
+    const skillRefs = resolveAgentConfigToSkills(agentConfig, displayNameToId);
+    for (const ref of skillRefs) {
+      if (!seenSkillIds.has(ref.id)) {
+        seenSkillIds.add(ref.id);
+        allSkillIds.push(ref.id);
+      }
+    }
+  }
+  const agentCount = typedKeys(stack.agents).length;
+  verbose(`Stack '${stack.id}' has ${allSkillIds.length} skills from ${agentCount} agents`);
+  return {
+    id: stack.id,
+    name: stack.name,
+    description: stack.description,
+    audience: [],
+    // Not used in new format
+    skills: {},
+    // Skills come from stack agent configs, resolved at runtime
+    allSkillIds,
+    philosophy: stack.philosophy || ""
+  };
+}
+function mergeLocalSkillsIntoMatrix(matrix, localResult) {
+  for (const metadata of localResult.skills) {
+    const existingSkill = matrix.skills[metadata.id];
+    const category = existingSkill?.category ?? metadata.category;
+    const displayName = existingSkill?.displayName ?? matrix.displayNames[metadata.id];
+    const resolvedSkill = {
+      id: metadata.id,
+      displayName,
+      description: metadata.description,
+      usageGuidance: metadata.usageGuidance,
+      category,
+      categoryExclusive: metadata.categoryExclusive,
+      tags: metadata.tags ?? [],
+      author: "@local",
+      conflictsWith: existingSkill?.conflictsWith ?? [],
+      recommends: existingSkill?.recommends ?? [],
+      requires: existingSkill?.requires ?? [],
+      alternatives: existingSkill?.alternatives ?? [],
+      discourages: existingSkill?.discourages ?? [],
+      compatibleWith: existingSkill?.compatibleWith ?? [],
+      requiresSetup: existingSkill?.requiresSetup ?? [],
+      providesSetupFor: existingSkill?.providesSetupFor ?? [],
+      path: metadata.path,
+      local: true,
+      localPath: metadata.localPath
+    };
+    matrix.skills[metadata.id] = resolvedSkill;
+    verbose(`Added local skill: ${metadata.id} (category: ${category})`);
+  }
+  return matrix;
+}
+
+// src/cli/lib/loading/defaults-loader.ts
+init_esm_shims();
+import { parse as parseYaml8 } from "yaml";
+var cachedDefaults = null;
+function getCachedDefaults() {
+  return cachedDefaults;
+}
+
+// src/cli/lib/skills/skill-agent-mappings.ts
+var SKILL_TO_AGENTS = {
+  "web/*": [
+    "web-developer",
+    "web-reviewer",
+    "web-researcher",
+    "web-pm",
+    "pattern-scout",
+    "web-pattern-critique",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "api/*": [
+    "api-developer",
+    "api-reviewer",
+    "api-researcher",
+    "web-architecture",
+    "web-pm",
+    "pattern-scout",
+    "web-pattern-critique",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "mobile/*": [
+    "web-developer",
+    "web-reviewer",
+    "web-researcher",
+    "web-pm",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "infra/*": [
+    "web-architecture",
+    "web-developer",
+    "api-developer",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "security/*": [
+    "web-developer",
+    "api-developer",
+    "web-reviewer",
+    "api-reviewer",
+    "web-architecture",
+    "web-pm",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "reviewing/*": [
+    "web-reviewer",
+    "api-reviewer",
+    "cli-reviewer",
+    "web-pattern-critique",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "cli/*": [
+    "cli-developer",
+    "cli-reviewer",
+    "api-developer",
+    "api-reviewer",
+    "api-researcher",
+    "web-architecture",
+    "web-pm",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "research/*": [
+    "web-researcher",
+    "api-researcher",
+    "web-pm",
+    "pattern-scout",
+    "web-pattern-critique",
+    "documentor",
+    "agent-summoner",
+    "skill-summoner"
+  ],
+  "methodology/*": [
+    "web-developer",
+    "api-developer",
+    "web-reviewer",
+    "api-reviewer",
+    "web-researcher",
+    "api-researcher",
+    "web-tester",
+    "web-pm",
+    "web-architecture",
+    "pattern-scout",
+    "web-pattern-critique",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "web/testing": ["web-tester", "web-developer", "web-reviewer"],
+  "api/testing": ["web-tester", "api-developer", "api-reviewer"],
+  "web/mocks": ["web-tester", "web-developer", "web-reviewer"]
+};
+var DEFAULT_AGENTS = ["agent-summoner", "skill-summoner", "documentor"];
+function getEffectiveSkillToAgents() {
+  const defaults = getCachedDefaults();
+  if (defaults?.skill_to_agents) {
+    return defaults.skill_to_agents;
+  }
+  return SKILL_TO_AGENTS;
+}
+function getAgentsForSkill(skillPath, category, projectConfig) {
+  const normalizedPath = skillPath.replace(/^skills\//, "").replace(/\/$/, "");
+  const skillToAgents = getEffectiveSkillToAgents();
+  if (skillToAgents[category]) {
+    return skillToAgents[category];
+  }
+  for (const [pattern, agents] of Object.entries(skillToAgents)) {
+    if (normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`)) {
+      return agents;
+    }
+  }
+  for (const [pattern, agents] of Object.entries(skillToAgents)) {
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -2);
+      if (normalizedPath.startsWith(prefix)) {
+        return agents;
+      }
+    }
+  }
+  return DEFAULT_AGENTS;
+}
+
+// src/cli/lib/skills/skill-plugin-compiler.ts
+init_esm_shims();
+import path20 from "path";
+import { parse as parseYaml9 } from "yaml";
+var SKILL_FILES = ["SKILL.md", "reference.md"];
+var SKILL_DIRS = ["examples", "scripts"];
+function sanitizeSkillName(name) {
+  return name.replace(/\+/g, "-");
+}
+async function readSkillMetadata(skillPath) {
+  const metadataPath = path20.join(skillPath, "metadata.yaml");
+  if (!await fileExists(metadataPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(metadataPath);
+    const lines = content.split("\n");
+    const yamlContent = lines[0]?.startsWith("# yaml-language-server:") ? lines.slice(1).join("\n") : content;
+    const result = skillMetadataConfigSchema.safeParse(parseYaml9(yamlContent));
+    if (!result.success) {
+      warn(
+        `Invalid metadata.yaml at ${skillPath}: ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+      );
+      return null;
+    }
+    return result.data;
+  } catch (error) {
+    warn(`Failed to read metadata.yaml at ${skillPath}: ${error}`);
+    return null;
+  }
+}
+function generateReadme(skillName, frontmatter, metadata) {
+  const lines = [];
+  lines.push(`# ${skillName}`);
+  lines.push("");
+  lines.push(frontmatter.description);
+  lines.push("");
+  if (metadata?.tags && metadata.tags.length > 0) {
+    lines.push("## Tags");
+    lines.push("");
+    lines.push(metadata.tags.map((t) => `\`${t}\``).join(" "));
+    lines.push("");
+  }
+  lines.push("## Installation");
+  lines.push("");
+  lines.push("Add this plugin to your Claude Code configuration:");
+  lines.push("");
+  lines.push("```json");
+  lines.push(`{`);
+  lines.push(`  "plugins": ["${skillName}"]`);
+  lines.push(`}`);
+  lines.push("```");
+  lines.push("");
+  lines.push("## Usage");
+  lines.push("");
+  lines.push(`This skill is automatically available when installed.`);
+  if (metadata?.requires && metadata.requires.length > 0) {
+    lines.push("");
+    lines.push("**Requires:** " + metadata.requires.join(", "));
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("*Generated by Claude Collective skill-plugin-compiler*");
+  lines.push("");
+  return lines.join("\n");
+}
+async function compileSkillPlugin(options) {
+  const { skillPath, outputDir, skillName: overrideName } = options;
+  const dirBasename = path20.basename(skillPath);
+  const skillMdPath = path20.join(skillPath, "SKILL.md");
+  if (!await fileExists(skillMdPath)) {
+    throw new Error(
+      `Skill '${dirBasename}' is missing required SKILL.md file. Expected at: ${skillMdPath}`
+    );
+  }
+  const skillMdContent = await readFile(skillMdPath);
+  const frontmatter = parseFrontmatter(skillMdContent, skillMdPath);
+  if (!frontmatter) {
+    throw new Error(
+      `Skill '${dirBasename}' has invalid or missing YAML frontmatter in SKILL.md. Required fields: 'name' and 'description'. File: ${skillMdPath}`
+    );
+  }
+  const skillName = overrideName ?? sanitizeSkillName(frontmatter.name);
+  verbose(`Compiling skill plugin: ${skillName} from ${skillPath}`);
+  const metadata = await readSkillMetadata(skillPath);
+  const pluginDir = path20.join(outputDir, skillName);
+  const skillsDir = path20.join(pluginDir, "skills", skillName);
+  await ensureDir(pluginDir);
+  await ensureDir(skillsDir);
+  const newHash = await hashSkillFolder(skillPath);
+  const { version, contentHash } = await determinePluginVersion(
+    newHash,
+    pluginDir,
+    getPluginManifestPath
+  );
+  const manifest = generateSkillPluginManifest({
+    skillName,
+    description: frontmatter.description,
+    author: metadata?.author,
+    version,
+    keywords: metadata?.tags
+  });
+  await writePluginManifest(pluginDir, manifest);
+  await writeContentHash(pluginDir, contentHash, getPluginManifestPath);
+  verbose(`  Wrote plugin.json for ${skillName} (v${version})`);
+  await writeFile(path20.join(skillsDir, "SKILL.md"), skillMdContent);
+  verbose(`  Copied SKILL.md`);
+  for (const fileName of SKILL_FILES) {
+    if (fileName === "SKILL.md") continue;
+    const sourcePath = path20.join(skillPath, fileName);
+    if (await fileExists(sourcePath)) {
+      const content = await readFile(sourcePath);
+      await writeFile(path20.join(skillsDir, fileName), content);
+      verbose(`  Copied ${fileName}`);
+    }
+  }
+  for (const dirName of SKILL_DIRS) {
+    const sourceDir = path20.join(skillPath, dirName);
+    if (await fileExists(sourceDir)) {
+      await copy(sourceDir, path20.join(skillsDir, dirName));
+      verbose(`  Copied ${dirName}/`);
+    }
+  }
+  const readme = generateReadme(skillName, frontmatter, metadata);
+  await writeFile(path20.join(pluginDir, "README.md"), readme);
+  verbose(`  Generated README.md`);
+  return {
+    pluginPath: pluginDir,
+    manifest,
+    skillName
+  };
+}
+async function compileAllSkillPlugins(skillsDir, outputDir) {
+  const results = [];
+  const skillMdFiles = await glob("**/SKILL.md", skillsDir);
+  for (const skillMdFile of skillMdFiles) {
+    const skillPath = path20.join(skillsDir, path20.dirname(skillMdFile));
+    try {
+      const result = await compileSkillPlugin({
+        skillPath,
+        outputDir
+      });
+      results.push(result);
+      console.log(`  [OK] ${result.skillName}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const dirBasename = path20.basename(skillPath);
+      console.warn(`  [WARN] Failed to compile skill from ${dirBasename}: ${errorMessage}`);
+    }
+  }
+  return results;
+}
+function printCompilationSummary(results) {
+  console.log(`
+Compiled ${results.length} skill plugins:`);
+  for (const result of results) {
+    console.log(`  - ${result.skillName} (v${result.manifest.version})`);
+  }
+}
+
+// src/cli/lib/skills/local-skill-loader.ts
+init_esm_shims();
+import { parse as parseYaml10 } from "yaml";
+import path21 from "path";
+var LOCAL_CATEGORY = "local";
+var LOCAL_AUTHOR = "@local";
+async function discoverLocalSkills(projectDir) {
+  const localSkillsPath = path21.join(projectDir, LOCAL_SKILLS_PATH);
+  if (!await directoryExists(localSkillsPath)) {
+    verbose(`Local skills directory not found: ${localSkillsPath}`);
+    return null;
+  }
+  const skills = [];
+  const skillDirs = await listDirectories(localSkillsPath);
+  for (const skillDirName of skillDirs) {
+    const skill = await extractLocalSkill(localSkillsPath, skillDirName);
+    if (skill) {
+      skills.push(skill);
+    }
+  }
+  verbose(`Discovered ${skills.length} local skills from ${localSkillsPath}`);
+  return {
+    skills,
+    localSkillsPath
+  };
+}
+async function extractLocalSkill(localSkillsPath, skillDirName) {
+  const skillDir = path21.join(localSkillsPath, skillDirName);
+  const metadataPath = path21.join(skillDir, "metadata.yaml");
+  const skillMdPath = path21.join(skillDir, "SKILL.md");
+  if (!await fileExists(metadataPath)) {
+    verbose(`Skipping local skill '${skillDirName}': No metadata.yaml found`);
+    return null;
+  }
+  if (!await fileExists(skillMdPath)) {
+    verbose(`Skipping local skill '${skillDirName}': No SKILL.md found`);
+    return null;
+  }
+  const metadataContent = await readFile(metadataPath);
+  const parsed = localRawMetadataSchema.safeParse(parseYaml10(metadataContent));
+  if (!parsed.success) {
+    warn(
+      `Skipping local skill '${skillDirName}': Invalid metadata.yaml \u2014 ${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+    return null;
+  }
+  const metadata = parsed.data;
+  if (!metadata.cli_name) {
+    warn(`Skipping local skill '${skillDirName}': Missing required 'cli_name' in metadata.yaml`);
+    return null;
+  }
+  const skillMdContent = await readFile(skillMdPath);
+  const frontmatter = parseFrontmatter(skillMdContent, skillMdPath);
+  if (!frontmatter) {
+    warn(`Skipping local skill '${skillDirName}': Invalid SKILL.md frontmatter`);
+    return null;
+  }
+  const relativePath = `${LOCAL_SKILLS_PATH}/${skillDirName}/`;
+  const skillId = frontmatter.name;
+  const category = metadata.category || LOCAL_CATEGORY;
+  if (!metadata.category) {
+    warn(
+      `Local skill '${skillDirName}' has no category in metadata.yaml \u2014 defaulting to '${LOCAL_CATEGORY}' (will not appear in wizard domain views)`
+    );
+  }
+  const extracted = {
+    id: skillId,
+    directoryPath: skillDirName,
+    description: metadata.cli_description || frontmatter.description,
+    usageGuidance: metadata.usage_guidance,
+    category,
+    categoryExclusive: metadata.category_exclusive ?? false,
+    author: LOCAL_AUTHOR,
+    tags: metadata.tags ?? [],
+    compatibleWith: metadata.compatible_with ?? [],
+    conflictsWith: metadata.conflicts_with ?? [],
+    requires: metadata.requires ?? [],
+    requiresSetup: metadata.requires_setup ?? [],
+    providesSetupFor: metadata.provides_setup_for ?? [],
+    path: relativePath,
+    local: true,
+    localPath: relativePath
+  };
+  verbose(`Extracted local skill: ${skillId}`);
+  return extracted;
+}
+
+// src/cli/lib/skills/source-switcher.ts
+init_esm_shims();
+import path22 from "path";
+async function archiveLocalSkill(projectDir, skillId) {
+  const skillPath = path22.join(projectDir, LOCAL_SKILLS_PATH, skillId);
+  const archivedDir = path22.join(projectDir, LOCAL_SKILLS_PATH, ARCHIVED_SKILLS_DIR_NAME);
+  const archivedSkillPath = path22.join(archivedDir, skillId);
+  if (!await directoryExists(skillPath)) {
+    warn(`Skill directory not found for archiving: ${skillPath}`);
+    return;
+  }
+  await ensureDir(archivedDir);
+  await copy(skillPath, archivedSkillPath);
+  await remove(skillPath);
+  verbose(`Archived local skill '${skillId}' to ${ARCHIVED_SKILLS_DIR_NAME}/`);
+}
+async function restoreArchivedSkill(projectDir, skillId) {
+  const skillPath = path22.join(projectDir, LOCAL_SKILLS_PATH, skillId);
+  const archivedSkillPath = path22.join(
+    projectDir,
+    LOCAL_SKILLS_PATH,
+    ARCHIVED_SKILLS_DIR_NAME,
+    skillId
+  );
+  if (!await directoryExists(archivedSkillPath)) {
+    return false;
+  }
+  await copy(archivedSkillPath, skillPath);
+  await remove(archivedSkillPath);
+  verbose(`Restored archived skill '${skillId}' from ${ARCHIVED_SKILLS_DIR_NAME}/`);
+  return true;
+}
+
+// src/cli/lib/configuration/config-generator.ts
+function extractSubcategory(categoryPath) {
+  if (categoryPath === "local") return void 0;
+  const parts = categoryPath.split("/");
+  return parts.length >= 2 ? parts[1] : parts[0];
+}
+function generateProjectConfigFromSkills(name, selectedSkillIds, matrix, options) {
+  const neededAgents = /* @__PURE__ */ new Set();
+  const stackProperty = {};
+  for (const skillId of selectedSkillIds) {
+    const skill = matrix.skills[skillId];
+    if (!skill) {
+      continue;
+    }
+    const skillPath = skill.path;
+    const category = skill.category;
+    const agents = getAgentsForSkill(skillPath, category);
+    const subcategory = extractSubcategory(category);
+    for (const agentId of agents) {
+      neededAgents.add(agentId);
+      if (subcategory) {
+        if (!stackProperty[agentId]) {
+          stackProperty[agentId] = {};
+        }
+        stackProperty[agentId][subcategory] = skillId;
+      }
+    }
+  }
+  const config = {
+    name,
+    agents: Array.from(neededAgents).sort(),
+    skills: [...selectedSkillIds]
+  };
+  if (Object.keys(stackProperty).length > 0) {
+    config.stack = stackProperty;
+  }
+  if (options?.description) {
+    config.description = options.description;
+  }
+  if (options?.author) {
+    config.author = options.author;
+  }
+  return config;
+}
+function buildStackProperty(stack, displayNameToId) {
+  const result = {};
+  for (const [agentId, agentConfig] of typedEntries(stack.agents)) {
+    if (!agentConfig || Object.keys(agentConfig).length === 0) {
+      continue;
+    }
+    const resolvedMappings = {};
+    for (const [subcategoryId, displayName] of typedEntries(
+      agentConfig
+    )) {
+      if (!displayName) continue;
+      const skillId = displayNameToId[displayName];
+      if (skillId) {
+        resolvedMappings[subcategoryId] = skillId;
+      } else {
+        resolvedMappings[subcategoryId] = displayName;
+      }
+    }
+    if (Object.keys(resolvedMappings).length > 0) {
+      result[agentId] = resolvedMappings;
+    }
+  }
+  return result;
+}
+
+// src/cli/lib/configuration/config-merger.ts
+init_esm_shims();
+import { difference } from "remeda";
+
+// src/cli/lib/configuration/project-config.ts
+init_esm_shims();
+import path23 from "path";
+import { parse as parseYaml11 } from "yaml";
+var CONFIG_PATH = `${CLAUDE_SRC_DIR}/config.yaml`;
+var LEGACY_CONFIG_PATH = `${CLAUDE_DIR}/config.yaml`;
+async function loadProjectConfig(projectDir) {
+  const srcConfigPath = path23.join(projectDir, CONFIG_PATH);
+  const legacyConfigPath = path23.join(projectDir, LEGACY_CONFIG_PATH);
+  let configPath = srcConfigPath;
+  if (!await fileExists(srcConfigPath)) {
+    if (await fileExists(legacyConfigPath)) {
+      configPath = legacyConfigPath;
+      verbose(`Using legacy config location: ${legacyConfigPath}`);
+    } else {
+      verbose(`Project config not found at ${srcConfigPath} or ${legacyConfigPath}`);
+      return null;
+    }
+  }
+  try {
+    const content = await readFile(configPath);
+    const parsed = parseYaml11(content);
+    if (!parsed || typeof parsed !== "object") {
+      warn(`Invalid project config structure at ${configPath}`);
+      return null;
+    }
+    const result = projectConfigLoaderSchema.safeParse(parsed);
+    if (!result.success) {
+      warn(`Invalid project config at ${configPath}: ${result.error.message}`);
+      return null;
+    }
+    const config = result.data;
+    if (!config.name) {
+      warn(
+        `Project config at ${configPath} is missing required 'name' field \u2014 defaulting to directory name`
+      );
+      config.name = path23.basename(projectDir);
+    }
+    if (!config.skills) {
+      warn(`Project config at ${configPath} is missing 'skills' array \u2014 defaulting to empty`);
+      config.skills = [];
+    }
+    verbose(`Loaded project config from ${configPath}`);
+    return {
+      config,
+      configPath
+    };
+  } catch (error) {
+    warn(`Failed to parse project config at ${configPath}: ${error}`);
+    return null;
+  }
+}
+function validateProjectConfig(config) {
+  const errors = [];
+  const warnings = [];
+  if (!config || typeof config !== "object") {
+    return { valid: false, errors: ["Config must be an object"], warnings: [] };
+  }
+  const c = config;
+  if (!c.name || typeof c.name !== "string") {
+    errors.push("name is required and must be a string");
+  }
+  if (!c.agents || !Array.isArray(c.agents)) {
+    errors.push("agents is required and must be an array");
+  } else {
+    for (const agent of c.agents) {
+      if (typeof agent !== "string") {
+        errors.push(`agents must contain strings, found: ${typeof agent}`);
+      }
+    }
+  }
+  if (c.version !== void 0 && c.version !== "1") {
+    errors.push('version must be "1" (or omitted for default)');
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+// src/cli/lib/configuration/config-merger.ts
+async function mergeWithExistingConfig(newConfig, context) {
+  const localConfig = { ...newConfig };
+  const existingFullConfig = await loadProjectConfig(context.projectDir);
+  if (existingFullConfig) {
+    const existingConfig = existingFullConfig.config;
+    if (existingConfig.name) {
+      localConfig.name = existingConfig.name;
+    }
+    if (existingConfig.description) {
+      localConfig.description = existingConfig.description;
+    }
+    if (existingConfig.source) {
+      localConfig.source = existingConfig.source;
+    }
+    if (existingConfig.agents && existingConfig.agents.length > 0) {
+      const newAgentIds = difference(localConfig.agents, existingConfig.agents);
+      localConfig.agents = [...existingConfig.agents, ...newAgentIds];
+    }
+    if (existingConfig.stack) {
+      const mergedStack = { ...localConfig.stack };
+      for (const [agentId, agentConfig] of Object.entries(existingConfig.stack)) {
+        mergedStack[agentId] = { ...mergedStack[agentId], ...agentConfig };
+      }
+      localConfig.stack = mergedStack;
+    }
+    if (existingConfig.author) {
+      localConfig.author = existingConfig.author;
+    }
+    if (existingConfig.agents_source) {
+      localConfig.agents_source = existingConfig.agents_source;
+    }
+    if (existingConfig.marketplace) {
+      localConfig.marketplace = existingConfig.marketplace;
+    }
+    return {
+      config: localConfig,
+      merged: true,
+      existingConfigPath: existingFullConfig.configPath
+    };
+  }
+  const existingProjectConfig = await loadProjectSourceConfig(context.projectDir);
+  if (existingProjectConfig?.author) {
+    localConfig.author = existingProjectConfig.author;
+  }
+  if (existingProjectConfig?.agents_source) {
+    localConfig.agents_source = existingProjectConfig.agents_source;
+  }
+  return { config: localConfig, merged: false };
+}
+
+// src/cli/lib/configuration/config-saver.ts
+init_esm_shims();
+import path24 from "path";
+import { parse as parseYaml12, stringify as stringifyYaml5 } from "yaml";
+var YAML_INDENT2 = 2;
+async function saveSourceToProjectConfig(projectDir, source) {
+  const configPath = path24.join(projectDir, CLAUDE_SRC_DIR, "config.yaml");
+  let config = {};
+  if (await fileExists(configPath)) {
+    const content = await readFile(configPath);
+    try {
+      const parsed = parseYaml12(content);
+      const result = projectSourceConfigSchema.safeParse(parsed);
+      config = result.success ? result.data : {};
+      if (!result.success) {
+        warn(
+          `Invalid config at ${configPath}: ${result.error.issues.map((i) => i.message).join(", ")}. Starting with empty config.`
+        );
+      }
+    } catch (error) {
+      warn(
+        `Failed to parse existing config at ${configPath}: ${error instanceof Error ? error.message : String(error)}. Starting with empty config.`
+      );
+    }
+  }
+  config.source = source;
+  await ensureDir(path24.join(projectDir, CLAUDE_SRC_DIR));
+  const configYaml = stringifyYaml5(config, { indent: YAML_INDENT2 });
+  await writeFile(configPath, configYaml);
+}
+
+// src/cli/lib/loading/source-fetcher.ts
+function sanitizeSourceForCache(source) {
+  return source.replace(/:/g, "-").replace(/[\/]/g, "-").replace(/--+/g, "-").replace(/^-|-$/g, "");
+}
+function getCacheDir(source) {
+  const sanitized = sanitizeSourceForCache(source);
+  return path25.join(CACHE_DIR, "sources", sanitized);
+}
+async function fetchFromSource(source, options = {}) {
+  const { forceRefresh = false, subdir } = options;
+  if (isLocalSource(source)) {
+    return fetchFromLocalSource(source, subdir);
+  }
+  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);
+  if (!await directoryExists(absolutePath)) {
+    throw new Error(`Local source not found: ${absolutePath}`);
+  }
+  verbose(`Using local source: ${absolutePath}`);
+  return {
+    path: absolutePath,
+    fromCache: false,
+    source
+  };
+}
+async function fetchFromRemoteSource(source, options) {
+  const { forceRefresh = false, subdir } = options;
+  const cacheDir = getCacheDir(source);
+  const fullSource = subdir ? `${source}/${subdir}` : source;
+  verbose(`Fetching from remote: ${fullSource}`);
+  verbose(`Cache directory: ${cacheDir}`);
+  if (!forceRefresh && await directoryExists(cacheDir)) {
+    verbose(`Using cached source: ${cacheDir}`);
+    return {
+      path: cacheDir,
+      fromCache: true,
+      source: fullSource
+    };
+  }
+  await ensureDir(path25.dirname(cacheDir));
+  try {
+    const result = await downloadTemplate(fullSource, {
+      dir: cacheDir,
+      force: true,
+      // Always force when downloading to avoid "already exists" error
+      offline: false
+    });
+    verbose(`Downloaded to: ${result.dir}`);
+    return {
+      path: result.dir,
+      fromCache: false,
+      source: fullSource
+    };
+  } catch (error) {
+    throw wrapGigetError(error, source);
+  }
+}
+function wrapGigetError(error, source) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("404") || message.includes("Not Found")) {
+    return new Error(
+      `Repository not found: ${source}
+
+This could mean:
+  - The repository doesn't exist
+  - The repository is private and you need to set authentication
+  - There's a typo in the URL
+
+For private repositories, set the GIGET_AUTH environment variable:
+  export GIGET_AUTH=ghp_your_github_token`
+    );
+  }
+  if (message.includes("401") || message.includes("Unauthorized")) {
+    return new Error(
+      `Authentication required for: ${source}
+
+Set the GIGET_AUTH environment variable with a GitHub token:
+  export GIGET_AUTH=ghp_your_github_token
+
+Create a token at: https://github.com/settings/tokens
+Required scope: repo (for private repos) or public_repo (for public)`
+    );
+  }
+  if (message.includes("403") || message.includes("Forbidden")) {
+    return new Error(
+      `Access denied to: ${source}
+
+Your token may not have sufficient permissions.
+Ensure your GIGET_AUTH token has the 'repo' scope for private repositories.`
+    );
+  }
+  if (message.includes("ENOTFOUND") || message.includes("ETIMEDOUT") || message.includes("network")) {
+    return new Error(
+      `Network error fetching: ${source}
+
+Please check your internet connection.
+If you're behind a corporate proxy, you may need to set:
+  export HTTPS_PROXY=http://your-proxy:port
+  export FORCE_NODE_FETCH=true  # Required for Node 20+`
+    );
+  }
+  return new Error(`Failed to fetch ${source}: ${message}`);
+}
+async function fetchMarketplace(source, options = {}) {
+  const result = await fetchFromSource(source, {
+    forceRefresh: options.forceRefresh,
+    subdir: ""
+    // Root of repo
+  });
+  const marketplacePath = path25.join(result.path, ".claude-plugin", "marketplace.json");
+  if (!await directoryExists(path25.dirname(marketplacePath))) {
+    throw new Error(
+      `Marketplace not found at: ${marketplacePath}
+
+Expected .claude-plugin/marketplace.json in the source repository.`
+    );
+  }
+  const content = await readFile(marketplacePath);
+  const parsed = JSON.parse(content);
+  const validation = marketplaceSchema.safeParse(parsed);
+  if (!validation.success) {
+    throw new Error(
+      `Invalid marketplace.json at: ${marketplacePath}
+
+Validation errors: ${validation.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  const marketplace = validation.data;
+  verbose(`Loaded marketplace: ${marketplace.name} v${marketplace.version}`);
+  return {
+    marketplace,
+    sourcePath: result.path,
+    fromCache: result.fromCache ?? false
+  };
+}
+
+// src/cli/lib/configuration/source-manager.ts
+var DEFAULT_SOURCE_NAME = "public";
+async function addSource(projectDir, url) {
+  const result = await fetchMarketplace(url, { forceRefresh: true });
+  const name = result.marketplace.name;
+  const skillCount = result.marketplace.plugins.length;
+  const config = await loadProjectSourceConfig(projectDir) ?? {};
+  const sources = config.sources ?? [];
+  const exists = sources.some((s) => s.name === name);
+  if (exists) {
+    throw new Error(`Source "${name}" already exists`);
+  }
+  sources.push({ name, url });
+  config.sources = sources;
+  await saveProjectConfig(projectDir, config);
+  verbose(`Added source "${name}" with ${skillCount} skills`);
+  return { name, skillCount };
+}
+async function removeSource(projectDir, name) {
+  if (name === DEFAULT_SOURCE_NAME) {
+    throw new Error(`Cannot remove the "${DEFAULT_SOURCE_NAME}" source`);
+  }
+  const config = await loadProjectSourceConfig(projectDir) ?? {};
+  const sources = config.sources ?? [];
+  const filtered = sources.filter((s) => s.name !== name);
+  if (filtered.length === sources.length) {
+    throw new Error(`Source "${name}" not found`);
+  }
+  config.sources = filtered;
+  await saveProjectConfig(projectDir, config);
+  verbose(`Removed source "${name}"`);
+}
+async function getSourceSummary(projectDir, matrix) {
+  const config = await loadProjectSourceConfig(projectDir) ?? {};
+  const sources = [
+    {
+      name: DEFAULT_SOURCE_NAME,
+      url: config.source ?? DEFAULT_SOURCE,
+      enabled: true
+    }
+  ];
+  if (config.sources) {
+    for (const source of config.sources) {
+      sources.push({ ...source, enabled: true });
+    }
+  }
+  let localSkillCount = 0;
+  try {
+    const localResult = await discoverLocalSkills(projectDir);
+    if (localResult) {
+      localSkillCount = localResult.skills.length;
+    }
+  } catch {
+    verbose("Failed to discover local skills for source summary");
+  }
+  let pluginSkillCount = 0;
+  if (matrix) {
+    try {
+      const pluginDir = getCollectivePluginDir(projectDir);
+      const pluginSkillsDir = getPluginSkillsDir(pluginDir);
+      const skillIds = await getPluginSkillIds(pluginSkillsDir, matrix);
+      pluginSkillCount = skillIds.length;
+    } catch {
+      verbose("Failed to count plugin skills for source summary");
+    }
+  }
+  return { sources, localSkillCount, pluginSkillCount };
+}
+
+export {
+  generateAgentPluginManifest,
+  writePluginManifest,
+  findPluginManifest,
+  getCollectivePluginDir,
+  getProjectPluginsDir,
+  getPluginSkillsDir,
+  getPluginAgentsDir,
+  getPluginManifestPath,
+  getPluginSkillIds,
+  DEFAULT_SOURCE,
+  SOURCE_ENV_VAR,
+  getProjectConfigPath,
+  loadProjectSourceConfig,
+  saveProjectConfig,
+  resolveSource,
+  resolveAgentsSource,
+  formatOrigin,
+  resolveAuthor,
+  resolveAllSources,
+  getCurrentDate,
+  hashString,
+  hashFile,
+  determinePluginVersion,
+  writeContentHash,
+  readForkedFromMetadata,
+  compareSkills,
+  injectForkedFromMetadata,
+  copySkillsToPluginFromSource,
+  copySkillsToLocalFlattened,
+  parseFrontmatter,
+  loadAllAgents,
+  loadProjectAgents,
+  loadPluginSkills,
+  resolveAlias,
+  validateSelection,
+  getAvailableSkills,
+  fetchFromSource,
+  searchExtraSources,
+  loadStacks,
+  buildSkillRefsFromConfig,
+  resolveAgents,
+  extractFrontmatter,
+  createLiquidEngine,
+  compileAgentForPlugin,
+  compileStackPlugin,
+  printStackCompilationSummary,
+  claudePluginInstall,
+  isClaudeCLIAvailable,
+  claudePluginMarketplaceExists,
+  claudePluginMarketplaceAdd,
+  claudePluginUninstall,
+  installStackAsPlugin,
+  loadSkillsMatrixFromSource,
+  compileSkillPlugin,
+  compileAllSkillPlugins,
+  printCompilationSummary,
+  discoverLocalSkills,
+  archiveLocalSkill,
+  restoreArchivedSkill,
+  loadProjectConfig,
+  validateProjectConfig,
+  saveSourceToProjectConfig,
+  addSource,
+  removeSource,
+  getSourceSummary,
+  detectInstallation,
+  installLocal,
+  getInstallationInfo,
+  formatInstallationDisplay,
+  bumpPluginVersion,
+  getPluginVersion,
+  validatePlugin,
+  validateAllPlugins,
+  printPluginValidationResult
+};
+//# sourceMappingURL=chunk-ETQ3BPGU.js.map