@agents-inc/cli 0.47.0 → 0.50.0

package/dist/{chunk-GFDGYQ6M.js → chunk-HMSHB5EQ.js}

@@ -9,6 +9,7 @@ import {
   agentFrontmatterValidationSchema,
   agentNameSchema,
   agentYamlConfigSchema,
+  agentYamlGenerationSchema,
   categoryPathSchema,
   copy,
   directoryExists,
@@ -26,6 +27,7 @@ import {
   localSkillMetadataSchema,
   log,
   marketplaceSchema,
+  metadataValidationSchema,
   pluginAuthorSchema,
   pluginManifestSchema,
   projectConfigLoaderSchema,
@@ -34,19 +36,21 @@ import {
   readFileOptional,
   readFileSafe,
   remove,
+  skillCategoriesFileSchema,
   skillDisplayNameSchema,
   skillFrontmatterLoaderSchema,
   skillFrontmatterValidationSchema,
   skillIdSchema,
   skillMetadataLoaderSchema,
-  skillsMatrixConfigSchema,
+  skillRulesFileSchema,
+  stackConfigValidationSchema,
   stacksConfigSchema,
   validateNestingDepth,
   verbose,
   warn,
   warnUnknownFields,
   writeFile
-} from "./chunk-C4QI54PN.js";
+} from "./chunk-WBHPCBVN.js";
 import {
   ARCHIVED_SKILLS_DIR_NAME,
   CACHE_DIR,
@@ -74,13 +78,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-FTD5Z6QD.js";
+} from "./chunk-AWP5A6IM.js";
 import {
   init_esm_shims
 } from "./chunk-DHET7RCE.js";
@@ -90,6 +95,7 @@ init_esm_shims();
 
 // src/cli/lib/configuration/config.ts
 init_esm_shims();
+import os from "os";
 import path from "path";
 import { stringify as stringifyYaml } from "yaml";
 
@@ -137,6 +143,18 @@ async function loadProjectSourceConfig(projectDir) {
   verbose(`Loaded project config from ${configPath}`);
   return data;
 }
+async function loadGlobalSourceConfig() {
+  const homeDir = os.homedir();
+  const globalConfigPath = path.join(homeDir, CLAUDE_SRC_DIR, PROJECT_CONFIG_FILE);
+  if (!await fileExists(globalConfigPath)) {
+    verbose(`Global config not found at ${globalConfigPath}`);
+    return null;
+  }
+  const data = await safeLoadYamlFile(globalConfigPath, projectSourceConfigSchema);
+  if (!data) return null;
+  verbose(`Loaded global config from ${globalConfigPath}`);
+  return data;
+}
 async function saveProjectConfig(projectDir, config) {
   const configPath = getProjectConfigPath(projectDir);
   await ensureDir(path.join(projectDir, CLAUDE_SRC_DIR));
@@ -146,9 +164,13 @@ async function saveProjectConfig(projectDir, config) {
   await writeFile(configPath, `${schemaComment}${content}`);
   verbose(`Saved project config to ${configPath}`);
 }
-async function resolveSource(flagValue, projectDir) {
+async function loadEffectiveSourceConfig(projectDir) {
   const projectConfig = projectDir ? await loadProjectSourceConfig(projectDir) : null;
-  const marketplace = projectConfig?.marketplace;
+  return projectConfig ?? await loadGlobalSourceConfig();
+}
+async function resolveSource(flagValue, projectDir) {
+  const effectiveConfig = await loadEffectiveSourceConfig(projectDir);
+  const marketplace = effectiveConfig?.marketplace;
   if (flagValue !== void 0) {
     if (flagValue === "" || flagValue.trim() === "") {
       throw new Error(
@@ -178,10 +200,10 @@ ${message}`
       }
     }
   }
-  if (projectConfig?.source) {
-    verbose(`Source from project config: ${projectConfig.source}`);
+  if (effectiveConfig?.source) {
+    verbose(`Source from project config: ${effectiveConfig.source}`);
     return {
-      source: projectConfig.source,
+      source: effectiveConfig.source,
       sourceOrigin: "project",
       marketplace
     };
@@ -200,11 +222,11 @@ async function resolveAgentsSource(flagValue, projectDir) {
     verbose(`Agents source from --agent-source flag: ${flagValue}`);
     return { agentsSource: flagValue, agentsSourceOrigin: "flag" };
   }
-  const projectConfig = projectDir ? await loadProjectSourceConfig(projectDir) : null;
-  if (projectConfig?.agentsSource) {
-    verbose(`Agents source from project config: ${projectConfig.agentsSource}`);
+  const effectiveConfig = await loadEffectiveSourceConfig(projectDir);
+  if (effectiveConfig?.agentsSource) {
+    verbose(`Agents source from project config: ${effectiveConfig.agentsSource}`);
     return {
-      agentsSource: projectConfig.agentsSource,
+      agentsSource: effectiveConfig.agentsSource,
       agentsSourceOrigin: "project"
     };
   }
@@ -237,11 +259,11 @@ function formatOrigin(type, origin) {
   return origin;
 }
 async function resolveAuthor(projectDir) {
-  const projectConfig = projectDir ? await loadProjectSourceConfig(projectDir) : null;
-  return projectConfig?.author;
+  const effectiveConfig = await loadEffectiveSourceConfig(projectDir);
+  return effectiveConfig?.author;
 }
 async function resolveAllSources(projectDir) {
-  const projectConfig = projectDir ? await loadProjectSourceConfig(projectDir) : null;
+  const effectiveConfig = await loadEffectiveSourceConfig(projectDir);
   const resolvedConfig = await resolveSource(void 0, projectDir);
   const primary = {
     name: "marketplace",
@@ -250,8 +272,8 @@ async function resolveAllSources(projectDir) {
   };
   const extras = [];
   const seenNames = /* @__PURE__ */ new Set();
-  if (projectConfig?.sources) {
-    for (const source of projectConfig.sources) {
+  if (effectiveConfig?.sources) {
+    for (const source of effectiveConfig.sources) {
       if (!seenNames.has(source.name)) {
         seenNames.add(source.name);
         extras.push(source);
@@ -418,7 +440,7 @@ function isLocalSource(source) {
 init_esm_shims();
 import { createHash } from "crypto";
 import { downloadTemplate } from "giget";
-import os from "os";
+import os3 from "os";
 import path4 from "path";
 
 // src/cli/lib/configuration/index.ts
@@ -533,6 +555,7 @@ import { difference } from "remeda";
 
 // src/cli/lib/configuration/project-config.ts
 init_esm_shims();
+import os2 from "os";
 import path3 from "path";
 
 // src/cli/lib/stacks/stacks-loader.ts
@@ -629,7 +652,7 @@ function getStackSkillIds(stack) {
 // src/cli/lib/configuration/project-config.ts
 var CONFIG_PATH = `${CLAUDE_SRC_DIR}/config.yaml`;
 var LEGACY_CONFIG_PATH = `${CLAUDE_DIR}/config.yaml`;
-async function loadProjectConfig(projectDir) {
+async function loadProjectConfigFromDir(projectDir) {
   const srcConfigPath = path3.join(projectDir, CONFIG_PATH);
   const legacyConfigPath = path3.join(projectDir, LEGACY_CONFIG_PATH);
   let configPath = srcConfigPath;
@@ -666,6 +689,15 @@ async function loadProjectConfig(projectDir) {
     configPath
   };
 }
+async function loadProjectConfig(projectDir) {
+  const projectResult = await loadProjectConfigFromDir(projectDir);
+  if (projectResult) return projectResult;
+  const homeDir = os2.homedir();
+  if (projectDir !== homeDir) {
+    return loadProjectConfigFromDir(homeDir);
+  }
+  return null;
+}
 function validateProjectConfig(config) {
   const errors = [];
   const warnings = [];
@@ -803,7 +835,7 @@ function getGigetCacheDir(source) {
     return void 0;
   }
   const templateName = uriMatch.groups.repo.replace("/", "-").replace(/[^\da-z-]/gi, "-");
-  const gigetCacheRoot = process.env.XDG_CACHE_HOME ? path4.resolve(process.env.XDG_CACHE_HOME, "giget") : path4.resolve(os.homedir(), ".cache", "giget");
+  const gigetCacheRoot = process.env.XDG_CACHE_HOME ? path4.resolve(process.env.XDG_CACHE_HOME, "giget") : path4.resolve(os3.homedir(), ".cache", "giget");
   return path4.join(gigetCacheRoot, providerName, templateName);
 }
 async function clearGigetCache(source) {
@@ -977,8 +1009,8 @@ Too many plugins: ${marketplace.plugins.length} (limit: ${MAX_MARKETPLACE_PLUGIN
 
 // src/cli/lib/skills/local-skill-loader.ts
 init_esm_shims();
-import { parse as parseYaml8 } from "yaml";
-import path22 from "path";
+import { parse as parseYaml9 } from "yaml";
+import path23 from "path";
 
 // src/cli/lib/loading/index.ts
 init_esm_shims();
@@ -1004,7 +1036,7 @@ function parseFrontmatter(content, filePath) {
 async function loadAllAgents(projectRoot) {
   const agents = {};
   const agentSourcesDir = path5.join(projectRoot, DIRS.agents);
-  const files = await glob("**/agent.yaml", agentSourcesDir);
+  const files = await glob(`**/${STANDARD_FILES.AGENT_METADATA_YAML}`, agentSourcesDir);
   for (const file of files) {
     const fullPath = path5.join(agentSourcesDir, file);
     try {
@@ -1022,7 +1054,7 @@ async function loadAllAgents(projectRoot) {
       };
       verbose(`Loaded agent: ${config.id} from ${file}`);
     } catch (error) {
-      warn(`Skipping invalid agent.yaml at '${fullPath}': ${getErrorMessage(error)}`);
+      warn(`Skipping invalid metadata.yaml at '${fullPath}': ${getErrorMessage(error)}`);
     }
   }
   return agents;
@@ -1034,7 +1066,7 @@ async function loadProjectAgents(projectRoot) {
     verbose(`No project agents directory at ${projectAgentsDir}`);
     return agents;
   }
-  const files = await glob("**/agent.yaml", projectAgentsDir);
+  const files = await glob(`**/${STANDARD_FILES.AGENT_METADATA_YAML}`, projectAgentsDir);
   for (const file of files) {
     const fullPath = path5.join(projectAgentsDir, file);
     try {
@@ -1054,7 +1086,7 @@ async function loadProjectAgents(projectRoot) {
       };
       verbose(`Loaded project agent: ${config.id} from ${file}`);
     } catch (error) {
-      warn(`Skipping invalid agent.yaml at '${fullPath}': ${getErrorMessage(error)}`);
+      warn(`Skipping invalid metadata.yaml at '${fullPath}': ${getErrorMessage(error)}`);
     }
   }
   return agents;
@@ -1159,13 +1191,14 @@ async function loadPluginSkills(pluginDir) {
 
 // src/cli/lib/loading/source-loader.ts
 init_esm_shims();
-import path21 from "path";
+import os6 from "os";
+import path22 from "path";
 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",
@@ -1291,6 +1324,10 @@ async function writeContentHash(pluginDir, contentHash, getManifestPath) {
 
 // src/cli/lib/skills/skill-metadata.ts
 async function readForkedFromMetadata(skillDir) {
+  const metadata = await readLocalSkillMetadata(skillDir);
+  return metadata?.forkedFrom ?? null;
+}
+async function readLocalSkillMetadata(skillDir) {
   const metadataPath = path7.join(skillDir, STANDARD_FILES.METADATA_YAML);
   if (!await fileExists(metadataPath)) {
     return null;
@@ -1301,7 +1338,7 @@ async function readForkedFromMetadata(skillDir) {
     warn(`Invalid metadata.yaml at ${metadataPath}: ${formatZodErrors(result.error.issues)}`);
     return null;
   }
-  return result.data.forkedFrom ?? null;
+  return result.data;
 }
 async function getLocalSkillsWithMetadata(projectDir) {
   const localSkillsPath = path7.join(projectDir, LOCAL_SKILLS_PATH);
@@ -1474,8 +1511,8 @@ async function copySkillsToLocalFlattened(selectedSkillIds, localSkillsDir, matr
 
 // src/cli/lib/skills/skill-plugin-compiler.ts
 init_esm_shims();
-import path17 from "path";
-import { parse as parseYaml6 } from "yaml";
+import path18 from "path";
+import { parse as parseYaml7 } from "yaml";
 
 // src/cli/lib/plugins/index.ts
 init_esm_shims();
@@ -1582,19 +1619,21 @@ init_esm_shims();
 
 // src/cli/lib/installation/installation.ts
 init_esm_shims();
+import os4 from "os";
 import path11 from "path";
-async function detectInstallation(projectDir = process.cwd()) {
+async function detectProjectInstallation(projectDir) {
   const srcConfigPath = path11.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_YAML);
   const legacyConfigPath = path11.join(projectDir, CLAUDE_DIR, STANDARD_FILES.CONFIG_YAML);
   const localConfigPath = await fileExists(srcConfigPath) ? srcConfigPath : await fileExists(legacyConfigPath) ? legacyConfigPath : null;
   if (!localConfigPath) {
     return null;
   }
-  const loaded = await loadProjectConfig(projectDir);
+  const loaded = await loadProjectConfigFromDir(projectDir);
   const mode = loaded?.config?.installMode ?? "local";
   if (mode === "local") {
     return {
       mode: "local",
+      scope: "project",
       configPath: localConfigPath,
       agentsDir: path11.join(projectDir, CLAUDE_DIR, "agents"),
       skillsDir: path11.join(projectDir, CLAUDE_DIR, "skills"),
@@ -1603,12 +1642,45 @@ async function detectInstallation(projectDir = process.cwd()) {
   }
   return {
     mode: "plugin",
+    scope: "project",
     configPath: localConfigPath,
     agentsDir: path11.join(projectDir, CLAUDE_DIR, "agents"),
     skillsDir: path11.join(projectDir, CLAUDE_DIR, PLUGINS_SUBDIR),
     projectDir
   };
 }
+async function detectGlobalInstallation() {
+  const homeDir = os4.homedir();
+  const srcConfigPath = path11.join(homeDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_YAML);
+  if (!await fileExists(srcConfigPath)) {
+    return null;
+  }
+  const loaded = await loadProjectConfigFromDir(homeDir);
+  const mode = loaded?.config?.installMode ?? "local";
+  if (mode === "local") {
+    return {
+      mode: "local",
+      scope: "global",
+      configPath: srcConfigPath,
+      agentsDir: path11.join(homeDir, CLAUDE_DIR, "agents"),
+      skillsDir: path11.join(homeDir, CLAUDE_DIR, "skills"),
+      projectDir: homeDir
+    };
+  }
+  return {
+    mode: "plugin",
+    scope: "global",
+    configPath: srcConfigPath,
+    agentsDir: path11.join(homeDir, CLAUDE_DIR, "agents"),
+    skillsDir: path11.join(homeDir, CLAUDE_DIR, PLUGINS_SUBDIR),
+    projectDir: homeDir
+  };
+}
+async function detectInstallation(projectDir = process.cwd()) {
+  const projectInstallation = await detectProjectInstallation(projectDir);
+  if (projectInstallation) return projectInstallation;
+  return detectGlobalInstallation();
+}
 
 // src/cli/lib/installation/local-installer.ts
 init_esm_shims();
@@ -1684,7 +1756,7 @@ async function resolveAgents(agents, skills, compileConfig, _projectRoot, stack)
       const availableAgents = typedKeys(agents);
       const agentList = availableAgents.length > 0 ? `Available agents: ${availableAgents.slice(0, 5).join(", ")}${availableAgents.length > 5 ? ` (and ${availableAgents.length - 5} more)` : ""}` : "No agents found in scanned directories";
       throw new Error(
-        `Agent '${agentName}' referenced in compile config but not found in scanned agents. ${agentList}. Check that src/agents/${agentName}/agent.yaml exists.`
+        `Agent '${agentName}' referenced in compile config but not found in scanned agents. ${agentList}. Check that src/agents/${agentName}/metadata.yaml exists.`
       );
     }
     const agentConfig = compileConfig.agents[agentName];
@@ -2181,9 +2253,6 @@ async function buildLocalConfig(wizardResult, sourceResult) {
 }
 function setConfigMetadata(config, wizardResult, sourceResult, sourceFlag) {
   config.installMode = wizardResult.installMode;
-  if (wizardResult.expertMode) {
-    config.expertMode = true;
-  }
   if (wizardResult.selectedDomains && wizardResult.selectedDomains.length > 0) {
     config.domains = wizardResult.selectedDomains;
   }
@@ -2225,7 +2294,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) {
@@ -2359,7 +2429,7 @@ init_esm_shims();
 // src/cli/lib/plugins/plugin-settings.ts
 init_esm_shims();
 import path15 from "path";
-import os2 from "os";
+import os5 from "os";
 import { z } from "zod";
 var pluginSettingsSchema = z.object({
   enabledPlugins: z.record(z.string(), z.unknown()).optional()
@@ -2410,7 +2480,7 @@ async function resolvePluginInstallPaths(pluginKeys, projectDir) {
   if (pluginKeys.length === 0) {
     return [];
   }
-  const registryPath = path15.join(os2.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR, INSTALLED_PLUGINS_FILE);
+  const registryPath = path15.join(os5.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR, INSTALLED_PLUGINS_FILE);
   if (!await fileExists(registryPath)) {
     verbose(`Plugin registry not found at '${registryPath}'`);
     return [];
@@ -2585,9 +2655,221 @@ function formatInstallationDisplay(info) {
 // src/cli/lib/plugins/plugin-validator.ts
 init_esm_shims();
 import { z as z2 } from "zod";
+import path17 from "path";
+import fg2 from "fast-glob";
+import { countBy } from "remeda";
+
+// src/cli/lib/schema-validator.ts
+init_esm_shims();
+import { sumBy } from "remeda";
 import path16 from "path";
+import { parse as parseYaml6 } from "yaml";
 import fg from "fast-glob";
-import { countBy } from "remeda";
+var VALIDATION_TARGETS = [
+  {
+    name: "Skill Categories",
+    schema: skillCategoriesFileSchema,
+    pattern: STANDARD_FILES.SKILL_CATEGORIES_YAML,
+    baseDir: "config"
+  },
+  {
+    name: "Skill Rules",
+    schema: skillRulesFileSchema,
+    pattern: STANDARD_FILES.SKILL_RULES_YAML,
+    baseDir: "config"
+  },
+  {
+    name: "Skill Metadata",
+    schema: metadataValidationSchema,
+    pattern: `**/${STANDARD_FILES.METADATA_YAML}`,
+    baseDir: "src/skills"
+  },
+  {
+    name: "Stack Skill Metadata",
+    schema: metadataValidationSchema,
+    pattern: `**/skills/**/${STANDARD_FILES.METADATA_YAML}`,
+    baseDir: "src/stacks"
+  },
+  {
+    name: "Stack Config",
+    schema: stackConfigValidationSchema,
+    pattern: `*/${STANDARD_FILES.CONFIG_YAML}`,
+    baseDir: "src/stacks"
+  },
+  {
+    name: "Agent Definition",
+    schema: agentYamlGenerationSchema,
+    pattern: `**/${STANDARD_FILES.AGENT_METADATA_YAML}`,
+    baseDir: "src/agents"
+  },
+  {
+    name: "Skill Frontmatter",
+    schema: skillFrontmatterValidationSchema,
+    pattern: `**/${STANDARD_FILES.SKILL_MD}`,
+    baseDir: "src/skills",
+    extractor: extractFrontmatter
+  },
+  {
+    name: "Stack Skill Frontmatter",
+    schema: skillFrontmatterValidationSchema,
+    pattern: `**/skills/**/${STANDARD_FILES.SKILL_MD}`,
+    baseDir: "src/stacks",
+    extractor: extractFrontmatter
+  },
+  {
+    name: "Stacks Config",
+    schema: stacksConfigSchema,
+    pattern: "stacks.yaml",
+    baseDir: "config"
+  },
+  {
+    name: "Project Source Config",
+    schema: projectSourceConfigSchema,
+    pattern: STANDARD_FILES.CONFIG_YAML,
+    baseDir: CLAUDE_SRC_DIR
+  },
+  {
+    name: "Project Skill Metadata",
+    schema: metadataValidationSchema,
+    pattern: `*/${STANDARD_FILES.METADATA_YAML}`,
+    baseDir: `${CLAUDE_DIR}/skills`
+  },
+  {
+    name: "Project Skill Frontmatter",
+    schema: skillFrontmatterValidationSchema,
+    pattern: `*/${STANDARD_FILES.SKILL_MD}`,
+    baseDir: `${CLAUDE_DIR}/skills`,
+    extractor: extractFrontmatter
+  },
+  {
+    name: "Project Agent Frontmatter",
+    schema: agentFrontmatterValidationSchema,
+    pattern: "*.md",
+    baseDir: `${CLAUDE_DIR}/agents`,
+    extractor: extractFrontmatter
+  },
+  {
+    name: "Plugin Manifest",
+    schema: pluginManifestSchema,
+    pattern: `*/${STANDARD_FILES.PLUGIN_JSON}`,
+    baseDir: `${CLAUDE_DIR}/plugins`,
+    extractor: (content) => JSON.parse(content)
+  }
+];
+function formatZodErrors2(error) {
+  return error.issues.map((issue) => {
+    const path24 = issue.path.join(".");
+    if (issue.code === "unrecognized_keys") {
+      return `Unrecognized key: "${issue.keys.join('", "')}"`;
+    }
+    return path24 ? `${path24}: ${issue.message}` : issue.message;
+  });
+}
+async function validateFile(filePath, schema, extractor) {
+  try {
+    if (!await fileExists(filePath)) {
+      return { valid: false, errors: [`File not found: ${filePath}`] };
+    }
+    const content = await readFile(filePath);
+    let parsed;
+    if (extractor) {
+      parsed = extractor(content);
+      if (parsed === null) {
+        return {
+          valid: false,
+          errors: ["Failed to extract content (no valid frontmatter found)"]
+        };
+      }
+    } else {
+      parsed = parseYaml6(content);
+    }
+    const result = schema.safeParse(parsed);
+    if (result.success) {
+      return { valid: true, errors: [] };
+    }
+    return { valid: false, errors: formatZodErrors2(result.error) };
+  } catch (error) {
+    const message = getErrorMessage(error);
+    return { valid: false, errors: [`Failed to parse content: ${message}`] };
+  }
+}
+async function validateTarget(target, rootDir = process.cwd()) {
+  const baseDir = path16.join(rootDir, target.baseDir);
+  const pattern = path16.join(baseDir, target.pattern);
+  const files = await fg(pattern, { absolute: true });
+  const result = {
+    schemaName: target.name,
+    valid: true,
+    totalFiles: files.length,
+    validFiles: 0,
+    invalidFiles: []
+  };
+  if (files.length === 0) {
+    return result;
+  }
+  for (const file of files) {
+    const validation = await validateFile(file, target.schema, target.extractor);
+    const relativePath = path16.relative(rootDir, file);
+    if (validation.valid) {
+      result.validFiles++;
+    } else {
+      result.valid = false;
+      result.invalidFiles.push({
+        file: relativePath,
+        errors: validation.errors
+      });
+    }
+  }
+  return result;
+}
+async function validateAllSchemas(rootDir = process.cwd()) {
+  const results = [];
+  for (const target of VALIDATION_TARGETS) {
+    const result = await validateTarget(target, rootDir);
+    results.push(result);
+  }
+  const summary = {
+    totalSchemas: results.length,
+    totalFiles: sumBy(results, (r) => r.totalFiles),
+    validFiles: sumBy(results, (r) => r.validFiles),
+    invalidFiles: sumBy(results, (r) => r.invalidFiles.length)
+  };
+  return {
+    valid: results.every((r) => r.valid),
+    results,
+    summary
+  };
+}
+function printValidationResults(result) {
+  log("\n  Schema Validation Summary:");
+  log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  log(`  Total schemas checked: ${result.summary.totalSchemas}`);
+  log(`  Total files: ${result.summary.totalFiles}`);
+  log(`  Valid: ${result.summary.validFiles}`);
+  log(`  Invalid: ${result.summary.invalidFiles}`);
+  for (const schemaResult of result.results) {
+    if (schemaResult.totalFiles === 0) continue;
+    const status = schemaResult.valid ? "\u2713" : "\u2717";
+    log(
+      `
+  ${status} ${schemaResult.schemaName}: ${schemaResult.validFiles}/${schemaResult.totalFiles} valid`
+    );
+    if (schemaResult.invalidFiles.length > 0) {
+      for (const file of schemaResult.invalidFiles) {
+        log(`
+    ${file.file}:`);
+        file.errors.forEach((e) => log(`      - ${e}`));
+      }
+    }
+  }
+  if (result.valid) {
+    log("\n  \u2713 All schemas validated successfully\n");
+  } else {
+    log("\n  \u2717 Validation failed\n");
+  }
+}
+
+// src/cli/lib/plugins/plugin-validator.ts
 var PLUGIN_DIR = PLUGIN_MANIFEST_DIR;
 var PLUGIN_MANIFEST = STANDARD_FILES.PLUGIN_JSON;
 var KEBAB_CASE_REGEX = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
@@ -2603,15 +2885,6 @@ var pluginManifestValidationSchema = z2.object({
   skills: z2.union([z2.string(), z2.array(z2.string())]).optional(),
   hooks: z2.union([z2.string(), hooksRecordSchema]).optional()
 }).strict();
-function formatZodErrors2(error) {
-  return error.issues.map((issue) => {
-    const path23 = issue.path.join(".");
-    if (issue.code === "unrecognized_keys") {
-      return `Unrecognized key: "${issue.keys.join('", "')}"`;
-    }
-    return path23 ? `${path23}: ${issue.message}` : issue.message;
-  });
-}
 function isKebabCase(str) {
   return KEBAB_CASE_REGEX.test(str);
 }
@@ -2628,15 +2901,15 @@ async function validatePluginStructure(pluginPath) {
       warnings: []
     };
   }
-  const pluginDir = path16.join(pluginPath, PLUGIN_DIR);
+  const pluginDir = path17.join(pluginPath, PLUGIN_DIR);
   if (!await directoryExists(pluginDir)) {
     errors.push(`Missing ${PLUGIN_DIR}/ directory`);
   }
-  const manifestPath = path16.join(pluginDir, PLUGIN_MANIFEST);
+  const manifestPath = path17.join(pluginDir, PLUGIN_MANIFEST);
   if (!await fileExists(manifestPath)) {
     errors.push(`Missing ${PLUGIN_DIR}/${PLUGIN_MANIFEST}`);
   }
-  const readmePath = path16.join(pluginPath, "README.md");
+  const readmePath = path17.join(pluginPath, "README.md");
   if (!await fileExists(readmePath)) {
     warnings.push("Missing README.md (recommended for documentation)");
   }
@@ -2686,15 +2959,15 @@ async function validatePluginManifest(manifestPath) {
   if (!manifest.description) {
     warnings.push("Missing description field (recommended for discoverability)");
   }
-  const pluginDir = path16.dirname(path16.dirname(manifestPath));
+  const pluginDir = path17.dirname(path17.dirname(manifestPath));
   if (manifest.skills && typeof manifest.skills === "string") {
-    const skillsPath = path16.join(pluginDir, manifest.skills);
+    const skillsPath = path17.join(pluginDir, manifest.skills);
     if (!await directoryExists(skillsPath)) {
       errors.push(`Skills path does not exist: ${manifest.skills}`);
     }
   }
   if (manifest.agents && typeof manifest.agents === "string") {
-    const agentsPath = path16.join(pluginDir, manifest.agents);
+    const agentsPath = path17.join(pluginDir, manifest.agents);
     if (!await directoryExists(agentsPath)) {
       errors.push(`Agents path does not exist: ${manifest.agents}`);
     }
@@ -2783,9 +3056,9 @@ function prefixResult(result, prefix) {
   };
 }
 async function validatePluginSkillFiles(pluginPath, skillsRelPath) {
-  const skillsDir = path16.join(pluginPath, skillsRelPath);
+  const skillsDir = path17.join(pluginPath, skillsRelPath);
   if (!await directoryExists(skillsDir)) return EMPTY_RESULT;
-  const files = await fg("**/SKILL.md", { cwd: skillsDir, absolute: true });
+  const files = await fg2("**/SKILL.md", { cwd: skillsDir, absolute: true });
   if (files.length === 0) {
     return {
       valid: true,
@@ -2795,15 +3068,15 @@ async function validatePluginSkillFiles(pluginPath, skillsRelPath) {
   }
   const results = await Promise.all(
     files.map(
-      async (f) => prefixResult(await validateSkillFrontmatter(f), path16.relative(pluginPath, f))
+      async (f) => prefixResult(await validateSkillFrontmatter(f), path17.relative(pluginPath, f))
     )
   );
   return mergeResults(results);
 }
 async function validatePluginAgentFiles(pluginPath, agentsRelPath) {
-  const agentsDir = path16.join(pluginPath, agentsRelPath);
+  const agentsDir = path17.join(pluginPath, agentsRelPath);
   if (!await directoryExists(agentsDir)) return EMPTY_RESULT;
-  const files = await fg("*.md", { cwd: agentsDir, absolute: true });
+  const files = await fg2("*.md", { cwd: agentsDir, absolute: true });
   if (files.length === 0) {
     return {
       valid: true,
@@ -2813,7 +3086,7 @@ async function validatePluginAgentFiles(pluginPath, agentsRelPath) {
   }
   const results = await Promise.all(
     files.map(
-      async (f) => prefixResult(await validateAgentFrontmatter(f), path16.relative(pluginPath, f))
+      async (f) => prefixResult(await validateAgentFrontmatter(f), path17.relative(pluginPath, f))
     )
   );
   return mergeResults(results);
@@ -2829,7 +3102,7 @@ async function loadManifestForValidation(manifestPath) {
 async function validatePlugin(pluginPath) {
   const structureResult = await validatePluginStructure(pluginPath);
   if (!structureResult.valid) return structureResult;
-  const manifestPath = path16.join(pluginPath, PLUGIN_DIR, PLUGIN_MANIFEST);
+  const manifestPath = path17.join(pluginPath, PLUGIN_DIR, PLUGIN_MANIFEST);
   const manifestResult = await validatePluginManifest(manifestPath);
   const manifest = await loadManifestForValidation(manifestPath);
   const skillsResult = manifest?.skills && typeof manifest.skills === "string" ? await validatePluginSkillFiles(pluginPath, manifest.skills) : EMPTY_RESULT;
@@ -2857,7 +3130,7 @@ async function validateAllPlugins(pluginsDir) {
   const allDirs = await listDirectories(pluginsDir);
   const pluginDirs = [];
   for (const dirName of allDirs) {
-    const potentialPluginDir = path16.join(pluginsDir, dirName, PLUGIN_DIR);
+    const potentialPluginDir = path17.join(pluginsDir, dirName, PLUGIN_DIR);
     if (await directoryExists(potentialPluginDir)) {
       pluginDirs.push(dirName);
     }
@@ -2881,7 +3154,7 @@ async function validateAllPlugins(pluginsDir) {
     };
   }
   for (const pluginName of pluginDirs) {
-    const pluginPath = path16.join(pluginsDir, pluginName);
+    const pluginPath = path17.join(pluginsDir, pluginName);
     const result = await validatePlugin(pluginPath);
     results.push({ name: pluginName, result });
   }
@@ -2919,7 +3192,7 @@ function sanitizeSkillName(name) {
   return name.replace(/\+/g, "-");
 }
 async function readSkillMetadata(skillPath) {
-  const metadataPath = path17.join(skillPath, STANDARD_FILES.METADATA_YAML);
+  const metadataPath = path18.join(skillPath, STANDARD_FILES.METADATA_YAML);
   if (!await fileExists(metadataPath)) {
     return null;
   }
@@ -2927,7 +3200,7 @@ async function readSkillMetadata(skillPath) {
     const content = await readFile(metadataPath);
     const lines = content.split("\n");
     const yamlContent = lines[0]?.startsWith("# yaml-language-server:") ? lines.slice(1).join("\n") : content;
-    const result = skillMetadataLoaderSchema.safeParse(parseYaml6(yamlContent));
+    const result = skillMetadataLoaderSchema.safeParse(parseYaml7(yamlContent));
     if (!result.success) {
       warn(`Invalid metadata.yaml at '${skillPath}': ${formatZodErrors(result.error.issues)}`);
       return null;
@@ -2976,8 +3249,8 @@ function generateReadme(skillName, frontmatter, metadata) {
 }
 async function compileSkillPlugin(options) {
   const { skillPath, outputDir, skillName: overrideName } = options;
-  const dirBasename = path17.basename(skillPath);
-  const skillMdPath = path17.join(skillPath, STANDARD_FILES.SKILL_MD);
+  const dirBasename = path18.basename(skillPath);
+  const skillMdPath = path18.join(skillPath, STANDARD_FILES.SKILL_MD);
   if (!await fileExists(skillMdPath)) {
     throw new Error(
       `Skill '${dirBasename}' is missing required ${STANDARD_FILES.SKILL_MD} file. Expected at: ${skillMdPath}`
@@ -2993,8 +3266,8 @@ async function compileSkillPlugin(options) {
   const skillName = overrideName ?? sanitizeSkillName(frontmatter.name);
   verbose(`Compiling skill plugin: ${skillName} from ${skillPath}`);
   const metadata = await readSkillMetadata(skillPath);
-  const pluginDir = path17.join(outputDir, skillName);
-  const skillsDir = path17.join(pluginDir, "skills", skillName);
+  const pluginDir = path18.join(outputDir, skillName);
+  const skillsDir = path18.join(pluginDir, "skills", skillName);
   await ensureDir(pluginDir);
   await ensureDir(skillsDir);
   const newHash = await computeSkillFolderHash(skillPath);
@@ -3013,26 +3286,26 @@ async function compileSkillPlugin(options) {
   await writePluginManifest(pluginDir, manifest);
   await writeContentHash(pluginDir, contentHash, getPluginManifestPath);
   verbose(`  Wrote plugin.json for ${skillName} (v${version})`);
-  await writeFile(path17.join(skillsDir, STANDARD_FILES.SKILL_MD), skillMdContent);
+  await writeFile(path18.join(skillsDir, STANDARD_FILES.SKILL_MD), skillMdContent);
   verbose(`  Copied ${STANDARD_FILES.SKILL_MD}`);
   for (const fileName of SKILL_CONTENT_FILES) {
     if (fileName === STANDARD_FILES.SKILL_MD) continue;
-    const sourcePath = path17.join(skillPath, fileName);
+    const sourcePath = path18.join(skillPath, fileName);
     if (await fileExists(sourcePath)) {
       const content = await readFile(sourcePath);
-      await writeFile(path17.join(skillsDir, fileName), content);
+      await writeFile(path18.join(skillsDir, fileName), content);
       verbose(`  Copied ${fileName}`);
     }
   }
   for (const dirName of SKILL_CONTENT_DIRS) {
-    const sourceDir = path17.join(skillPath, dirName);
+    const sourceDir = path18.join(skillPath, dirName);
     if (await fileExists(sourceDir)) {
-      await copy(sourceDir, path17.join(skillsDir, dirName));
+      await copy(sourceDir, path18.join(skillsDir, dirName));
       verbose(`  Copied ${dirName}/`);
     }
   }
   const readme = generateReadme(skillName, frontmatter, metadata);
-  await writeFile(path17.join(pluginDir, "README.md"), readme);
+  await writeFile(path18.join(pluginDir, "README.md"), readme);
   verbose("  Generated README.md");
   return {
     pluginPath: pluginDir,
@@ -3044,7 +3317,7 @@ async function compileAllSkillPlugins(skillsDir, outputDir) {
   const results = [];
   const skillMdFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir);
   for (const skillMdFile of skillMdFiles) {
-    const skillPath = path17.join(skillsDir, path17.dirname(skillMdFile));
+    const skillPath = path18.join(skillsDir, path18.dirname(skillMdFile));
     try {
       const result = await compileSkillPlugin({
         skillPath,
@@ -3054,7 +3327,7 @@ async function compileAllSkillPlugins(skillsDir, outputDir) {
       log(`  [OK] ${result.skillName}`);
     } catch (error) {
       const errorMessage = getErrorMessage(error);
-      const dirBasename = path17.basename(skillPath);
+      const dirBasename = path18.basename(skillPath);
       warn(`Failed to compile skill from '${dirBasename}': ${errorMessage}`);
     }
   }
@@ -3070,7 +3343,7 @@ Compiled ${results.length} skill plugins:`);
 
 // src/cli/lib/skills/source-switcher.ts
 init_esm_shims();
-import path18 from "path";
+import path19 from "path";
 function validateSkillId(skillId) {
   if (!isValidSkillId(skillId)) {
     return false;
@@ -3078,19 +3351,19 @@ function validateSkillId(skillId) {
   return !(skillId.includes("\0") || skillId.includes("..") || skillId.includes("/") || skillId.includes("\\"));
 }
 function validatePathBoundary(resolvedPath, expectedParent) {
-  const normalizedPath = path18.resolve(resolvedPath);
-  const normalizedParent = path18.resolve(expectedParent);
-  return normalizedPath.startsWith(normalizedParent + path18.sep);
+  const normalizedPath = path19.resolve(resolvedPath);
+  const normalizedParent = path19.resolve(expectedParent);
+  return normalizedPath.startsWith(normalizedParent + path19.sep);
 }
 async function archiveLocalSkill(projectDir, skillId) {
   if (!validateSkillId(skillId)) {
     warn(`Invalid skill ID for archiving: '${skillId}'`);
     return;
   }
-  const skillsDir = path18.resolve(path18.join(projectDir, LOCAL_SKILLS_PATH));
-  const skillPath = path18.resolve(path18.join(skillsDir, skillId));
-  const archivedDir = path18.resolve(path18.join(skillsDir, ARCHIVED_SKILLS_DIR_NAME));
-  const archivedSkillPath = path18.resolve(path18.join(archivedDir, skillId));
+  const skillsDir = path19.resolve(path19.join(projectDir, LOCAL_SKILLS_PATH));
+  const skillPath = path19.resolve(path19.join(skillsDir, skillId));
+  const archivedDir = path19.resolve(path19.join(skillsDir, ARCHIVED_SKILLS_DIR_NAME));
+  const archivedSkillPath = path19.resolve(path19.join(archivedDir, skillId));
   if (!validatePathBoundary(skillPath, skillsDir) || !validatePathBoundary(archivedSkillPath, archivedDir)) {
     warn(`Skill ID '${skillId}' resolves outside the skills directory.`);
     return;
@@ -3110,10 +3383,10 @@ async function restoreArchivedSkill(projectDir, skillId) {
     warn(`Invalid skill ID for restoring: '${skillId}'`);
     return false;
   }
-  const skillsDir = path18.resolve(path18.join(projectDir, LOCAL_SKILLS_PATH));
-  const skillPath = path18.resolve(path18.join(skillsDir, skillId));
-  const archivedDir = path18.resolve(path18.join(skillsDir, ARCHIVED_SKILLS_DIR_NAME));
-  const archivedSkillPath = path18.resolve(path18.join(archivedDir, skillId));
+  const skillsDir = path19.resolve(path19.join(projectDir, LOCAL_SKILLS_PATH));
+  const skillPath = path19.resolve(path19.join(skillsDir, skillId));
+  const archivedDir = path19.resolve(path19.join(skillsDir, ARCHIVED_SKILLS_DIR_NAME));
+  const archivedSkillPath = path19.resolve(path19.join(archivedDir, skillId));
   if (!validatePathBoundary(skillPath, skillsDir) || !validatePathBoundary(archivedSkillPath, archivedDir)) {
     warn(`Skill ID '${skillId}' resolves outside the skills directory.`);
     return false;
@@ -3133,39 +3406,61 @@ init_esm_shims();
 
 // src/cli/lib/matrix/matrix-loader.ts
 init_esm_shims();
-import { parse as parseYaml7 } from "yaml";
-import path19 from "path";
+import { parse as parseYaml8 } from "yaml";
+import path20 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 = parseYaml8(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 raw = parseYaml8(content);
+  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: [],
@@ -3173,24 +3468,24 @@ 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 = [];
   const metadataFiles = await glob(`**/${STANDARD_FILES.METADATA_YAML}`, skillsDir);
   for (const metadataFile of metadataFiles) {
-    const skillDir = path19.dirname(metadataFile);
-    const skillMdPath = path19.join(skillsDir, skillDir, STANDARD_FILES.SKILL_MD);
-    const metadataPath = path19.join(skillsDir, metadataFile);
+    const skillDir = path20.dirname(metadataFile);
+    const skillMdPath = path20.join(skillsDir, skillDir, STANDARD_FILES.SKILL_MD);
+    const metadataPath = path20.join(skillsDir, metadataFile);
     if (!await fileExists(skillMdPath)) {
       verbose(`Skipping ${metadataFile}: No ${STANDARD_FILES.SKILL_MD} found`);
       continue;
     }
     const metadataContent = await readFile(metadataPath);
-    const rawMetadata = parseYaml7(metadataContent);
+    const rawMetadata = parseYaml8(metadataContent);
     const metadataResult = rawMetadataSchema.safeParse(rawMetadata);
     if (!metadataResult.success) {
       warn(
@@ -3205,9 +3500,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;
@@ -3217,14 +3512,8 @@ 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 } : {}
@@ -3271,25 +3560,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,
@@ -3382,41 +3682,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
   };
 }
@@ -3438,26 +3745,31 @@ function initializeSelectionContext(currentSelections, matrix) {
   const selectedSet = new Set(resolvedSelections);
   return { resolvedSelections, selectedSet };
 }
-function isDisabled(skillId, currentSelections, matrix, options) {
-  if (options?.expertMode) {
-    return false;
-  }
+function isDiscouraged(skillId, currentSelections, matrix) {
   const fullId = resolveAlias(skillId, matrix);
   const skill = matrix.skills[fullId];
   if (!skill) {
     return false;
   }
-  for (const selectedId of currentSelections) {
-    const selectedFullId = resolveAlias(selectedId, matrix);
-    if (skill.conflictsWith.some((c) => c.skillId === selectedFullId)) {
+  const { resolvedSelections, selectedSet } = initializeSelectionContext(currentSelections, matrix);
+  for (const selectedId of resolvedSelections) {
+    const selectedSkill = matrix.skills[selectedId];
+    if (selectedSkill?.discourages.some((d) => d.skillId === fullId)) {
+      return true;
+    }
+    if (skill.discourages.some((d) => d.skillId === selectedId)) {
+      return true;
+    }
+  }
+  for (const selectedId of resolvedSelections) {
+    if (skill.conflictsWith.some((c) => c.skillId === selectedId)) {
       return true;
     }
-    const selectedSkill = matrix.skills[selectedFullId];
+    const selectedSkill = matrix.skills[selectedId];
     if (selectedSkill?.conflictsWith.some((c) => c.skillId === fullId)) {
       return true;
     }
   }
-  const { selectedSet } = initializeSelectionContext(currentSelections, matrix);
   for (const requirement of skill.requires) {
     if (requirement.needsAny) {
       const hasAny = requirement.skillIds.some((reqId) => selectedSet.has(reqId));
@@ -3473,13 +3785,26 @@ function isDisabled(skillId, currentSelections, matrix, options) {
   }
   return false;
 }
-function getDisableReason(skillId, currentSelections, matrix) {
+function getDiscourageReason(skillId, currentSelections, matrix) {
   const fullId = resolveAlias(skillId, matrix);
   const skill = matrix.skills[fullId];
   if (!skill) {
     return void 0;
   }
   const { resolvedSelections, selectedSet } = initializeSelectionContext(currentSelections, matrix);
+  for (const selectedId of resolvedSelections) {
+    const selectedSkill = matrix.skills[selectedId];
+    if (selectedSkill) {
+      const discourage = selectedSkill.discourages.find((d) => d.skillId === fullId);
+      if (discourage) {
+        return discourage.reason;
+      }
+    }
+    const reverseDiscourage = skill.discourages.find((d) => d.skillId === selectedId);
+    if (reverseDiscourage) {
+      return reverseDiscourage.reason;
+    }
+  }
   for (const selectedId of resolvedSelections) {
     const conflict = skill.conflictsWith.find((c) => c.skillId === selectedId);
     if (conflict) {
@@ -3511,46 +3836,6 @@ function getDisableReason(skillId, currentSelections, matrix) {
   }
   return void 0;
 }
-function isDiscouraged(skillId, currentSelections, matrix) {
-  const fullId = resolveAlias(skillId, matrix);
-  const skill = matrix.skills[fullId];
-  if (!skill) {
-    return false;
-  }
-  const { resolvedSelections } = initializeSelectionContext(currentSelections, matrix);
-  for (const selectedId of resolvedSelections) {
-    const selectedSkill = matrix.skills[selectedId];
-    if (selectedSkill?.discourages.some((d) => d.skillId === fullId)) {
-      return true;
-    }
-    if (skill.discourages.some((d) => d.skillId === selectedId)) {
-      return true;
-    }
-  }
-  return false;
-}
-function getDiscourageReason(skillId, currentSelections, matrix) {
-  const fullId = resolveAlias(skillId, matrix);
-  const skill = matrix.skills[fullId];
-  if (!skill) {
-    return void 0;
-  }
-  const { resolvedSelections } = initializeSelectionContext(currentSelections, matrix);
-  for (const selectedId of resolvedSelections) {
-    const selectedSkill = matrix.skills[selectedId];
-    if (selectedSkill) {
-      const discourage = selectedSkill.discourages.find((d) => d.skillId === fullId);
-      if (discourage) {
-        return discourage.reason;
-      }
-    }
-    const reverseDiscourage = skill.discourages.find((d) => d.skillId === selectedId);
-    if (reverseDiscourage) {
-      return reverseDiscourage.reason;
-    }
-  }
-  return void 0;
-}
 function isRecommended(skillId, currentSelections, matrix) {
   const fullId = resolveAlias(skillId, matrix);
   const skill = matrix.skills[fullId];
@@ -3713,7 +3998,7 @@ function validateSelection(selections, matrix) {
     warnings
   };
 }
-function getAvailableSkills(categoryId, currentSelections, matrix, options) {
+function getAvailableSkills(categoryId, currentSelections, matrix) {
   const skillOptions = [];
   const { selectedSet } = initializeSelectionContext(currentSelections, matrix);
   for (const skill of Object.values(matrix.skills)) {
@@ -3721,15 +4006,12 @@ function getAvailableSkills(categoryId, currentSelections, matrix, options) {
     if (skill.category !== categoryId) {
       continue;
     }
-    const disabled = isDisabled(skill.id, currentSelections, matrix, options);
-    const discouraged = !disabled && isDiscouraged(skill.id, currentSelections, matrix);
-    const recommended = !disabled && !discouraged && isRecommended(skill.id, currentSelections, matrix);
+    const discouraged = isDiscouraged(skill.id, currentSelections, matrix);
+    const recommended = !discouraged && isRecommended(skill.id, currentSelections, matrix);
     skillOptions.push({
       id: skill.id,
       displayName: skill.displayName,
       description: skill.description,
-      disabled,
-      disabledReason: disabled ? getDisableReason(skill.id, currentSelections, matrix) : void 0,
       discouraged,
       discouragedReason: discouraged ? getDiscourageReason(skill.id, currentSelections, matrix) : void 0,
       recommended,
@@ -3768,12 +4050,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}'`);
     }
   }
 }
@@ -3821,7 +4106,7 @@ function checkSkillRelationRefs(matrix, issues) {
 
 // src/cli/lib/loading/multi-source-loader.ts
 init_esm_shims();
-import path20 from "path";
+import path21 from "path";
 async function loadSkillsFromAllSources(primaryMatrix, sourceConfig, projectDir, forceRefresh = false, marketplace) {
   const resolvedMarketplace = marketplace ?? sourceConfig.marketplace;
   const isDefaultPublicSource = sourceConfig.source === DEFAULT_SOURCE;
@@ -3910,7 +4195,7 @@ async function tagPublicSourceSkills(matrix, forceRefresh) {
   }
   try {
     const fetchResult = await fetchFromSource(DEFAULT_SOURCE, { forceRefresh });
-    const skillsDir = path20.join(fetchResult.path, SKILLS_DIR_PATH);
+    const skillsDir = path21.join(fetchResult.path, SKILLS_DIR_PATH);
     const publicSkills = await extractAllSkills(skillsDir);
     let matchCount = 0;
     for (const publicSkill of publicSkills) {
@@ -3948,7 +4233,7 @@ async function tagExtraSources(matrix, projectDir, forceRefresh) {
     verbose(`Loading extra source: ${extraSource.name} (${extraSource.url})`);
     try {
       const fetchResult = await fetchFromSource(extraSource.url, { forceRefresh });
-      const skillsDir = path20.join(fetchResult.path, SKILLS_DIR_PATH);
+      const skillsDir = path21.join(fetchResult.path, SKILLS_DIR_PATH);
       const skills = await extractAllSkills(skillsDir);
       let matchCount = 0;
       for (const extractedSkill of skills) {
@@ -3991,7 +4276,7 @@ async function searchExtraSources(alias, configuredSources) {
   for (const source of configuredSources) {
     try {
       const fetchResult = await fetchFromSource(source.url, { forceRefresh: false });
-      const skillsDir = path20.join(fetchResult.path, SKILLS_DIR_PATH);
+      const skillsDir = path21.join(fetchResult.path, SKILLS_DIR_PATH);
       const skills = await extractAllSkills(skillsDir);
       for (const skill of skills) {
         const segments = skill.directoryPath.split("/");
@@ -4029,7 +4314,11 @@ async function loadSkillsMatrixFromSource(options = {}) {
     result = await loadFromRemote(source, sourceConfig, forceRefresh);
   }
   const resolvedProjectDir = projectDir || process.cwd();
-  const localSkillsResult = await discoverLocalSkills(resolvedProjectDir);
+  let localSkillsResult = await discoverLocalSkills(resolvedProjectDir);
+  const homeDir = os6.homedir();
+  if ((!localSkillsResult || localSkillsResult.skills.length === 0) && resolvedProjectDir !== homeDir) {
+    localSkillsResult = await discoverLocalSkills(homeDir);
+  }
   if (localSkillsResult && localSkillsResult.skills.length > 0) {
     verbose(
       `Found ${localSkillsResult.skills.length} local skill(s) in ${localSkillsResult.localSkillsPath}`
@@ -4049,7 +4338,7 @@ async function loadSkillsMatrixFromSource(options = {}) {
 async function loadFromLocal(source, sourceConfig) {
   let skillsPath;
   if (isLocalSource(source)) {
-    skillsPath = path21.isAbsolute(source) ? source : path21.resolve(process.cwd(), source);
+    skillsPath = path22.isAbsolute(source) ? source : path22.resolve(process.cwd(), source);
   } else {
     skillsPath = PROJECT_ROOT;
   }
@@ -4088,47 +4377,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 = path22.join(PROJECT_ROOT, SKILL_CATEGORIES_YAML_PATH);
+  const cliRulesPath = path22.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 = path22.join(basePath, SKILL_CATEGORIES_YAML_PATH);
+  const sourceRulesPath = path22.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);
+  const skillsDir = path22.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) {
@@ -4206,9 +4510,9 @@ function getMarketplaceLabel(sourceResult) {
   }
   return marketplace;
 }
-async function discoverCustomAgentValues(agentsDir, file, parseYaml9, builtinDomains) {
-  const content = await readFile(path21.join(agentsDir, file));
-  const raw = parseYaml9(content);
+async function discoverCustomAgentValues(agentsDir, file, parseYaml10, builtinDomains) {
+  const content = await readFile(path22.join(agentsDir, file));
+  const raw = parseYaml10(content);
   if (raw?.custom !== true) return {};
   const result = {};
   if (typeof raw?.id === "string" && !agentNameSchema.safeParse(raw.id).success) {
@@ -4219,16 +4523,16 @@ async function discoverCustomAgentValues(agentsDir, file, parseYaml9, builtinDom
   }
   return result;
 }
-async function discoverCustomSkillValues(skillsDir, file, parseYaml9, builtinSubcategories, builtinDomains) {
-  const content = await readFile(path21.join(skillsDir, file));
+async function discoverCustomSkillValues(skillsDir, file, parseYaml10, builtinSubcategories, builtinDomains) {
+  const content = await readFile(path22.join(skillsDir, file));
   const frontmatter = parseFrontmatter(content);
   if (!frontmatter) return {};
   const skillId = frontmatter.name;
-  const skillDir = path21.dirname(path21.join(skillsDir, file));
-  const metadataPath = path21.join(skillDir, STANDARD_FILES.METADATA_YAML);
+  const skillDir = path22.dirname(path22.join(skillsDir, file));
+  const metadataPath = path22.join(skillDir, STANDARD_FILES.METADATA_YAML);
   if (!await fileExists(metadataPath)) return {};
   const metadataContent = await readFile(metadataPath);
-  const metadataRaw = parseYaml9(metadataContent);
+  const metadataRaw = parseYaml10(metadataContent);
   if (metadataRaw?.custom !== true) return {};
   const result = {};
   result.skillId = skillId;
@@ -4243,26 +4547,26 @@ async function discoverCustomSkillValues(skillsDir, file, parseYaml9, builtinSub
   return result;
 }
 async function discoverAndExtendFromSource(basePath) {
-  const { parse: parseYaml9 } = await import("yaml");
+  const { parse: parseYaml10 } = 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);
+  const agentsDir = path22.join(basePath, DIRS.agents);
   if (await directoryExists(agentsDir)) {
-    const agentFiles = await glob(`**/${STANDARD_FILES.AGENT_YAML}`, agentsDir);
+    const agentFiles = await glob(`**/${STANDARD_FILES.AGENT_METADATA_YAML}`, agentsDir);
     for (const file of agentFiles) {
       try {
-        const result = await discoverCustomAgentValues(agentsDir, file, parseYaml9, builtinDomains);
+        const result = await discoverCustomAgentValues(agentsDir, file, parseYaml10, builtinDomains);
         if (result.agentName) customAgentNames.push(result.agentName);
         if (result.domain) customDomains.push(result.domain);
       } catch {
       }
     }
   }
-  const skillsDir = path21.join(basePath, DIRS.skills);
+  const skillsDir = path22.join(basePath, DIRS.skills);
   if (await directoryExists(skillsDir)) {
     const skillFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir);
     for (const file of skillFiles) {
@@ -4270,7 +4574,7 @@ async function discoverAndExtendFromSource(basePath) {
         const result = await discoverCustomSkillValues(
           skillsDir,
           file,
-          parseYaml9,
+          parseYaml10,
           builtinSubcategories,
           builtinDomains
         );
@@ -4305,7 +4609,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 ?? [],
@@ -4328,7 +4631,7 @@ function mergeLocalSkillsIntoMatrix(matrix, localResult) {
 
 // src/cli/lib/skills/local-skill-loader.ts
 async function discoverLocalSkills(projectDir) {
-  const localSkillsPath = path22.join(projectDir, LOCAL_SKILLS_PATH);
+  const localSkillsPath = path23.join(projectDir, LOCAL_SKILLS_PATH);
   if (!await directoryExists(localSkillsPath)) {
     verbose(`Local skills directory not found: ${localSkillsPath}`);
     return null;
@@ -4348,9 +4651,9 @@ async function discoverLocalSkills(projectDir) {
   };
 }
 async function extractLocalSkill(localSkillsPath, skillDirName) {
-  const skillDir = path22.join(localSkillsPath, skillDirName);
-  const metadataPath = path22.join(skillDir, STANDARD_FILES.METADATA_YAML);
-  const skillMdPath = path22.join(skillDir, STANDARD_FILES.SKILL_MD);
+  const skillDir = path23.join(localSkillsPath, skillDirName);
+  const metadataPath = path23.join(skillDir, STANDARD_FILES.METADATA_YAML);
+  const skillMdPath = path23.join(skillDir, STANDARD_FILES.SKILL_MD);
   if (!await fileExists(metadataPath)) {
     verbose(`Skipping local skill '${skillDirName}': No metadata.yaml found`);
     return null;
@@ -4360,24 +4663,23 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
     return null;
   }
   const metadataContent = await readFile(metadataPath);
-  const parsed = localRawMetadataSchema.safeParse(parseYaml8(metadataContent));
+  const parsed = localRawMetadataSchema.safeParse(parseYaml9(metadataContent));
   if (!parsed.success) {
-    warn(
+    verbose(
       `Skipping local skill '${skillDirName}': invalid metadata.yaml \u2014 ${formatZodErrors(parsed.error.issues)}`
     );
     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);
   if (!frontmatter) {
-    warn(`Skipping local skill '${skillDirName}': invalid SKILL.md frontmatter`);
+    verbose(`Skipping local skill '${skillDirName}': invalid SKILL.md frontmatter`);
     return null;
   }
   const relativePath = `${LOCAL_SKILLS_PATH}/${skillDirName}/`;
@@ -4394,14 +4696,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
@@ -4518,7 +4814,8 @@ export {
   printCompilationSummary,
   archiveLocalSkill,
   restoreArchivedSkill,
-  loadSkillsMatrix,
+  loadSkillCategories,
+  loadSkillRules,
   extractAllSkills,
   mergeMatrixWithSkills,
   resolveAlias,
@@ -4542,13 +4839,16 @@ export {
   addSource,
   removeSource,
   getSourceSummary,
+  detectProjectInstallation,
   detectInstallation,
   installPluginConfig,
   installLocal,
   getInstallationInfo,
   formatInstallationDisplay,
+  validateAllSchemas,
+  printValidationResults,
   validatePlugin,
   validateAllPlugins,
   printPluginValidationResult
 };
-//# sourceMappingURL=chunk-GFDGYQ6M.js.map
+//# sourceMappingURL=chunk-HMSHB5EQ.js.map