@agents-inc/cli 0.61.0 → 0.64.0

package/dist/{chunk-FWMWWE3X.js → chunk-53URJ5XK.js}

@@ -4,11 +4,17 @@ import {
   loadPluginSkills,
   loadSkillsByIds,
   parseFrontmatter
-} from "./chunk-OCEFD7V6.js";
+} from "./chunk-F3REOP7N.js";
 import {
   typedEntries,
   typedKeys
 } from "./chunk-T4EXUIBY.js";
+import {
+  findSkill,
+  getMatrix,
+  getSkill,
+  useMatrixStore
+} from "./chunk-BKL3DF2Q.js";
 import {
   CATEGORY_VALUES,
   DOMAIN_VALUES,
@@ -52,7 +58,7 @@ import {
   warn,
   warnUnknownFields,
   writeFile
-} from "./chunk-LWXRUR6B.js";
+} from "./chunk-LMZXL5RQ.js";
 import {
   CACHE_DIR,
   CACHE_HASH_LENGTH,
@@ -88,7 +94,7 @@ import {
   STANDARD_FILES,
   YAML_FORMATTING,
   yamlSchemaComment
-} from "./chunk-6OWHQ7HM.js";
+} from "./chunk-EGMQ3SXN.js";
 import {
   defaultCategories,
   defaultRules,
@@ -100,7 +106,7 @@ import {
 
 // src/cli/lib/loading/source-loader.ts
 init_esm_shims();
-import os7 from "os";
+import os9 from "os";
 import path26 from "path";
 import { unique as unique4 } from "remeda";
 
@@ -216,13 +222,17 @@ async function loadGlobalSourceConfig() {
   verbose(`Loaded global config from ${homeDir}`);
   return data;
 }
-async function saveProjectConfig(projectDir, config) {
+async function writeProjectSourceConfig(projectDir, config) {
   const configPath = getProjectConfigPath(projectDir);
   await ensureDir(path2.join(projectDir, CLAUDE_SRC_DIR));
   const cleaned = JSON.parse(JSON.stringify(config));
   const body = JSON.stringify(cleaned, null, 2);
-  const content = `export default ${body};
-`;
+  const content = [
+    `import type { ProjectConfig } from "./config-types";`,
+    ``,
+    `export default ${body} satisfies ProjectConfig;`,
+    ``
+  ].join("\n");
   await writeFile(configPath, content);
   verbose(`Saved project config to ${configPath}`);
 }
@@ -504,13 +514,14 @@ function extractCategoryFromPath(categoryPath) {
   if (categoryPath === "local") return void 0;
   return categoryPath;
 }
-function generateProjectConfigFromSkills(name, selectedSkillIds, matrix, options) {
+function generateProjectConfigFromSkills(name, selectedSkillIds, options) {
+  const matrix = getMatrix();
   const agentList = options?.selectedAgents ? [...options.selectedAgents].sort() : [];
   verbose(
     `generateProjectConfigFromSkills: ${selectedSkillIds.length} skills, matrix has ${typedKeys(matrix.skills).length} entries, agents=[${agentList.join(", ")}]`
   );
   const looked = selectedSkillIds.map((skillId) => {
-    const skill = matrix.skills[skillId];
+    const skill = findSkill(skillId);
     if (!skill) warn(`Skill '${skillId}' NOT FOUND in matrix`);
     return { skillId, skill };
   });
@@ -868,7 +879,7 @@ async function mergeWithExistingConfig(newConfig, context) {
 init_esm_shims();
 async function saveSourceToProjectConfig(projectDir, source) {
   const existing = await loadProjectSourceConfig(projectDir) ?? {};
-  await saveProjectConfig(projectDir, { ...existing, source });
+  await writeProjectSourceConfig(projectDir, { ...existing, source });
 }
 
 // src/cli/lib/configuration/source-manager.ts
@@ -1431,23 +1442,25 @@ function resolveSuggestedStacks() {
 // src/cli/lib/matrix/matrix-resolver.ts
 init_esm_shims();
 import { groupBy } from "remeda";
-function getLabel(skill, fallback) {
-  return skill?.displayName || skill?.id || fallback;
+function getLabel(skill) {
+  return skill.displayName;
 }
-function resolveAlias(skillId, matrix) {
+function resolveAlias(skillId) {
+  const matrix = getMatrix();
   if (matrix.skills[skillId]) return skillId;
   throw new Error(`Unknown skill ID: '${skillId}' \u2014 not found in the matrix`);
 }
-function initializeSelectionContext(currentSelections, matrix) {
-  const resolvedSelections = currentSelections.map((s) => resolveAlias(s, matrix));
+function initializeSelectionContext(currentSelections) {
+  const resolvedSelections = currentSelections.map((s) => resolveAlias(s));
   const selectedSet = new Set(resolvedSelections);
   return { resolvedSelections, selectedSet };
 }
-function isDiscouraged(skillId, currentSelections, matrix) {
-  const fullId = resolveAlias(skillId, matrix);
+function isDiscouraged(skillId, currentSelections) {
+  const matrix = getMatrix();
+  const fullId = resolveAlias(skillId);
   const skill = matrix.skills[fullId];
   if (!skill) return false;
-  const { resolvedSelections, selectedSet } = initializeSelectionContext(currentSelections, matrix);
+  const { resolvedSelections, selectedSet } = initializeSelectionContext(currentSelections);
   for (const selectedId of resolvedSelections) {
     const selectedSkill = matrix.skills[selectedId];
     if (selectedSkill?.discourages.some((d) => d.skillId === fullId)) {
@@ -1481,11 +1494,12 @@ function isDiscouraged(skillId, currentSelections, matrix) {
   }
   return false;
 }
-function getDiscourageReason(skillId, currentSelections, matrix) {
-  const fullId = resolveAlias(skillId, matrix);
+function getDiscourageReason(skillId, currentSelections) {
+  const matrix = getMatrix();
+  const fullId = resolveAlias(skillId);
   const skill = matrix.skills[fullId];
   if (!skill) return void 0;
-  const { resolvedSelections, selectedSet } = initializeSelectionContext(currentSelections, matrix);
+  const { resolvedSelections, selectedSet } = initializeSelectionContext(currentSelections);
   for (const selectedId of resolvedSelections) {
     const selectedSkill = matrix.skills[selectedId];
     if (selectedSkill) {
@@ -1502,14 +1516,13 @@ function getDiscourageReason(skillId, currentSelections, matrix) {
   for (const selectedId of resolvedSelections) {
     const conflict = skill.conflictsWith.find((c) => c.skillId === selectedId);
     if (conflict) {
-      const selectedSkill2 = matrix.skills[selectedId];
-      return `${conflict.reason} (conflicts with ${getLabel(selectedSkill2, selectedId)})`;
+      return `${conflict.reason} (conflicts with ${getLabel(matrix.skills[selectedId])})`;
     }
     const selectedSkill = matrix.skills[selectedId];
     if (selectedSkill) {
       const reverseConflict = selectedSkill.conflictsWith.find((c) => c.skillId === fullId);
       if (reverseConflict) {
-        return `${reverseConflict.reason} (conflicts with ${getLabel(selectedSkill, selectedId)})`;
+        return `${reverseConflict.reason} (conflicts with ${getLabel(selectedSkill)})`;
       }
     }
   }
@@ -1517,21 +1530,28 @@ function getDiscourageReason(skillId, currentSelections, matrix) {
     if (requirement.needsAny) {
       const hasAny = requirement.skillIds.some((reqId) => selectedSet.has(reqId));
       if (!hasAny) {
-        const requiredNames = requirement.skillIds.map((id) => getLabel(matrix.skills[id], id)).join(" or ");
+        const requiredNames = requirement.skillIds.map((id) => {
+          const s = findSkill(id);
+          return s ? getLabel(s) : id;
+        }).join(" or ");
         return `${requirement.reason} (requires ${requiredNames})`;
       }
     } else {
       const missingIds = requirement.skillIds.filter((reqId) => !selectedSet.has(reqId));
       if (missingIds.length > 0) {
-        const missingNames = missingIds.map((id) => getLabel(matrix.skills[id], id)).join(", ");
+        const missingNames = missingIds.map((id) => {
+          const s = findSkill(id);
+          return s ? getLabel(s) : id;
+        }).join(", ");
         return `${requirement.reason} (requires ${missingNames})`;
       }
     }
   }
   return void 0;
 }
-function isRecommended(skillId, currentSelections, matrix) {
-  const fullId = resolveAlias(skillId, matrix);
+function isRecommended(skillId, currentSelections) {
+  const matrix = getMatrix();
+  const fullId = resolveAlias(skillId);
   const skill = matrix.skills[fullId];
   if (!skill) return false;
   if (!skill.isRecommended) {
@@ -1540,7 +1560,7 @@ function isRecommended(skillId, currentSelections, matrix) {
   if (currentSelections.length === 0) {
     return true;
   }
-  const { resolvedSelections } = initializeSelectionContext(currentSelections, matrix);
+  const { resolvedSelections } = initializeSelectionContext(currentSelections);
   if (skill.compatibleWith.length === 0) {
     return true;
   }
@@ -1551,13 +1571,15 @@ function isRecommended(skillId, currentSelections, matrix) {
   }
   return false;
 }
-function getRecommendReason(skillId, _currentSelections, matrix) {
-  const fullId = resolveAlias(skillId, matrix);
+function getRecommendReason(skillId, _currentSelections) {
+  const matrix = getMatrix();
+  const fullId = resolveAlias(skillId);
   const skill = matrix.skills[fullId];
   if (!skill) return void 0;
   return skill.recommendedReason;
 }
-function validateConflicts(resolvedSelections, matrix) {
+function validateConflicts(resolvedSelections) {
+  const matrix = getMatrix();
   const errors = [];
   for (let i = 0; i < resolvedSelections.length; i++) {
     const skillA = matrix.skills[resolvedSelections[i]];
@@ -1568,7 +1590,7 @@ function validateConflicts(resolvedSelections, matrix) {
       if (conflict) {
         errors.push({
           type: "conflict",
-          message: `${getLabel(skillA, skillA.id)} conflicts with ${getLabel(matrix.skills[skillBId], skillBId)}: ${conflict.reason}`,
+          message: `${getLabel(skillA)} conflicts with ${getLabel(matrix.skills[skillBId])}: ${conflict.reason}`,
           skills: [skillA.id, skillBId]
         });
       }
@@ -1576,7 +1598,8 @@ function validateConflicts(resolvedSelections, matrix) {
   }
   return { errors, warnings: [] };
 }
-function validateRequirements(resolvedSelections, selectedSet, matrix) {
+function validateRequirements(resolvedSelections, selectedSet) {
+  const matrix = getMatrix();
   const errors = [];
   for (const skillId of resolvedSelections) {
     const skill = matrix.skills[skillId];
@@ -1587,7 +1610,7 @@ function validateRequirements(resolvedSelections, selectedSet, matrix) {
         if (!hasAny) {
           errors.push({
             type: "missingRequirement",
-            message: `${getLabel(skill, skillId)} requires one of: ${requirement.skillIds.map((id) => getLabel(matrix.skills[id], id)).join(", ")}`,
+            message: `${getLabel(skill)} requires one of: ${requirement.skillIds.map((id) => getLabel(matrix.skills[id])).join(", ")}`,
             skills: [skillId, ...requirement.skillIds]
           });
         }
@@ -1596,7 +1619,7 @@ function validateRequirements(resolvedSelections, selectedSet, matrix) {
         if (missingIds.length > 0) {
           errors.push({
             type: "missingRequirement",
-            message: `${getLabel(skill, skillId)} requires: ${missingIds.map((id) => getLabel(matrix.skills[id], id)).join(", ")}`,
+            message: `${getLabel(skill)} requires: ${missingIds.map((id) => getLabel(getSkill(id))).join(", ")}`,
             skills: [skillId, ...missingIds]
           });
         }
@@ -1605,7 +1628,8 @@ function validateRequirements(resolvedSelections, selectedSet, matrix) {
   }
   return { errors, warnings: [] };
 }
-function validateExclusivity(resolvedSelections, matrix) {
+function validateExclusivity(resolvedSelections) {
+  const matrix = getMatrix();
   const errors = [];
   const validSkills = resolvedSelections.map((skillId) => ({ skillId, skill: matrix.skills[skillId] })).filter((entry) => entry.skill != null);
   const categorySelections = groupBy(validSkills, (entry) => entry.skill.category);
@@ -1616,7 +1640,7 @@ function validateExclusivity(resolvedSelections, matrix) {
       if (category?.exclusive) {
         errors.push({
           type: "categoryExclusive",
-          message: `Category "${category.displayName}" only allows one selection, but multiple selected: ${skillIds.map((id) => getLabel(matrix.skills[id], id)).join(", ")}`,
+          message: `Category "${category.displayName}" only allows one selection, but multiple selected: ${skillIds.map((id) => getLabel(matrix.skills[id])).join(", ")}`,
           skills: skillIds
         });
       }
@@ -1624,7 +1648,8 @@ function validateExclusivity(resolvedSelections, matrix) {
   }
   return { errors, warnings: [] };
 }
-function validateRecommendations(resolvedSelections, selectedSet, matrix) {
+function validateRecommendations(resolvedSelections, selectedSet) {
+  const matrix = getMatrix();
   const warnings = [];
   for (const [, skill] of typedEntries(matrix.skills)) {
     if (!skill) continue;
@@ -1636,13 +1661,14 @@ function validateRecommendations(resolvedSelections, selectedSet, matrix) {
     if (hasConflict) continue;
     warnings.push({
       type: "missing_recommendation",
-      message: `${getLabel(skill, skill.id)} is recommended: ${skill.recommendedReason ?? ""}`,
+      message: `${getLabel(skill)} is recommended: ${skill.recommendedReason ?? ""}`,
       skills: [skill.id]
     });
   }
   return { errors: [], warnings };
 }
-function validateSetupUsage(resolvedSelections, selectedSet, matrix) {
+function validateSetupUsage(resolvedSelections, selectedSet) {
+  const matrix = getMatrix();
   const warnings = [];
   for (const skillId of resolvedSelections) {
     const skill = matrix.skills[skillId];
@@ -1651,7 +1677,7 @@ function validateSetupUsage(resolvedSelections, selectedSet, matrix) {
     if (!hasUsageSkill) {
       warnings.push({
         type: "unused_setup",
-        message: `Setup skill "${getLabel(skill, skillId)}" selected but no corresponding usage skills: ${skill.providesSetupFor.map((id) => getLabel(matrix.skills[id], id)).join(", ")}`,
+        message: `Setup skill "${getLabel(skill)}" selected but no corresponding usage skills: ${skill.providesSetupFor.map((id) => getLabel(matrix.skills[id])).join(", ")}`,
         skills: [skillId, ...skill.providesSetupFor]
       });
     }
@@ -1664,14 +1690,14 @@ function mergeValidationResults(results) {
     warnings: results.flatMap((r) => r.warnings)
   };
 }
-function validateSelection(selections, matrix) {
-  const { resolvedSelections, selectedSet } = initializeSelectionContext(selections, matrix);
+function validateSelection(selections) {
+  const { resolvedSelections, selectedSet } = initializeSelectionContext(selections);
   const { errors, warnings } = mergeValidationResults([
-    validateConflicts(resolvedSelections, matrix),
-    validateRequirements(resolvedSelections, selectedSet, matrix),
-    validateExclusivity(resolvedSelections, matrix),
-    validateRecommendations(resolvedSelections, selectedSet, matrix),
-    validateSetupUsage(resolvedSelections, selectedSet, matrix)
+    validateConflicts(resolvedSelections),
+    validateRequirements(resolvedSelections, selectedSet),
+    validateExclusivity(resolvedSelections),
+    validateRecommendations(resolvedSelections, selectedSet),
+    validateSetupUsage(resolvedSelections, selectedSet)
   ]);
   return {
     valid: errors.length === 0,
@@ -1679,25 +1705,23 @@ function validateSelection(selections, matrix) {
     warnings
   };
 }
-function getAvailableSkills(categoryId, currentSelections, matrix) {
+function getAvailableSkills(categoryId, currentSelections) {
+  const matrix = getMatrix();
   const skillOptions = [];
-  const { selectedSet } = initializeSelectionContext(currentSelections, matrix);
+  const { selectedSet } = initializeSelectionContext(currentSelections);
   for (const skill of Object.values(matrix.skills)) {
     if (!skill) continue;
     if (skill.category !== categoryId) {
       continue;
     }
-    const discouraged = isDiscouraged(skill.id, currentSelections, matrix);
-    const recommended = !discouraged && isRecommended(skill.id, currentSelections, matrix);
+    const discouraged = isDiscouraged(skill.id, currentSelections);
+    const recommended = !discouraged && isRecommended(skill.id, currentSelections);
     skillOptions.push({
       id: skill.id,
-      slug: skill.slug,
-      displayName: skill.displayName,
-      description: skill.description,
       discouraged,
-      discouragedReason: discouraged ? getDiscourageReason(skill.id, currentSelections, matrix) : void 0,
+      discouragedReason: discouraged ? getDiscourageReason(skill.id, currentSelections) : void 0,
       recommended,
-      recommendedReason: recommended ? getRecommendReason(skill.id, currentSelections, matrix) : void 0,
+      recommendedReason: recommended ? getRecommendReason(skill.id, currentSelections) : void 0,
       selected: selectedSet.has(skill.id),
       alternatives: skill.alternatives.map((a) => a.skillId)
     });
@@ -1955,6 +1979,7 @@ async function detectInstallation(projectDir = process.cwd()) {
 
 // src/cli/lib/installation/local-installer.ts
 init_esm_shims();
+import os7 from "os";
 import path19 from "path";
 
 // src/cli/lib/skills/index.ts
@@ -3081,14 +3106,32 @@ async function claudePluginUninstall(pluginName, scope, projectDir) {
 
 // src/cli/lib/configuration/config-writer.ts
 init_esm_shims();
-import os5 from "os";
+import os6 from "os";
 import path18 from "path";
 
 // src/cli/lib/configuration/config-types-writer.ts
 init_esm_shims();
+import os5 from "os";
 import path17 from "path";
 import { unique as unique3 } from "remeda";
 var MULTI_LINE_THRESHOLD = 6;
+async function getGlobalConfigTypesPath() {
+  const globalConfigTypesPath = path17.join(
+    GLOBAL_INSTALL_ROOT,
+    CLAUDE_SRC_DIR,
+    STANDARD_FILES.CONFIG_TYPES_TS
+  );
+  if (await fileExists(globalConfigTypesPath)) {
+    return globalConfigTypesPath;
+  }
+  return null;
+}
+function computeGlobalTypesImportPath(projectDir) {
+  const projectClaudeSrc = path17.join(projectDir, CLAUDE_SRC_DIR);
+  const globalClaudeSrc = path17.join(GLOBAL_INSTALL_ROOT, CLAUDE_SRC_DIR);
+  const relativePath = path17.relative(projectClaudeSrc, globalClaudeSrc);
+  return relativePath.split(path17.sep).join("/");
+}
 var PROJECT_CONFIG_INTERFACE_TEMPLATE = `export type InstallMode = "local" | "plugin" | "mixed";
 
 export type SkillConfig = {
@@ -3150,8 +3193,8 @@ function loadConfigTypesDataInBackground(sourceFlag, projectDir) {
     if (!await directoryExists(claudeSrcDir)) {
       throw new Error(`${CLAUDE_SRC_DIR}/ not found \u2014 run '${CLI_BIN_NAME} init' first`);
     }
-    const { loadSkillsMatrixFromSource: loadSkillsMatrixFromSource2 } = await import("./source-loader-KMEBBZCQ.js");
-    const { loadAllAgents: loadAllAgents2 } = await import("./loader-2O32KKAQ.js");
+    const { loadSkillsMatrixFromSource: loadSkillsMatrixFromSource2 } = await import("./source-loader-O5RMYUBW.js");
+    const { loadAllAgents: loadAllAgents2 } = await import("./loader-4YOZCFIP.js");
     const sourceResult = await loadSkillsMatrixFromSource2({
       sourceFlag,
       projectDir,
@@ -3171,25 +3214,48 @@ function loadConfigTypesDataInBackground(sourceFlag, projectDir) {
 async function regenerateConfigTypes(projectDir, backgroundData, extras) {
   const data = await backgroundData;
   const claudeSrcDir = path17.join(projectDir, CLAUDE_SRC_DIR);
-  const source = generateConfigTypesSource(
-    data.matrix,
-    data.agentNames,
-    data.customAgentNames,
-    extras
-  );
+  const isProjectScope = path17.resolve(projectDir) !== path17.resolve(os5.homedir());
+  const globalConfigTypes = isProjectScope ? await getGlobalConfigTypesPath() : null;
+  let source;
+  if (globalConfigTypes) {
+    source = generateProjectConfigTypesSource({
+      globalTypesImportPath: computeGlobalTypesImportPath(projectDir),
+      projectSkillIds: extras?.extraSkillIds ?? [],
+      projectAgentNames: extras?.extraAgentNames ?? [],
+      projectDomains: extras?.extraDomains ?? []
+    });
+    verbose("Using project config-types.ts that imports from global");
+  } else {
+    source = generateConfigTypesSource(data.matrix, data.agentNames, data.customAgentNames, extras);
+  }
   const configTypesPath = path17.join(claudeSrcDir, STANDARD_FILES.CONFIG_TYPES_TS);
   await writeFile(configTypesPath, source);
   verbose(`Regenerated ${STANDARD_FILES.CONFIG_TYPES_TS}`);
 }
-function generateConfigTypesSource(matrix, agentNames, customAgentNames = [], extras) {
+function generateConfigTypesSource(matrix, agentNames, customAgentNames = [], extras, config) {
   const extraSkillIds = extras?.extraSkillIds ?? [];
   const extraAgentNamesArr = extras?.extraAgentNames ?? [];
   const extraDomainsArr = extras?.extraDomains ?? [];
   const extraCategoriesArr = extras?.extraCategories ?? [];
-  const skillIds = unique3([...typedKeys(matrix.skills), ...extraSkillIds]).sort();
-  const sortedAgents = unique3([...agentNames, ...extraAgentNamesArr]).sort();
-  const domains = unique3([...extractDomains(matrix), ...extraDomainsArr]).sort();
-  const categories = unique3([...typedKeys(matrix.categories), ...extraCategoriesArr]).sort();
+  let skillIds;
+  let sortedAgents;
+  let domains;
+  let categories;
+  if (config) {
+    const configSkillIds = config.skills.map((s) => s.id);
+    skillIds = unique3([...configSkillIds, ...extraSkillIds]).sort();
+    const configAgentNames = config.agents.map((a) => a.name);
+    sortedAgents = unique3([...configAgentNames, ...extraAgentNamesArr]).sort();
+    const configCategories = deriveCategories(configSkillIds, matrix);
+    categories = unique3([...configCategories, ...extraCategoriesArr]).sort();
+    const configDomains = deriveDomains(categories, matrix);
+    domains = unique3([...configDomains, ...extraDomainsArr]).sort();
+  } else {
+    skillIds = unique3([...typedKeys(matrix.skills), ...extraSkillIds]).sort();
+    sortedAgents = unique3([...agentNames, ...extraAgentNamesArr]).sort();
+    domains = unique3([...extractDomains(matrix), ...extraDomainsArr]).sort();
+    categories = unique3([...typedKeys(matrix.categories), ...extraCategoriesArr]).sort();
+  }
   const customSkillSet = new Set(extraSkillIds);
   for (const id of typedKeys(matrix.skills)) {
     const skill = matrix.skills[id];
@@ -3248,6 +3314,26 @@ function extractDomains(matrix) {
   }
   return [...domainSet].sort();
 }
+function deriveCategories(skillIds, matrix) {
+  const categorySet = /* @__PURE__ */ new Set();
+  for (const id of skillIds) {
+    const skill = matrix.skills[id];
+    if (skill?.category && skill.category !== "local") {
+      categorySet.add(skill.category);
+    }
+  }
+  return [...categorySet];
+}
+function deriveDomains(categories, matrix) {
+  const domainSet = /* @__PURE__ */ new Set();
+  for (const cat of categories) {
+    const def = matrix.categories[cat];
+    if (def?.domain) {
+      domainSet.add(def.domain);
+    }
+  }
+  return [...domainSet];
+}
 function formatSectionedUnion(custom, marketplace) {
   if (custom.length === 0 && marketplace.length === 0) {
     return "string";
@@ -3285,53 +3371,195 @@ function formatUnion(members) {
   }
   return "\n" + quoted.map((q) => `  | ${q}`).join("\n");
 }
+function generateProjectConfigTypesSource(options) {
+  const importPath = `${options.globalTypesImportPath}/config-types`;
+  const skillIdUnion = formatExtendedUnion("GlobalSkillId", options.projectSkillIds);
+  const agentNameUnion = formatExtendedUnion("GlobalAgentName", options.projectAgentNames);
+  const domainUnion = formatExtendedUnion("GlobalDomain", options.projectDomains);
+  const hasProjectCategories = options.projectCategories && options.projectCategories.length > 0;
+  const categoryUnion = hasProjectCategories ? formatExtendedUnion("GlobalCategory", options.projectCategories) : "GlobalCategory";
+  const categoryImport = `  Category as GlobalCategory,
+`;
+  return `// AUTO-GENERATED by agentsinc \u2014 DO NOT EDIT
+
+import type {
+  SkillId as GlobalSkillId,
+  AgentName as GlobalAgentName,
+  Domain as GlobalDomain,
+${categoryImport}} from "${importPath}";
+
+export type SkillId = ${skillIdUnion};
+
+export type AgentName = ${agentNameUnion};
+
+export type Domain = ${domainUnion};
+
+export type Category = ${categoryUnion};
+
+${PROJECT_CONFIG_INTERFACE_TEMPLATE}`;
+}
+function formatExtendedUnion(globalTypeName, projectMembers) {
+  if (projectMembers.length === 0) {
+    return globalTypeName;
+  }
+  const sorted = [...projectMembers].sort();
+  const quoted = sorted.map((m) => `"${m}"`);
+  if (quoted.length < MULTI_LINE_THRESHOLD) {
+    return `${globalTypeName} | ${quoted.join(" | ")}`;
+  }
+  return `
+  | ${globalTypeName}
+` + quoted.map((q) => `  | ${q}`).join("\n");
+}
 
 // src/cli/lib/configuration/config-writer.ts
+var EXTRACTED_FIELDS = /* @__PURE__ */ new Set(["skills", "agents", "stack", "domains"]);
 function generateConfigSource(config, options) {
   const serializable = config.stack ? { ...config, stack: compactStackForYaml(config.stack) } : { ...config };
   const cleaned = JSON.parse(JSON.stringify(serializable));
   if (options?.isProjectConfig) {
     return generateProjectConfigWithGlobalImport(cleaned, getGlobalConfigImportPath());
   }
-  const body = JSON.stringify(cleaned, null, 2);
-  return [
-    `import type { ProjectConfig } from "./config-types";`,
-    ``,
-    `export default ${body} satisfies ProjectConfig;`,
-    ``
-  ].join("\n");
+  return generateStandaloneConfig(cleaned);
+}
+function generateStandaloneConfig(cleaned) {
+  const skillsArr = cleaned.skills ?? [];
+  const agentsArr = cleaned.agents ?? [];
+  const stackObj = cleaned.stack;
+  const domainsArr = cleaned.domains ?? [];
+  const hasSkills = skillsArr.length > 0;
+  const hasAgents = agentsArr.length > 0;
+  const hasStack = stackObj != null && Object.keys(stackObj).length > 0;
+  const hasDomains = domainsArr.length > 0;
+  const typeImports = buildTypeImports({ hasSkills, hasAgents, hasStack, hasDomains });
+  const lines = [`import type { ${typeImports} } from "./config-types";`];
+  if (hasSkills) {
+    lines.push(``);
+    const items = skillsArr.map((s) => `  ${JSON.stringify(s)},`).join("\n");
+    lines.push(`const skills: SkillConfig[] = [`);
+    lines.push(items);
+    lines.push(`];`);
+  }
+  if (hasAgents) {
+    lines.push(``);
+    const items = agentsArr.map((a) => `  ${JSON.stringify(a)},`).join("\n");
+    lines.push(`const agents: AgentScopeConfig[] = [`);
+    lines.push(items);
+    lines.push(`];`);
+  }
+  if (hasStack) {
+    lines.push(``);
+    const stackBody = JSON.stringify(stackObj, null, 2);
+    lines.push(`const stack: Partial<Record<AgentName, StackAgentConfig>> = ${stackBody};`);
+  }
+  if (hasDomains) {
+    lines.push(``);
+    const items = domainsArr.map((d) => JSON.stringify(d)).join(", ");
+    lines.push(`const domains: Domain[] = [${items}];`);
+  }
+  const exportFields = [];
+  for (const [key, value] of Object.entries(cleaned)) {
+    if (EXTRACTED_FIELDS.has(key)) {
+      if (key === "skills") {
+        exportFields.push(`  skills${hasSkills ? "" : ": []"},`);
+      } else if (key === "agents") {
+        exportFields.push(`  agents${hasAgents ? "" : ": []"},`);
+      } else if (key === "stack" && hasStack) {
+        exportFields.push(`  stack,`);
+      } else if (key === "domains") {
+        exportFields.push(`  domains${hasDomains ? "" : ": []"},`);
+      }
+    } else {
+      exportFields.push(`  ${JSON.stringify(key)}: ${JSON.stringify(value)},`);
+    }
+  }
+  lines.push(``);
+  lines.push(`export default {`);
+  lines.push(...exportFields);
+  lines.push(`} satisfies ProjectConfig;`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function buildTypeImports(flags) {
+  const types = [];
+  if (flags.hasStack) types.push("AgentName");
+  if (flags.hasAgents) types.push("AgentScopeConfig");
+  if (flags.hasDomains) types.push("Domain");
+  types.push("ProjectConfig");
+  if (flags.hasSkills) types.push("SkillConfig");
+  if (flags.hasStack) types.push("StackAgentConfig");
+  return types.join(", ");
 }
 function generateProjectConfigWithGlobalImport(cleaned, globalImportPath) {
   const importPath = `${globalImportPath}/config`;
-  const skillItems = (cleaned.skills ?? []).map((s) => `    ${JSON.stringify(s)},`).join("\n");
-  const agentItems = (cleaned.agents ?? []).map((a) => `    ${JSON.stringify(a)},`).join("\n");
-  const domainsBlock = cleaned.domains ? `  domains: [...(globalConfig.domains ?? []),
-${cleaned.domains.map((d) => `    ${JSON.stringify(d)},`).join("\n")}
-  ],` : "";
-  const arrayFields = /* @__PURE__ */ new Set(["skills", "agents", "domains", "name"]);
-  const scalarFields = Object.entries(cleaned).filter(([key]) => !arrayFields.has(key)).map(([key, value]) => `  ${JSON.stringify(key)}: ${JSON.stringify(value)},`).join("\n");
-  const tail = (domainsBlock ? `${domainsBlock}
-` : "") + (scalarFields ? `${scalarFields}
-` : "");
-  return `import globalConfig from "${importPath}";
-import type { ProjectConfig } from "./config-types";
-
-export default {
-  ...globalConfig,
-${cleaned.name ? `  name: ${JSON.stringify(cleaned.name)},
-` : ""}  skills: [
-    ...globalConfig.skills,
-${skillItems ? `${skillItems}
-` : ""}  ],
-  agents: [
-    ...globalConfig.agents,
-${agentItems ? `${agentItems}
-` : ""}  ],
-${tail}} satisfies ProjectConfig;
-`;
+  const skillsArr = cleaned.skills ?? [];
+  const agentsArr = cleaned.agents ?? [];
+  const stackObj = cleaned.stack;
+  const domainsArr = cleaned.domains ?? [];
+  const hasProjectDomains = domainsArr.length > 0;
+  const hasStack = stackObj != null && Object.keys(stackObj).length > 0;
+  const typeImports = buildTypeImports({
+    hasSkills: true,
+    // Always present (spread from global)
+    hasAgents: true,
+    // Always present (spread from global)
+    hasStack,
+    hasDomains: hasProjectDomains
+  });
+  const lines = [
+    `import globalConfig from "${importPath}";`,
+    `import type { ${typeImports} } from "./config-types";`
+  ];
+  lines.push(``);
+  const skillItems = skillsArr.map((s) => `  ${JSON.stringify(s)},`).join("\n");
+  lines.push(`const skills: SkillConfig[] = [`);
+  lines.push(`  ...globalConfig.skills,`);
+  if (skillItems) lines.push(skillItems);
+  lines.push(`];`);
+  lines.push(``);
+  const agentItems = agentsArr.map((a) => `  ${JSON.stringify(a)},`).join("\n");
+  lines.push(`const agents: AgentScopeConfig[] = [`);
+  lines.push(`  ...globalConfig.agents,`);
+  if (agentItems) lines.push(agentItems);
+  lines.push(`];`);
+  if (hasStack) {
+    lines.push(``);
+    const stackBody = JSON.stringify(stackObj, null, 2);
+    lines.push(`const stack: Partial<Record<AgentName, StackAgentConfig>> = ${stackBody};`);
+  }
+  if (hasProjectDomains) {
+    lines.push(``);
+    const domainItems = domainsArr.map((d) => `  ${JSON.stringify(d)},`).join("\n");
+    lines.push(`const domains: Domain[] = [`);
+    lines.push(`  ...(globalConfig.domains ?? []),`);
+    if (domainItems) lines.push(domainItems);
+    lines.push(`];`);
+  }
+  const scalarFields = Object.entries(cleaned).filter(([key]) => !EXTRACTED_FIELDS.has(key) && key !== "name").map(([key, value]) => `  ${JSON.stringify(key)}: ${JSON.stringify(value)},`).join("\n");
+  const exportFields = [`  ...globalConfig,`];
+  if (cleaned.name) {
+    exportFields.push(`  name: ${JSON.stringify(cleaned.name)},`);
+  }
+  exportFields.push(`  skills,`);
+  exportFields.push(`  agents,`);
+  if (hasStack) {
+    exportFields.push(`  stack,`);
+  }
+  if (hasProjectDomains) {
+    exportFields.push(`  domains,`);
+  }
+  if (scalarFields) {
+    exportFields.push(scalarFields);
+  }
+  lines.push(``);
+  lines.push(`export default {`);
+  lines.push(...exportFields);
+  lines.push(`} satisfies ProjectConfig;`);
+  lines.push(``);
+  return lines.join("\n");
 }
 function getGlobalConfigImportPath() {
-  return path18.join(os5.homedir(), CLAUDE_SRC_DIR);
+  return path18.join(os6.homedir(), CLAUDE_SRC_DIR);
 }
 function generateBlankGlobalConfigSource() {
   return `import type { ProjectConfig } from "./config-types";
@@ -3358,7 +3586,7 @@ export type Category = never;
 ${PROJECT_CONFIG_INTERFACE_TEMPLATE}`;
 }
 async function ensureBlankGlobalConfig() {
-  const globalConfigDir = path18.join(os5.homedir(), CLAUDE_SRC_DIR);
+  const globalConfigDir = path18.join(os6.homedir(), CLAUDE_SRC_DIR);
   const configPath = path18.join(globalConfigDir, STANDARD_FILES.CONFIG_TS);
   if (await fileExists(configPath)) {
     verbose("Global config already exists, skipping blank creation");
@@ -3375,11 +3603,11 @@ async function ensureBlankGlobalConfig() {
 
 // src/cli/lib/installation/local-installer.ts
 function resolveInstallPaths(projectDir, scope = "project") {
-  const baseDir = scope === "global" ? GLOBAL_INSTALL_ROOT : projectDir;
+  const baseDir = scope === "global" ? os7.homedir() : projectDir;
   return {
     skillsDir: path19.join(baseDir, LOCAL_SKILLS_PATH),
     agentsDir: path19.join(baseDir, CLAUDE_DIR, "agents"),
-    configPath: path19.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_TS)
+    configPath: path19.join(baseDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_TS)
   };
 }
 async function prepareDirectories(paths) {
@@ -3397,13 +3625,13 @@ async function deleteAndCopySkills(skills, sourceResult, projectDir, skillsDir)
   const skillIds = skills.map((s) => s.id);
   return copySkillsToLocalFlattened(skillIds, skillsDir, sourceResult.matrix, sourceResult);
 }
-function buildLocalSkillsMap(copiedSkills, matrix) {
+function buildLocalSkillsMap(copiedSkills) {
   return Object.fromEntries(
-    copiedSkills.filter((cs) => matrix.skills[cs.skillId]).map((cs) => [
+    copiedSkills.filter((cs) => findSkill(cs.skillId)).map((cs) => [
       cs.skillId,
       {
         id: cs.skillId,
-        description: matrix.skills[cs.skillId].description || "",
+        description: findSkill(cs.skillId).description,
         path: cs.destPath,
         content: ""
         // Content not needed for skill references
@@ -3443,12 +3671,7 @@ async function buildLocalConfig(wizardResult, sourceResult) {
   };
   if (wizardResult.selectedStackId) {
     if (loadedStack) {
-      localConfig = generateProjectConfigFromSkills(
-        DEFAULT_PLUGIN_NAME,
-        skillIds,
-        sourceResult.matrix,
-        agentOptions
-      );
+      localConfig = generateProjectConfigFromSkills(DEFAULT_PLUGIN_NAME, skillIds, agentOptions);
       if (localConfig.stack) {
         const stackProperty = buildStackProperty(loadedStack);
         for (const [agentId, agentConfig] of typedEntries(stackProperty)) {
@@ -3481,12 +3704,7 @@ async function buildLocalConfig(wizardResult, sourceResult) {
       );
     }
   } else {
-    localConfig = generateProjectConfigFromSkills(
-      DEFAULT_PLUGIN_NAME,
-      skillIds,
-      sourceResult.matrix,
-      agentOptions
-    );
+    localConfig = generateProjectConfigFromSkills(DEFAULT_PLUGIN_NAME, skillIds, agentOptions);
   }
   verbose(
     `buildLocalConfig result: stack=${localConfig.stack ? Object.keys(localConfig.stack).length + " agents" : "UNDEFINED"}, agents=[${localConfig.agents.map((a) => a.name).join(", ")}], skills=${localConfig.skills.length}`
@@ -3551,12 +3769,76 @@ function buildAgentScopeMap(config) {
   }
   return map;
 }
-async function writeConfigTypes(configPath, matrix, agents) {
+async function writeStandaloneConfigTypes(configPath, matrix, agents, finalConfig) {
   const typesPath = path19.join(path19.dirname(configPath), STANDARD_FILES.CONFIG_TYPES_TS);
   const customAgentNames = typedKeys(agents).filter((name) => agents[name]?.custom === true);
-  const source = generateConfigTypesSource(matrix, typedKeys(agents), customAgentNames);
+  const source = generateConfigTypesSource(
+    matrix,
+    typedKeys(agents),
+    customAgentNames,
+    void 0,
+    finalConfig
+  );
   await writeFile(typesPath, source);
 }
+async function writeProjectConfigTypes(projectConfigPath, projectDir, projectConfig, matrix) {
+  const typesPath = path19.join(path19.dirname(projectConfigPath), STANDARD_FILES.CONFIG_TYPES_TS);
+  const projectClaudeSrc = path19.join(projectDir, CLAUDE_SRC_DIR);
+  const globalClaudeSrc = path19.join(os7.homedir(), CLAUDE_SRC_DIR);
+  const relativePath = path19.relative(projectClaudeSrc, globalClaudeSrc);
+  const globalTypesImportPath = relativePath.split(path19.sep).join("/");
+  const projectSkillIds = projectConfig?.skills.map((s) => s.id) ?? [];
+  const projectAgentNames = projectConfig?.agents.map((a) => a.name) ?? [];
+  let projectCategories = [];
+  let projectDomains = [];
+  if (matrix && projectSkillIds.length > 0) {
+    const categorySet = /* @__PURE__ */ new Set();
+    for (const id of projectSkillIds) {
+      const skill = matrix.skills[id];
+      if (skill?.category && skill.category !== "local") {
+        categorySet.add(skill.category);
+      }
+    }
+    projectCategories = [...categorySet].sort();
+    const domainSet = /* @__PURE__ */ new Set();
+    for (const cat of projectCategories) {
+      const def = matrix.categories[cat];
+      if (def?.domain) {
+        domainSet.add(def.domain);
+      }
+    }
+    projectDomains = [...domainSet].sort();
+  }
+  const source = generateProjectConfigTypesSource({
+    globalTypesImportPath,
+    projectSkillIds,
+    projectAgentNames,
+    projectDomains,
+    projectCategories
+  });
+  await writeFile(typesPath, source);
+  verbose("Using project config-types.ts that imports from global");
+}
+async function writeScopedConfigs(finalConfig, matrix, agents, projectDir, projectConfigPath) {
+  const homeDir = os7.homedir();
+  const isProjectContext = path19.resolve(projectDir) !== path19.resolve(homeDir);
+  if (!isProjectContext) {
+    await writeConfigFile(finalConfig, projectConfigPath);
+    await writeStandaloneConfigTypes(projectConfigPath, matrix, agents, finalConfig);
+    return;
+  }
+  const { global: globalConfig, project: projectSplitConfig } = splitConfigByScope(finalConfig);
+  const globalConfigPath = path19.join(homeDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_TS);
+  await ensureDir(path19.dirname(globalConfigPath));
+  await writeConfigFile(globalConfig, globalConfigPath);
+  verbose(`Updated global config at ${globalConfigPath}`);
+  await writeStandaloneConfigTypes(globalConfigPath, matrix, agents, globalConfig);
+  verbose("Updated global config-types.ts with actual types");
+  await ensureDir(path19.dirname(projectConfigPath));
+  await writeConfigFile(projectSplitConfig, projectConfigPath, { isProjectConfig: true });
+  verbose(`Updated project config at ${projectConfigPath}`);
+  await writeProjectConfigTypes(projectConfigPath, projectDir, finalConfig, matrix);
+}
 async function compileAndWriteAgents(compileConfig, agents, localSkills, sourceResult, projectDir, agentsDir, installMode, agentScopeMap) {
   const engine = await createLiquidEngine(projectDir);
   const resolvedAgents = await resolveAgents(
@@ -3565,7 +3847,7 @@ async function compileAndWriteAgents(compileConfig, agents, localSkills, sourceR
     compileConfig,
     sourceResult.sourcePath
   );
-  const globalAgentsDir = path19.join(GLOBAL_INSTALL_ROOT, CLAUDE_DIR, "agents");
+  const globalAgentsDir = path19.join(os7.homedir(), CLAUDE_DIR, "agents");
   const compiledAgentNames = [];
   for (const [name, agent] of typedEntries(resolvedAgents)) {
     const output = await compileAgentForPlugin(
@@ -3587,14 +3869,22 @@ async function compileAndWriteAgents(compileConfig, agents, localSkills, sourceR
 }
 async function installPluginConfig(options) {
   const { wizardResult, sourceResult, projectDir, sourceFlag } = options;
-  const paths = resolveInstallPaths(projectDir);
-  await ensureDir(paths.agentsDir);
-  await ensureDir(path19.dirname(paths.configPath));
+  const projectPaths = resolveInstallPaths(projectDir, "project");
+  const hasProjectAgents = wizardResult.skills.some((s) => s.scope !== "global") || (wizardResult.agentConfigs ?? []).some((a) => a.scope !== "global");
+  if (hasProjectAgents) {
+    await ensureDir(projectPaths.agentsDir);
+  }
+  await ensureDir(path19.dirname(projectPaths.configPath));
   const agents = await loadMergedAgents(sourceResult.sourcePath);
   const mergeResult = await buildAndMergeConfig(wizardResult, sourceResult, projectDir, sourceFlag);
   const finalConfig = mergeResult.config;
-  await writeConfigFile(finalConfig, paths.configPath);
-  await writeConfigTypes(paths.configPath, sourceResult.matrix, agents);
+  await writeScopedConfigs(
+    finalConfig,
+    sourceResult.matrix,
+    agents,
+    projectDir,
+    projectPaths.configPath
+  );
   const compileAgentsConfig = buildCompileAgents(finalConfig, agents);
   const compileConfig = {
     name: DEFAULT_PLUGIN_NAME,
@@ -3612,17 +3902,17 @@ async function installPluginConfig(options) {
     skillsForCompilation,
     sourceResult,
     projectDir,
-    paths.agentsDir,
+    projectPaths.agentsDir,
     deriveInstallMode(finalConfig.skills),
     buildAgentScopeMap(finalConfig)
   );
   return {
     config: finalConfig,
-    configPath: paths.configPath,
+    configPath: projectPaths.configPath,
     compiledAgents: compiledAgentNames,
     wasMerged: mergeResult.merged,
     mergedConfigPath: mergeResult.existingConfigPath,
-    agentsDir: paths.agentsDir
+    agentsDir: projectPaths.agentsDir
   };
 }
 async function installLocal(options) {
@@ -3631,19 +3921,29 @@ async function installLocal(options) {
   const globalPaths = resolveInstallPaths(projectDir, "global");
   const projectSkills = wizardResult.skills.filter((s) => s.scope !== "global");
   const globalSkills = wizardResult.skills.filter((s) => s.scope === "global");
-  await prepareDirectories(projectPaths);
+  const hasProjectItems = projectSkills.length > 0 || (wizardResult.agentConfigs ?? []).some((a) => a.scope !== "global");
+  if (hasProjectItems) {
+    await prepareDirectories(projectPaths);
+  } else {
+    await ensureDir(path19.dirname(projectPaths.configPath));
+  }
   if (globalSkills.length > 0) {
     await ensureDir(globalPaths.skillsDir);
   }
   const projectCopied = projectSkills.length > 0 ? await deleteAndCopySkills(projectSkills, sourceResult, projectDir, projectPaths.skillsDir) : [];
   const globalCopied = globalSkills.length > 0 ? await deleteAndCopySkills(globalSkills, sourceResult, projectDir, globalPaths.skillsDir) : [];
   const copiedSkills = [...projectCopied, ...globalCopied];
-  const localSkillsForResolution = buildLocalSkillsMap(copiedSkills, sourceResult.matrix);
+  const localSkillsForResolution = buildLocalSkillsMap(copiedSkills);
   const agents = await loadMergedAgents(sourceResult.sourcePath);
   const mergeResult = await buildAndMergeConfig(wizardResult, sourceResult, projectDir, sourceFlag);
   const finalConfig = mergeResult.config;
-  await writeConfigFile(finalConfig, projectPaths.configPath);
-  await writeConfigTypes(projectPaths.configPath, sourceResult.matrix, agents);
+  await writeScopedConfigs(
+    finalConfig,
+    sourceResult.matrix,
+    agents,
+    projectDir,
+    projectPaths.configPath
+  );
   const compileAgentsConfig = buildCompileAgents(finalConfig, agents);
   const compileConfig = {
     name: DEFAULT_PLUGIN_NAME,
@@ -3766,7 +4066,7 @@ init_esm_shims();
 // src/cli/lib/plugins/plugin-settings.ts
 init_esm_shims();
 import path21 from "path";
-import os6 from "os";
+import os8 from "os";
 import { z as z2 } from "zod";
 var pluginSettingsSchema = z2.object({
   enabledPlugins: z2.record(z2.string(), z2.unknown()).optional()
@@ -3817,7 +4117,7 @@ async function resolvePluginInstallPaths(pluginKeys, projectDir) {
   if (pluginKeys.length === 0) {
     return [];
   }
-  const registryPath = path21.join(os6.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR, INSTALLED_PLUGINS_FILE);
+  const registryPath = path21.join(os8.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR, INSTALLED_PLUGINS_FILE);
   if (!await fileExists(registryPath)) {
     verbose(`Plugin registry not found at '${registryPath}'`);
     return [];
@@ -4817,7 +5117,7 @@ async function addSource(projectDir, url) {
   }
   sources.push({ name, url });
   config.sources = sources;
-  await saveProjectConfig(projectDir, config);
+  await writeProjectSourceConfig(projectDir, config);
   verbose(`Added source "${name}" with ${skillCount} skills`);
   return { name, skillCount };
 }
@@ -4832,7 +5132,7 @@ async function removeSource(projectDir, name) {
     throw new Error(`Source "${name}" not found`);
   }
   config.sources = filtered;
-  await saveProjectConfig(projectDir, config);
+  await writeProjectSourceConfig(projectDir, config);
   verbose(`Removed source "${name}"`);
 }
 async function getSourceSummary(projectDir) {
@@ -4884,7 +5184,7 @@ async function loadSkillsMatrixFromSource(options = {}) {
   const resolvedProjectDir = projectDir || process.cwd();
   await discoverAndExtendFromLocalSkills(resolvedProjectDir);
   let localSkillsResult = await discoverLocalSkills(resolvedProjectDir);
-  const homeDir = os7.homedir();
+  const homeDir = os9.homedir();
   if ((!localSkillsResult || localSkillsResult.skills.length === 0) && resolvedProjectDir !== homeDir) {
     await discoverAndExtendFromLocalSkills(homeDir);
     localSkillsResult = await discoverLocalSkills(homeDir);
@@ -4905,6 +5205,7 @@ async function loadSkillsMatrixFromSource(options = {}) {
     );
   }
   checkMatrixHealth(result.matrix);
+  useMatrixStore.getState().setMatrix(result.matrix);
   return result;
 }
 async function loadFromLocal(source, sourceConfig) {
@@ -5276,13 +5577,11 @@ export {
   SOURCE_ENV_VAR,
   getProjectConfigPath,
   loadProjectSourceConfig,
-  saveProjectConfig,
   resolveSource,
   resolveAgentsSource,
   formatOrigin,
   resolveAuthor,
   resolveAllSources,
-  splitConfigByScope,
   loadStacks,
   getStackSkillIds,
   loadProjectConfig,
@@ -5306,10 +5605,6 @@ export {
   printCompilationSummary,
   deleteLocalSkill,
   migrateLocalSkillScope,
-  loadSkillCategories,
-  loadSkillRules,
-  extractAllSkills,
-  mergeMatrixWithSkills,
   resolveAlias,
   validateSelection,
   getAvailableSkills,
@@ -5338,13 +5633,14 @@ export {
   getSourceSummary,
   loadConfigTypesDataInBackground,
   regenerateConfigTypes,
+  generateConfigSource,
   ensureBlankGlobalConfig,
   deriveInstallMode,
   detectProjectInstallation,
   detectGlobalInstallation,
   detectInstallation,
   buildAndMergeConfig,
-  writeConfigFile,
+  writeScopedConfigs,
   installPluginConfig,
   installLocal,
   detectMigrations,
@@ -5357,4 +5653,4 @@ export {
   validateAllPlugins,
   printPluginValidationResult
 };
-//# sourceMappingURL=chunk-FWMWWE3X.js.map
+//# sourceMappingURL=chunk-53URJ5XK.js.map