agents-inc 0.155.0 → 0.157.0

package/dist/chunk-XAXJWXI4.js

@@ -1,1667 +0,0 @@
-#!/usr/bin/env node
-import {
-  typedKeys
-} from "./chunk-VASLW636.js";
-import {
-  AUTHOR_HANDLE_PATTERN,
-  CLAUDE_SRC_DIR,
-  DIRS,
-  KEBAB_CASE_PATTERN,
-  LOCAL_PSEUDO_CATEGORY,
-  PROJECT_ROOT,
-  STANDARD_DIRS,
-  STANDARD_FILES
-} from "./chunk-IO5YBKHV.js";
-
-// src/cli/lib/loading/loader.ts
-import { parse as parseYaml2 } from "yaml";
-import path2 from "path";
-import { unique } from "remeda";
-
-// src/cli/utils/errors.ts
-function getErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/cli/utils/frontmatter.ts
-import { parse as parseYaml } 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 parseYaml(match[1]);
-  } catch {
-    return null;
-  }
-}
-
-// src/cli/utils/fs.ts
-import fs from "fs-extra";
-import fg from "fast-glob";
-import os from "os";
-import path from "path";
-
-// src/cli/lib/config-gate/gate-token.ts
-import { AsyncLocalStorage } from "async_hooks";
-var gateToken = new AsyncLocalStorage();
-var GlobalPairWriteViolation = class extends Error {
-  constructor(targetPath) {
-    super(
-      `${targetPath} may only be written through config-gate \u2014 see src/cli/lib/config-gate/index.ts`
-    );
-    this.name = "GlobalPairWriteViolation";
-  }
-};
-function withGateToken(fn) {
-  return gateToken.run(true, fn);
-}
-function hasGateToken() {
-  return gateToken.getStore() === true;
-}
-function assertGateToken(targetPath) {
-  if (hasGateToken()) return;
-  throw new GlobalPairWriteViolation(targetPath);
-}
-
-// src/cli/utils/fs.ts
-function isPathWithin(child, parent) {
-  const resolvedChild = path.resolve(child);
-  const resolvedParent = path.resolve(parent);
-  return resolvedChild === resolvedParent || resolvedChild.startsWith(resolvedParent + path.sep);
-}
-async function readFile(filePath) {
-  return fs.readFile(filePath, "utf-8");
-}
-async function readFileSafe(filePath, maxSizeBytes) {
-  const stats = await fs.stat(filePath);
-  if (stats.size > maxSizeBytes) {
-    throw new Error(
-      `File too large: '${filePath}' is ${stats.size} bytes (limit: ${maxSizeBytes} bytes)`
-    );
-  }
-  return fs.readFile(filePath, "utf-8");
-}
-async function readFileOptional(filePath, fallback = "") {
-  try {
-    return await fs.readFile(filePath, "utf-8");
-  } catch {
-    return fallback;
-  }
-}
-async function fileExists(filePath) {
-  return fs.pathExists(filePath);
-}
-async function directoryExists(dirPath) {
-  try {
-    const stat = await fs.stat(dirPath);
-    return stat.isDirectory();
-  } catch {
-    return false;
-  }
-}
-async function listDirectories(dirPath) {
-  try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-  } catch {
-    return [];
-  }
-}
-async function glob(pattern, cwd, { dot = false } = {}) {
-  return fg(pattern, { cwd, onlyFiles: true, dot });
-}
-function isGlobalPairPath(resolvedPath) {
-  const globalConfigDir = path.join(os.homedir(), CLAUDE_SRC_DIR);
-  return resolvedPath === path.join(globalConfigDir, STANDARD_FILES.CONFIG_TS) || resolvedPath === path.join(globalConfigDir, STANDARD_FILES.CONFIG_TYPES_TS);
-}
-async function writeFile(filePath, content) {
-  const resolvedPath = path.resolve(filePath);
-  if (isGlobalPairPath(resolvedPath)) assertGateToken(resolvedPath);
-  await fs.ensureDir(path.dirname(filePath));
-  await fs.writeFile(filePath, content, "utf-8");
-}
-async function ensureDir(dirPath) {
-  await fs.ensureDir(dirPath);
-}
-async function remove(filePath) {
-  await fs.remove(filePath);
-}
-async function isDirectoryEmpty(dirPath) {
-  try {
-    const entries = await fs.readdir(dirPath);
-    return entries.length === 0;
-  } catch {
-    return true;
-  }
-}
-async function removeDirIfEmpty(dir) {
-  if (!await directoryExists(dir)) return false;
-  if (!await isDirectoryEmpty(dir)) return false;
-  await remove(dir);
-  return true;
-}
-async function copy(src, dest) {
-  await fs.copy(src, dest);
-}
-
-// src/cli/utils/logger.ts
-var verboseMode = false;
-function setVerbose(enabled) {
-  verboseMode = enabled;
-}
-function verbose(msg) {
-  if (verboseMode) {
-    console.log(`  ${msg}`);
-  }
-}
-function log(msg) {
-  console.log(msg);
-}
-var bufferMode = false;
-var messageBuffer = [];
-function enableBuffering() {
-  bufferMode = true;
-  messageBuffer = [];
-}
-function drainBuffer() {
-  const messages = [...messageBuffer];
-  messageBuffer = [];
-  return messages;
-}
-function disableBuffering() {
-  bufferMode = false;
-  messageBuffer = [];
-}
-function warn(msg, options) {
-  if (options?.suppressInTest && process.env.VITEST) {
-    return;
-  }
-  if (bufferMode) {
-    messageBuffer.push({ level: "warn", text: msg });
-    return;
-  }
-  console.warn(`  Warning: ${msg}`);
-}
-
-// src/cli/lib/schemas.ts
-import { z as z2 } from "zod";
-import { partition } from "remeda";
-
-// src/cli/lib/schema-validator.ts
-import "zod";
-function formatZodIssue(issue) {
-  const path3 = issue.path.join(".");
-  if (issue.code === "unrecognized_keys") {
-    return `Unrecognized key: "${issue.keys.join('", "')}"`;
-  }
-  return path3 ? `${path3}: ${issue.message}` : issue.message;
-}
-function formatZodErrors(error) {
-  return error.issues.map(formatZodIssue);
-}
-
-// src/cli/types/generated/source-types.ts
-var SKILL_SLUGS = [
-  "ai-planning",
-  "ai-reviewing",
-  "angular-standalone",
-  "ant-design",
-  "anthropic-sdk",
-  "api-performance",
-  "api-planning",
-  "api-reviewing",
-  "apollo-server",
-  "app-links",
-  "appwrite",
-  "astro",
-  "auth-security",
-  "aws-sdk",
-  "axiom-pino-sentry",
-  "base-ui",
-  "better-auth-drizzle-hono",
-  "biome",
-  "ble-nfc",
-  "bullmq",
-  "chakra-ui",
-  "changesets",
-  "chroma",
-  "clack",
-  "claude-vision",
-  "clerk",
-  "cli-commander",
-  "cli-planning",
-  "cli-reviewing",
-  "cloudflare-workers",
-  "cockroachdb",
-  "cohere-sdk",
-  "component-library",
-  "composable-components",
-  "css-animations",
-  "cva",
-  "cypress-e2e",
-  "d3",
-  "date-fns",
-  "design-tokens",
-  "detox",
-  "dnd-kit",
-  "docker",
-  "docusaurus",
-  "drizzle",
-  "eas",
-  "edgedb",
-  "elasticsearch",
-  "electron",
-  "electron-forge",
-  "electron-ipc",
-  "electron-multiwindow",
-  "electron-security",
-  "electron-storage",
-  "electron-testing",
-  "electron-ui",
-  "electron-updater",
-  "elevenlabs",
-  "elysia",
-  "error-boundaries",
-  "eslint-prettier",
-  "expo",
-  "expo-router",
-  "express",
-  "expressive-typescript",
-  "fastify",
-  "file-upload-patterns",
-  "firebase",
-  "framer-motion",
-  "gesture-handler",
-  "git-hooks",
-  "github-actions",
-  "google-gemini-sdk",
-  "graphql-apollo",
-  "graphql-urql",
-  "headless-ui",
-  "hono",
-  "huggingface-inference",
-  "image-handling",
-  "infra-reviewing",
-  "jotai",
-  "knex",
-  "kubernetes",
-  "langchain",
-  "langfuse",
-  "leaflet",
-  "lexical",
-  "litellm",
-  "llamaindex",
-  "maestro",
-  "mantine",
-  "mapbox",
-  "meilisearch",
-  "mercurius",
-  "mistral-sdk",
-  "mmkv",
-  "mobx",
-  "modal",
-  "mongodb",
-  "mongoose",
-  "msw",
-  "mui",
-  "mysql",
-  "native-js",
-  "nativewind",
-  "neon",
-  "nestjs",
-  "netlify",
-  "next-intl",
-  "nextauth",
-  "nextjs",
-  "ngrx-signalstore",
-  "nuxt",
-  "nx",
-  "oclif-ink",
-  "offline-first",
-  "ollama",
-  "openai-sdk",
-  "openai-whisper",
-  "openapi",
-  "payload",
-  "pinecone",
-  "pinia",
-  "planetscale",
-  "playwright-e2e",
-  "pnpm-workspaces",
-  "postgresql",
-  "posthog-analytics",
-  "posthog-flags",
-  "prisma",
-  "promptfoo",
-  "pulumi",
-  "push",
-  "qdrant",
-  "qwik",
-  "radix-ui",
-  "react",
-  "react-hook-form",
-  "react-intl",
-  "react-native",
-  "react-native-paper",
-  "react-native-performance",
-  "react-native-security",
-  "react-navigation",
-  "react-query",
-  "react-router",
-  "react-testing-library",
-  "react-three-fiber",
-  "reanimated",
-  "recharts",
-  "redis",
-  "redux-toolkit",
-  "remix",
-  "replicate",
-  "research-methodology",
-  "resend-react-email",
-  "result-types",
-  "reviewing",
-  "rxjs",
-  "sanity",
-  "scss-modules",
-  "sequelize",
-  "service-workers",
-  "setup-axiom-pino-sentry",
-  "setup-env",
-  "setup-posthog",
-  "setup-resend",
-  "shadcn-ui",
-  "skia",
-  "socket-io",
-  "solidjs",
-  "sqlite-powersync",
-  "sse",
-  "sst",
-  "stack-detect",
-  "storybook",
-  "strapi",
-  "strategies",
-  "stripe",
-  "supabase",
-  "surrealdb",
-  "svelte",
-  "sveltekit",
-  "swr",
-  "tailwind",
-  "tamagui",
-  "tanstack-form",
-  "tanstack-router",
-  "tanstack-table",
-  "tasks",
-  "tauri",
-  "tauri-backend",
-  "tauri-bundling",
-  "tauri-mobile",
-  "tauri-multiwindow",
-  "tauri-plugins",
-  "tauri-security",
-  "terraform",
-  "theming",
-  "tiptap",
-  "together-ai",
-  "tool-use-patterns",
-  "trpc",
-  "turborepo",
-  "turborepo-ci",
-  "turso",
-  "typeorm",
-  "typescript-config",
-  "unistyles",
-  "upstash",
-  "vee-validate",
-  "vercel",
-  "vercel-ai-sdk",
-  "vercel-kv",
-  "vercel-postgres",
-  "view-transitions",
-  "vision-camera",
-  "visual-regression",
-  "vite",
-  "vitepress",
-  "vitest",
-  "vue-composition-api",
-  "vue-i18n",
-  "vue-test-utils",
-  "vuetify",
-  "vueuse",
-  "watermelondb",
-  "weaviate",
-  "web-accessibility",
-  "web-performance",
-  "web-planning",
-  "web-reviewing",
-  "webhooks",
-  "websockets",
-  "xquik",
-  "yoga",
-  "zod-validation",
-  "zustand"
-];
-var SKILL_IDS = [
-  "ai-infrastructure-huggingface-inference",
-  "ai-infrastructure-litellm",
-  "ai-infrastructure-modal",
-  "ai-infrastructure-ollama",
-  "ai-infrastructure-replicate",
-  "ai-infrastructure-together-ai",
-  "ai-observability-langfuse",
-  "ai-observability-promptfoo",
-  "ai-orchestration-langchain",
-  "ai-orchestration-llamaindex",
-  "ai-orchestration-vercel-ai-sdk",
-  "ai-patterns-tool-use-patterns",
-  "ai-provider-anthropic-sdk",
-  "ai-provider-claude-vision",
-  "ai-provider-cohere-sdk",
-  "ai-provider-elevenlabs",
-  "ai-provider-google-gemini-sdk",
-  "ai-provider-mistral-sdk",
-  "ai-provider-openai-sdk",
-  "ai-provider-openai-whisper",
-  "api-analytics-posthog-analytics",
-  "api-analytics-setup-posthog",
-  "api-auth-better-auth-drizzle-hono",
-  "api-auth-clerk",
-  "api-auth-nextauth",
-  "api-baas-appwrite",
-  "api-baas-firebase",
-  "api-baas-neon",
-  "api-baas-planetscale",
-  "api-baas-supabase",
-  "api-baas-turso",
-  "api-caching-strategies",
-  "api-cms-payload",
-  "api-cms-sanity",
-  "api-cms-strapi",
-  "api-commerce-stripe",
-  "api-database-cockroachdb",
-  "api-database-drizzle",
-  "api-database-edgedb",
-  "api-database-knex",
-  "api-database-mongodb",
-  "api-database-mongoose",
-  "api-database-mysql",
-  "api-database-postgresql",
-  "api-database-prisma",
-  "api-database-redis",
-  "api-database-sequelize",
-  "api-database-surrealdb",
-  "api-database-typeorm",
-  "api-database-upstash",
-  "api-database-vercel-kv",
-  "api-database-vercel-postgres",
-  "api-email-resend-react-email",
-  "api-email-setup-resend",
-  "api-flags-posthog-flags",
-  "api-framework-elysia",
-  "api-framework-express",
-  "api-framework-fastify",
-  "api-framework-hono",
-  "api-framework-nestjs",
-  "api-graphql-apollo-server",
-  "api-graphql-mercurius",
-  "api-graphql-yoga",
-  "api-messaging-webhooks",
-  "api-observability-axiom-pino-sentry",
-  "api-observability-setup-axiom-pino-sentry",
-  "api-performance-api-performance",
-  "api-queue-bullmq",
-  "api-search-elasticsearch",
-  "api-search-meilisearch",
-  "api-search-xquik",
-  "api-specs-openapi",
-  "api-vector-db-chroma",
-  "api-vector-db-pinecone",
-  "api-vector-db-qdrant",
-  "api-vector-db-weaviate",
-  "cli-framework-cli-commander",
-  "cli-framework-oclif-ink",
-  "cli-prompts-clack",
-  "desktop-backend-tauri",
-  "desktop-framework-electron",
-  "desktop-framework-tauri",
-  "desktop-ipc-electron",
-  "desktop-mobile-tauri",
-  "desktop-multiwindow-electron",
-  "desktop-multiwindow-tauri",
-  "desktop-packaging-electron-forge",
-  "desktop-packaging-tauri",
-  "desktop-plugins-tauri",
-  "desktop-security-electron",
-  "desktop-security-tauri",
-  "desktop-storage-electron",
-  "desktop-testing-electron",
-  "desktop-ui-electron",
-  "desktop-updates-electron-updater",
-  "infra-ci-cd-docker",
-  "infra-ci-cd-github-actions",
-  "infra-ci-cd-turborepo-ci",
-  "infra-config-setup-env",
-  "infra-containers-kubernetes",
-  "infra-iac-pulumi",
-  "infra-iac-sst",
-  "infra-iac-terraform",
-  "infra-platform-aws-sdk",
-  "infra-platform-cloudflare-workers",
-  "infra-platform-netlify",
-  "infra-platform-vercel",
-  "meta-config-stack-detect",
-  "meta-design-composable-components",
-  "meta-design-expressive-typescript",
-  "meta-methodology-research-methodology",
-  "meta-planning-ai-planning",
-  "meta-planning-api-planning",
-  "meta-planning-cli-planning",
-  "meta-planning-web-planning",
-  "meta-reviewing-ai-reviewing",
-  "meta-reviewing-api-reviewing",
-  "meta-reviewing-cli-reviewing",
-  "meta-reviewing-infra-reviewing",
-  "meta-reviewing-reviewing",
-  "meta-reviewing-web-reviewing",
-  "mobile-animation-gesture-handler",
-  "mobile-animation-reanimated",
-  "mobile-animation-skia",
-  "mobile-background-tasks",
-  "mobile-camera-vision-camera",
-  "mobile-deep-linking-app-links",
-  "mobile-deployment-eas",
-  "mobile-framework-expo",
-  "mobile-framework-react-native",
-  "mobile-hardware-ble-nfc",
-  "mobile-navigation-expo-router",
-  "mobile-navigation-react-navigation",
-  "mobile-notifications-push",
-  "mobile-performance-react-native",
-  "mobile-security-react-native",
-  "mobile-storage-mmkv",
-  "mobile-storage-sqlite-powersync",
-  "mobile-storage-watermelondb",
-  "mobile-styling-nativewind",
-  "mobile-styling-unistyles",
-  "mobile-testing-detox",
-  "mobile-testing-maestro",
-  "mobile-ui-components-react-native-paper",
-  "mobile-ui-components-tamagui",
-  "shared-monorepo-nx",
-  "shared-monorepo-pnpm-workspaces",
-  "shared-monorepo-turborepo",
-  "shared-security-auth-security",
-  "shared-tooling-biome",
-  "shared-tooling-changesets",
-  "shared-tooling-eslint-prettier",
-  "shared-tooling-git-hooks",
-  "shared-tooling-typescript-config",
-  "web-3d-react-three-fiber",
-  "web-accessibility-web-accessibility",
-  "web-animation-css-animations",
-  "web-animation-framer-motion",
-  "web-animation-view-transitions",
-  "web-data-fetching-graphql-apollo",
-  "web-data-fetching-graphql-urql",
-  "web-data-fetching-swr",
-  "web-data-fetching-trpc",
-  "web-dataviz-d3",
-  "web-dataviz-recharts",
-  "web-dnd-dnd-kit",
-  "web-editor-lexical",
-  "web-editor-tiptap",
-  "web-error-handling-error-boundaries",
-  "web-error-handling-result-types",
-  "web-files-file-upload-patterns",
-  "web-files-image-handling",
-  "web-forms-react-hook-form",
-  "web-forms-tanstack-form",
-  "web-forms-vee-validate",
-  "web-forms-zod-validation",
-  "web-framework-angular-standalone",
-  "web-framework-react",
-  "web-framework-solidjs",
-  "web-framework-svelte",
-  "web-framework-vue-composition-api",
-  "web-i18n-next-intl",
-  "web-i18n-react-intl",
-  "web-i18n-vue-i18n",
-  "web-maps-leaflet",
-  "web-maps-mapbox",
-  "web-meta-framework-astro",
-  "web-meta-framework-docusaurus",
-  "web-meta-framework-nextjs",
-  "web-meta-framework-nuxt",
-  "web-meta-framework-qwik",
-  "web-meta-framework-remix",
-  "web-meta-framework-sveltekit",
-  "web-meta-framework-vitepress",
-  "web-mocks-msw",
-  "web-performance-web-performance",
-  "web-pwa-offline-first",
-  "web-pwa-service-workers",
-  "web-realtime-socket-io",
-  "web-realtime-sse",
-  "web-realtime-websockets",
-  "web-routing-react-router",
-  "web-routing-tanstack-router",
-  "web-server-state-react-query",
-  "web-state-jotai",
-  "web-state-mobx",
-  "web-state-ngrx-signalstore",
-  "web-state-pinia",
-  "web-state-redux-toolkit",
-  "web-state-zustand",
-  "web-styling-cva",
-  "web-styling-design-tokens",
-  "web-styling-scss-modules",
-  "web-styling-tailwind",
-  "web-styling-theming",
-  "web-testing-cypress-e2e",
-  "web-testing-playwright-e2e",
-  "web-testing-react-testing-library",
-  "web-testing-visual-regression",
-  "web-testing-vitest",
-  "web-testing-vue-test-utils",
-  "web-tooling-component-library",
-  "web-tooling-storybook",
-  "web-tooling-vite",
-  "web-ui-ant-design",
-  "web-ui-base-ui",
-  "web-ui-chakra-ui",
-  "web-ui-headless-ui",
-  "web-ui-mantine",
-  "web-ui-mui",
-  "web-ui-radix-ui",
-  "web-ui-shadcn-ui",
-  "web-ui-tanstack-table",
-  "web-ui-vuetify",
-  "web-utilities-date-fns",
-  "web-utilities-native-js",
-  "web-utilities-rxjs",
-  "web-utilities-vueuse"
-];
-var CATEGORIES = [
-  "ai-infrastructure",
-  "ai-observability",
-  "ai-orchestration",
-  "ai-patterns",
-  "ai-provider",
-  "api-analytics",
-  "api-api",
-  "api-auth",
-  "api-baas",
-  "api-caching",
-  "api-cms",
-  "api-commerce",
-  "api-db-host",
-  "api-document",
-  "api-email",
-  "api-graphql",
-  "api-kv",
-  "api-messaging",
-  "api-observability",
-  "api-orm",
-  "api-performance",
-  "api-queue",
-  "api-search",
-  "api-specs",
-  "api-sql-engine",
-  "api-vector-db",
-  "cli-framework",
-  "cli-prompts",
-  "desktop-backend",
-  "desktop-framework",
-  "desktop-ipc",
-  "desktop-mobile",
-  "desktop-multiwindow",
-  "desktop-packaging",
-  "desktop-plugins",
-  "desktop-security",
-  "desktop-storage",
-  "desktop-testing",
-  "desktop-ui",
-  "desktop-updates",
-  "infra-ci-cd",
-  "infra-config",
-  "infra-containers",
-  "infra-iac",
-  "infra-platform",
-  "meta-design",
-  "meta-methodology",
-  "meta-planning",
-  "meta-reviewing",
-  "mobile-animation",
-  "mobile-background",
-  "mobile-camera",
-  "mobile-deep-linking",
-  "mobile-deployment",
-  "mobile-framework",
-  "mobile-hardware",
-  "mobile-navigation",
-  "mobile-notifications",
-  "mobile-performance",
-  "mobile-security",
-  "mobile-storage",
-  "mobile-styling",
-  "mobile-testing",
-  "mobile-ui-components",
-  "shared-lint",
-  "shared-monorepo",
-  "shared-security",
-  "shared-task-runner",
-  "shared-tooling",
-  "web-3d",
-  "web-accessibility",
-  "web-animation",
-  "web-client-state",
-  "web-dataviz",
-  "web-dnd",
-  "web-docs",
-  "web-e2e",
-  "web-editor",
-  "web-error-handling",
-  "web-file-upload",
-  "web-files",
-  "web-form-library",
-  "web-forms",
-  "web-framework",
-  "web-graphql-client",
-  "web-i18n",
-  "web-maps",
-  "web-meta-framework",
-  "web-mocking",
-  "web-performance",
-  "web-pwa",
-  "web-realtime",
-  "web-routing",
-  "web-rpc",
-  "web-server-state",
-  "web-streaming",
-  "web-styling",
-  "web-testing",
-  "web-tooling",
-  "web-ui-components",
-  "web-ui-kit",
-  "web-utilities"
-];
-var DOMAINS = [
-  "ai",
-  "api",
-  "cli",
-  "desktop",
-  "infra",
-  "meta",
-  "mobile",
-  "shared",
-  "web"
-];
-var AGENT_NAMES = [
-  "agent-summoner",
-  "ai-developer",
-  "ai-researcher",
-  "ai-tester",
-  "api-developer",
-  "api-researcher",
-  "api-tester",
-  "cli-developer",
-  "cli-researcher",
-  "cli-tester",
-  "codex-keeper",
-  "convention-keeper",
-  "pm",
-  "reviewer",
-  "skill-summoner",
-  "web-developer",
-  "web-researcher",
-  "web-tester"
-];
-
-// src/cli/utils/type-guards.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isDomain(value) {
-  return DOMAINS.includes(value);
-}
-function isAgentName(value) {
-  return AGENT_NAMES.includes(value);
-}
-function isSkillId(value) {
-  return SKILL_IDS.includes(value);
-}
-function isSkillAssignment(value) {
-  if (typeof value !== "object" || value === null) return false;
-  return typeof value.id === "string";
-}
-
-// src/cli/types/matrix.ts
-var MODEL_NAMES = ["sonnet", "opus", "haiku", "fable", "inherit"];
-var EFFORT_NAMES = ["low", "medium", "high", "xhigh", "max"];
-var PERMISSION_MODES = [
-  "default",
-  "acceptEdits",
-  "dontAsk",
-  "bypassPermissions",
-  "plan",
-  "delegate"
-];
-
-// src/cli/lib/schemas.ts
-var modelNameSchema = z2.enum(MODEL_NAMES);
-var effortLevelSchema = z2.enum(EFFORT_NAMES);
-var permissionModeSchema = z2.enum(PERMISSION_MODES);
-var skillSlugSchema = z2.enum(SKILL_SLUGS);
-var categoryPathSchema = z2.string().refine(
-  (val) => {
-    if (val === LOCAL_PSEUDO_CATEGORY) return true;
-    if (CATEGORIES.includes(val)) return true;
-    return KEBAB_CASE_PATTERN.test(val);
-  },
-  {
-    message: "Must be a valid category path (e.g., 'web-framework', 'shared-testing', or 'local')"
-  }
-);
-var agentHookActionSchema = z2.object({
-  type: z2.enum(["command", "script", "prompt"]),
-  command: z2.string().exactOptional(),
-  script: z2.string().exactOptional(),
-  prompt: z2.string().exactOptional()
-});
-var agentHookDefinitionSchema = z2.object({
-  matcher: z2.string().exactOptional(),
-  hooks: z2.array(agentHookActionSchema).exactOptional()
-});
-var hooksRecordSchema = z2.record(z2.string(), z2.array(agentHookDefinitionSchema));
-var strictAgentHookDefinitionSchema = z2.object({
-  matcher: z2.string().exactOptional(),
-  hooks: z2.array(agentHookActionSchema).min(1)
-});
-var strictHooksRecordSchema = z2.record(
-  z2.string(),
-  z2.array(strictAgentHookDefinitionSchema)
-);
-var skillAssignmentSchema = z2.object({
-  id: z2.string(),
-  preloaded: z2.boolean().exactOptional(),
-  local: z2.boolean().exactOptional(),
-  path: z2.string().exactOptional()
-});
-var skillFrontmatterLoaderSchema = z2.object({
-  /** Lenient (any string): local/custom skills have non-builtin IDs */
-  name: z2.string(),
-  description: z2.string(),
-  model: modelNameSchema.exactOptional()
-});
-var skillMetadataLoaderSchema = z2.object({
-  category: categoryPathSchema.exactOptional(),
-  author: z2.string().exactOptional(),
-  domain: z2.string(),
-  custom: z2.boolean().exactOptional()
-}).passthrough();
-var matrixRawMetadataSchema = z2.object({
-  category: categoryPathSchema,
-  author: z2.string(),
-  displayName: z2.string().exactOptional(),
-  slug: z2.string(),
-  cliDescription: z2.string().exactOptional(),
-  usageGuidance: z2.string().exactOptional(),
-  // Boundary cast: domain is a string at the YAML parse boundary; narrowed to Domain type
-  domain: z2.string(),
-  custom: z2.boolean().exactOptional()
-});
-var pluginAuthorSchema = z2.object({
-  name: z2.string().min(1),
-  email: z2.string().exactOptional()
-});
-var pluginManifestObjectSchema = z2.object({
-  name: z2.string(),
-  version: z2.string().exactOptional(),
-  description: z2.string().exactOptional(),
-  author: pluginAuthorSchema.exactOptional(),
-  /** Lenient: a plugin authored elsewhere may carry any category string or none at all */
-  category: z2.string().exactOptional(),
-  keywords: z2.array(z2.string()).exactOptional(),
-  commands: z2.union([z2.string(), z2.array(z2.string())]).exactOptional(),
-  agents: z2.union([z2.string(), z2.array(z2.string())]).exactOptional(),
-  skills: z2.union([z2.string(), z2.array(z2.string())]).exactOptional(),
-  hooks: z2.union([z2.string(), hooksRecordSchema]).exactOptional()
-});
-var pluginManifestSchema = pluginManifestObjectSchema;
-var pluginManifestValidationSchema = pluginManifestObjectSchema.strict();
-var agentYamlConfigSchema = z2.object({
-  id: z2.string(),
-  title: z2.string(),
-  description: z2.string(),
-  model: modelNameSchema.exactOptional(),
-  effort: effortLevelSchema.exactOptional(),
-  tools: z2.array(z2.string()),
-  disallowedTools: z2.array(z2.string()).exactOptional(),
-  permissionMode: permissionModeSchema.exactOptional(),
-  hooks: hooksRecordSchema.exactOptional(),
-  outputFormat: z2.string().exactOptional(),
-  domain: z2.string().exactOptional(),
-  custom: z2.boolean().exactOptional()
-});
-var skillAssignmentElementSchema = z2.union([
-  z2.string(),
-  skillAssignmentSchema
-]);
-var stackAgentConfigSchema = z2.record(
-  z2.string(),
-  z2.union([skillAssignmentElementSchema, z2.array(skillAssignmentElementSchema)])
-);
-var RENAMED_CONFIG_FIELDS = { source: "marketplace" };
-var RENAMED_SKILL_ENTRY_FIELDS = { source: "origin" };
-function renamedFieldMessage(oldKey, newKey) {
-  return `"${oldKey}" was renamed to "${newKey}". Rename the key in this config \u2014 the CLI does not read "${oldKey}" any more and will not fall back to it.`;
-}
-function reportRenamedKeys(record, renames, path3, ctx) {
-  for (const [oldKey, newKey] of Object.entries(renames)) {
-    if (!(oldKey in record)) continue;
-    ctx.addIssue({
-      code: "custom",
-      path: [...path3, oldKey],
-      message: renamedFieldMessage(oldKey, newKey)
-    });
-  }
-}
-function refuseRenamedFields(config, ctx) {
-  if (!isRecord(config)) return;
-  reportRenamedKeys(config, RENAMED_CONFIG_FIELDS, [], ctx);
-  const { skills } = config;
-  if (!Array.isArray(skills)) return;
-  for (const [index, entry] of skills.entries()) {
-    if (!isRecord(entry)) continue;
-    reportRenamedKeys(entry, RENAMED_SKILL_ENTRY_FIELDS, ["skills", index], ctx);
-  }
-}
-var renamedFieldGuard = z2.unknown().superRefine(refuseRenamedFields);
-var projectConfigFields = z2.object({
-  /** Project/plugin name in kebab-case */
-  name: z2.string().exactOptional(),
-  description: z2.string().exactOptional(),
-  /** Per-agent configuration with scope (e.g., [{ name: "web-developer", scope: "project" }]) */
-  agents: z2.array(
-    z2.object({
-      name: z2.string(),
-      scope: z2.enum(["project", "global"]),
-      /** Per-agent overrides of the agent's own metadata defaults */
-      model: modelNameSchema.exactOptional(),
-      effort: effortLevelSchema.exactOptional(),
-      excluded: z2.boolean().exactOptional()
-    })
-  ).exactOptional(),
-  /** Per-skill configuration with scope and provenance */
-  skills: z2.array(
-    z2.object({
-      id: z2.string(),
-      scope: z2.enum(["project", "global"]),
-      origin: z2.string(),
-      excluded: z2.boolean().exactOptional()
-    })
-  ).exactOptional(),
-  /** Author handle (e.g., "@vince") */
-  author: z2.string().exactOptional(),
-  /** Selected domains from the wizard (persisted for edit mode restoration) */
-  selectedDomains: z2.array(z2.string()).exactOptional(),
-  /** Agent-to-category-to-skill mappings from selected stack (accepts same formats as stacks.ts) */
-  stack: z2.record(z2.string(), stackAgentConfigSchema).exactOptional(),
-  /** The marketplace this install reads skills from, as a path or URL (e.g., "github:my-org/skills") */
-  marketplace: z2.string().exactOptional(),
-  /** The name that marketplace's manifest gives it, which plugins are registered under */
-  marketplaceName: z2.string().exactOptional(),
-  /** Separate source for agents when different from skills source */
-  agentsSource: z2.string().exactOptional(),
-  /** Tracked project installation paths (global config only) */
-  projects: z2.array(z2.string()).exactOptional()
-}).passthrough();
-var projectConfigLoaderSchema = renamedFieldGuard.pipe(projectConfigFields);
-var categoryDefinitionSchema = z2.object({
-  id: z2.string(),
-  displayName: z2.string(),
-  description: z2.string(),
-  domain: z2.string().exactOptional(),
-  exclusive: z2.boolean(),
-  required: z2.boolean(),
-  order: z2.number(),
-  icon: z2.string().exactOptional()
-});
-var skillRefInRules = skillSlugSchema;
-var skillGroupRuleSchema = z2.object({
-  skills: z2.array(skillRefInRules).min(2),
-  reason: z2.string()
-});
-var conflictRuleSchema = skillGroupRuleSchema;
-var discourageRuleSchema = skillGroupRuleSchema;
-var requireRuleSchema = z2.object({
-  skill: skillRefInRules,
-  needs: z2.array(skillRefInRules).min(1),
-  needsAny: z2.boolean().exactOptional(),
-  reason: z2.string()
-});
-var alternativeGroupSchema = z2.object({
-  purpose: z2.string(),
-  skills: z2.array(skillRefInRules).min(1)
-});
-var relationshipDefinitionsSchema = z2.object({
-  conflicts: z2.array(conflictRuleSchema),
-  discourages: z2.array(discourageRuleSchema),
-  requires: z2.array(requireRuleSchema),
-  alternatives: z2.array(alternativeGroupSchema)
-});
-var skillCategoriesFileSchema = z2.object({
-  version: z2.string(),
-  categories: z2.record(z2.string(), categoryDefinitionSchema)
-});
-var skillRulesFileSchema = z2.object({
-  version: z2.string(),
-  relationships: relationshipDefinitionsSchema.exactOptional()
-});
-var localRawMetadataSchema = z2.object({
-  /** Short name shown in the wizard grid (e.g., "my-custom-react") */
-  displayName: z2.string(),
-  /** Kebab-case short key for alias resolution (e.g., "react") */
-  slug: z2.string(),
-  /** One-line description for the wizard */
-  cliDescription: z2.string().exactOptional(),
-  /** Category to place this skill in (e.g., "web-framework") */
-  category: categoryPathSchema,
-  /** When an AI agent should invoke this skill */
-  usageGuidance: z2.string().exactOptional(),
-  /** Domain this skill belongs to (e.g., "web", "api", "cli") */
-  domain: z2.string(),
-  /** True if this skill was created outside the CLI's built-in vocabulary */
-  custom: z2.boolean().exactOptional()
-}).passthrough();
-var localSkillMetadataSchema = z2.object({
-  forkedFrom: z2.object({
-    /** Original skill ID before forking — lenient (any string) since custom/extra-source skills have non-builtin IDs */
-    skillId: z2.string(),
-    /** SHA hash of the original content at fork time (for diff detection) */
-    contentHash: z2.string(),
-    /** ISO date when the fork was created */
-    date: z2.string(),
-    /** Source URL the skill was installed from (e.g., "github:agents-inc/skills") */
-    source: z2.string().exactOptional(),
-    /** Directory inside that repository, for a skill only its own bytes can install again */
-    path: z2.string().exactOptional()
-  }).exactOptional()
-}).passthrough();
-var stackSchema = z2.object({
-  id: z2.string().min(1),
-  name: z2.string().min(1),
-  description: z2.string(),
-  /** Maps agent IDs to their category-to-skill assignments */
-  agents: z2.record(z2.string(), stackAgentConfigSchema),
-  /** High-level philosophy guiding this stack's technology choices */
-  philosophy: z2.string().exactOptional()
-});
-var stacksConfigSchema = z2.object({
-  stacks: z2.array(stackSchema).min(1)
-});
-var marketplaceRemoteSourceSchema = z2.object({
-  source: z2.enum(["github", "url"]),
-  repo: z2.string().exactOptional(),
-  url: z2.string().exactOptional(),
-  ref: z2.string().exactOptional()
-});
-var marketplacePluginSchema = z2.object({
-  name: z2.string().min(1),
-  /** Local directory path (relative to pluginRoot) or remote source config */
-  source: z2.union([z2.string(), marketplaceRemoteSourceSchema]),
-  description: z2.string().exactOptional(),
-  version: z2.string().exactOptional(),
-  author: pluginAuthorSchema.exactOptional(),
-  /** Lenient: external data may have any category string or none at all */
-  category: z2.string().exactOptional(),
-  keywords: z2.array(z2.string()).exactOptional()
-});
-var marketplaceOwnerSchema = pluginAuthorSchema;
-var marketplaceMetadataSchema = z2.object({
-  /** Base directory for resolving plugin source paths (e.g., "plugins/") */
-  pluginRoot: z2.string().exactOptional()
-});
-var marketplaceSchema = z2.object({
-  $schema: z2.string().exactOptional(),
-  name: z2.string().min(1),
-  version: z2.string().min(1),
-  description: z2.string().exactOptional(),
-  owner: marketplaceOwnerSchema,
-  metadata: marketplaceMetadataSchema.exactOptional(),
-  plugins: z2.array(marketplacePluginSchema).min(1)
-});
-var sourceRevalidationSchema = z2.object({
-  /** The tarball URL giget resolved for this source. */
-  tar: z2.string().min(1),
-  etag: z2.string().min(1).exactOptional()
-});
-var permissionConfigSchema = z2.object({
-  /** Tool names or patterns to explicitly allow */
-  allow: z2.array(z2.string()).exactOptional(),
-  /** Tool names or patterns to explicitly deny */
-  deny: z2.array(z2.string()).exactOptional()
-});
-var settingsFileSchema = z2.object({
-  permissions: permissionConfigSchema.exactOptional()
-}).passthrough();
-var brandingConfigSchema = z2.object({
-  /** Custom CLI name (e.g., "Acme Dev Tools") */
-  name: z2.string().exactOptional(),
-  /** Custom tagline shown in wizard header */
-  tagline: z2.string().exactOptional()
-});
-var projectSourceConfigFields = z2.object({
-  /** The marketplace this install reads skills from, as a path or URL */
-  marketplace: z2.string().exactOptional(),
-  /** Author handle for this project's config */
-  author: z2.string().exactOptional(),
-  /** The name that marketplace's manifest gives it, which plugins are registered under */
-  marketplaceName: z2.string().exactOptional(),
-  /** Separate source for agent definitions (when different from skills) */
-  agentsSource: z2.string().exactOptional(),
-  /** Branding overrides for white-labeling the CLI */
-  branding: brandingConfigSchema.exactOptional(),
-  /** Custom skills directory override (default: "src/skills") */
-  skillsDir: z2.string().exactOptional(),
-  /** Custom agents directory override (default: "src/agents") */
-  agentsDir: z2.string().exactOptional(),
-  /** Custom stacks file path override (default: "config/stacks.ts") */
-  stacksFile: z2.string().exactOptional(),
-  /** Custom categories file path override (default: "config/skill-categories.ts") */
-  categoriesFile: z2.string().exactOptional(),
-  /** Custom rules file path override (default: "config/skill-rules.ts") */
-  rulesFile: z2.string().exactOptional()
-}).passthrough();
-var projectSourceConfigSchema = renamedFieldGuard.pipe(projectSourceConfigFields);
-var agentYamlGenerationSchema = z2.object({
-  $schema: z2.string().exactOptional(),
-  id: z2.string().min(1),
-  title: z2.string().min(1),
-  description: z2.string().min(1),
-  model: modelNameSchema.exactOptional(),
-  effort: effortLevelSchema.exactOptional(),
-  tools: z2.array(z2.string()).min(1),
-  disallowedTools: z2.array(z2.string()).exactOptional(),
-  permissionMode: permissionModeSchema.exactOptional(),
-  hooks: strictHooksRecordSchema.exactOptional(),
-  outputFormat: z2.string().exactOptional(),
-  domain: z2.string().exactOptional(),
-  custom: z2.boolean().exactOptional()
-}).strict();
-var agentFrontmatterValidationSchema = z2.object({
-  /** Agent name in kebab-case (becomes the Task tool identifier) */
-  name: z2.string().regex(KEBAB_CASE_PATTERN).min(1),
-  description: z2.string().min(1),
-  /** Comma-separated list of allowed tools */
-  tools: z2.string().exactOptional(),
-  /** Comma-separated list of denied tools */
-  disallowedTools: z2.string().exactOptional(),
-  model: modelNameSchema.exactOptional(),
-  effort: effortLevelSchema.exactOptional(),
-  permissionMode: permissionModeSchema.exactOptional(),
-  /** Skill names to preload (embed in agent prompt) */
-  skills: z2.array(z2.string().min(1)).exactOptional(),
-  hooks: strictHooksRecordSchema.exactOptional()
-}).strict();
-var skillFrontmatterValidationSchema = z2.object({
-  name: z2.string().min(1),
-  description: z2.string().min(1),
-  /** If true, Claude cannot invoke this skill on its own */
-  "disable-model-invocation": z2.boolean().exactOptional(),
-  /** If true, user can invoke this skill directly */
-  "user-invocable": z2.boolean().exactOptional(),
-  /** Comma-separated list of tools this skill can use */
-  "allowed-tools": z2.string().exactOptional(),
-  model: modelNameSchema.exactOptional(),
-  /** "fork" means skill runs in a forked context (separate conversation) */
-  context: z2.enum(["fork"]).exactOptional(),
-  /** Agent name this skill is scoped to */
-  agent: z2.string().exactOptional(),
-  /** Hint text shown when user invokes the skill */
-  "argument-hint": z2.string().exactOptional()
-}).strict();
-var forkedFromSchema = z2.object({
-  /** Original skill ID */
-  skillId: z2.string(),
-  /** Version of the original at fork time */
-  version: z2.number().int().min(1).exactOptional(),
-  /** Content hash of the original at fork time */
-  contentHash: z2.string(),
-  /** Source URL or identifier */
-  source: z2.string().exactOptional(),
-  /** Directory inside that source, for a skill only its own bytes can install again */
-  path: z2.string().exactOptional(),
-  /** ISO date of the fork */
-  date: z2.string()
-});
-var CLI_DESCRIPTION_MAX_LENGTH = 60;
-var skillMetadataBaseSchema = z2.object({
-  /** Author handle — must start with @ (e.g., "@vince") */
-  author: z2.string().regex(AUTHOR_HANDLE_PATTERN),
-  /** Short display name for the wizard grid (max 30 chars) */
-  displayName: z2.string().min(1).max(30),
-  /** One-line description for the wizard (max 60 chars recommended; over-length is a validation warning) */
-  cliDescription: z2.string().min(1).max(CLI_DESCRIPTION_MAX_LENGTH),
-  /** When an AI agent should invoke this skill (min 10 chars to ensure usefulness) */
-  usageGuidance: z2.string().min(10),
-  /** 7-char hex SHA of skill content (for change detection) */
-  contentHash: z2.string().regex(/^[a-f0-9]{7}$/).exactOptional(),
-  /** ISO date of last update */
-  updated: z2.string().exactOptional(),
-  /** Provenance tracking when skill was forked from another */
-  forkedFrom: forkedFromSchema.exactOptional(),
-  /** Domain assignment from metadata */
-  domain: z2.string().exactOptional(),
-  /** True if this skill was created outside the CLI's built-in vocabulary */
-  custom: z2.boolean().exactOptional()
-});
-var metadataValidationSchema = skillMetadataBaseSchema.extend({
-  /** Domain-prefixed category — must be a known built-in category */
-  category: z2.enum(CATEGORIES),
-  /** Kebab-case short key — must be a known built-in slug */
-  slug: z2.enum(SKILL_SLUGS)
-}).strict();
-var customMetadataValidationSchema = skillMetadataBaseSchema.extend({
-  /** Any string category — custom skills may define their own categories */
-  category: z2.string(),
-  /** Kebab-case short key for alias resolution, search, and relationship rules */
-  slug: z2.string().regex(/^[a-z][a-z0-9-]*$/).min(1).max(50)
-});
-var stackSkillAssignmentSchema = z2.object({
-  id: z2.string().min(1),
-  /** If true, skill content is embedded in the compiled agent prompt */
-  preloaded: z2.boolean().exactOptional()
-}).strict();
-var stackConfigValidationSchema = z2.object({
-  /** Unique stack identifier in kebab-case */
-  id: z2.string().regex(KEBAB_CASE_PATTERN).exactOptional(),
-  name: z2.string().min(1),
-  version: z2.string(),
-  author: z2.string().min(1),
-  description: z2.string().exactOptional(),
-  /** ISO date when this stack was first created */
-  created: z2.string().exactOptional(),
-  /** ISO date of last update */
-  updated: z2.string().exactOptional(),
-  /** Primary framework this stack is designed for (e.g., "nextjs", "remix") */
-  framework: z2.string().exactOptional(),
-  /** All skills used in this stack (flat list, at least one required) */
-  skills: z2.array(stackSkillAssignmentSchema).min(1),
-  /** Agent IDs this stack compiles (at least one required) */
-  agents: z2.array(z2.string().regex(KEBAB_CASE_PATTERN)).min(1),
-  /** Per-agent skill assignments: { agentId: { category: [skillAssignment] } } */
-  agentSkills: z2.record(z2.string(), z2.record(z2.string(), z2.array(stackSkillAssignmentSchema))).exactOptional(),
-  /** High-level philosophy guiding technology choices */
-  philosophy: z2.string().exactOptional(),
-  /** Guiding principles for agents using this stack */
-  principles: z2.array(z2.string().min(1)).exactOptional(),
-  tags: z2.array(z2.string().regex(KEBAB_CASE_PATTERN)).exactOptional(),
-  /** Per-skill overrides: alternative suggestions and lock status */
-  overrides: z2.record(
-    z2.string(),
-    z2.object({
-      /** Suggested alternative skill IDs if this one is swapped */
-      alternatives: z2.array(z2.string().min(1)).exactOptional(),
-      /** If true, this skill cannot be swapped by the user */
-      locked: z2.boolean().exactOptional()
-    }).strict()
-  ).exactOptional(),
-  /** Community metrics for sorting/ranking */
-  metrics: z2.object({
-    upvotes: z2.number().int().min(0).exactOptional(),
-    downloads: z2.number().int().min(0).exactOptional()
-  }).strict().exactOptional(),
-  /** Lifecycle hooks triggered by file changes or commands */
-  hooks: strictHooksRecordSchema.exactOptional()
-}).strict();
-function formatZodIssues(issues) {
-  return issues.map(formatZodIssue).join("; ");
-}
-function validateSkillMetadata(rawMetadata) {
-  const schema = isCustomMetadata(rawMetadata) ? customMetadataValidationSchema : metadataValidationSchema;
-  return schema.safeParse(rawMetadata);
-}
-function describeMetadataSchemaFailure(issues, rawMetadata) {
-  const [absent, malformed] = partition(issues, (issue) => isAbsentField(issue, rawMetadata));
-  return [
-    ...absent.length > 0 ? [nameMissingFields(absent)] : [],
-    ...malformed.map(formatZodIssue)
-  ].join("; ");
-}
-function isAbsentField(issue, rawMetadata) {
-  const [field, ...nested] = issue.path;
-  return nested.length === 0 && typeof field === "string" && rawMetadata[field] === void 0;
-}
-function nameMissingFields(absent) {
-  const fields = absent.map((issue) => issue.path.join("."));
-  return `missing required ${fields.length === 1 ? "field" : "fields"}: ${fields.join(", ")}`;
-}
-function isOverLengthCliDescription(issue) {
-  return issue.code === "too_big" && issue.path.length === 1 && issue.path[0] === "cliDescription";
-}
-function readCliDescription(raw) {
-  if (raw == null || typeof raw !== "object") return void 0;
-  const value = raw.cliDescription;
-  return typeof value === "string" ? value : void 0;
-}
-function formatOverLengthWarning(issue, cliDescription) {
-  if (cliDescription === void 0) return formatZodIssue(issue);
-  return `cliDescription is ${cliDescription.length} characters \u2014 exceeds the recommended maximum of ${CLI_DESCRIPTION_MAX_LENGTH}`;
-}
-function splitMetadataValidationIssues(error, rawMetadata) {
-  const [overLength, hardFailures] = partition(error.issues, isOverLengthCliDescription);
-  const cliDescription = readCliDescription(rawMetadata);
-  const warnings = overLength.map((issue) => formatOverLengthWarning(issue, cliDescription));
-  return { errors: hardFailures.map(formatZodIssue), warnings };
-}
-function validateNestingDepth(value, maxDepth) {
-  function check(val, depth) {
-    if (depth > maxDepth) return false;
-    if (Array.isArray(val)) {
-      return val.every((item) => check(item, depth + 1));
-    }
-    if (val !== null && typeof val === "object") {
-      return Object.values(val).every((v) => check(v, depth + 1));
-    }
-    return true;
-  }
-  return check(value, 0);
-}
-function isCustomMetadata(raw) {
-  if (raw == null || typeof raw !== "object") return false;
-  if (!("custom" in raw)) return false;
-  return raw.custom === true;
-}
-function warnUnknownFields(parsed, expectedKeys, context) {
-  const expectedSet = new Set(expectedKeys);
-  const unknownKeys = Object.keys(parsed).filter((k) => !expectedSet.has(k));
-  if (unknownKeys.length > 0) {
-    warn(`Unknown fields in ${context}: ${unknownKeys.join(", ")}`);
-  }
-}
-
-// src/cli/lib/loading/loader.ts
-async function readSkillMetadata(metadataPath) {
-  let parsed;
-  try {
-    parsed = parseYaml2(await readFile(metadataPath));
-  } catch (error) {
-    return { usable: false, reason: getErrorMessage(error) };
-  }
-  if (!isFieldMapping(parsed)) {
-    return { usable: false, reason: `expected metadata fields, found ${nameYamlValue(parsed)}` };
-  }
-  const validated = localRawMetadataSchema.safeParse(parsed);
-  if (!validated.success) {
-    return { usable: false, reason: describeMetadataSchemaFailure(validated.error.issues, parsed) };
-  }
-  return { usable: true, metadata: validated.data };
-}
-function isFieldMapping(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function nameYamlValue(value) {
-  if (value === null || value === void 0) return "an empty file";
-  if (Array.isArray(value)) return "a list";
-  return `a ${typeof value}`;
-}
-function parseFrontmatter(content, filePath) {
-  const rawFrontmatter = extractFrontmatter(content);
-  if (rawFrontmatter === null) return null;
-  const parsed = skillFrontmatterLoaderSchema.safeParse(rawFrontmatter);
-  if (!parsed.success) {
-    const location = filePath ?? "unknown file";
-    warn(`Invalid SKILL.md frontmatter in '${location}': ${formatZodIssues(parsed.error.issues)}`);
-    return null;
-  }
-  return parsed.data;
-}
-async function loadAgentsFromDir(agentsDir, sourceRoot, options) {
-  const agents = {};
-  const files = await glob(`**/${STANDARD_FILES.AGENT_METADATA_YAML}`, agentsDir);
-  for (const file of files) {
-    const fullPath = path2.join(agentsDir, file);
-    try {
-      const content = await readFile(fullPath);
-      const config = agentYamlConfigSchema.parse(parseYaml2(content));
-      agents[config.id] = {
-        title: config.title,
-        description: config.description,
-        ...config.model !== void 0 && { model: config.model },
-        tools: config.tools,
-        path: path2.dirname(file),
-        sourceRoot,
-        ...options.agentBaseDir ? { agentBaseDir: options.agentBaseDir } : {},
-        ...config.domain ? { domain: config.domain } : {},
-        ...options.includeCustomFlag && config.custom === true ? { custom: true } : {}
-      };
-      verbose(`Loaded ${options.verboseLabel}: ${config.id} from ${file}`);
-    } catch (error) {
-      warn(`Skipping invalid metadata.yaml at '${fullPath}': ${getErrorMessage(error)}`);
-    }
-  }
-  return agents;
-}
-async function loadAllAgents(projectRoot) {
-  return loadAgentsFromDir(path2.join(projectRoot, DIRS.agents), projectRoot, {
-    includeCustomFlag: true,
-    verboseLabel: "agent"
-  });
-}
-async function loadMergedAgents(sourcePath) {
-  const [cliAgents, sourceAgents] = await Promise.all([
-    loadAllAgents(PROJECT_ROOT),
-    loadAllAgents(sourcePath)
-  ]);
-  return { ...cliAgents, ...sourceAgents };
-}
-async function loadProjectAgents(projectRoot) {
-  const projectAgentsDir = path2.join(projectRoot, CLAUDE_SRC_DIR, STANDARD_DIRS.AGENTS);
-  if (!await directoryExists(projectAgentsDir)) {
-    verbose(`No project agents directory at ${projectAgentsDir}`);
-    const noAgents = {};
-    return noAgents;
-  }
-  return loadAgentsFromDir(projectAgentsDir, projectRoot, {
-    // Project agents are in .claude-src/agents/
-    agentBaseDir: `${CLAUDE_SRC_DIR}/agents`,
-    verboseLabel: "project agent"
-  });
-}
-async function buildIdToDirectoryPathMap(skillsDir) {
-  const files = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir);
-  const parsed = await Promise.all(
-    files.map(async (file) => {
-      const fullPath = path2.join(skillsDir, file);
-      return { file, frontmatter: parseFrontmatter(await readFile(fullPath), fullPath) };
-    })
-  );
-  return Object.fromEntries(
-    parsed.filter(
-      (entry) => Boolean(entry.frontmatter?.name)
-    ).flatMap(({ file, frontmatter }) => {
-      const directoryPath = file.replace(`/${STANDARD_FILES.SKILL_MD}`, "");
-      return [
-        [frontmatter.name, directoryPath],
-        [directoryPath, directoryPath]
-      ];
-    })
-  );
-}
-async function loadSkillsByIds(skillIds, projectRoot) {
-  const skills = {};
-  const skillsDir = path2.join(projectRoot, DIRS.skills);
-  const idToDirectoryPath = await buildIdToDirectoryPathMap(skillsDir);
-  const expandDirectoryRef = (skillId) => {
-    const childSkills = typedKeys(idToDirectoryPath).filter(
-      (id) => idToDirectoryPath[id]?.startsWith(`${skillId}/`)
-    );
-    if (childSkills.length === 0) {
-      warn(`Unknown skill reference '${skillId}'`);
-      return [];
-    }
-    verbose(`Expanded directory '${skillId}' to ${childSkills.length} skills`);
-    return childSkills;
-  };
-  const uniqueSkillIds = unique(
-    skillIds.flatMap(({ id }) => idToDirectoryPath[id] ? [id] : expandDirectoryRef(id))
-  );
-  for (const skillId of uniqueSkillIds) {
-    const directoryPath = idToDirectoryPath[skillId];
-    if (!directoryPath) {
-      warn(`Could not find skill '${skillId}': no matching skill found`);
-      continue;
-    }
-    const skillPath = path2.join(skillsDir, directoryPath);
-    const skillMdPath = path2.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;
-      verbose(`Loaded skill: ${canonicalId} (from ${directoryPath})`);
-    } catch (error) {
-      warn(`Could not load skill '${skillId}': ${getErrorMessage(error)}`);
-    }
-  }
-  return skills;
-}
-async function loadSkillsFromDir(skillsDir, options = {}) {
-  const { pathPrefix = "", requireMetadata = false } = options;
-  const skills = {};
-  const unusableMetadata = [];
-  if (!await directoryExists(skillsDir)) {
-    return { skills, unusableMetadata };
-  }
-  const skillFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir);
-  for (const skillFile of skillFiles) {
-    const skillPath = path2.join(skillsDir, skillFile);
-    const skillDir = path2.dirname(skillPath);
-    const relativePath = path2.relative(skillsDir, skillDir);
-    const skillDirName = path2.basename(skillDir);
-    const displayPath = pathPrefix ? `${pathPrefix}/${relativePath}/` : `${relativePath}/`;
-    if (requireMetadata) {
-      const metadataPath = path2.join(skillDir, STANDARD_FILES.METADATA_YAML);
-      if (!await fileExists(metadataPath)) {
-        warn(
-          `Skill '${skillDirName}' in '${displayPath}' is missing ${STANDARD_FILES.METADATA_YAML} \u2014 skipped. Add ${STANDARD_FILES.METADATA_YAML} to register it with the CLI.`
-        );
-        continue;
-      }
-      const metadata = await readSkillMetadata(metadataPath);
-      if (!metadata.usable) {
-        unusableMetadata.push({ skillDirName, metadataPath, reason: metadata.reason });
-        verbose(`  Unusable ${STANDARD_FILES.METADATA_YAML} in '${skillDirName}'`);
-        continue;
-      }
-    }
-    try {
-      const content = await readFile(skillPath);
-      const frontmatter = parseFrontmatter(content, skillPath);
-      if (!frontmatter?.name) {
-        warn(`Skipping skill in '${skillDirName}': missing or invalid frontmatter name`);
-        continue;
-      }
-      const canonicalId = frontmatter.name;
-      skills[canonicalId] = {
-        id: canonicalId,
-        path: displayPath,
-        description: frontmatter.description || ""
-      };
-      verbose(`  Loaded skill: ${canonicalId}`);
-    } catch (error) {
-      verbose(`  Failed to load skill: ${skillFile} - ${getErrorMessage(error)}`);
-    }
-  }
-  return { skills, unusableMetadata };
-}
-async function loadPluginSkills(pluginDir) {
-  const { skills } = await loadSkillsFromDir(path2.join(pluginDir, "skills"), {
-    pathPrefix: "skills",
-    requireMetadata: false
-  });
-  return skills;
-}
-
-export {
-  getErrorMessage,
-  GlobalPairWriteViolation,
-  withGateToken,
-  assertGateToken,
-  isPathWithin,
-  readFile,
-  readFileSafe,
-  readFileOptional,
-  fileExists,
-  directoryExists,
-  listDirectories,
-  glob,
-  writeFile,
-  ensureDir,
-  remove,
-  isDirectoryEmpty,
-  removeDirIfEmpty,
-  copy,
-  setVerbose,
-  verbose,
-  log,
-  enableBuffering,
-  drainBuffer,
-  disableBuffering,
-  warn,
-  formatZodErrors,
-  AGENT_NAMES,
-  isRecord,
-  isDomain,
-  isAgentName,
-  isSkillId,
-  isSkillAssignment,
-  MODEL_NAMES,
-  EFFORT_NAMES,
-  skillMetadataLoaderSchema,
-  matrixRawMetadataSchema,
-  pluginManifestSchema,
-  pluginManifestValidationSchema,
-  projectConfigLoaderSchema,
-  skillCategoriesFileSchema,
-  skillRulesFileSchema,
-  localSkillMetadataSchema,
-  stacksConfigSchema,
-  marketplaceSchema,
-  sourceRevalidationSchema,
-  settingsFileSchema,
-  projectSourceConfigSchema,
-  agentYamlGenerationSchema,
-  agentFrontmatterValidationSchema,
-  skillFrontmatterValidationSchema,
-  metadataValidationSchema,
-  stackConfigValidationSchema,
-  formatZodIssues,
-  validateSkillMetadata,
-  splitMetadataValidationIssues,
-  validateNestingDepth,
-  warnUnknownFields,
-  extractFrontmatter,
-  readSkillMetadata,
-  parseFrontmatter,
-  loadAllAgents,
-  loadMergedAgents,
-  loadProjectAgents,
-  loadSkillsByIds,
-  loadSkillsFromDir,
-  loadPluginSkills
-};
-//# sourceMappingURL=chunk-XAXJWXI4.js.map