agents-inc 0.152.1 → 0.154.0

package/dist/{chunk-PMM2MYMA.js → chunk-4VCWL2IG.js}

@@ -11,7 +11,7 @@ import {
   PROJECT_ROOT,
   STANDARD_DIRS,
   STANDARD_FILES
-} from "./chunk-76ADG7LQ.js";
+} from "./chunk-R54KIGN2.js";
 
 // src/cli/lib/loading/loader.ts
 import { parse as parseYaml2 } from "yaml";
@@ -129,6 +129,20 @@ async function 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);
 }
@@ -173,10 +187,11 @@ function warn(msg, options) {
 }
 
 // src/cli/lib/schemas.ts
-import { z } from "zod";
+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") {
@@ -190,10 +205,14 @@ function formatZodErrors(error) {
 
 // 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",
@@ -201,6 +220,7 @@ var SKILL_SLUGS = [
   "auth-security",
   "aws-sdk",
   "axiom-pino-sentry",
+  "base-ui",
   "better-auth-drizzle-hono",
   "biome",
   "ble-nfc",
@@ -212,15 +232,19 @@ var SKILL_SLUGS = [
   "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",
@@ -260,6 +284,7 @@ var SKILL_SLUGS = [
   "hono",
   "huggingface-inference",
   "image-handling",
+  "infra-reviewing",
   "jotai",
   "knex",
   "kubernetes",
@@ -354,6 +379,7 @@ var SKILL_SLUGS = [
   "sqlite-powersync",
   "sse",
   "sst",
+  "stack-detect",
   "storybook",
   "strapi",
   "strategies",
@@ -377,6 +403,7 @@ var SKILL_SLUGS = [
   "tauri-plugins",
   "tauri-security",
   "terraform",
+  "theming",
   "tiptap",
   "together-ai",
   "tool-use-patterns",
@@ -395,6 +422,7 @@ var SKILL_SLUGS = [
   "vercel-postgres",
   "view-transitions",
   "vision-camera",
+  "visual-regression",
   "vite",
   "vitepress",
   "vitest",
@@ -407,12 +435,255 @@ var SKILL_SLUGS = [
   "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",
@@ -426,16 +697,19 @@ var CATEGORIES = [
   "api-caching",
   "api-cms",
   "api-commerce",
-  "api-database",
+  "api-db-host",
+  "api-document",
   "api-email",
-  "api-framework",
   "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",
@@ -458,6 +732,7 @@ var CATEGORIES = [
   "infra-platform",
   "meta-design",
   "meta-methodology",
+  "meta-planning",
   "meta-reviewing",
   "mobile-animation",
   "mobile-background",
@@ -474,8 +749,10 @@ var CATEGORIES = [
   "mobile-styling",
   "mobile-testing",
   "mobile-ui-components",
+  "shared-lint",
   "shared-monorepo",
   "shared-security",
+  "shared-task-runner",
   "shared-tooling",
   "web-3d",
   "web-accessibility",
@@ -483,12 +760,16 @@ var CATEGORIES = [
   "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",
@@ -497,11 +778,14 @@ var CATEGORIES = [
   "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 = [
@@ -518,26 +802,21 @@ var DOMAINS = [
 var AGENT_NAMES = [
   "agent-summoner",
   "ai-developer",
-  "ai-reviewer",
+  "ai-researcher",
+  "ai-tester",
   "api-developer",
-  "api-pm",
   "api-researcher",
-  "api-reviewer",
   "api-tester",
   "cli-developer",
-  "cli-reviewer",
+  "cli-researcher",
   "cli-tester",
   "codex-keeper",
   "convention-keeper",
-  "infra-reviewer",
-  "pattern-scout",
+  "pm",
+  "reviewer",
   "skill-summoner",
-  "web-architecture",
   "web-developer",
-  "web-pattern-critique",
-  "web-pm",
   "web-researcher",
-  "web-reviewer",
   "web-tester"
 ];
 
@@ -554,17 +833,10 @@ var PERMISSION_MODES = [
 ];
 
 // src/cli/lib/schemas.ts
-var boundSkillSchema = z.object({
-  id: z.string(),
-  sourceUrl: z.string(),
-  sourceName: z.string(),
-  boundTo: z.string(),
-  description: z.string().optional()
-});
-var modelNameSchema = z.enum(MODEL_NAMES);
-var effortLevelSchema = z.enum(EFFORT_NAMES);
-var permissionModeSchema = z.enum(PERMISSION_MODES);
-var skillSlugSchema = z.enum(SKILL_SLUGS);
+var modelNameSchema = z2.enum(MODEL_NAMES);
+var effortLevelSchema = z2.enum(EFFORT_NAMES);
+var permissionModeSchema = z2.enum(PERMISSION_MODES);
+var skillSlugSchema = z2.enum(SKILL_SLUGS);
 function validateCategoryField(val, ctx) {
   if (!val.category) return;
   if (val.custom) {
@@ -584,7 +856,7 @@ function validateCategoryField(val, ctx) {
     }
   }
 }
-var categoryPathSchema = z.string().refine(
+var categoryPathSchema = z2.string().refine(
   (val) => {
     if (val === LOCAL_PSEUDO_CATEGORY) return true;
     if (CATEGORIES.includes(val)) return true;
@@ -594,456 +866,428 @@ var categoryPathSchema = z.string().refine(
     message: "Must be a valid category path (e.g., 'web-framework', 'shared-testing', or 'local')"
   }
 );
-var agentHookActionSchema = z.object({
-  type: z.enum(["command", "script", "prompt"]),
-  command: z.string().optional(),
-  script: z.string().optional(),
-  prompt: z.string().optional()
+var agentHookActionSchema = z2.object({
+  type: z2.enum(["command", "script", "prompt"]),
+  command: z2.string().exactOptional(),
+  script: z2.string().exactOptional(),
+  prompt: z2.string().exactOptional()
 });
-var agentHookDefinitionSchema = z.object({
-  matcher: z.string().optional(),
-  hooks: z.array(agentHookActionSchema).optional()
+var agentHookDefinitionSchema = z2.object({
+  matcher: z2.string().exactOptional(),
+  hooks: z2.array(agentHookActionSchema).exactOptional()
 });
-var hooksRecordSchema = z.record(z.string(), z.array(agentHookDefinitionSchema));
-var strictAgentHookDefinitionSchema = z.object({
-  matcher: z.string().optional(),
-  hooks: z.array(agentHookActionSchema).min(1)
+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 = z.record(
-  z.string(),
-  z.array(strictAgentHookDefinitionSchema)
+var strictHooksRecordSchema = z2.record(
+  z2.string(),
+  z2.array(strictAgentHookDefinitionSchema)
 );
-var skillAssignmentSchema = z.object({
-  id: z.string(),
-  preloaded: z.boolean().optional(),
-  local: z.boolean().optional(),
-  path: z.string().optional()
+var skillAssignmentSchema = z2.object({
+  id: z2.string(),
+  preloaded: z2.boolean().exactOptional(),
+  local: z2.boolean().exactOptional(),
+  path: z2.string().exactOptional()
 });
-var skillFrontmatterLoaderSchema = z.object({
+var skillFrontmatterLoaderSchema = z2.object({
   /** Lenient (any string): local/custom skills have non-builtin IDs */
-  name: z.string(),
-  description: z.string(),
-  model: modelNameSchema.optional()
+  name: z2.string(),
+  description: z2.string(),
+  model: modelNameSchema.exactOptional()
 });
-var skillMetadataLoaderSchema = z.object({
+var skillMetadataLoaderSchema = z2.object({
   // Field accepts any string; cross-field validation in superRefine enforces strict/custom rules
-  category: z.string().optional(),
-  author: z.string().optional(),
-  domain: z.string(),
-  custom: z.boolean().optional()
+  category: z2.string().exactOptional(),
+  author: z2.string().exactOptional(),
+  domain: z2.string(),
+  custom: z2.boolean().exactOptional()
 }).passthrough().superRefine(validateCategoryField);
-var matrixRawMetadataSchema = z.object({
+var matrixRawMetadataSchema = z2.object({
   category: categoryPathSchema,
-  author: z.string(),
-  displayName: z.string().optional(),
-  slug: z.string(),
-  cliDescription: z.string().optional(),
-  usageGuidance: z.string().optional(),
+  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: z.string(),
-  custom: z.boolean().optional()
+  domain: z2.string(),
+  custom: z2.boolean().exactOptional()
 });
-var pluginAuthorSchema = z.object({
-  name: z.string().min(1),
-  email: z.string().optional()
+var pluginAuthorSchema = z2.object({
+  name: z2.string().min(1),
+  email: z2.string().exactOptional()
 });
-var pluginManifestObjectSchema = z.object({
-  name: z.string(),
-  version: z.string().optional(),
-  description: z.string().optional(),
-  author: pluginAuthorSchema.optional(),
-  keywords: z.array(z.string()).optional(),
-  commands: z.union([z.string(), z.array(z.string())]).optional(),
-  agents: z.union([z.string(), z.array(z.string())]).optional(),
-  skills: z.union([z.string(), z.array(z.string())]).optional(),
-  hooks: z.union([z.string(), hooksRecordSchema]).optional()
+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 = z.object({
-  id: z.string(),
-  title: z.string(),
-  description: z.string(),
-  model: modelNameSchema.optional(),
-  effort: effortLevelSchema.optional(),
-  tools: z.array(z.string()),
-  disallowedTools: z.array(z.string()).optional(),
-  permissionMode: permissionModeSchema.optional(),
-  hooks: hooksRecordSchema.optional(),
-  outputFormat: z.string().optional(),
-  domain: z.string().optional(),
-  custom: z.boolean().optional()
+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 = z.union([
-  z.string(),
+var skillAssignmentElementSchema = z2.union([
+  z2.string(),
   skillAssignmentSchema
 ]);
-var stackAgentConfigSchema = z.record(
-  z.string(),
-  z.union([skillAssignmentElementSchema, z.array(skillAssignmentElementSchema)])
+var stackAgentConfigSchema = z2.record(
+  z2.string(),
+  z2.union([skillAssignmentElementSchema, z2.array(skillAssignmentElementSchema)])
 );
-var projectConfigLoaderSchema = z.object({
+var projectConfigLoaderSchema = z2.object({
   /** Project/plugin name in kebab-case */
-  name: z.string().optional(),
-  description: z.string().optional(),
+  name: z2.string().exactOptional(),
+  description: z2.string().exactOptional(),
   /** Per-agent configuration with scope (e.g., [{ name: "web-developer", scope: "project" }]) */
-  agents: z.array(
-    z.object({
-      name: z.string(),
-      scope: z.enum(["project", "global"]),
+  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.optional(),
-      effort: effortLevelSchema.optional(),
-      excluded: z.boolean().optional()
+      model: modelNameSchema.exactOptional(),
+      effort: effortLevelSchema.exactOptional(),
+      excluded: z2.boolean().exactOptional()
     })
-  ).optional(),
+  ).exactOptional(),
   /** Per-skill configuration with scope and source */
-  skills: z.array(
-    z.object({
-      id: z.string(),
-      scope: z.enum(["project", "global"]),
-      source: z.string(),
-      excluded: z.boolean().optional()
+  skills: z2.array(
+    z2.object({
+      id: z2.string(),
+      scope: z2.enum(["project", "global"]),
+      source: z2.string(),
+      excluded: z2.boolean().exactOptional()
     })
-  ).optional(),
+  ).exactOptional(),
   /** Author handle (e.g., "@vince") */
-  author: z.string().optional(),
+  author: z2.string().exactOptional(),
   /** Selected domains from the wizard (persisted for edit mode restoration) */
-  domains: z.array(z.string()).optional(),
-  /** Selected agents from the wizard (persisted for edit mode restoration) */
-  selectedAgents: z.array(z.string()).optional(),
+  selectedDomains: z2.array(z2.string()).exactOptional(),
   /** Agent-to-category-to-skill mappings from selected stack (accepts same formats as stacks.ts) */
-  stack: z.record(z.string(), stackAgentConfigSchema).optional(),
+  stack: z2.record(z2.string(), stackAgentConfigSchema).exactOptional(),
   /** Skills source path or URL (e.g., "github:my-org/skills") */
-  source: z.string().optional(),
+  source: z2.string().exactOptional(),
   /** Marketplace identifier for plugin installation */
-  marketplace: z.string().optional(),
+  marketplace: z2.string().exactOptional(),
   /** Separate source for agents when different from skills source */
-  agentsSource: z.string().optional(),
+  agentsSource: z2.string().exactOptional(),
   /** Tracked project installation paths (global config only) */
-  projects: z.array(z.string()).optional()
+  projects: z2.array(z2.string()).exactOptional()
 }).passthrough();
-var categoryDefinitionSchema = z.object({
-  id: z.string(),
-  displayName: z.string(),
-  description: z.string(),
-  domain: z.string().optional(),
-  exclusive: z.boolean(),
-  required: z.boolean(),
-  order: z.number(),
-  icon: z.string().optional()
+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 = z.object({
-  skills: z.array(skillRefInRules).min(2),
-  reason: z.string()
+var skillGroupRuleSchema = z2.object({
+  skills: z2.array(skillRefInRules).min(2),
+  reason: z2.string()
 });
 var conflictRuleSchema = skillGroupRuleSchema;
 var discourageRuleSchema = skillGroupRuleSchema;
-var recommendationSchema = z.object({
+var requireRuleSchema = z2.object({
   skill: skillRefInRules,
-  reason: z.string()
+  needs: z2.array(skillRefInRules).min(1),
+  needsAny: z2.boolean().exactOptional(),
+  reason: z2.string()
 });
-var compatibilityGroupSchema = skillGroupRuleSchema;
-var requireRuleSchema = z.object({
-  skill: skillRefInRules,
-  needs: z.array(skillRefInRules).min(1),
-  needsAny: z.boolean().optional(),
-  reason: z.string()
-});
-var alternativeGroupSchema = z.object({
-  purpose: z.string(),
-  skills: z.array(skillRefInRules).min(1)
+var alternativeGroupSchema = z2.object({
+  purpose: z2.string(),
+  skills: z2.array(skillRefInRules).min(1)
 });
-var relationshipDefinitionsSchema = z.object({
-  conflicts: z.array(conflictRuleSchema),
-  discourages: z.array(discourageRuleSchema),
-  recommends: z.array(recommendationSchema),
-  requires: z.array(requireRuleSchema),
-  alternatives: z.array(alternativeGroupSchema),
-  compatibleWith: z.array(compatibilityGroupSchema).optional().default([])
+var relationshipDefinitionsSchema = z2.object({
+  conflicts: z2.array(conflictRuleSchema),
+  discourages: z2.array(discourageRuleSchema),
+  requires: z2.array(requireRuleSchema),
+  alternatives: z2.array(alternativeGroupSchema)
 });
-var skillCategoriesFileSchema = z.object({
-  version: z.string(),
-  categories: z.record(z.string(), categoryDefinitionSchema)
+var skillCategoriesFileSchema = z2.object({
+  version: z2.string(),
+  categories: z2.record(z2.string(), categoryDefinitionSchema)
 });
-var skillRulesFileSchema = z.object({
-  version: z.string(),
-  relationships: relationshipDefinitionsSchema.optional()
+var skillRulesFileSchema = z2.object({
+  version: z2.string(),
+  relationships: relationshipDefinitionsSchema.exactOptional()
 });
-var localRawMetadataSchema = z.object({
+var localRawMetadataSchema = z2.object({
   /** Short name shown in the wizard grid (e.g., "my-custom-react") */
-  displayName: z.string(),
+  displayName: z2.string(),
   /** Kebab-case short key for alias resolution (e.g., "react") */
-  slug: z.string(),
+  slug: z2.string(),
   /** One-line description for the wizard */
-  cliDescription: z.string().optional(),
+  cliDescription: z2.string().exactOptional(),
   /** Category to place this skill in (e.g., "web-framework") */
   // Field accepts any string; cross-field validation in superRefine enforces strict/custom rules
-  category: z.string(),
+  category: z2.string(),
   /** When an AI agent should invoke this skill */
-  usageGuidance: z.string().optional(),
+  usageGuidance: z2.string().exactOptional(),
   /** Domain this skill belongs to (e.g., "web", "api", "cli") */
-  domain: z.string(),
+  domain: z2.string(),
   /** True if this skill was created outside the CLI's built-in vocabulary */
-  custom: z.boolean().optional()
+  custom: z2.boolean().exactOptional()
 }).passthrough().superRefine(validateCategoryField);
-var localSkillMetadataSchema = z.object({
-  forkedFrom: z.object({
+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: z.string(),
+    skillId: z2.string(),
     /** SHA hash of the original content at fork time (for diff detection) */
-    contentHash: z.string(),
+    contentHash: z2.string(),
     /** ISO date when the fork was created */
-    date: z.string(),
+    date: z2.string(),
     /** Source URL the skill was installed from (e.g., "github:agents-inc/skills") */
-    source: z.string().optional()
-  }).optional()
+    source: z2.string().exactOptional()
+  }).exactOptional()
 }).passthrough();
-var stackSchema = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1),
-  description: z.string(),
+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: z.record(z.string(), stackAgentConfigSchema),
+  agents: z2.record(z2.string(), stackAgentConfigSchema),
   /** High-level philosophy guiding this stack's technology choices */
-  philosophy: z.string().optional()
+  philosophy: z2.string().exactOptional()
 });
-var stacksConfigSchema = z.object({
-  stacks: z.array(stackSchema).min(1)
+var stacksConfigSchema = z2.object({
+  stacks: z2.array(stackSchema).min(1)
 });
-var marketplaceRemoteSourceSchema = z.object({
-  source: z.enum(["github", "url"]),
-  repo: z.string().optional(),
-  url: z.string().optional(),
-  ref: z.string().optional()
+var marketplaceRemoteSourceSchema = z2.object({
+  source: z2.enum(["github", "url"]),
+  repo: z2.string().exactOptional(),
+  url: z2.string().exactOptional(),
+  ref: z2.string().exactOptional()
 });
-var marketplacePluginSchema = z.object({
-  name: z.string().min(1),
+var marketplacePluginSchema = z2.object({
+  name: z2.string().min(1),
   /** Local directory path (relative to pluginRoot) or remote source config */
-  source: z.union([z.string(), marketplaceRemoteSourceSchema]),
-  description: z.string().optional(),
-  version: z.string().optional(),
-  author: pluginAuthorSchema.optional(),
+  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: z.string().optional(),
-  keywords: z.array(z.string()).optional()
+  category: z2.string().exactOptional(),
+  keywords: z2.array(z2.string()).exactOptional()
 });
 var marketplaceOwnerSchema = pluginAuthorSchema;
-var marketplaceMetadataSchema = z.object({
+var marketplaceMetadataSchema = z2.object({
   /** Base directory for resolving plugin source paths (e.g., "plugins/") */
-  pluginRoot: z.string().optional()
+  pluginRoot: z2.string().exactOptional()
 });
-var marketplaceSchema = z.object({
-  $schema: z.string().optional(),
-  name: z.string().min(1),
-  version: z.string().min(1),
-  description: z.string().optional(),
+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.optional(),
-  plugins: z.array(marketplacePluginSchema).min(1)
+  metadata: marketplaceMetadataSchema.exactOptional(),
+  plugins: z2.array(marketplacePluginSchema).min(1)
 });
-var permissionConfigSchema = z.object({
+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: z.array(z.string()).optional(),
+  allow: z2.array(z2.string()).exactOptional(),
   /** Tool names or patterns to explicitly deny */
-  deny: z.array(z.string()).optional()
+  deny: z2.array(z2.string()).exactOptional()
 });
-var settingsFileSchema = z.object({
-  permissions: permissionConfigSchema.optional()
-}).passthrough();
-var importedSkillMetadataSchema = z.object({
-  forkedFrom: z.object({
-    /** Source URL or identifier where the skill was imported from */
-    source: z.string(),
-    /** Original skill name in the source */
-    skillName: z.string(),
-    /** SHA hash of the original content at import time */
-    contentHash: z.string(),
-    /** ISO date when the import was performed */
-    date: z.string()
-  }).optional()
+var settingsFileSchema = z2.object({
+  permissions: permissionConfigSchema.exactOptional()
 }).passthrough();
-var brandingConfigSchema = z.object({
+var brandingConfigSchema = z2.object({
   /** Custom CLI name (e.g., "Acme Dev Tools") */
-  name: z.string().optional(),
+  name: z2.string().exactOptional(),
   /** Custom tagline shown in wizard header */
-  tagline: z.string().optional()
+  tagline: z2.string().exactOptional()
 });
-var projectSourceConfigSchema = z.object({
+var projectSourceConfigSchema = z2.object({
   /** Primary skills source (path or URL) */
-  source: z.string().optional(),
+  source: z2.string().exactOptional(),
   /** Author handle for this project's config */
-  author: z.string().optional(),
+  author: z2.string().exactOptional(),
   /** Marketplace identifier for plugin installation */
-  marketplace: z.string().optional(),
+  marketplace: z2.string().exactOptional(),
   /** Separate source for agent definitions (when different from skills) */
-  agentsSource: z.string().optional(),
-  /** Additional skill sources (private marketplaces, custom repos) */
-  sources: z.array(
-    z.object({
-      /** Display name for the source (shown in wizard) */
-      name: z.string(),
-      /** Source URL (e.g., "github:acme-corp/claude-skills") */
-      url: z.string(),
-      description: z.string().optional(),
-      /** Git ref (branch/tag/commit) for the source */
-      ref: z.string().optional()
-    })
-  ).optional(),
-  /** Skills explicitly bound to categories via search (from Step Sources) */
-  boundSkills: z.array(boundSkillSchema).optional(),
+  agentsSource: z2.string().exactOptional(),
   /** Branding overrides for white-labeling the CLI */
-  branding: brandingConfigSchema.optional(),
+  branding: brandingConfigSchema.exactOptional(),
   /** Custom skills directory override (default: "src/skills") */
-  skillsDir: z.string().optional(),
+  skillsDir: z2.string().exactOptional(),
   /** Custom agents directory override (default: "src/agents") */
-  agentsDir: z.string().optional(),
+  agentsDir: z2.string().exactOptional(),
   /** Custom stacks file path override (default: "config/stacks.ts") */
-  stacksFile: z.string().optional(),
+  stacksFile: z2.string().exactOptional(),
   /** Custom categories file path override (default: "config/skill-categories.ts") */
-  categoriesFile: z.string().optional(),
+  categoriesFile: z2.string().exactOptional(),
   /** Custom rules file path override (default: "config/skill-rules.ts") */
-  rulesFile: z.string().optional()
+  rulesFile: z2.string().exactOptional()
 }).passthrough();
-var agentYamlGenerationSchema = z.object({
-  $schema: z.string().optional(),
-  id: z.string().min(1),
-  title: z.string().min(1),
-  description: z.string().min(1),
-  model: modelNameSchema.optional(),
-  effort: effortLevelSchema.optional(),
-  tools: z.array(z.string()).min(1),
-  disallowedTools: z.array(z.string()).optional(),
-  permissionMode: permissionModeSchema.optional(),
-  hooks: strictHooksRecordSchema.optional(),
-  outputFormat: z.string().optional(),
-  domain: z.string().optional(),
-  custom: z.boolean().optional()
+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 = z.object({
+var agentFrontmatterValidationSchema = z2.object({
   /** Agent name in kebab-case (becomes the Task tool identifier) */
-  name: z.string().regex(KEBAB_CASE_PATTERN).min(1),
-  description: z.string().min(1),
+  name: z2.string().regex(KEBAB_CASE_PATTERN).min(1),
+  description: z2.string().min(1),
   /** Comma-separated list of allowed tools */
-  tools: z.string().optional(),
+  tools: z2.string().exactOptional(),
   /** Comma-separated list of denied tools */
-  disallowedTools: z.string().optional(),
-  model: modelNameSchema.optional(),
-  effort: effortLevelSchema.optional(),
-  permissionMode: permissionModeSchema.optional(),
+  disallowedTools: z2.string().exactOptional(),
+  model: modelNameSchema.exactOptional(),
+  effort: effortLevelSchema.exactOptional(),
+  permissionMode: permissionModeSchema.exactOptional(),
   /** Skill names to preload (embed in agent prompt) */
-  skills: z.array(z.string().min(1)).optional(),
-  hooks: strictHooksRecordSchema.optional()
+  skills: z2.array(z2.string().min(1)).exactOptional(),
+  hooks: strictHooksRecordSchema.exactOptional()
 }).strict();
-var skillFrontmatterValidationSchema = z.object({
-  name: z.string().min(1),
-  description: z.string().min(1),
+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": z.boolean().optional(),
+  "disable-model-invocation": z2.boolean().exactOptional(),
   /** If true, user can invoke this skill directly */
-  "user-invocable": z.boolean().optional(),
+  "user-invocable": z2.boolean().exactOptional(),
   /** Comma-separated list of tools this skill can use */
-  "allowed-tools": z.string().optional(),
-  model: modelNameSchema.optional(),
+  "allowed-tools": z2.string().exactOptional(),
+  model: modelNameSchema.exactOptional(),
   /** "fork" means skill runs in a forked context (separate conversation) */
-  context: z.enum(["fork"]).optional(),
+  context: z2.enum(["fork"]).exactOptional(),
   /** Agent name this skill is scoped to */
-  agent: z.string().optional(),
+  agent: z2.string().exactOptional(),
   /** Hint text shown when user invokes the skill */
-  "argument-hint": z.string().optional()
+  "argument-hint": z2.string().exactOptional()
 }).strict();
-var forkedFromSchema = z.object({
+var forkedFromSchema = z2.object({
   /** Original skill ID */
-  skillId: z.string(),
+  skillId: z2.string(),
   /** Version of the original at fork time */
-  version: z.number().int().min(1).optional(),
+  version: z2.number().int().min(1).exactOptional(),
   /** Content hash of the original at fork time */
-  contentHash: z.string(),
+  contentHash: z2.string(),
   /** Source URL or identifier */
-  source: z.string().optional(),
+  source: z2.string().exactOptional(),
   /** ISO date of the fork */
-  date: z.string()
+  date: z2.string()
 });
 var CLI_DESCRIPTION_MAX_LENGTH = 60;
-var skillMetadataBaseSchema = z.object({
+var skillMetadataBaseSchema = z2.object({
   /** Author handle — must start with @ (e.g., "@vince") */
-  author: z.string().regex(AUTHOR_HANDLE_PATTERN),
+  author: z2.string().regex(AUTHOR_HANDLE_PATTERN),
   /** Short display name for the wizard grid (max 30 chars) */
-  displayName: z.string().min(1).max(30),
+  displayName: z2.string().min(1).max(30),
   /** One-line description for the wizard (max 60 chars recommended; over-length is a validation warning) */
-  cliDescription: z.string().min(1).max(CLI_DESCRIPTION_MAX_LENGTH),
+  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: z.string().min(10),
+  usageGuidance: z2.string().min(10),
   /** 7-char hex SHA of skill content (for change detection) */
-  contentHash: z.string().regex(/^[a-f0-9]{7}$/).optional(),
+  contentHash: z2.string().regex(/^[a-f0-9]{7}$/).exactOptional(),
   /** ISO date of last update */
-  updated: z.string().optional(),
+  updated: z2.string().exactOptional(),
   /** Provenance tracking when skill was forked from another */
-  forkedFrom: forkedFromSchema.optional(),
+  forkedFrom: forkedFromSchema.exactOptional(),
   /** Domain assignment from metadata */
-  domain: z.string().optional(),
+  domain: z2.string().exactOptional(),
   /** True if this skill was created outside the CLI's built-in vocabulary */
-  custom: z.boolean().optional()
+  custom: z2.boolean().exactOptional()
 });
 var metadataValidationSchema = skillMetadataBaseSchema.extend({
   /** Domain-prefixed category — must be a known built-in category */
-  category: z.enum(CATEGORIES),
+  category: z2.enum(CATEGORIES),
   /** Kebab-case short key — must be a known built-in slug */
-  slug: z.enum(SKILL_SLUGS)
+  slug: z2.enum(SKILL_SLUGS)
 }).strict();
 var customMetadataValidationSchema = skillMetadataBaseSchema.extend({
   /** Any string category — custom skills may define their own categories */
-  category: z.string(),
+  category: z2.string(),
   /** Kebab-case short key for alias resolution, search, and relationship rules */
-  slug: z.string().regex(/^[a-z][a-z0-9-]*$/).min(1).max(50)
+  slug: z2.string().regex(/^[a-z][a-z0-9-]*$/).min(1).max(50)
 });
-var stackSkillAssignmentSchema = z.object({
-  id: z.string().min(1),
+var stackSkillAssignmentSchema = z2.object({
+  id: z2.string().min(1),
   /** If true, skill content is embedded in the compiled agent prompt */
-  preloaded: z.boolean().optional()
+  preloaded: z2.boolean().exactOptional()
 }).strict();
-var stackConfigValidationSchema = z.object({
+var stackConfigValidationSchema = z2.object({
   /** Unique stack identifier in kebab-case */
-  id: z.string().regex(KEBAB_CASE_PATTERN).optional(),
-  name: z.string().min(1),
-  version: z.string(),
-  author: z.string().min(1),
-  description: z.string().optional(),
+  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: z.string().optional(),
+  created: z2.string().exactOptional(),
   /** ISO date of last update */
-  updated: z.string().optional(),
+  updated: z2.string().exactOptional(),
   /** Primary framework this stack is designed for (e.g., "nextjs", "remix") */
-  framework: z.string().optional(),
+  framework: z2.string().exactOptional(),
   /** All skills used in this stack (flat list, at least one required) */
-  skills: z.array(stackSkillAssignmentSchema).min(1),
+  skills: z2.array(stackSkillAssignmentSchema).min(1),
   /** Agent IDs this stack compiles (at least one required) */
-  agents: z.array(z.string().regex(KEBAB_CASE_PATTERN)).min(1),
+  agents: z2.array(z2.string().regex(KEBAB_CASE_PATTERN)).min(1),
   /** Per-agent skill assignments: { agentId: { category: [skillAssignment] } } */
-  agentSkills: z.record(z.string(), z.record(z.string(), z.array(stackSkillAssignmentSchema))).optional(),
+  agentSkills: z2.record(z2.string(), z2.record(z2.string(), z2.array(stackSkillAssignmentSchema))).exactOptional(),
   /** High-level philosophy guiding technology choices */
-  philosophy: z.string().optional(),
+  philosophy: z2.string().exactOptional(),
   /** Guiding principles for agents using this stack */
-  principles: z.array(z.string().min(1)).optional(),
-  tags: z.array(z.string().regex(KEBAB_CASE_PATTERN)).optional(),
+  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: z.record(
-    z.string(),
-    z.object({
+  overrides: z2.record(
+    z2.string(),
+    z2.object({
       /** Suggested alternative skill IDs if this one is swapped */
-      alternatives: z.array(z.string().min(1)).optional(),
+      alternatives: z2.array(z2.string().min(1)).exactOptional(),
       /** If true, this skill cannot be swapped by the user */
-      locked: z.boolean().optional()
+      locked: z2.boolean().exactOptional()
     }).strict()
-  ).optional(),
+  ).exactOptional(),
   /** Community metrics for sorting/ranking */
-  metrics: z.object({
-    upvotes: z.number().int().min(0).optional(),
-    downloads: z.number().int().min(0).optional()
-  }).strict().optional(),
+  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.optional()
+  hooks: strictHooksRecordSchema.exactOptional()
 }).strict();
 function formatZodIssues(issues) {
   return issues.map(formatZodIssue).join("; ");
@@ -1052,6 +1296,21 @@ 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";
 }
@@ -1097,6 +1356,30 @@ function warnUnknownFields(parsed, expectedKeys, context) {
 }
 
 // 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;
@@ -1119,7 +1402,7 @@ async function loadAgentsFromDir(agentsDir, sourceRoot, options) {
       agents[config.id] = {
         title: config.title,
         description: config.description,
-        model: config.model,
+        ...config.model !== void 0 && { model: config.model },
         tools: config.tools,
         path: path2.dirname(file),
         sourceRoot,
@@ -1222,7 +1505,7 @@ async function loadSkillsByIds(skillIds, projectRoot) {
       skills[canonicalId] = skillDef;
       verbose(`Loaded skill: ${canonicalId} (from ${directoryPath})`);
     } catch (error) {
-      warn(`Could not load skill '${skillId}': ${error}`);
+      warn(`Could not load skill '${skillId}': ${getErrorMessage(error)}`);
     }
   }
   return skills;
@@ -1230,8 +1513,9 @@ async function loadSkillsByIds(skillIds, projectRoot) {
 async function loadSkillsFromDir(skillsDir, options = {}) {
   const { pathPrefix = "", requireMetadata = false } = options;
   const skills = {};
+  const unusableMetadata = [];
   if (!await directoryExists(skillsDir)) {
-    return skills;
+    return { skills, unusableMetadata };
   }
   const skillFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir);
   for (const skillFile of skillFiles) {
@@ -1248,6 +1532,12 @@ async function loadSkillsFromDir(skillsDir, options = {}) {
         );
         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);
@@ -1264,16 +1554,17 @@ async function loadSkillsFromDir(skillsDir, options = {}) {
       };
       verbose(`  Loaded skill: ${canonicalId}`);
     } catch (error) {
-      verbose(`  Failed to load skill: ${skillFile} - ${error}`);
+      verbose(`  Failed to load skill: ${skillFile} - ${getErrorMessage(error)}`);
     }
   }
-  return skills;
+  return { skills, unusableMetadata };
 }
 async function loadPluginSkills(pluginDir) {
-  return loadSkillsFromDir(path2.join(pluginDir, "skills"), {
+  const { skills } = await loadSkillsFromDir(path2.join(pluginDir, "skills"), {
     pathPrefix: "skills",
     requireMetadata: false
   });
+  return skills;
 }
 
 export {
@@ -1285,28 +1576,12 @@ export {
   drainBuffer,
   disableBuffering,
   warn,
-  extractFrontmatter,
-  GlobalPairWriteViolation,
-  withGateToken,
-  assertGateToken,
-  isPathWithin,
-  readFile,
-  readFileSafe,
-  readFileOptional,
-  fileExists,
-  directoryExists,
-  listDirectories,
-  glob,
-  writeFile,
-  ensureDir,
-  remove,
-  copy,
   formatZodErrors,
+  SKILL_IDS,
   DOMAINS,
   AGENT_NAMES,
   MODEL_NAMES,
   EFFORT_NAMES,
-  modelNameSchema,
   skillMetadataLoaderSchema,
   matrixRawMetadataSchema,
   pluginManifestSchema,
@@ -1314,12 +1589,11 @@ export {
   projectConfigLoaderSchema,
   skillCategoriesFileSchema,
   skillRulesFileSchema,
-  localRawMetadataSchema,
   localSkillMetadataSchema,
   stacksConfigSchema,
   marketplaceSchema,
+  sourceRevalidationSchema,
   settingsFileSchema,
-  importedSkillMetadataSchema,
   projectSourceConfigSchema,
   agentYamlGenerationSchema,
   agentFrontmatterValidationSchema,
@@ -1331,6 +1605,24 @@ export {
   splitMetadataValidationIssues,
   validateNestingDepth,
   warnUnknownFields,
+  GlobalPairWriteViolation,
+  withGateToken,
+  assertGateToken,
+  isPathWithin,
+  readFile,
+  readFileSafe,
+  readFileOptional,
+  fileExists,
+  directoryExists,
+  listDirectories,
+  glob,
+  writeFile,
+  ensureDir,
+  remove,
+  removeDirIfEmpty,
+  copy,
+  extractFrontmatter,
+  readSkillMetadata,
   parseFrontmatter,
   loadAllAgents,
   loadMergedAgents,
@@ -1339,4 +1631,4 @@ export {
   loadSkillsFromDir,
   loadPluginSkills
 };
-//# sourceMappingURL=chunk-PMM2MYMA.js.map
+//# sourceMappingURL=chunk-4VCWL2IG.js.map