@agents-inc/cli 0.32.1

package/dist/chunk-MM7NK5N2.js

@@ -0,0 +1,4542 @@
+#!/usr/bin/env node
+import {
+  typedEntries,
+  typedKeys
+} from "./chunk-T4EXUIBY.js";
+import {
+  SKILL_ID_PATTERN,
+  agentFrontmatterValidationSchema,
+  agentYamlConfigSchema,
+  categoryPathSchema,
+  copy,
+  directoryExists,
+  ensureDir,
+  fileExists,
+  formatZodErrors,
+  getErrorMessage,
+  glob,
+  hooksRecordSchema,
+  listDirectories,
+  localRawMetadataSchema,
+  localSkillMetadataSchema,
+  log,
+  marketplaceSchema,
+  pluginAuthorSchema,
+  pluginManifestSchema,
+  projectConfigLoaderSchema,
+  projectSourceConfigSchema,
+  readFile,
+  readFileOptional,
+  readFileSafe,
+  remove,
+  skillDisplayNameSchema,
+  skillFrontmatterLoaderSchema,
+  skillFrontmatterValidationSchema,
+  skillIdSchema,
+  skillMetadataLoaderSchema,
+  skillsMatrixConfigSchema,
+  stacksConfigSchema,
+  validateNestingDepth,
+  verbose,
+  warn,
+  warnUnknownFields,
+  writeFile
+} from "./chunk-BZN2Z5P7.js";
+import {
+  ARCHIVED_SKILLS_DIR_NAME,
+  CACHE_DIR,
+  CACHE_HASH_LENGTH,
+  CACHE_READABLE_PREFIX_LENGTH,
+  CLAUDE_DIR,
+  CLAUDE_SRC_DIR,
+  DEFAULT_BRANDING,
+  DEFAULT_DISPLAY_VERSION,
+  DEFAULT_PLUGIN_NAME,
+  DEFAULT_VERSION,
+  DIRS,
+  GITHUB_SOURCE,
+  HASH_PREFIX_LENGTH,
+  LOCAL_SKILLS_PATH,
+  MAX_CONFIG_FILE_SIZE,
+  MAX_JSON_NESTING_DEPTH,
+  MAX_MARKETPLACE_FILE_SIZE,
+  MAX_MARKETPLACE_PLUGINS,
+  MAX_PLUGIN_FILE_SIZE,
+  PLUGINS_SUBDIR,
+  PLUGIN_MANIFEST_DIR,
+  PLUGIN_MANIFEST_FILE,
+  PROJECT_ROOT,
+  SCHEMA_PATHS,
+  SKILLS_DIR_PATH,
+  SKILLS_MATRIX_PATH,
+  STACKS_FILE_PATH,
+  STANDARD_DIRS,
+  STANDARD_FILES,
+  YAML_FORMATTING,
+  yamlSchemaComment
+} from "./chunk-LAPCUV4D.js";
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.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 { stringify as stringifyYaml } from "yaml";
+
+// src/cli/utils/yaml.ts
+init_esm_shims();
+import { parse as parseYaml } from "yaml";
+async function safeLoadYamlFile(filePath, schema, maxSizeBytes = MAX_CONFIG_FILE_SIZE) {
+  try {
+    const content = await readFileSafe(filePath, maxSizeBytes);
+    const parsed = parseYaml(content);
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+      warn(`Invalid YAML at '${filePath}': ${result.error.message}`);
+      return null;
+    }
+    return result.data;
+  } catch (error) {
+    warn(`Failed to parse YAML at '${filePath}': ${error}`);
+    return null;
+  }
+}
+
+// src/cli/lib/configuration/config.ts
+var DEFAULT_SOURCE = `${GITHUB_SOURCE.GITHUB_PREFIX}claude-collective/skills`;
+var SOURCE_ENV_VAR = "CC_SOURCE";
+var PROJECT_CONFIG_FILE = STANDARD_FILES.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, STANDARD_FILES.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;
+    }
+  }
+  const data = await safeLoadYamlFile(configPath, projectSourceConfigSchema);
+  if (!data) return null;
+  verbose(`Loaded project config from ${configPath}`);
+  return data;
+}
+async function saveProjectConfig(projectDir, config) {
+  const configPath = getProjectConfigPath(projectDir);
+  await ensureDir(path.join(projectDir, CLAUDE_SRC_DIR));
+  const schemaComment = `${yamlSchemaComment(SCHEMA_PATHS.projectSourceConfig)}
+`;
+  const content = stringifyYaml(config, { lineWidth: YAML_FORMATTING.LINE_WIDTH_NONE });
+  await writeFile(configPath, `${schemaComment}${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. Provide a valid source: a local directory path or a git repository URL (e.g., './my-skills' or 'https://github.com/user/repo')"
+      );
+    }
+    validateSourceFormat(flagValue.trim(), "--source");
+    verbose(`Source from --source flag: ${flagValue}`);
+    return { source: flagValue, sourceOrigin: "flag", marketplace };
+  }
+  const envValue = process.env[SOURCE_ENV_VAR];
+  if (envValue) {
+    const trimmed = envValue.trim();
+    if (trimmed === "") {
+      warn(`${SOURCE_ENV_VAR} is set but empty \u2014 ignoring and falling back to next source.`);
+    } else {
+      try {
+        validateSourceFormat(trimmed, SOURCE_ENV_VAR);
+        verbose(`Source from ${SOURCE_ENV_VAR} env var: ${trimmed}`);
+        return { source: trimmed, sourceOrigin: "env", marketplace };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        warn(
+          `${SOURCE_ENV_VAR} has an invalid value \u2014 ignoring and falling back to next source.
+${message}`
+        );
+      }
+    }
+  }
+  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. Provide a valid source: a local directory path or a git repository URL (e.g., './my-agents' or 'https://github.com/user/repo')"
+      );
+    }
+    validateSourceFormat(flagValue.trim(), "--agent-source");
+    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";
+      default:
+        break;
+    }
+  }
+  switch (origin) {
+    case "flag":
+      return "--agent-source flag";
+    case "default":
+      return "default (local CLI)";
+    default:
+      break;
+  }
+  return origin;
+}
+async function resolveAuthor(projectDir) {
+  const projectConfig = projectDir ? await loadProjectSourceConfig(projectDir) : null;
+  return projectConfig?.author;
+}
+async function resolveBranding(projectDir) {
+  const projectConfig = projectDir ? await loadProjectSourceConfig(projectDir) : null;
+  return {
+    name: projectConfig?.branding?.name ?? DEFAULT_BRANDING.NAME,
+    tagline: projectConfig?.branding?.tagline ?? DEFAULT_BRANDING.TAGLINE
+  };
+}
+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 };
+}
+var REMOTE_PROTOCOLS = [
+  GITHUB_SOURCE.GITHUB_PREFIX,
+  // "github:"
+  GITHUB_SOURCE.GH_PREFIX,
+  // "gh:"
+  "gitlab:",
+  "bitbucket:",
+  "sourcehut:",
+  "https://",
+  "http://"
+];
+var MIN_REMOTE_PATH_LENGTH = 3;
+var MAX_SOURCE_LENGTH = 512;
+var NULL_BYTE_PATTERN = /\0/;
+var PATH_TRAVERSAL_PATTERN = /\.\./;
+var UNC_PATH_PATTERN = /^(?:\/\/|\\\\)/;
+var PRIVATE_IPV4_PATTERN = /^(?:127\.\d+\.\d+\.\d+|10\.\d+\.\d+\.\d+|172\.(?:1[6-9]|2\d|3[01])\.\d+\.\d+|192\.168\.\d+\.\d+|0\.0\.0\.0|169\.254\.\d+\.\d+)$/;
+var PRIVATE_IPV6_PATTERN = /^\[(?:::1|::ffff:(?:127\.\d+\.\d+\.\d+|10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+)|fd[0-9a-f]{2}:.*|fe80:.*)\]$/i;
+function validateSourceFormat(source, flagName) {
+  if (NULL_BYTE_PATTERN.test(source)) {
+    throw new Error(
+      `${flagName} contains invalid characters.
+
+Source values must not contain null bytes.
+Examples:
+  ${flagName} ./my-skills
+  ${flagName} github:user/repo`
+    );
+  }
+  if (source.length > MAX_SOURCE_LENGTH) {
+    throw new Error(
+      `${flagName} value is too long (${source.length} characters, max ${MAX_SOURCE_LENGTH}).
+
+Provide a shorter source path or URL.
+Examples:
+  ${flagName} ./my-skills
+  ${flagName} github:user/repo`
+    );
+  }
+  const matchedProtocol = REMOTE_PROTOCOLS.find((prefix) => source.startsWith(prefix));
+  if (matchedProtocol) {
+    validateRemoteSource(source, matchedProtocol, flagName);
+  } else {
+    validateLocalPath(source, flagName);
+  }
+}
+function validateRemoteSource(source, protocol, flagName) {
+  const pathAfterProtocol = source.slice(protocol.length).trim();
+  if (pathAfterProtocol.length < MIN_REMOTE_PATH_LENGTH) {
+    throw new Error(
+      `${flagName} has an incomplete URL: "${source}"
+
+A repository path is required after the protocol prefix.
+Examples:
+  ${flagName} github:user/repo
+  ${flagName} https://github.com/user/repo`
+    );
+  }
+  if (PATH_TRAVERSAL_PATTERN.test(pathAfterProtocol)) {
+    throw new Error(
+      `${flagName} contains path traversal in URL: "${source}"
+
+Remote source URLs must not contain '..' sequences.
+Examples:
+  ${flagName} github:user/repo
+  ${flagName} https://github.com/user/repo`
+    );
+  }
+  if (protocol === "https://" || protocol === "http://") {
+    validateHttpUrl(source, flagName);
+  }
+  if (protocol !== "https://" && protocol !== "http://") {
+    validateGitShorthand(source, pathAfterProtocol, flagName);
+  }
+}
+function validateHttpUrl(source, flagName) {
+  const afterProtocol = source.replace(/^https?:\/\//, "");
+  const hostnameWithPort = afterProtocol.split("/")[0] ?? "";
+  const hostname = hostnameWithPort.split(":")[0] ?? "";
+  const isBracketedIPv6 = hostnameWithPort.startsWith("[") && hostnameWithPort.includes("]");
+  if (!hostname || !hostname.includes(".") && hostname !== "localhost" && !isBracketedIPv6) {
+    throw new Error(
+      `${flagName} has an invalid URL: "${source}"
+
+The URL must include a valid hostname.
+Examples:
+  ${flagName} https://github.com/user/repo
+  ${flagName} https://gitlab.company.com/team/skills`
+    );
+  }
+  if (PRIVATE_IPV4_PATTERN.test(hostname) || PRIVATE_IPV6_PATTERN.test(hostnameWithPort)) {
+    throw new Error(
+      `${flagName} points to a private or reserved IP address: "${source}"
+
+Source URLs must not target private network addresses.
+Use a public hostname instead.
+Examples:
+  ${flagName} https://github.com/user/repo
+  ${flagName} https://gitlab.company.com/team/skills`
+    );
+  }
+}
+function validateGitShorthand(source, repoPath, flagName) {
+  if (!repoPath.includes("/")) {
+    throw new Error(
+      `${flagName} has an invalid repository reference: "${source}"
+
+Git shorthand sources require an owner/repo format.
+Examples:
+  ${flagName} github:user/repo
+  ${flagName} gh:organization/skills`
+    );
+  }
+}
+function validateLocalPath(source, flagName) {
+  const CONTROL_CHAR_PATTERN = /[\x00-\x08\x0E-\x1F\x7F]/u;
+  if (CONTROL_CHAR_PATTERN.test(source)) {
+    throw new Error(
+      `${flagName} contains invalid characters: "${source}"
+
+Source paths must not contain control characters.
+Examples:
+  ${flagName} ./my-skills
+  ${flagName} /home/user/skills`
+    );
+  }
+  if (UNC_PATH_PATTERN.test(source)) {
+    throw new Error(
+      `${flagName} contains a UNC network path: "${source}"
+
+Network paths (\\\\server\\share or //server/share) are not allowed for security reasons.
+Use a local directory path or a remote URL instead.
+Examples:
+  ${flagName} ./my-skills
+  ${flagName} /home/user/skills
+  ${flagName} https://github.com/user/repo`
+    );
+  }
+}
+function isLocalSource(source) {
+  if (source.startsWith("/") || source.startsWith(".")) {
+    return true;
+  }
+  const hasRemoteProtocol = REMOTE_PROTOCOLS.some((prefix) => source.startsWith(prefix));
+  if (!hasRemoteProtocol) {
+    if (source.includes("..") || source.includes("~")) {
+      throw new Error(
+        `Invalid source path: ${source}. Path traversal patterns like '..' and '~' are not allowed for security reasons. Use absolute paths or remote URLs instead (e.g., '/home/user/skills' or 'https://github.com/user/repo').`
+      );
+    }
+  }
+  return !hasRemoteProtocol;
+}
+
+// src/cli/lib/loading/source-fetcher.ts
+init_esm_shims();
+import { createHash as createHash2 } from "crypto";
+import { downloadTemplate } from "giget";
+import path24 from "path";
+
+// 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 { sortBy } from "remeda";
+import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
+
+// src/cli/lib/versioning.ts
+init_esm_shims();
+import { createHash } from "crypto";
+import path2 from "path";
+
+// src/cli/lib/metadata-keys.ts
+init_esm_shims();
+var METADATA_KEYS = {
+  CLI_NAME: "cli_name",
+  CLI_DESCRIPTION: "cli_description",
+  CATEGORY: "category",
+  FORKED_FROM: "forked_from",
+  CONTENT_HASH: "content_hash",
+  USAGE_GUIDANCE: "usage_guidance"
+};
+var IMPORT_DEFAULTS = {
+  CATEGORY: "imported",
+  AUTHOR: "@imported"
+};
+var LOCAL_DEFAULTS = {
+  CATEGORY: "local",
+  AUTHOR: "@local"
+};
+var SKILL_CONTENT_FILES = [STANDARD_FILES.SKILL_MD, STANDARD_FILES.REFERENCE_MD];
+var SKILL_CONTENT_DIRS = [STANDARD_DIRS.EXAMPLES, STANDARD_DIRS.SCRIPTS];
+
+// src/cli/lib/versioning.ts
+function getCurrentDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+function computeStringHash(content) {
+  const hash = createHash("sha256");
+  hash.update(content);
+  return hash.digest("hex").slice(0, HASH_PREFIX_LENGTH);
+}
+async function computeFileHash(filePath) {
+  const content = await readFile(filePath);
+  return computeStringHash(content);
+}
+async function computeSkillFolderHash(skillPath) {
+  const contents = [];
+  for (const fileName of SKILL_CONTENT_FILES) {
+    const filePath = path2.join(skillPath, fileName);
+    if (await fileExists(filePath)) {
+      const content = await readFile(filePath);
+      contents.push(`${fileName}:${content}`);
+    }
+  }
+  for (const dirName of SKILL_CONTENT_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 computeStringHash(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 readFileSafe(manifestPath, MAX_PLUGIN_FILE_SIZE);
+    const manifest = pluginManifestSchema.parse(JSON.parse(content));
+    const hashFilePath = manifestPath.replace(STANDARD_FILES.PLUGIN_JSON, CONTENT_HASH_FILE);
+    let contentHash;
+    if (await fileExists(hashFilePath)) {
+      contentHash = (await readFile(hashFilePath)).trim();
+    }
+    return {
+      version: manifest.version ?? DEFAULT_VERSION,
+      contentHash
+    };
+  } catch (error) {
+    warn(`Failed to read plugin manifest at '${manifestPath}': ${getErrorMessage(error)}`);
+    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(
+    STANDARD_FILES.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, STANDARD_FILES.METADATA_YAML);
+  if (!await fileExists(metadataPath)) {
+    return null;
+  }
+  const content = await readFile(metadataPath);
+  const result = localSkillMetadataSchema.safeParse(parseYaml2(content));
+  if (!result.success) {
+    warn(`Invalid metadata.yaml at ${metadataPath}: ${formatZodErrors(result.error.issues)}`);
+    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, STANDARD_FILES.SKILL_MD);
+  if (!await fileExists(skillMdPath)) {
+    return null;
+  }
+  return computeFileHash(skillMdPath);
+}
+async function compareLocalSkillsWithSource(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, STANDARD_FILES.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(parseYaml2(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 schemaComment = `${yamlSchemaComment(SCHEMA_PATHS.metadata)}
+`;
+  const newYamlContent = stringifyYaml2(metadata, { lineWidth: YAML_FORMATTING.LINE_WIDTH_NONE });
+  await writeFile(metadataPath, `${schemaComment}${newYamlContent}`);
+}
+
+// src/cli/lib/skills/skill-copier.ts
+init_esm_shims();
+import path4 from "path";
+var NULL_BYTE_PATTERN2 = /\0/;
+function validateSkillPath(resolvedPath, expectedParent, skillPath) {
+  if (NULL_BYTE_PATTERN2.test(skillPath)) {
+    throw new Error(`Invalid skill path: '${skillPath}' contains null bytes`);
+  }
+  const normalizedResolved = path4.resolve(resolvedPath);
+  const normalizedParent = path4.resolve(expectedParent);
+  if (!normalizedResolved.startsWith(normalizedParent + path4.sep) && normalizedResolved !== normalizedParent) {
+    throw new Error(
+      `Invalid skill path: '${skillPath}' escapes expected directory '${normalizedParent}'`
+    );
+  }
+}
+function resolveSkillPath(basePath, skillPath) {
+  const resolved = path4.join(basePath, skillPath);
+  validateSkillPath(resolved, basePath, skillPath);
+  return resolved;
+}
+async function generateSkillHash(skillSourcePath) {
+  const skillMdPath = path4.join(skillSourcePath, STANDARD_FILES.SKILL_MD);
+  return computeFileHash(skillMdPath);
+}
+function getSkillSourcePathFromSource(skill, sourceResult) {
+  const srcDir = path4.join(sourceResult.sourcePath, "src");
+  return resolveSkillPath(srcDir, skill.path);
+}
+function getFlattenedSkillDestPath(skill, localSkillsDir) {
+  return resolveSkillPath(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 results = await Promise.all(
+    selectedSkillIds.map(async (skillId) => {
+      const skill = matrix.skills[skillId];
+      if (!skill) {
+        warn(`Skill not found in matrix: '${skillId}'`);
+        return null;
+      }
+      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);
+        return {
+          skillId: skill.id,
+          sourcePath: skill.localPath,
+          destPath: skill.localPath,
+          contentHash,
+          local: true
+        };
+      }
+      return copySkillToLocalFlattened(skill, localSkillsDir, sourceResult);
+    })
+  );
+  return results.filter((r) => r !== null);
+}
+
+// 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 parseYaml3 } 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(parseYaml3(yamlContent));
+  if (!parsed.success) {
+    const location = filePath ?? "unknown file";
+    warn(`Invalid SKILL.md frontmatter in '${location}': ${formatZodErrors(parsed.error.issues)}`);
+    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(parseYaml3(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}': ${getErrorMessage(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(parseYaml3(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}': ${getErrorMessage(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 {
+        warn(`Unknown skill reference '${skillId}'`);
+      }
+    }
+  }
+  const uniqueSkillIds = unique(expandedSkillIds);
+  for (const skillId of uniqueSkillIds) {
+    const directoryPath = idToDirectoryPath[skillId];
+    if (!directoryPath) {
+      warn(`Could not find skill '${skillId}': no matching skill found`);
+      continue;
+    }
+    const skillPath = path5.join(skillsDir, directoryPath);
+    const skillMdPath = path5.join(skillPath, STANDARD_FILES.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) {
+      warn(`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 parseYaml4 } 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 = parseYaml4(content);
+  const result = skillsMatrixConfigSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(
+      `Invalid skills matrix at '${configPath}': ${formatZodErrors(result.error.issues)}`
+    );
+  }
+  verbose(`Loaded skills matrix: ${configPath}`);
+  return result.data;
+}
+async function extractAllSkills(skillsDir) {
+  const skills = [];
+  const metadataFiles = await glob(`**/${STANDARD_FILES.METADATA_YAML}`, skillsDir);
+  for (const metadataFile of metadataFiles) {
+    const skillDir = path6.dirname(metadataFile);
+    const skillMdPath = path6.join(skillsDir, skillDir, STANDARD_FILES.SKILL_MD);
+    const metadataPath = path6.join(skillsDir, metadataFile);
+    if (!await fileExists(skillMdPath)) {
+      verbose(`Skipping ${metadataFile}: No ${STANDARD_FILES.SKILL_MD} found`);
+      continue;
+    }
+    const metadataContent = await readFile(metadataPath);
+    const rawMetadata = parseYaml4(metadataContent);
+    const metadataResult = rawMetadataSchema.safeParse(rawMetadata);
+    if (!metadataResult.success) {
+      warn(
+        `Skipping '${metadataFile}': invalid metadata.yaml \u2014 ${formatZodErrors(metadataResult.error.issues)}`
+      );
+      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 '${METADATA_KEYS.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) {
+    let slashIdx = skill.id.indexOf("/");
+    while (slashIdx !== -1) {
+      const suffix = skill.id.slice(slashIdx + 1);
+      if (suffix && aliasTargets.has(suffix) && suffix !== skill.id) {
+        map[suffix] = skill.id;
+      }
+      slashIdx = skill.id.indexOf("/", slashIdx + 1);
+    }
+  }
+  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 resolveConflicts(skillId, metadataConflicts, conflictRules, resolve) {
+  const conflicts = [];
+  for (const conflictRef of metadataConflicts) {
+    conflicts.push({
+      skillId: resolve(conflictRef, "conflictsWith"),
+      reason: "Defined in skill metadata"
+    });
+  }
+  for (const rule of conflictRules) {
+    const resolved = rule.skills.map((id) => resolve(id, "conflicts"));
+    if (!resolved.includes(skillId)) continue;
+    for (const other of resolved) {
+      if (other !== skillId && !conflicts.some((c) => c.skillId === other)) {
+        conflicts.push({ skillId: other, reason: rule.reason });
+      }
+    }
+  }
+  return conflicts;
+}
+function resolveRecommends(skillId, compatibleWith, recommendRules, resolve) {
+  const recommends = [];
+  for (const compatRef of compatibleWith) {
+    recommends.push({
+      skillId: resolve(compatRef, "compatibleWith"),
+      reason: "Compatible with this skill"
+    });
+  }
+  for (const rule of recommendRules) {
+    if (resolve(rule.when, "recommends.when") !== skillId) continue;
+    for (const suggested of rule.suggest) {
+      const canonicalId = resolve(suggested, "recommends.suggest");
+      if (!recommends.some((r) => r.skillId === canonicalId)) {
+        recommends.push({ skillId: canonicalId, reason: rule.reason });
+      }
+    }
+  }
+  return recommends;
+}
+function resolveRequirements(skillId, metadataRequires, requireRules, resolve) {
+  const requires = [];
+  if (metadataRequires.length > 0) {
+    requires.push({
+      skillIds: metadataRequires.map((id) => resolve(id, "requires")),
+      needsAny: false,
+      reason: "Defined in skill metadata"
+    });
+  }
+  for (const rule of requireRules) {
+    if (resolve(rule.skill, "requires.skill") !== skillId) continue;
+    requires.push({
+      skillIds: rule.needs.map((id) => resolve(id, "requires.needs")),
+      needsAny: rule.needs_any ?? false,
+      reason: rule.reason
+    });
+  }
+  return requires;
+}
+function resolveAlternatives(skillId, alternativeGroups, resolve) {
+  const alternatives = [];
+  for (const group of alternativeGroups) {
+    const resolved = group.skills.map((id) => resolve(id, "alternatives"));
+    if (!resolved.includes(skillId)) continue;
+    for (const alt of resolved) {
+      if (alt !== skillId) {
+        alternatives.push({ skillId: alt, purpose: group.purpose });
+      }
+    }
+  }
+  return alternatives;
+}
+function resolveDiscourages(skillId, discourageRules, resolve) {
+  if (!discourageRules) return [];
+  const discourages = [];
+  for (const rule of discourageRules) {
+    const resolved = rule.skills.map((id) => resolve(id, "discourages"));
+    if (!resolved.includes(skillId)) continue;
+    for (const other of resolved) {
+      if (other !== skillId && !discourages.some((d) => d.skillId === other)) {
+        discourages.push({ skillId: other, reason: rule.reason });
+      }
+    }
+  }
+  return discourages;
+}
+function buildResolvedSkill(skill, matrix, displayNameToId, displayNames, directoryPathToId, aliasTargetToSkillId) {
+  const resolve = (id, context) => resolveToCanonicalId(
+    id,
+    displayNameToId,
+    directoryPathToId,
+    aliasTargetToSkillId,
+    context ? `${skill.id} ${context}` : void 0
+  );
+  const { relationships } = matrix;
+  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: resolveConflicts(
+      skill.id,
+      skill.conflictsWith,
+      relationships.conflicts,
+      resolve
+    ),
+    recommends: resolveRecommends(
+      skill.id,
+      skill.compatibleWith,
+      relationships.recommends,
+      resolve
+    ),
+    requires: resolveRequirements(skill.id, skill.requires, relationships.requires, resolve),
+    alternatives: resolveAlternatives(skill.id, relationships.alternatives, resolve),
+    discourages: resolveDiscourages(skill.id, relationships.discourages, resolve),
+    compatibleWith: skill.compatibleWith.map((id) => resolve(id, "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 initializeSelectionContext(currentSelections, matrix) {
+  const resolvedSelections = currentSelections.map((s) => resolveAlias(s, matrix));
+  const selectedSet = new Set(resolvedSelections);
+  return { resolvedSelections, selectedSet };
+}
+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?.conflictsWith.some((c) => c.skillId === fullId)) {
+      return true;
+    }
+  }
+  const { selectedSet } = initializeSelectionContext(currentSelections, matrix);
+  for (const requirement of skill.requires) {
+    if (requirement.needsAny) {
+      const hasAny = requirement.skillIds.some((reqId) => selectedSet.has(reqId));
+      if (!hasAny) {
+        return true;
+      }
+    } else {
+      const hasAll = requirement.skillIds.every((reqId) => selectedSet.has(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, selectedSet } = initializeSelectionContext(currentSelections, 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) => selectedSet.has(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) => !selectedSet.has(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 } = initializeSelectionContext(currentSelections, matrix);
+  for (const selectedId of resolvedSelections) {
+    const selectedSkill = matrix.skills[selectedId];
+    if (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 } = initializeSelectionContext(currentSelections, 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 } = initializeSelectionContext(currentSelections, matrix);
+  for (const selectedId of resolvedSelections) {
+    const selectedSkill = matrix.skills[selectedId];
+    if (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 } = initializeSelectionContext(currentSelections, 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 validateConflicts(resolvedSelections, matrix) {
+  const errors = [];
+  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]
+        });
+      }
+    }
+  }
+  return { errors, warnings: [] };
+}
+function validateRequirements(resolvedSelections, selectedSet, matrix) {
+  const errors = [];
+  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) => selectedSet.has(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) => !selectedSet.has(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]
+          });
+        }
+      }
+    }
+  }
+  return { errors, warnings: [] };
+}
+function validateExclusivity(resolvedSelections, matrix) {
+  const errors = [];
+  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
+        });
+      }
+    }
+  }
+  return { errors, warnings: [] };
+}
+function validateRecommendations(resolvedSelections, selectedSet, matrix) {
+  const warnings = [];
+  for (const skillId of resolvedSelections) {
+    const skill = matrix.skills[skillId];
+    if (!skill) continue;
+    for (const recommendation of skill.recommends) {
+      if (!selectedSet.has(recommendation.skillId)) {
+        const recommendedSkill = matrix.skills[recommendation.skillId];
+        if (recommendedSkill) {
+          const hasConflict = recommendedSkill.conflictsWith.some(
+            (c) => selectedSet.has(c.skillId)
+          );
+          if (!hasConflict) {
+            warnings.push({
+              type: "missing_recommendation",
+              message: `${getLabel(skill, skillId)} recommends ${getLabel(recommendedSkill, recommendation.skillId)}: ${recommendation.reason}`,
+              skills: [skillId, recommendation.skillId]
+            });
+          }
+        }
+      }
+    }
+  }
+  return { errors: [], warnings };
+}
+function validateSetupUsage(resolvedSelections, selectedSet, matrix) {
+  const warnings = [];
+  for (const skillId of resolvedSelections) {
+    const skill = matrix.skills[skillId];
+    if (!skill || skill.providesSetupFor.length === 0) continue;
+    const hasUsageSkill = skill.providesSetupFor.some((usageId) => selectedSet.has(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 { errors: [], warnings };
+}
+function mergeValidationResults(results) {
+  return {
+    errors: results.flatMap((r) => r.errors),
+    warnings: results.flatMap((r) => r.warnings)
+  };
+}
+function validateSelection(selections, matrix) {
+  const { resolvedSelections, selectedSet } = initializeSelectionContext(selections, matrix);
+  const { errors, warnings } = mergeValidationResults([
+    validateConflicts(resolvedSelections, matrix),
+    validateRequirements(resolvedSelections, selectedSet, matrix),
+    validateExclusivity(resolvedSelections, matrix),
+    validateRecommendations(resolvedSelections, selectedSet, matrix),
+    validateSetupUsage(resolvedSelections, selectedSet, matrix)
+  ]);
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function getAvailableSkills(categoryId, currentSelections, matrix, options) {
+  const skillOptions = [];
+  const { selectedSet } = initializeSelectionContext(currentSelections, 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: selectedSet.has(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 = PLUGIN_MANIFEST_DIR;
+var PLUGIN_MANIFEST_FILE2 = STANDARD_FILES.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";
+import { last, zip } from "remeda";
+function getProjectPluginsDir(projectDir) {
+  const dir = projectDir ?? process.cwd();
+  return path9.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR);
+}
+function getPluginAgentsDir(pluginDir) {
+  return path9.join(pluginDir, "agents");
+}
+function getPluginManifestPath(pluginDir) {
+  return path9.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+}
+
+// src/cli/lib/plugins/plugin-info.ts
+init_esm_shims();
+import { readdir } from "fs/promises";
+
+// 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, STANDARD_FILES.CONFIG_YAML);
+  const legacyConfigPath = path10.join(projectDir, CLAUDE_DIR, STANDARD_FILES.CONFIG_YAML);
+  const localConfigPath = await fileExists(srcConfigPath) ? srcConfigPath : await fileExists(legacyConfigPath) ? legacyConfigPath : null;
+  if (!localConfigPath) {
+    return null;
+  }
+  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
+    };
+  }
+  return {
+    mode: "plugin",
+    configPath: localConfigPath,
+    agentsDir: path10.join(projectDir, CLAUDE_DIR, "agents"),
+    skillsDir: path10.join(projectDir, CLAUDE_DIR, PLUGINS_SUBDIR),
+    projectDir
+  };
+}
+
+// src/cli/lib/installation/local-installer.ts
+init_esm_shims();
+import path14 from "path";
+import { stringify as stringifyYaml3 } from "yaml";
+
+// src/cli/lib/stacks/index.ts
+init_esm_shims();
+
+// src/cli/lib/stacks/stacks-loader.ts
+init_esm_shims();
+import { parse as parseYaml5 } from "yaml";
+import path11 from "path";
+import { mapValues, pipe, flatMap, unique as unique2 } from "remeda";
+var stacksCache = /* @__PURE__ */ new Map();
+function normalizeAgentConfig(agentConfig) {
+  return mapValues(agentConfig, (value) => {
+    const items = Array.isArray(value) ? value : [value];
+    return items.map(
+      (item) => typeof item === "string" ? { id: item, preloaded: false } : item
+    );
+  });
+}
+function normalizeStackRecord(rawStack) {
+  return mapValues(rawStack, (agentConfig) => normalizeAgentConfig(agentConfig));
+}
+async function loadStacks(configDir, stacksFile) {
+  const resolvedStacksFile = stacksFile ?? STACKS_FILE_PATH;
+  const cacheKey = `${configDir}:${resolvedStacksFile}`;
+  const cached = stacksCache.get(cacheKey);
+  if (cached) return cached;
+  const stacksPath = path11.join(configDir, resolvedStacksFile);
+  if (!await fileExists(stacksPath)) {
+    verbose(`No stacks file found at ${stacksPath}`);
+    return [];
+  }
+  try {
+    const content = await readFile(stacksPath);
+    const result = stacksConfigSchema.safeParse(parseYaml5(content));
+    if (!result.success) {
+      throw new Error(
+        `Invalid stacks.yaml at '${stacksPath}': ${formatZodErrors(result.error.issues)}`
+      );
+    }
+    const stacks = result.data.stacks.map((stack) => ({
+      ...stack,
+      agents: mapValues(
+        stack.agents,
+        (agentConfig) => normalizeAgentConfig(agentConfig)
+      )
+    }));
+    stacksCache.set(cacheKey, stacks);
+    verbose(`Loaded ${stacks.length} stacks from ${stacksPath}`);
+    return stacks;
+  } catch (error) {
+    const errorMessage = getErrorMessage(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) {
+  const skillRefs = [];
+  for (const [subcategory, assignments] of typedEntries(
+    agentConfig
+  )) {
+    if (!assignments) continue;
+    for (const assignment of assignments) {
+      if (!SKILL_ID_PATTERN.test(assignment.id)) {
+        warn(
+          `Invalid skill ID '${assignment.id}' for subcategory '${subcategory}' in stack config. Skipping.`
+        );
+        continue;
+      }
+      skillRefs.push({
+        id: assignment.id,
+        usage: `when working with ${subcategory}`,
+        preloaded: assignment.preloaded ?? false
+      });
+    }
+  }
+  return skillRefs;
+}
+function getStackSkillIds(stack) {
+  return pipe(
+    Object.values(stack),
+    flatMap(resolveAgentConfigToSkills),
+    (refs) => refs.map((r) => r.id),
+    unique2()
+  );
+}
+
+// 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 as pipe2, flatMap as flatMap2, 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) {
+  return resolveAgentConfigToSkills(agentStack);
+}
+function resolveAgentSkillsFromStack(agentName, stack) {
+  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 = resolveAgentConfigToSkills(agentConfig);
+  verbose(`Resolved ${skillRefs.length} skills for agent '${agentName}' from stack '${stack.id}'`);
+  return skillRefs;
+}
+async function resolveAgentSkillRefs(agentName, agentConfig, stack) {
+  if (agentConfig.skills && agentConfig.skills.length > 0) {
+    return agentConfig.skills;
+  }
+  if (stack) {
+    const stackSkills = resolveAgentSkillsFromStack(agentName, stack);
+    if (stackSkills.length > 0) {
+      verbose(`Resolved ${stackSkills.length} skills from stack for ${agentName}`);
+      return stackSkills;
+    }
+  }
+  return [];
+}
+async function resolveAgents(agents, skills, compileConfig, _projectRoot, stack) {
+  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 resolveAgentSkillRefs(agentName, agentConfig, stack);
+    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 convertStackToCompileConfig(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 parseYaml6 } 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 parseYaml6(match[1]);
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/lib/compiler.ts
+var LIQUID_SYNTAX_PATTERN = /\{\{|\}\}|\{%|%\}/g;
+function sanitizeLiquidSyntax(value, fieldName) {
+  if (!LIQUID_SYNTAX_PATTERN.test(value)) return value;
+  LIQUID_SYNTAX_PATTERN.lastIndex = 0;
+  const sanitized = value.replace(LIQUID_SYNTAX_PATTERN, "");
+  warn(`Stripped Liquid template syntax from '${fieldName}' \u2014 possible template injection attempt`);
+  return sanitized;
+}
+function sanitizeString(value, fieldName) {
+  if (value === void 0) return void 0;
+  return sanitizeLiquidSyntax(value, fieldName);
+}
+function sanitizeStringArray(values, fieldName) {
+  if (!values) return values;
+  return values.map((v) => sanitizeLiquidSyntax(v, fieldName));
+}
+function sanitizeSkills(skills) {
+  return skills.map((s) => ({
+    ...s,
+    id: sanitizeLiquidSyntax(s.id, "skill.id"),
+    description: sanitizeLiquidSyntax(s.description, "skill.description"),
+    usage: sanitizeLiquidSyntax(s.usage, "skill.usage"),
+    pluginRef: sanitizeString(s.pluginRef, "skill.pluginRef")
+  }));
+}
+function sanitizeCompiledAgentData(data) {
+  const sanitizedAgent = {
+    ...data.agent,
+    name: sanitizeLiquidSyntax(data.agent.name, "agent.name"),
+    title: sanitizeLiquidSyntax(data.agent.title, "agent.title"),
+    description: sanitizeLiquidSyntax(data.agent.description, "agent.description"),
+    tools: sanitizeStringArray(data.agent.tools, "agent.tools") ?? data.agent.tools,
+    disallowed_tools: sanitizeStringArray(data.agent.disallowed_tools, "agent.disallowed_tools"),
+    model: sanitizeString(data.agent.model, "agent.model"),
+    permission_mode: sanitizeString(
+      data.agent.permission_mode,
+      "agent.permission_mode"
+    )
+  };
+  const sanitizedSkills = sanitizeSkills(data.skills);
+  const sanitizedPreloaded = sanitizeSkills(data.preloadedSkills);
+  const sanitizedDynamic = sanitizeSkills(data.dynamicSkills);
+  const sanitizedPreloadedIds = data.preloadedSkillIds.map(
+    (id) => sanitizeLiquidSyntax(String(id), "preloadedSkillId")
+  );
+  return {
+    agent: sanitizedAgent,
+    intro: sanitizeLiquidSyntax(data.intro, "intro"),
+    workflow: sanitizeLiquidSyntax(data.workflow, "workflow"),
+    examples: sanitizeLiquidSyntax(data.examples, "examples"),
+    criticalRequirementsTop: sanitizeLiquidSyntax(
+      data.criticalRequirementsTop,
+      "criticalRequirementsTop"
+    ),
+    criticalReminders: sanitizeLiquidSyntax(data.criticalReminders, "criticalReminders"),
+    outputFormat: sanitizeLiquidSyntax(data.outputFormat, "outputFormat"),
+    skills: sanitizedSkills,
+    preloadedSkills: sanitizedPreloaded,
+    dynamicSkills: sanitizedDynamic,
+    preloadedSkillIds: sanitizedPreloadedIds
+  };
+}
+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 unique3 } from "remeda";
+function hashStackConfig(stack) {
+  const stackSkillIds = stack.stack ? getStackSkillIds(stack.stack).sort() : [];
+  const parts = [
+    `name:${stack.name}`,
+    `description:${stack.description ?? ""}`,
+    `skills:${stackSkillIds.join(",")}`,
+    `agents:${(stack.agents || []).sort().join(",")}`
+  ];
+  return computeStringHash(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, STANDARD_FILES.INTRO_MD));
+  const workflow = await readFile(path13.join(agentDir, STANDARD_FILES.WORKFLOW_MD));
+  const examples = await readFileOptional(
+    path13.join(agentDir, STANDARD_FILES.EXAMPLES_MD),
+    "## Examples\n\n_No examples defined._"
+  );
+  const criticalRequirementsTop = await readFileOptional(
+    path13.join(agentDir, STANDARD_FILES.CRITICAL_REQUIREMENTS_MD),
+    ""
+  );
+  const criticalReminders = await readFileOptional(
+    path13.join(agentDir, STANDARD_FILES.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, STANDARD_FILES.OUTPUT_FORMAT_MD),
+    ""
+  );
+  if (!outputFormat) {
+    outputFormat = await readFileOptional(
+      path13.join(categoryDir, STANDARD_FILES.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", sanitizeCompiledAgentData(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 = unique3(skillPlugins).sort();
+    for (const skill of uniqueSkills) {
+      lines.push(`- \`${skill}\``);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(`*Generated by ${DEFAULT_BRANDING.NAME} 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`
+  );
+  let newStack = options.stack || await loadStackById(stackId, projectRoot);
+  if (!newStack) {
+    newStack = await loadStackById(stackId, PROJECT_ROOT);
+  }
+  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);
+      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)
+    };
+  } else {
+    throw new Error(`Stack '${stackId}' not found in config/stacks.yaml`);
+  }
+  const stackSkillIds = stack.stack ? getStackSkillIds(stack.stack) : [];
+  const skills = await loadSkillsByIds(
+    stackSkillIds.map((id) => ({ id })),
+    projectRoot
+  );
+  const compileConfig = convertStackToCompileConfig(stackId, stack);
+  const resolvedAgents = await resolveAgents(agents, skills, compileConfig, projectRoot, newStack);
+  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, STANDARD_FILES.CLAUDE_MD);
+  if (await fileExists(claudeMdPath)) {
+    const claudeContent = await readFile(claudeMdPath);
+    await writeFile(path13.join(pluginDir, STANDARD_FILES.CLAUDE_MD), claudeContent);
+    verbose(`  Copied ${STANDARD_FILES.CLAUDE_MD}`);
+  }
+  const newHash = hashStackConfig(stack);
+  const { version, contentHash } = await determinePluginVersion(
+    newHash,
+    pluginDir,
+    getPluginManifestPath
+  );
+  const uniqueSkillPlugins = unique3(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) {
+  log(`
+Stack plugin compiled: ${result.stackName}`);
+  log(`  Path: ${result.pluginPath}`);
+  log(`  Agents: ${result.agents.length}`);
+  for (const agent of result.agents) {
+    log(`    - ${agent}`);
+  }
+  if (result.skillPlugins.length > 0) {
+    log(`  Skills included: ${result.skillPlugins.length}`);
+    for (const skill of result.skillPlugins) {
+      log(`    - ${skill}`);
+    }
+  }
+  if (result.hasHooks) {
+    log("  Hooks: enabled");
+  }
+}
+
+// src/cli/lib/installation/local-installer.ts
+function resolveInstallPaths(projectDir) {
+  return {
+    skillsDir: path14.join(projectDir, LOCAL_SKILLS_PATH),
+    agentsDir: path14.join(projectDir, CLAUDE_DIR, "agents"),
+    configPath: path14.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_YAML)
+  };
+}
+async function prepareDirectories(paths) {
+  await ensureDir(paths.skillsDir);
+  await ensureDir(paths.agentsDir);
+  await ensureDir(path14.dirname(paths.configPath));
+}
+async function archiveAndCopySkills(wizardResult, sourceResult, projectDir, skillsDir) {
+  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);
+    }
+  }
+  return copySkillsToLocalFlattened(
+    wizardResult.selectedSkills,
+    skillsDir,
+    sourceResult.matrix,
+    sourceResult
+  );
+}
+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 loadMergedAgents(sourcePath) {
+  const cliAgents = await loadAllAgents(PROJECT_ROOT);
+  const sourceAgents = await loadAllAgents(sourcePath);
+  return { ...cliAgents, ...sourceAgents };
+}
+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(
+        DEFAULT_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(
+      DEFAULT_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;
+  }
+}
+async function buildAndMergeConfig(wizardResult, sourceResult, projectDir, sourceFlag) {
+  const { config } = await buildLocalConfig(wizardResult, sourceResult);
+  setConfigMetadata(config, wizardResult, sourceResult, sourceFlag);
+  return mergeWithExistingConfig(config, { projectDir });
+}
+var PATH_OVERRIDES_COMMENT = [
+  "",
+  "# Custom paths (for marketplace repos with non-standard layouts):",
+  `# skills_dir: ${SKILLS_DIR_PATH}`,
+  `# agents_dir: ${DIRS.agents}`,
+  `# stacks_file: ${STACKS_FILE_PATH}`,
+  `# matrix_file: ${SKILLS_MATRIX_PATH}`,
+  ""
+].join("\n");
+async function writeConfigFile(config, configPath) {
+  const schemaComment = `${yamlSchemaComment(SCHEMA_PATHS.projectConfig)}
+`;
+  const serializable = config.stack ? { ...config, stack: compactStackForYaml(config.stack) } : config;
+  const configYaml = stringifyYaml3(serializable, {
+    indent: YAML_FORMATTING.INDENT,
+    lineWidth: YAML_FORMATTING.LINE_WIDTH
+  });
+  await writeFile(configPath, `${schemaComment}${configYaml}${PATH_OVERRIDES_COMMENT}`);
+}
+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(path14.join(agentsDir, `${name}.md`), output);
+    compiledAgentNames.push(name);
+  }
+  return compiledAgentNames;
+}
+async function installPluginConfig(options) {
+  const { wizardResult, sourceResult, projectDir, sourceFlag } = options;
+  const paths = resolveInstallPaths(projectDir);
+  await ensureDir(paths.agentsDir);
+  await ensureDir(path14.dirname(paths.configPath));
+  const agents = await loadMergedAgents(sourceResult.sourcePath);
+  const mergeResult = await buildAndMergeConfig(wizardResult, sourceResult, projectDir, sourceFlag);
+  const finalConfig = mergeResult.config;
+  await writeConfigFile(finalConfig, paths.configPath);
+  const compileAgentsConfig = buildCompileAgents(finalConfig, agents);
+  const compileConfig = {
+    name: DEFAULT_PLUGIN_NAME,
+    description: finalConfig.description || `Plugin setup with ${wizardResult.selectedSkills.length} skills`,
+    agents: compileAgentsConfig
+  };
+  const stackSkillIds = finalConfig.stack ? getStackSkillIds(finalConfig.stack) : [];
+  const skillsForCompilation = await loadSkillsByIds(
+    stackSkillIds.map((id) => ({ id })),
+    sourceResult.sourcePath
+  );
+  const compiledAgentNames = await compileAndWriteAgents(
+    compileConfig,
+    agents,
+    skillsForCompilation,
+    sourceResult,
+    projectDir,
+    paths.agentsDir,
+    wizardResult.installMode
+  );
+  return {
+    config: finalConfig,
+    configPath: paths.configPath,
+    compiledAgents: compiledAgentNames,
+    wasMerged: mergeResult.merged,
+    mergedConfigPath: mergeResult.existingConfigPath,
+    agentsDir: paths.agentsDir
+  };
+}
+async function installLocal(options) {
+  const { wizardResult, sourceResult, projectDir, sourceFlag } = options;
+  const paths = resolveInstallPaths(projectDir);
+  await prepareDirectories(paths);
+  const copiedSkills = await archiveAndCopySkills(
+    wizardResult,
+    sourceResult,
+    projectDir,
+    paths.skillsDir
+  );
+  const localSkillsForResolution = buildLocalSkillsMap(copiedSkills, sourceResult.matrix);
+  const agents = await loadMergedAgents(sourceResult.sourcePath);
+  const mergeResult = await buildAndMergeConfig(wizardResult, sourceResult, projectDir, sourceFlag);
+  const finalConfig = mergeResult.config;
+  await writeConfigFile(finalConfig, paths.configPath);
+  const compileAgentsConfig = buildCompileAgents(finalConfig, agents);
+  const compileConfig = {
+    name: DEFAULT_PLUGIN_NAME,
+    description: finalConfig.description || `Local setup with ${wizardResult.selectedSkills.length} skills`,
+    agents: compileAgentsConfig
+  };
+  const compiledAgentNames = await compileAndWriteAgents(
+    compileConfig,
+    agents,
+    localSkillsForResolution,
+    sourceResult,
+    projectDir,
+    paths.agentsDir,
+    wizardResult.installMode
+  );
+  return {
+    copiedSkills,
+    config: finalConfig,
+    configPath: paths.configPath,
+    compiledAgents: compiledAgentNames,
+    wasMerged: mergeResult.merged,
+    mergedConfigPath: mergeResult.existingConfigPath,
+    skillsDir: paths.skillsDir,
+    agentsDir: paths.agentsDir
+  };
+}
+
+// src/cli/lib/plugins/plugin-discovery.ts
+init_esm_shims();
+
+// src/cli/lib/plugins/plugin-settings.ts
+init_esm_shims();
+import path15 from "path";
+import os from "os";
+import { z as z2 } from "zod";
+var pluginSettingsSchema = z2.object({
+  enabledPlugins: z2.record(z2.string(), z2.unknown()).optional()
+}).passthrough();
+var pluginInstallationSchema = z2.object({
+  scope: z2.enum(["user", "project", "local"]),
+  projectPath: z2.string().optional(),
+  installPath: z2.string(),
+  version: z2.string(),
+  installedAt: z2.string(),
+  lastUpdated: z2.string().optional(),
+  gitCommitSha: z2.string().optional()
+});
+var installedPluginsSchema = z2.object({
+  version: z2.number(),
+  plugins: z2.record(z2.string(), z2.array(pluginInstallationSchema))
+}).passthrough();
+var SETTINGS_FILE = "settings.json";
+var INSTALLED_PLUGINS_FILE = "installed_plugins.json";
+async function getEnabledPluginKeys(projectDir) {
+  const settingsPath = path15.join(projectDir, CLAUDE_DIR, SETTINGS_FILE);
+  if (!await fileExists(settingsPath)) {
+    verbose(`No settings.json found at '${settingsPath}'`);
+    return [];
+  }
+  try {
+    const content = await readFileSafe(settingsPath, MAX_CONFIG_FILE_SIZE);
+    const raw = JSON.parse(content);
+    const result = pluginSettingsSchema.safeParse(raw);
+    if (!result.success) {
+      verbose(`Invalid settings.json structure: ${getErrorMessage(result.error)}`);
+      return [];
+    }
+    const settings = result.data;
+    if (!settings.enabledPlugins) {
+      verbose(`No enabledPlugins found in '${settingsPath}'`);
+      return [];
+    }
+    const enabledKeys = typedEntries(settings.enabledPlugins).filter(([, enabled]) => enabled === true).map(([key]) => key);
+    verbose(`Found ${enabledKeys.length} enabled plugins in settings.json`);
+    return enabledKeys;
+  } catch (error) {
+    verbose(`Failed to read settings.json: ${getErrorMessage(error)}`);
+    return [];
+  }
+}
+async function resolvePluginInstallPaths(pluginKeys, projectDir) {
+  if (pluginKeys.length === 0) {
+    return [];
+  }
+  const registryPath = path15.join(os.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR, INSTALLED_PLUGINS_FILE);
+  if (!await fileExists(registryPath)) {
+    verbose(`Plugin registry not found at '${registryPath}'`);
+    return [];
+  }
+  try {
+    const content = await readFileSafe(registryPath, MAX_CONFIG_FILE_SIZE);
+    const raw = JSON.parse(content);
+    const result = installedPluginsSchema.safeParse(raw);
+    if (!result.success) {
+      verbose(`Invalid plugin registry structure: ${getErrorMessage(result.error)}`);
+      return [];
+    }
+    const registry = result.data;
+    const resolvedPaths = [];
+    for (const pluginKey of pluginKeys) {
+      const installations = registry.plugins[pluginKey];
+      if (!installations || installations.length === 0) {
+        verbose(`Plugin '${pluginKey}' not found in registry`);
+        continue;
+      }
+      const projectInstall = installations.find(
+        (install) => install.scope === "project" && install.projectPath === projectDir
+      );
+      if (projectInstall) {
+        resolvedPaths.push({
+          pluginKey,
+          installPath: projectInstall.installPath
+        });
+        verbose(`Resolved '${pluginKey}' to '${projectInstall.installPath}'`);
+        continue;
+      }
+      const userInstall = installations.find((install) => install.scope === "user");
+      if (userInstall) {
+        resolvedPaths.push({
+          pluginKey,
+          installPath: userInstall.installPath
+        });
+        verbose(`Resolved '${pluginKey}' to '${userInstall.installPath}' (user scope)`);
+        continue;
+      }
+      verbose(`No matching installation found for '${pluginKey}'`);
+    }
+    return resolvedPaths;
+  } catch (error) {
+    verbose(`Failed to read plugin registry: ${getErrorMessage(error)}`);
+    return [];
+  }
+}
+async function getVerifiedPluginInstallPaths(projectDir) {
+  const enabledKeys = await getEnabledPluginKeys(projectDir);
+  const resolvedPaths = await resolvePluginInstallPaths(enabledKeys, projectDir);
+  const verified = [];
+  for (const { pluginKey, installPath } of resolvedPaths) {
+    const pluginJsonPath = path15.join(installPath, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+    if (await fileExists(pluginJsonPath)) {
+      verified.push({ pluginKey, installPath });
+    } else {
+      verbose(`Plugin '${pluginKey}' manifest does not exist at: '${pluginJsonPath}'`);
+    }
+  }
+  verbose(`Verified ${verified.length} plugin install paths`);
+  return verified;
+}
+
+// src/cli/lib/plugins/plugin-discovery.ts
+async function discoverAllPluginSkills(projectDir) {
+  const allSkills = {};
+  try {
+    const pluginPaths = await getVerifiedPluginInstallPaths(projectDir);
+    if (pluginPaths.length === 0) {
+      verbose(`No enabled plugins found in settings.json`);
+      return allSkills;
+    }
+    for (const { pluginKey, installPath } of pluginPaths) {
+      verbose(`Discovering skills from plugin: '${pluginKey}'`);
+      try {
+        const pluginSkills = await loadPluginSkills(installPath);
+        for (const [id, skill] of typedEntries(pluginSkills)) {
+          if (skill) {
+            allSkills[id] = skill;
+          }
+        }
+      } catch (error) {
+        verbose(`Failed to load skills from '${pluginKey}': ${getErrorMessage(error)}`);
+      }
+    }
+  } catch (error) {
+    verbose(`Plugin discovery failed: ${getErrorMessage(error)}`);
+  }
+  return allSkills;
+}
+async function hasIndividualPlugins(projectDir) {
+  try {
+    const pluginPaths = await getVerifiedPluginInstallPaths(projectDir);
+    return pluginPaths.length > 0;
+  } catch (error) {
+    verbose(`Failed to check for individual plugins: ${getErrorMessage(error)}`);
+    return false;
+  }
+}
+async function listPluginNames(projectDir) {
+  try {
+    const pluginPaths = await getVerifiedPluginInstallPaths(projectDir);
+    return pluginPaths.map(({ pluginKey }) => pluginKey);
+  } catch (error) {
+    verbose(`Failed to list plugin names: ${getErrorMessage(error)}`);
+    return [];
+  }
+}
+
+// src/cli/lib/plugins/plugin-info.ts
+async function getInstallationInfo() {
+  const installation = await detectInstallation();
+  if (!installation) {
+    return null;
+  }
+  let skillCount = 0;
+  let agentCount = 0;
+  let name = DEFAULT_PLUGIN_NAME;
+  let version = DEFAULT_DISPLAY_VERSION;
+  if (installation.mode === "plugin") {
+    try {
+      const pluginSkills = await discoverAllPluginSkills(installation.projectDir);
+      skillCount = Object.keys(pluginSkills).length;
+    } catch {
+    }
+  } else 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 {
+    }
+  }
+  const loaded = await loadProjectConfig(installation.projectDir);
+  if (loaded?.config) {
+    name = loaded.config.name || DEFAULT_PLUGIN_NAME;
+    version = installation.mode === "local" ? "local" : "plugin";
+  }
+  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 readFileSafe(manifestPath, MAX_PLUGIN_FILE_SIZE);
+  const manifest = pluginManifestSchema.parse(JSON.parse(content));
+  const [major, minor, patch] = parseVersion(manifest.version || DEFAULT_VERSION);
+  let newVersion;
+  switch (type) {
+    case "major":
+      newVersion = `${major + 1}.0.0`;
+      break;
+    case "minor":
+      newVersion = `${major}.${minor + 1}.0`;
+      break;
+    case "patch":
+      newVersion = `${major}.${minor}.${patch + 1}`;
+      break;
+    default: {
+      const exhaustiveCheck = type;
+      throw new Error(`Unknown version bump type: ${exhaustiveCheck}`);
+    }
+  }
+  manifest.version = newVersion;
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  return newVersion;
+}
+async function getPluginVersion(pluginDir) {
+  const manifestPath = path16.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+  const content = await readFileSafe(manifestPath, MAX_PLUGIN_FILE_SIZE);
+  const manifest = pluginManifestSchema.parse(JSON.parse(content));
+  return manifest.version || DEFAULT_VERSION;
+}
+
+// src/cli/lib/plugins/plugin-validator.ts
+init_esm_shims();
+import { z as z3 } from "zod";
+import path17 from "path";
+import fg from "fast-glob";
+import { countBy } from "remeda";
+var PLUGIN_DIR = PLUGIN_MANIFEST_DIR;
+var PLUGIN_MANIFEST = STANDARD_FILES.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 = z3.object({
+  name: z3.string(),
+  version: z3.string().optional(),
+  description: z3.string().optional(),
+  author: pluginAuthorSchema.optional(),
+  keywords: z3.array(z3.string()).optional(),
+  commands: z3.union([z3.string(), z3.array(z3.string())]).optional(),
+  agents: z3.union([z3.string(), z3.array(z3.string())]).optional(),
+  skills: z3.union([z3.string(), z3.array(z3.string())]).optional(),
+  hooks: z3.union([z3.string(), hooksRecordSchema]).optional()
+}).strict();
+function formatZodErrors2(error) {
+  return error.issues.map((issue) => {
+    const path25 = issue.path.join(".");
+    if (issue.code === "unrecognized_keys") {
+      return `Unrecognized key: "${issue.keys.join('", "')}"`;
+    }
+    return path25 ? `${path25}: ${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 readFileSafe(manifestPath, MAX_PLUGIN_FILE_SIZE);
+    manifest = JSON.parse(content);
+  } catch (err) {
+    return {
+      valid: false,
+      errors: [`Invalid JSON in ${PLUGIN_MANIFEST}: ${getErrorMessage(err)}`],
+      warnings: []
+    };
+  }
+  const result = pluginManifestValidationSchema.safeParse(manifest);
+  if (!result.success) {
+    errors.push(...formatZodErrors2(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(...formatZodErrors2(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(...formatZodErrors2(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
+  };
+}
+function mergeResults(results) {
+  const errors = results.flatMap((r) => r.errors);
+  const warnings = results.flatMap((r) => r.warnings);
+  return { valid: errors.length === 0, errors, warnings };
+}
+var EMPTY_RESULT = { valid: true, errors: [], warnings: [] };
+function prefixResult(result, prefix) {
+  return {
+    valid: result.valid,
+    errors: result.valid ? [] : result.errors.map((e) => `${prefix}: ${e}`),
+    warnings: result.warnings.map((w) => `${prefix}: ${w}`)
+  };
+}
+async function validatePluginSkillFiles(pluginPath, skillsRelPath) {
+  const skillsDir = path17.join(pluginPath, skillsRelPath);
+  if (!await directoryExists(skillsDir)) return EMPTY_RESULT;
+  const files = await fg("**/SKILL.md", { cwd: skillsDir, absolute: true });
+  if (files.length === 0) {
+    return {
+      valid: true,
+      errors: [],
+      warnings: [`Skills directory exists but contains no SKILL.md files: ${skillsRelPath}`]
+    };
+  }
+  const results = await Promise.all(
+    files.map(
+      async (f) => prefixResult(await validateSkillFrontmatter(f), path17.relative(pluginPath, f))
+    )
+  );
+  return mergeResults(results);
+}
+async function validatePluginAgentFiles(pluginPath, agentsRelPath) {
+  const agentsDir = path17.join(pluginPath, agentsRelPath);
+  if (!await directoryExists(agentsDir)) return EMPTY_RESULT;
+  const files = await fg("*.md", { cwd: agentsDir, absolute: true });
+  if (files.length === 0) {
+    return {
+      valid: true,
+      errors: [],
+      warnings: [`Agents directory exists but contains no .md files: ${agentsRelPath}`]
+    };
+  }
+  const results = await Promise.all(
+    files.map(
+      async (f) => prefixResult(await validateAgentFrontmatter(f), path17.relative(pluginPath, f))
+    )
+  );
+  return mergeResults(results);
+}
+async function loadManifestForValidation(manifestPath) {
+  try {
+    const content = await readFileSafe(manifestPath, MAX_PLUGIN_FILE_SIZE);
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function validatePlugin(pluginPath) {
+  const structureResult = await validatePluginStructure(pluginPath);
+  if (!structureResult.valid) return structureResult;
+  const manifestPath = path17.join(pluginPath, PLUGIN_DIR, PLUGIN_MANIFEST);
+  const manifestResult = await validatePluginManifest(manifestPath);
+  const manifest = await loadManifestForValidation(manifestPath);
+  const skillsResult = manifest?.skills && typeof manifest.skills === "string" ? await validatePluginSkillFiles(pluginPath, manifest.skills) : EMPTY_RESULT;
+  const agentsResult = manifest?.agents && typeof manifest.agents === "string" ? await validatePluginAgentFiles(pluginPath, manifest.agents) : EMPTY_RESULT;
+  return mergeResults([structureResult, manifestResult, skillsResult, agentsResult]);
+}
+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: countBy(results, (r) => String(r.result.valid))["true"] ?? 0,
+    invalid: countBy(results, (r) => String(r.result.valid))["false"] ?? 0,
+    withWarnings: countBy(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;
+  }
+  log(`
+  ${status} ${name}`);
+  if (result.errors.length > 0) {
+    log("    Errors:");
+    result.errors.forEach((e) => log(`      - ${e}`));
+  }
+  if (result.warnings.length > 0) {
+    log("    Warnings:");
+    result.warnings.forEach((w) => 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 allPluginSkillIds = await collectPluginSkillIds(matrix, projectDir);
+  if (allPluginSkillIds.length === 0) {
+    return;
+  }
+  for (const skillId of allPluginSkillIds) {
+    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 ${allPluginSkillIds.length} plugin-installed skills`);
+}
+async function collectPluginSkillIds(_matrix, projectDir) {
+  const pluginSkills = await discoverAllPluginSkills(projectDir);
+  const skillIds = Object.keys(pluginSkills);
+  if (skillIds.length === 0) {
+    verbose("No plugin skills discovered from settings.json");
+  }
+  return skillIds;
+}
+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 mergedMatrix = await loadAndMergeFromBasePath(skillsPath);
+  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 mergedMatrix = await loadAndMergeFromBasePath(fetchResult.path);
+  let marketplace = sourceConfig.marketplace;
+  if (!marketplace) {
+    try {
+      const marketplaceResult = await fetchMarketplace(source, { forceRefresh });
+      marketplace = marketplaceResult.marketplace.name;
+      verbose(`Using marketplace name from marketplace.json: ${marketplace}`);
+    } catch {
+      warn(`Source does not have a marketplace.json - falling back to local mode`);
+    }
+  }
+  return {
+    matrix: mergedMatrix,
+    sourceConfig,
+    sourcePath: fetchResult.path,
+    isLocal: false,
+    marketplace
+  };
+}
+async function loadAndMergeFromBasePath(basePath) {
+  const sourceProjectConfig = await loadProjectSourceConfig(basePath);
+  const matrixRelPath = sourceProjectConfig?.matrix_file ?? SKILLS_MATRIX_PATH;
+  const skillsDirRelPath = sourceProjectConfig?.skills_dir ?? SKILLS_DIR_PATH;
+  const stacksRelFile = sourceProjectConfig?.stacks_file;
+  const sourceMatrixPath = path19.join(basePath, matrixRelPath);
+  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(basePath, skillsDirRelPath);
+  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(basePath, stacksRelFile);
+  const stacks = sourceStacks.length > 0 ? sourceStacks : await loadStacks(PROJECT_ROOT);
+  if (stacks.length > 0) {
+    mergedMatrix.suggestedStacks = stacks.map((stack) => convertStackToResolvedStack(stack));
+    const stackSource = sourceStacks.length > 0 ? "source" : "CLI";
+    verbose(`Loaded ${stacks.length} stacks from ${stackSource}`);
+  }
+  return mergedMatrix;
+}
+function convertStackToResolvedStack(stack) {
+  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);
+    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 extractSourceName(source) {
+  const withoutProtocol = source.replace(/^(?:github|gh|gitlab|bitbucket|sourcehut):/, "");
+  const withoutUrl = withoutProtocol.replace(/^https?:\/\/[^/]+\//, "");
+  const firstSegment = withoutUrl.split("/")[0];
+  return firstSegment || source;
+}
+function getMarketplaceLabel(sourceResult) {
+  if (sourceResult.isLocal) return void 0;
+  const { marketplace } = sourceResult;
+  if (!marketplace) {
+    const name = extractSourceName(sourceResult.sourceConfig.source);
+    return `${name} (public)`;
+  }
+  const PUBLIC_MARKETPLACE_COUNT = 1;
+  const isDefaultSource = sourceResult.sourceConfig.source === DEFAULT_SOURCE;
+  if (!isDefaultSource) {
+    return `${marketplace} + ${PUBLIC_MARKETPLACE_COUNT} public`;
+  }
+  return marketplace;
+}
+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_DEFAULTS.AUTHOR,
+      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();
+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 parseYaml7 } from "yaml";
+function sanitizeSkillName(name) {
+  return name.replace(/\+/g, "-");
+}
+async function readSkillMetadata(skillPath) {
+  const metadataPath = path20.join(skillPath, STANDARD_FILES.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 = skillMetadataLoaderSchema.safeParse(parseYaml7(yamlContent));
+    if (!result.success) {
+      warn(`Invalid metadata.yaml at '${skillPath}': ${formatZodErrors(result.error.issues)}`);
+      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 ${DEFAULT_BRANDING.NAME} 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, STANDARD_FILES.SKILL_MD);
+  if (!await fileExists(skillMdPath)) {
+    throw new Error(
+      `Skill '${dirBasename}' is missing required ${STANDARD_FILES.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 ${STANDARD_FILES.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 computeSkillFolderHash(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, STANDARD_FILES.SKILL_MD), skillMdContent);
+  verbose(`  Copied ${STANDARD_FILES.SKILL_MD}`);
+  for (const fileName of SKILL_CONTENT_FILES) {
+    if (fileName === STANDARD_FILES.SKILL_MD) continue;
+    const sourcePath = 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_CONTENT_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(`**/${STANDARD_FILES.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);
+      log(`  [OK] ${result.skillName}`);
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      const dirBasename = path20.basename(skillPath);
+      warn(`Failed to compile skill from '${dirBasename}': ${errorMessage}`);
+    }
+  }
+  return results;
+}
+function printCompilationSummary(results) {
+  log(`
+Compiled ${results.length} skill plugins:`);
+  for (const result of results) {
+    log(`  - ${result.skillName} (v${result.manifest.version})`);
+  }
+}
+
+// src/cli/lib/skills/local-skill-loader.ts
+init_esm_shims();
+import { parse as parseYaml8 } from "yaml";
+import path21 from "path";
+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, STANDARD_FILES.METADATA_YAML);
+  const skillMdPath = path21.join(skillDir, STANDARD_FILES.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(parseYaml8(metadataContent));
+  if (!parsed.success) {
+    warn(
+      `Skipping local skill '${skillDirName}': invalid metadata.yaml \u2014 ${formatZodErrors(parsed.error.issues)}`
+    );
+    return null;
+  }
+  const metadata = parsed.data;
+  if (!metadata.cli_name) {
+    warn(
+      `Skipping local skill '${skillDirName}': missing required '${METADATA_KEYS.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_DEFAULTS.CATEGORY;
+  if (!metadata.category) {
+    warn(
+      `Local skill '${skillDirName}' has no category in metadata.yaml \u2014 defaulting to '${LOCAL_DEFAULTS.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_DEFAULTS.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";
+function validateSkillId(skillId) {
+  if (!SKILL_ID_PATTERN.test(skillId)) {
+    return false;
+  }
+  return !(skillId.includes("\0") || skillId.includes("..") || skillId.includes("/") || skillId.includes("\\"));
+}
+function validatePathBoundary(resolvedPath, expectedParent) {
+  const normalizedPath = path22.resolve(resolvedPath);
+  const normalizedParent = path22.resolve(expectedParent);
+  return normalizedPath.startsWith(normalizedParent + path22.sep);
+}
+async function archiveLocalSkill(projectDir, skillId) {
+  if (!validateSkillId(skillId)) {
+    warn(`Invalid skill ID for archiving: '${skillId}'`);
+    return;
+  }
+  const skillsDir = path22.resolve(path22.join(projectDir, LOCAL_SKILLS_PATH));
+  const skillPath = path22.resolve(path22.join(skillsDir, skillId));
+  const archivedDir = path22.resolve(path22.join(skillsDir, ARCHIVED_SKILLS_DIR_NAME));
+  const archivedSkillPath = path22.resolve(path22.join(archivedDir, skillId));
+  if (!validatePathBoundary(skillPath, skillsDir) || !validatePathBoundary(archivedSkillPath, archivedDir)) {
+    warn(`Skill ID '${skillId}' resolves outside the skills directory.`);
+    return;
+  }
+  try {
+    await ensureDir(archivedDir);
+    await copy(skillPath, archivedSkillPath);
+    await remove(skillPath);
+  } catch (error) {
+    warn(`Failed to archive skill '${skillId}': ${getErrorMessage(error)}`);
+    return;
+  }
+  verbose(`Archived local skill '${skillId}' to ${ARCHIVED_SKILLS_DIR_NAME}/`);
+}
+async function restoreArchivedSkill(projectDir, skillId) {
+  if (!validateSkillId(skillId)) {
+    warn(`Invalid skill ID for restoring: '${skillId}'`);
+    return false;
+  }
+  const skillsDir = path22.resolve(path22.join(projectDir, LOCAL_SKILLS_PATH));
+  const skillPath = path22.resolve(path22.join(skillsDir, skillId));
+  const archivedDir = path22.resolve(path22.join(skillsDir, ARCHIVED_SKILLS_DIR_NAME));
+  const archivedSkillPath = path22.resolve(path22.join(archivedDir, skillId));
+  if (!validatePathBoundary(skillPath, skillsDir) || !validatePathBoundary(archivedSkillPath, archivedDir)) {
+    warn(`Skill ID '${skillId}' resolves outside the skills directory.`);
+    return false;
+  }
+  try {
+    await copy(archivedSkillPath, skillPath);
+    await remove(archivedSkillPath);
+  } catch {
+    return false;
+  }
+  verbose(`Restored archived skill '${skillId}' from ${ARCHIVED_SKILLS_DIR_NAME}/`);
+  return true;
+}
+
+// src/cli/lib/configuration/config-generator.ts
+function extractSubcategoryFromPath(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 = extractSubcategoryFromPath(category);
+    for (const agentId of agents) {
+      neededAgents.add(agentId);
+      if (subcategory) {
+        if (!stackProperty[agentId]) {
+          stackProperty[agentId] = {};
+        }
+        stackProperty[agentId][subcategory] = [{ id: skillId, preloaded: false }];
+      }
+    }
+  }
+  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) {
+  const result = {};
+  for (const [agentId, agentConfig] of typedEntries(stack.agents)) {
+    if (!agentConfig || Object.keys(agentConfig).length === 0) {
+      continue;
+    }
+    const resolvedMappings = {};
+    for (const [subcategoryId, assignments] of typedEntries(
+      agentConfig
+    )) {
+      if (!assignments || assignments.length === 0) continue;
+      resolvedMappings[subcategoryId] = assignments;
+    }
+    if (Object.keys(resolvedMappings).length > 0) {
+      result[agentId] = resolvedMappings;
+    }
+  }
+  return result;
+}
+function compactStackForYaml(stack) {
+  const result = {};
+  for (const [agentId, agentConfig] of Object.entries(stack)) {
+    const compacted = {};
+    for (const [subcategory, assignments] of typedEntries(
+      agentConfig
+    )) {
+      if (!assignments || assignments.length === 0) continue;
+      if (assignments.length === 1) {
+        const assignment = assignments[0];
+        if (!assignment.preloaded) {
+          compacted[subcategory] = assignment.id;
+        } else {
+          compacted[subcategory] = { id: assignment.id, preloaded: true };
+        }
+      } else {
+        compacted[subcategory] = assignments.map(
+          (a) => !a.preloaded ? a.id : { id: a.id, preloaded: true }
+        );
+      }
+    }
+    if (Object.keys(compacted).length > 0) {
+      result[agentId] = compacted;
+    }
+  }
+  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";
+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;
+    }
+  }
+  const data = await safeLoadYamlFile(configPath, projectConfigLoaderSchema);
+  if (!data) return null;
+  const config = data;
+  if (config.stack) {
+    config.stack = normalizeStackRecord(
+      config.stack
+    );
+  }
+  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
+  };
+}
+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();
+async function saveSourceToProjectConfig(projectDir, source) {
+  const existing = await loadProjectSourceConfig(projectDir) ?? {};
+  await saveProjectConfig(projectDir, { ...existing, source });
+}
+
+// src/cli/lib/loading/source-fetcher.ts
+var SAFE_NAME_PATTERN = /^[a-zA-Z0-9@._/ -]+$/;
+var MAX_NAME_LENGTH = 200;
+function sanitizeSourceForCache(source) {
+  const hash = createHash2("sha256").update(source).digest("hex").slice(0, CACHE_HASH_LENGTH);
+  const readable = source.replace(/[^a-zA-Z0-9]/g, "-").replace(/--+/g, "-").replace(/^-|-$/g, "").slice(0, CACHE_READABLE_PREFIX_LENGTH);
+  return readable ? `${readable}-${hash}` : hash;
+}
+function getCacheDir(source) {
+  const sanitized = sanitizeSourceForCache(source) || "unknown";
+  return path24.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 ? path24.join(source, subdir) : source;
+  const absolutePath = path24.isAbsolute(fullPath) ? fullPath : path24.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(path24.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 createDetailedFetchError(error, source);
+  }
+}
+function createDetailedFetchError(error, source) {
+  const message = getErrorMessage(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 = path24.join(result.path, PLUGIN_MANIFEST_DIR, "marketplace.json");
+  if (!await directoryExists(path24.dirname(marketplacePath))) {
+    throw new Error(
+      `Marketplace not found for source: ${source}
+
+The .claude-plugin/marketplace.json file is missing from this repository.
+
+Possible causes:
+  - The source URL may be incorrect
+  - The repository may not have a marketplace configured
+
+To create a marketplace, add a .claude-plugin/marketplace.json file to your source repository.`
+    );
+  }
+  const content = await readFileSafe(marketplacePath, MAX_MARKETPLACE_FILE_SIZE);
+  const parsed = JSON.parse(content);
+  if (!validateNestingDepth(parsed, MAX_JSON_NESTING_DEPTH)) {
+    throw new Error(
+      `Invalid marketplace.json at: ${marketplacePath}
+
+JSON structure exceeds maximum nesting depth of ${MAX_JSON_NESTING_DEPTH}.`
+    );
+  }
+  const validation = marketplaceSchema.safeParse(parsed);
+  if (!validation.success) {
+    throw new Error(
+      `Invalid marketplace.json at: ${marketplacePath}
+
+Validation errors: ${formatZodErrors(validation.error.issues)}`
+    );
+  }
+  const marketplace = validation.data;
+  const EXPECTED_MARKETPLACE_KEYS = [
+    "$schema",
+    "name",
+    "version",
+    "description",
+    "owner",
+    "metadata",
+    "plugins"
+  ];
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    warnUnknownFields(
+      parsed,
+      EXPECTED_MARKETPLACE_KEYS,
+      "marketplace.json"
+    );
+  }
+  if (marketplace.plugins.length > MAX_MARKETPLACE_PLUGINS) {
+    throw new Error(
+      `Invalid marketplace.json at: ${marketplacePath}
+
+Too many plugins: ${marketplace.plugins.length} (limit: ${MAX_MARKETPLACE_PLUGINS}).`
+    );
+  }
+  for (const plugin of marketplace.plugins) {
+    if (plugin.name.length > MAX_NAME_LENGTH) {
+      warn(
+        `Marketplace plugin name too long (${plugin.name.length} chars): '${plugin.name.slice(0, 50)}...'`
+      );
+    }
+    if (!SAFE_NAME_PATTERN.test(plugin.name)) {
+      warn(`Marketplace plugin name contains unsafe characters: '${plugin.name.slice(0, 50)}'`);
+    }
+  }
+  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) {
+  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;
+  try {
+    const discoveredSkills = await discoverAllPluginSkills(projectDir);
+    pluginSkillCount = Object.keys(discoveredSkills).length;
+  } catch {
+    verbose("Failed to discover plugin skills for source summary");
+  }
+  return { sources, localSkillCount, pluginSkillCount };
+}
+
+export {
+  generateAgentPluginManifest,
+  writePluginManifest,
+  findPluginManifest,
+  getProjectPluginsDir,
+  getPluginAgentsDir,
+  getPluginManifestPath,
+  DEFAULT_SOURCE,
+  SOURCE_ENV_VAR,
+  getProjectConfigPath,
+  loadProjectSourceConfig,
+  saveProjectConfig,
+  resolveSource,
+  resolveAgentsSource,
+  formatOrigin,
+  resolveAuthor,
+  resolveBranding,
+  resolveAllSources,
+  IMPORT_DEFAULTS,
+  LOCAL_DEFAULTS,
+  getCurrentDate,
+  computeStringHash,
+  computeFileHash,
+  determinePluginVersion,
+  writeContentHash,
+  readForkedFromMetadata,
+  compareLocalSkillsWithSource,
+  injectForkedFromMetadata,
+  copySkillsToLocalFlattened,
+  parseFrontmatter,
+  loadAllAgents,
+  loadProjectAgents,
+  resolveAlias,
+  validateSelection,
+  getAvailableSkills,
+  fetchFromSource,
+  searchExtraSources,
+  normalizeStackRecord,
+  loadStacks,
+  getStackSkillIds,
+  buildSkillRefsFromConfig,
+  resolveAgents,
+  extractFrontmatter,
+  createLiquidEngine,
+  compileAgentForPlugin,
+  compileStackPlugin,
+  printStackCompilationSummary,
+  loadSkillsMatrixFromSource,
+  getMarketplaceLabel,
+  compileSkillPlugin,
+  compileAllSkillPlugins,
+  printCompilationSummary,
+  discoverLocalSkills,
+  archiveLocalSkill,
+  restoreArchivedSkill,
+  loadProjectConfig,
+  validateProjectConfig,
+  saveSourceToProjectConfig,
+  discoverAllPluginSkills,
+  hasIndividualPlugins,
+  listPluginNames,
+  addSource,
+  removeSource,
+  getSourceSummary,
+  detectInstallation,
+  installPluginConfig,
+  installLocal,
+  getInstallationInfo,
+  formatInstallationDisplay,
+  bumpPluginVersion,
+  getPluginVersion,
+  validatePlugin,
+  validateAllPlugins,
+  printPluginValidationResult
+};
+//# sourceMappingURL=chunk-MM7NK5N2.js.map