@agents-inc/cli 0.46.0 → 0.48.0

package/dist/{chunk-RT6IBH37.js → chunk-P2SFRDWI.js}

@@ -4,7 +4,7 @@ import {
   typedKeys
 } from "./chunk-T4EXUIBY.js";
 import {
-  SKILL_ID_PATTERN,
+  DOMAIN_VALUES,
   SUBCATEGORY_VALUES,
   agentFrontmatterValidationSchema,
   agentNameSchema,
@@ -14,6 +14,7 @@ import {
   directoryExists,
   ensureDir,
   extendSchemasWithCustomValues,
+  extensibleDomainSchema,
   fileExists,
   formatZodErrors,
   getErrorMessage,
@@ -33,19 +34,20 @@ import {
   readFileOptional,
   readFileSafe,
   remove,
+  skillCategoriesFileSchema,
   skillDisplayNameSchema,
   skillFrontmatterLoaderSchema,
   skillFrontmatterValidationSchema,
   skillIdSchema,
   skillMetadataLoaderSchema,
-  skillsMatrixConfigSchema,
+  skillRulesFileSchema,
   stacksConfigSchema,
   validateNestingDepth,
   verbose,
   warn,
   warnUnknownFields,
   writeFile
-} from "./chunk-5QRJUBK7.js";
+} from "./chunk-YMUWTPOM.js";
 import {
   ARCHIVED_SKILLS_DIR_NAME,
   CACHE_DIR,
@@ -73,13 +75,14 @@ import {
   PROJECT_ROOT,
   SCHEMA_PATHS,
   SKILLS_DIR_PATH,
-  SKILLS_MATRIX_PATH,
+  SKILL_CATEGORIES_YAML_PATH,
+  SKILL_RULES_YAML_PATH,
   STACKS_FILE_PATH,
   STANDARD_DIRS,
   STANDARD_FILES,
   YAML_FORMATTING,
   yamlSchemaComment
-} from "./chunk-74HSA7C4.js";
+} from "./chunk-LESHL6SM.js";
 import {
   init_esm_shims
 } from "./chunk-DHET7RCE.js";
@@ -1016,7 +1019,8 @@ async function loadAllAgents(projectRoot) {
         model: config.model,
         tools: config.tools,
         path: agentPath,
-        sourceRoot: projectRoot
+        sourceRoot: projectRoot,
+        ...config.domain ? { domain: config.domain } : {}
       };
       verbose(`Loaded agent: ${config.id} from ${file}`);
     } catch (error) {
@@ -1046,8 +1050,9 @@ async function loadProjectAgents(projectRoot) {
         tools: config.tools,
         path: agentPath,
         sourceRoot: projectRoot,
-        agentBaseDir: `${CLAUDE_SRC_DIR}/agents`
+        agentBaseDir: `${CLAUDE_SRC_DIR}/agents`,
         // Project agents are in .claude-src/agents/
+        ...config.domain ? { domain: config.domain } : {}
       };
       verbose(`Loaded project agent: ${config.id} from ${file}`);
     } catch (error) {
@@ -1162,7 +1167,7 @@ import { unique as unique4 } from "remeda";
 // src/cli/lib/metadata-keys.ts
 init_esm_shims();
 var METADATA_KEYS = {
-  CLI_NAME: "cliName",
+  DISPLAY_NAME: "displayName",
   CLI_DESCRIPTION: "cliDescription",
   CATEGORY: "category",
   FORKED_FROM: "forkedFrom",
@@ -1558,7 +1563,7 @@ async function writePluginManifest(outputDir, manifest) {
 // src/cli/lib/plugins/plugin-finder.ts
 init_esm_shims();
 import path10 from "path";
-import { last, zip } from "remeda";
+import { zip } from "remeda";
 function getProjectPluginsDir(projectDir) {
   const dir = projectDir ?? process.cwd();
   return path10.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR);
@@ -2222,7 +2227,8 @@ var PATH_OVERRIDES_COMMENT = [
   `# skillsDir: ${SKILLS_DIR_PATH}`,
   `# agentsDir: ${DIRS.agents}`,
   `# stacksFile: ${STACKS_FILE_PATH}`,
-  `# matrixFile: ${SKILLS_MATRIX_PATH}`,
+  `# categoriesFile: ${SKILL_CATEGORIES_YAML_PATH}`,
+  `# rulesFile: ${SKILL_RULES_YAML_PATH}`,
   ""
 ].join("\n");
 async function writeConfigFile(config, configPath) {
@@ -3135,33 +3141,56 @@ import path19 from "path";
 import { z as z3 } from "zod";
 var rawMetadataSchema = z3.object({
   category: categoryPathSchema,
-  categoryExclusive: z3.boolean().optional(),
   author: z3.string(),
-  cliName: z3.string().optional(),
+  displayName: z3.string().optional(),
   cliDescription: z3.string().optional(),
   usageGuidance: z3.string().optional(),
   tags: z3.array(z3.string()).optional(),
-  // Lenient: accepts display names and skill IDs from YAML, resolved to canonical IDs during matrix merge
-  compatibleWith: z3.array(z3.string()).optional(),
-  conflictsWith: z3.array(z3.string()).optional(),
-  requires: z3.array(z3.string()).optional(),
-  requiresSetup: z3.array(z3.string()).optional(),
-  providesSetupFor: z3.array(z3.string()).optional(),
+  domain: extensibleDomainSchema.optional(),
   custom: z3.boolean().optional()
 });
-async function loadSkillsMatrix(configPath) {
+var KNOWN_DOMAINS = new Set(DOMAIN_VALUES);
+var AUTO_SYNTH_ORDER = 999;
+function synthesizeCategory(categoryPath, skillDomain) {
+  const prefix = categoryPath.split("-")[0];
+  const domain = skillDomain ?? (KNOWN_DOMAINS.has(prefix) ? prefix : void 0);
+  const displayName = categoryPath.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return {
+    id: categoryPath,
+    displayName,
+    description: `Auto-generated category for ${categoryPath}`,
+    domain,
+    exclusive: true,
+    required: false,
+    order: AUTO_SYNTH_ORDER,
+    custom: true
+  };
+}
+async function loadSkillCategories(configPath) {
+  const content = await readFile(configPath);
+  const raw = parseYaml7(content);
+  const result = skillCategoriesFileSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(
+      `Invalid skill categories at '${configPath}': ${formatZodErrors(result.error.issues)}`
+    );
+  }
+  verbose(`Loaded skill categories: ${configPath}`);
+  return result.data.categories;
+}
+async function loadSkillRules(configPath) {
   const content = await readFile(configPath);
   const raw = parseYaml7(content);
-  const result = skillsMatrixConfigSchema.safeParse(raw);
+  const result = skillRulesFileSchema.safeParse(raw);
   if (!result.success) {
     throw new Error(
-      `Invalid skills matrix at '${configPath}': ${formatZodErrors(result.error.issues)}`
+      `Invalid skill rules at '${configPath}': ${formatZodErrors(result.error.issues)}`
     );
   }
   const data = result.data;
-  const matrix = {
+  const config = {
     version: data.version,
-    categories: data.categories,
+    aliases: data.aliases ?? {},
     relationships: data.relationships ?? {
       conflicts: [],
       discourages: [],
@@ -3169,10 +3198,10 @@ async function loadSkillsMatrix(configPath) {
       requires: [],
       alternatives: []
     },
-    skillAliases: data.skillAliases ?? {}
+    perSkill: data["per-skill"] ?? {}
   };
-  verbose(`Loaded skills matrix: ${configPath}`);
-  return matrix;
+  verbose(`Loaded skill rules: ${configPath}`);
+  return config;
 }
 async function extractAllSkills(skillsDir) {
   const skills = [];
@@ -3201,9 +3230,9 @@ async function extractAllSkills(skillsDir) {
       verbose(`Skipping ${metadataFile}: Invalid SKILL.md frontmatter`);
       continue;
     }
-    if (!metadata.cliName) {
+    if (!metadata.displayName) {
       throw new Error(
-        `Skill at ${metadataFile} is missing required '${METADATA_KEYS.CLI_NAME}' field in metadata.yaml`
+        `Skill at ${metadataFile} is missing required '${METADATA_KEYS.DISPLAY_NAME}' field in metadata.yaml`
       );
     }
     const skillId = frontmatter.name;
@@ -3213,15 +3242,10 @@ async function extractAllSkills(skillsDir) {
       description: metadata.cliDescription || frontmatter.description,
       usageGuidance: metadata.usageGuidance,
       category: metadata.category,
-      categoryExclusive: metadata.categoryExclusive ?? true,
       author: metadata.author,
       tags: metadata.tags ?? [],
-      compatibleWith: metadata.compatibleWith ?? [],
-      conflictsWith: metadata.conflictsWith ?? [],
-      requires: metadata.requires ?? [],
-      requiresSetup: metadata.requiresSetup ?? [],
-      providesSetupFor: metadata.providesSetupFor ?? [],
       path: `skills/${skillDir}/`,
+      ...metadata.domain ? { domain: metadata.domain } : {},
       ...metadata.custom === true ? { custom: true } : {}
     };
     skills.push(extracted);
@@ -3266,25 +3290,36 @@ function resolveToCanonicalId(nameOrId, displayNameToId, directoryPathToId = {},
   }
   return nameOrId;
 }
-async function mergeMatrixWithSkills(matrix, skills) {
-  const displayNameToId = matrix.skillAliases;
+async function mergeMatrixWithSkills(categories, relationships, aliases, skills, perSkillRules) {
+  const displayNameToId = aliases;
   const displayNames = buildReverseDisplayNames(displayNameToId);
   const directoryPathToId = buildDirectoryPathToIdMap(skills);
   const resolvedSkills = {};
   for (const skill of skills) {
     const resolved = buildResolvedSkill(
       skill,
-      matrix,
+      categories,
+      relationships,
       displayNameToId,
       displayNames,
-      directoryPathToId
+      directoryPathToId,
+      perSkillRules
     );
     resolvedSkills[skill.id] = resolved;
   }
+  const synthesizedCategories = { ...categories };
+  for (const skill of skills) {
+    const subcategory = skill.category;
+    if (!synthesizedCategories[subcategory]) {
+      const synthesized = synthesizeCategory(skill.category, skill.domain);
+      synthesizedCategories[subcategory] = synthesized;
+      verbose(`Auto-synthesized category '${skill.category}' for skill '${skill.id}'`);
+    }
+  }
   const suggestedStacks = resolveSuggestedStacks();
   const merged = {
-    version: matrix.version,
-    categories: matrix.categories,
+    version: "1.0.0",
+    categories: synthesizedCategories,
     skills: resolvedSkills,
     suggestedStacks,
     displayNameToId,
@@ -3377,41 +3412,48 @@ function resolveDiscourages(skillId, discourageRules, resolve) {
   }
   return discourages;
 }
-function buildResolvedSkill(skill, matrix, displayNameToId, displayNames, directoryPathToId) {
+function buildResolvedSkill(skill, _categories, relationships, displayNameToId, displayNames, directoryPathToId, perSkillRules) {
   const resolve = (id, context) => resolveToCanonicalId(
     id,
     displayNameToId,
     directoryPathToId,
     context ? `${skill.id} ${context}` : void 0
   );
-  const { relationships } = matrix;
+  const skillAlias = displayNames[skill.id];
+  const perSkill = skillAlias ? perSkillRules?.[skillAlias] : void 0;
   return {
     id: skill.id,
     displayName: displayNames[skill.id],
     description: skill.description,
     usageGuidance: skill.usageGuidance,
     category: skill.category,
-    categoryExclusive: skill.categoryExclusive,
     tags: skill.tags,
     author: skill.author,
     conflictsWith: resolveConflicts(
       skill.id,
-      skill.conflictsWith,
+      perSkill?.conflictsWith ?? [],
       relationships.conflicts,
       resolve
     ),
     recommends: resolveRecommends(
       skill.id,
-      skill.compatibleWith,
+      perSkill?.compatibleWith ?? [],
       relationships.recommends,
       resolve
     ),
-    requires: resolveRequirements(skill.id, skill.requires, relationships.requires, resolve),
+    requires: resolveRequirements(
+      skill.id,
+      perSkill?.requires ?? [],
+      relationships.requires,
+      resolve
+    ),
     alternatives: resolveAlternatives(skill.id, relationships.alternatives, resolve),
     discourages: resolveDiscourages(skill.id, relationships.discourages, resolve),
-    compatibleWith: skill.compatibleWith.map((id) => resolve(id, "compatibleWith")),
-    requiresSetup: skill.requiresSetup.map((id) => resolve(id, "requiresSetup")),
-    providesSetupFor: skill.providesSetupFor.map((id) => resolve(id, "providesSetupFor")),
+    compatibleWith: (perSkill?.compatibleWith ?? []).map((id) => resolve(id, "compatibleWith")),
+    requiresSetup: (perSkill?.requiresSetup ?? []).map((id) => resolve(id, "requiresSetup")),
+    providesSetupFor: (perSkill?.providesSetupFor ?? []).map(
+      (id) => resolve(id, "providesSetupFor")
+    ),
     path: skill.path
   };
 }
@@ -3763,12 +3805,15 @@ function checkSubcategoryDomains(matrix, issues) {
 function checkSkillCategories(matrix, issues) {
   for (const [skillId, skill] of typedEntries(matrix.skills)) {
     if (!skill) continue;
-    if (!matrix.categories[skill.category]) {
+    const category = matrix.categories[skill.category];
+    if (!category) {
       issues.push({
         severity: "warning",
         finding: "skill-unknown-category",
         details: `Skill '${skillId}' references category '${skill.category}' which does not exist in the matrix`
       });
+    } else if (category.custom) {
+      verbose(`Skill '${skillId}' uses auto-synthesized category '${skill.category}'`);
     }
   }
 }
@@ -4083,47 +4128,62 @@ async function loadFromRemote(source, sourceConfig, forceRefresh) {
 }
 async function loadAndMergeFromBasePath(basePath) {
   const sourceProjectConfig = await loadProjectSourceConfig(basePath);
-  const matrixRelPath = sourceProjectConfig?.matrixFile ?? SKILLS_MATRIX_PATH;
   const skillsDirRelPath = sourceProjectConfig?.skillsDir ?? SKILLS_DIR_PATH;
   const stacksRelFile = sourceProjectConfig?.stacksFile;
-  const cliMatrixPath = path21.join(PROJECT_ROOT, SKILLS_MATRIX_PATH);
-  const cliMatrix = await loadSkillsMatrix(cliMatrixPath);
-  let matrix = cliMatrix;
+  const cliCategoriesPath = path21.join(PROJECT_ROOT, SKILL_CATEGORIES_YAML_PATH);
+  const cliRulesPath = path21.join(PROJECT_ROOT, SKILL_RULES_YAML_PATH);
+  const cliCategories = await loadSkillCategories(cliCategoriesPath);
+  const cliRules = await loadSkillRules(cliRulesPath);
+  let categories = cliCategories;
+  let relationships = cliRules.relationships;
+  let aliases = cliRules.aliases;
+  let perSkillRules = cliRules.perSkill;
   await discoverAndExtendFromSource(basePath);
-  const sourceMatrixPath = path21.join(basePath, matrixRelPath);
-  if (await fileExists(sourceMatrixPath)) {
-    const sourceMatrix = await loadSkillsMatrix(sourceMatrixPath);
-    const mergedCategories = { ...cliMatrix.categories, ...sourceMatrix.categories };
-    const mergedRelationships = {
-      conflicts: [...cliMatrix.relationships.conflicts, ...sourceMatrix.relationships.conflicts],
-      discourages: [
-        ...cliMatrix.relationships.discourages,
-        ...sourceMatrix.relationships.discourages
-      ],
-      recommends: [...cliMatrix.relationships.recommends, ...sourceMatrix.relationships.recommends],
-      requires: [...cliMatrix.relationships.requires, ...sourceMatrix.relationships.requires],
-      alternatives: [
-        ...cliMatrix.relationships.alternatives,
-        ...sourceMatrix.relationships.alternatives
-      ]
-    };
-    const mergedAliases = { ...cliMatrix.skillAliases, ...sourceMatrix.skillAliases };
-    matrix = {
-      version: cliMatrix.version,
-      categories: mergedCategories,
-      relationships: mergedRelationships,
-      skillAliases: mergedAliases
-    };
-    verbose(
-      `Matrix merged: CLI (${typedKeys(cliMatrix.categories).length} categories) + source (${typedKeys(sourceMatrix.categories).length} categories)`
-    );
+  const sourceCategoriesPath = path21.join(basePath, SKILL_CATEGORIES_YAML_PATH);
+  const sourceRulesPath = path21.join(basePath, SKILL_RULES_YAML_PATH);
+  const hasSourceCategories = await fileExists(sourceCategoriesPath);
+  const hasSourceRules = await fileExists(sourceRulesPath);
+  if (hasSourceCategories || hasSourceRules) {
+    if (hasSourceCategories) {
+      const sourceCategories = await loadSkillCategories(sourceCategoriesPath);
+      categories = { ...cliCategories, ...sourceCategories };
+      verbose(
+        `Loaded source categories: ${sourceCategoriesPath} (${typedKeys(sourceCategories).length} categories)`
+      );
+    }
+    if (hasSourceRules) {
+      const sourceRules = await loadSkillRules(sourceRulesPath);
+      relationships = {
+        conflicts: [...cliRules.relationships.conflicts, ...sourceRules.relationships.conflicts],
+        discourages: [
+          ...cliRules.relationships.discourages,
+          ...sourceRules.relationships.discourages
+        ],
+        recommends: [...cliRules.relationships.recommends, ...sourceRules.relationships.recommends],
+        requires: [...cliRules.relationships.requires, ...sourceRules.relationships.requires],
+        alternatives: [
+          ...cliRules.relationships.alternatives,
+          ...sourceRules.relationships.alternatives
+        ]
+      };
+      aliases = { ...cliRules.aliases, ...sourceRules.aliases };
+      perSkillRules = { ...cliRules.perSkill, ...sourceRules.perSkill };
+      verbose(`Loaded source rules: ${sourceRulesPath}`);
+    }
+    verbose(`Matrix merged: CLI (${typedKeys(cliCategories).length} categories) + source`);
   } else {
-    verbose(`Matrix from CLI only (source has no matrix): ${cliMatrixPath}`);
+    verbose(`Matrix from CLI only (source has no categories/rules files)`);
   }
   const skillsDir = path21.join(basePath, skillsDirRelPath);
   verbose(`Skills from source: ${skillsDir}`);
   const skills = await extractAllSkills(skillsDir);
-  const mergedMatrix = await mergeMatrixWithSkills(matrix, skills);
+  const mergedMatrix = await mergeMatrixWithSkills(
+    categories,
+    relationships,
+    aliases,
+    skills,
+    perSkillRules
+  );
   const sourceStacks = await loadStacks(basePath, stacksRelFile);
   const stacks = sourceStacks.length > 0 ? sourceStacks : await loadStacks(PROJECT_ROOT);
   if (stacks.length > 0) {
@@ -4131,6 +4191,17 @@ async function loadAndMergeFromBasePath(basePath) {
     const stackSource = sourceStacks.length > 0 ? "source" : "CLI";
     verbose(`Loaded ${stacks.length} stacks from ${stackSource}`);
   }
+  const agents = await loadAllAgents(basePath);
+  const agentDefinedDomains = {};
+  for (const [agentId, agentDef] of typedEntries(agents)) {
+    if (agentDef.domain) {
+      agentDefinedDomains[agentId] = agentDef.domain;
+    }
+  }
+  if (Object.keys(agentDefinedDomains).length > 0) {
+    mergedMatrix.agentDefinedDomains = agentDefinedDomains;
+    verbose(`Loaded ${Object.keys(agentDefinedDomains).length} agent domain definition(s)`);
+  }
   return mergedMatrix;
 }
 function convertStackToResolvedStack(stack) {
@@ -4190,15 +4261,20 @@ function getMarketplaceLabel(sourceResult) {
   }
   return marketplace;
 }
-async function discoverCustomAgentName(agentsDir, file, parseYaml9) {
+async function discoverCustomAgentValues(agentsDir, file, parseYaml9, builtinDomains) {
   const content = await readFile(path21.join(agentsDir, file));
   const raw = parseYaml9(content);
-  if (raw?.custom !== true) return void 0;
-  if (typeof raw?.id !== "string") return void 0;
-  if (agentNameSchema.safeParse(raw.id).success) return void 0;
-  return raw.id;
+  if (raw?.custom !== true) return {};
+  const result = {};
+  if (typeof raw?.id === "string" && !agentNameSchema.safeParse(raw.id).success) {
+    result.agentName = raw.id;
+  }
+  if (typeof raw?.domain === "string" && !builtinDomains.has(raw.domain)) {
+    result.domain = raw.domain;
+  }
+  return result;
 }
-async function discoverCustomSkillValues(skillsDir, file, parseYaml9, builtinSubcategories) {
+async function discoverCustomSkillValues(skillsDir, file, parseYaml9, builtinSubcategories, builtinDomains) {
   const content = await readFile(path21.join(skillsDir, file));
   const frontmatter = parseFrontmatter(content);
   if (!frontmatter) return {};
@@ -4210,19 +4286,23 @@ async function discoverCustomSkillValues(skillsDir, file, parseYaml9, builtinSub
   const metadataRaw = parseYaml9(metadataContent);
   if (metadataRaw?.custom !== true) return {};
   const result = {};
-  if (!SKILL_ID_PATTERN.test(skillId)) {
-    result.skillId = skillId;
-  }
+  result.skillId = skillId;
   const category = metadataRaw.category;
   if (typeof category === "string" && !builtinSubcategories.has(category)) {
     result.category = category;
   }
+  const domain = metadataRaw.domain;
+  if (typeof domain === "string" && !builtinDomains.has(domain)) {
+    result.domain = domain;
+  }
   return result;
 }
 async function discoverAndExtendFromSource(basePath) {
   const { parse: parseYaml9 } = await import("yaml");
   const builtinSubcategories = new Set(SUBCATEGORY_VALUES);
+  const builtinDomains = new Set(DOMAIN_VALUES);
   const customCategories = [];
+  const customDomains = [];
   const customAgentNames = [];
   const customSkillIds = [];
   const agentsDir = path21.join(basePath, DIRS.agents);
@@ -4230,8 +4310,9 @@ async function discoverAndExtendFromSource(basePath) {
     const agentFiles = await glob(`**/${STANDARD_FILES.AGENT_YAML}`, agentsDir);
     for (const file of agentFiles) {
       try {
-        const name = await discoverCustomAgentName(agentsDir, file, parseYaml9);
-        if (name) customAgentNames.push(name);
+        const result = await discoverCustomAgentValues(agentsDir, file, parseYaml9, builtinDomains);
+        if (result.agentName) customAgentNames.push(result.agentName);
+        if (result.domain) customDomains.push(result.domain);
       } catch {
       }
     }
@@ -4245,23 +4326,26 @@ async function discoverAndExtendFromSource(basePath) {
           skillsDir,
           file,
           parseYaml9,
-          builtinSubcategories
+          builtinSubcategories,
+          builtinDomains
         );
         if (result.skillId) customSkillIds.push(result.skillId);
         if (result.category) customCategories.push(result.category);
+        if (result.domain) customDomains.push(result.domain);
       } catch {
       }
     }
   }
-  const hasCustomValues = customCategories.length > 0 || customAgentNames.length > 0 || customSkillIds.length > 0;
+  const hasCustomValues = customCategories.length > 0 || customDomains.length > 0 || customAgentNames.length > 0 || customSkillIds.length > 0;
   if (hasCustomValues) {
     extendSchemasWithCustomValues({
       categories: unique4(customCategories),
+      domains: unique4(customDomains),
       agentNames: customAgentNames,
       skillIds: customSkillIds
     });
     verbose(
-      `Extended schemas with ${unique4(customCategories).length} custom categories, ${customAgentNames.length} custom agents, ${customSkillIds.length} custom skill IDs`
+      `Extended schemas with ${unique4(customCategories).length} custom categories, ${unique4(customDomains).length} custom domains, ${customAgentNames.length} custom agents, ${customSkillIds.length} custom skill IDs`
     );
   }
 }
@@ -4276,7 +4360,6 @@ function mergeLocalSkillsIntoMatrix(matrix, localResult) {
       description: metadata.description,
       usageGuidance: metadata.usageGuidance,
       category,
-      categoryExclusive: metadata.categoryExclusive,
       tags: metadata.tags ?? [],
       author: LOCAL_DEFAULTS.AUTHOR,
       conflictsWith: existingSkill?.conflictsWith ?? [],
@@ -4339,11 +4422,10 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
     return null;
   }
   const metadata = parsed.data;
-  if (!metadata.cliName) {
-    warn(
-      `Skipping local skill '${skillDirName}': missing required '${METADATA_KEYS.CLI_NAME}' in metadata.yaml`
+  if (!metadata.displayName) {
+    throw new Error(
+      `Local skill '${skillDirName}' is missing required '${METADATA_KEYS.DISPLAY_NAME}' field in metadata.yaml`
     );
-    return null;
   }
   const skillMdContent = await readFile(skillMdPath);
   const frontmatter = parseFrontmatter(skillMdContent, skillMdPath);
@@ -4365,14 +4447,8 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
     description: metadata.cliDescription || frontmatter.description,
     usageGuidance: metadata.usageGuidance,
     category,
-    categoryExclusive: metadata.categoryExclusive ?? false,
     author: LOCAL_DEFAULTS.AUTHOR,
     tags: metadata.tags ?? [],
-    compatibleWith: metadata.compatibleWith ?? [],
-    conflictsWith: metadata.conflictsWith ?? [],
-    requires: metadata.requires ?? [],
-    requiresSetup: metadata.requiresSetup ?? [],
-    providesSetupFor: metadata.providesSetupFor ?? [],
     path: relativePath,
     local: true,
     localPath: relativePath
@@ -4477,6 +4553,7 @@ export {
   getCurrentDate,
   computeStringHash,
   computeFileHash,
+  computeSkillFolderHash,
   determinePluginVersion,
   writeContentHash,
   readForkedFromMetadata,
@@ -4488,9 +4565,14 @@ export {
   printCompilationSummary,
   archiveLocalSkill,
   restoreArchivedSkill,
+  loadSkillCategories,
+  loadSkillRules,
+  extractAllSkills,
+  mergeMatrixWithSkills,
   resolveAlias,
   validateSelection,
   getAvailableSkills,
+  checkMatrixHealth,
   searchExtraSources,
   buildSkillRefsFromConfig,
   resolveAgents,
@@ -4517,4 +4599,4 @@ export {
   validateAllPlugins,
   printPluginValidationResult
 };
-//# sourceMappingURL=chunk-RT6IBH37.js.map
+//# sourceMappingURL=chunk-P2SFRDWI.js.map