agents-inc 0.154.0 → 0.156.0

package/dist/{chunk-CBF4ZYV3.js → chunk-WCAUUBHO.js}

@@ -1,11 +1,8 @@
 #!/usr/bin/env node
 import {
-  AGENT_NAMES,
-  DOMAINS,
   EFFORT_NAMES,
   GlobalPairWriteViolation,
   MODEL_NAMES,
-  SKILL_IDS,
   agentFrontmatterValidationSchema,
   assertGateToken,
   copy,
@@ -17,7 +14,11 @@ import {
   formatZodIssues,
   getErrorMessage,
   glob,
+  isAgentName,
   isPathWithin,
+  isRecord,
+  isSkillAssignment,
+  isSkillId,
   listDirectories,
   loadAllAgents,
   loadPluginSkills,
@@ -48,15 +49,17 @@ import {
   warnUnknownFields,
   withGateToken,
   writeFile
-} from "./chunk-4VCWL2IG.js";
+} from "./chunk-XAXJWXI4.js";
 import {
   BUILT_IN_MATRIX,
   allSkills,
+  byCategoryDeclarationOrder,
+  getCategoryDomain,
   getSkillById,
   hasSkill,
   initializeMatrix,
   matrix
-} from "./chunk-IPJOMAWC.js";
+} from "./chunk-RWOYPOMR.js";
 import {
   typedEntries,
   typedFromEntries,
@@ -94,6 +97,7 @@ import {
   PLUGIN_MANIFEST_DIR,
   PLUGIN_MANIFEST_FILE,
   PROJECT_ROOT,
+  PUBLIC_CATALOGUE_PACKAGE,
   SCHEMA_PATHS,
   SKILLS_DIR_PATH,
   SKILL_CATEGORIES_PATH,
@@ -103,8 +107,9 @@ import {
   STANDARD_DIRS,
   STANDARD_FILES,
   YAML_FORMATTING,
+  editorConfigUrl,
   marketplaceManifestPath
-} from "./chunk-R54KIGN2.js";
+} from "./chunk-IO5YBKHV.js";
 import {
   defaultCategories,
   defaultRules,
@@ -113,8 +118,8 @@ import {
 
 // src/cli/lib/loading/source-loader.ts
 import os15 from "os";
-import { unique as unique5 } from "remeda";
-import path26 from "path";
+import { unique as unique7 } from "remeda";
+import path28 from "path";
 
 // src/cli/lib/installation/is-home-directory.ts
 import fs from "fs";
@@ -137,17 +142,15 @@ var METADATA_KEYS = {
   USAGE_GUIDANCE: "usageGuidance"
 };
 var LOCAL_DEFAULTS = {
-  // Boundary cast: deliberately outside the generated Category union — scaffold
-  // placeholder written into starter files for the user to replace
-  CATEGORY: "dummy-category",
-  AUTHOR: "@dummy-author",
-  DOMAIN: "dummy"
+  AUTHOR: "@dummy-author"
 };
 var SKILL_CONTENT_FILES = [STANDARD_FILES.SKILL_MD, STANDARD_FILES.REFERENCE_MD];
 var SKILL_CONTENT_DIRS = [STANDARD_DIRS.EXAMPLES, STANDARD_DIRS.SCRIPTS];
 
 // src/cli/lib/configuration/config.ts
 import os3 from "os";
+import path3 from "path";
+import { z } from "zod";
 
 // src/cli/lib/configuration/config-loader.ts
 import path from "path";
@@ -157,12 +160,41 @@ var CONFIG_EXPORTS_PATH = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
   "../../config-exports.ts"
 );
+var ConfigSchemaError = class extends Error {
+  constructor(configPath, issues) {
+    super(`Config validation failed at '${configPath}': ${issues}`);
+    this.configPath = configPath;
+    this.issues = issues;
+    this.name = "ConfigSchemaError";
+  }
+  configPath;
+  issues;
+};
+var ConfigDefaultExportError = class extends Error {
+  constructor(configPath) {
+    super(`Config at '${configPath}' has no default export`);
+    this.configPath = configPath;
+    this.name = "ConfigDefaultExportError";
+  }
+  configPath;
+};
+var ES_MODULE_MARKER = "__esModule";
+function unwrapDefaultExport(namespace) {
+  if (isRecord(namespace) && namespace.default !== void 0) return namespace.default;
+  return namespace;
+}
+function declaresNoDefaultExport(namespace) {
+  return isRecord(namespace) && ES_MODULE_MARKER in namespace && !("default" in namespace);
+}
+function exportsNothing(value) {
+  return value == null || typeof value === "object" && Object.keys(value).length === 0;
+}
 async function loadConfig(configPath, schema) {
   if (!await fileExists(configPath)) {
     verbose(`Config not found at ${configPath}`);
     return null;
   }
-  let raw;
+  let namespace;
   try {
     const jiti = createJiti(import.meta.url, {
       moduleCache: false,
@@ -177,22 +209,24 @@ async function loadConfig(configPath, schema) {
         "@agents-inc/cli/config": CONFIG_EXPORTS_PATH
       }
     });
-    raw = await jiti.import(configPath, { default: true });
+    namespace = await jiti.import(configPath);
   } catch (error) {
     throw new Error(`Failed to load config from '${configPath}': ${getErrorMessage(error)}`, {
       cause: error
     });
   }
-  if (raw == null || typeof raw === "object" && Object.keys(raw).length === 0) {
-    verbose(`Config at ${configPath} has no default export`);
+  const raw = unwrapDefaultExport(namespace);
+  if (exportsNothing(raw)) {
+    verbose(`Config at ${configPath} exports nothing`);
     return null;
   }
+  if (declaresNoDefaultExport(namespace)) {
+    throw new ConfigDefaultExportError(configPath);
+  }
   if (schema) {
     const result = schema.safeParse(raw);
     if (!result.success) {
-      throw new Error(
-        `Config validation failed at '${configPath}': ${formatZodIssues(result.error.issues)}`
-      );
+      throw new ConfigSchemaError(configPath, formatZodIssues(result.error.issues));
     }
     return result.data;
   }
@@ -219,7 +253,7 @@ function resolveInstallPaths(projectDir, scope = "project") {
 
 // src/cli/lib/configuration/config.ts
 var DEFAULT_SOURCE = `${GITHUB_SOURCE.GITHUB_PREFIX}agents-inc/skills`;
-var SOURCE_ENV_VAR = "CC_SOURCE";
+var SOURCE_ENV_VAR = "CC_MARKETPLACE";
 async function loadSourceConfig(dir, scope) {
   const scopeLabel = scope === "project" ? "Project" : "Global";
   const configPath = getProjectConfigPath(dir);
@@ -231,7 +265,9 @@ async function loadSourceConfig(dir, scope) {
   try {
     data = await loadConfig(configPath, projectSourceConfigSchema);
   } catch (error) {
-    verbose(`Failed to load ${scope} source config at ${configPath}: ${getErrorMessage(error)}`);
+    if (error instanceof ConfigSchemaError || error instanceof ConfigDefaultExportError)
+      throw error;
+    verbose(`Failed to load ${scope} config at ${configPath}: ${getErrorMessage(error)}`);
     return null;
   }
   if (!data) return null;
@@ -258,33 +294,33 @@ async function loadOwnProjectSourceConfig(projectDir) {
 async function resolveSource(request) {
   const { caller, flag, projectDir } = request;
   const effective = await loadEffectiveSourceConfig(projectDir);
-  const marketplace = effective?.config.marketplace;
-  const marketplaceLabel = marketplace !== void 0 && { marketplace };
+  const marketplaceName = effective?.config.marketplaceName;
+  const marketplaceLabel = marketplaceName !== void 0 && { marketplace: marketplaceName };
   if (flag !== void 0) {
     assertNamedSourceUsable(flag);
-    verbose(`Source named by this run: ${flag}`);
+    verbose(`Marketplace named by this run: ${flag}`);
     return { source: flag, sourceOrigin: "flag", ...marketplaceLabel };
   }
   const envSource = caller === "init" ? readEnvSource() : void 0;
   if (envSource !== void 0) {
     return { source: envSource, sourceOrigin: "env", ...marketplaceLabel };
   }
-  if (effective?.config.source) {
-    verbose(`Source from ${effective.origin} config: ${effective.config.source}`);
+  if (effective?.config.marketplace) {
+    verbose(`Marketplace from ${effective.origin} config: ${effective.config.marketplace}`);
     return {
-      source: effective.config.source,
+      source: effective.config.marketplace,
       sourceOrigin: effective.origin,
       ...marketplaceLabel
     };
   }
-  verbose(`Using default source: ${DEFAULT_SOURCE}`);
+  verbose(`Using default marketplace: ${DEFAULT_SOURCE}`);
   return { source: DEFAULT_SOURCE, sourceOrigin: "default", ...marketplaceLabel };
 }
-var NAMED_SOURCE_LABEL = "The source";
+var NAMED_SOURCE_LABEL = "The marketplace";
 function assertNamedSourceUsable(flag) {
   if (flag.trim() === "") {
     throw new Error(
-      `${NAMED_SOURCE_LABEL} cannot be empty. Provide a valid source: a local directory path or a git repository URL (e.g., './my-skills' or 'https://github.com/user/repo')`
+      `${NAMED_SOURCE_LABEL} cannot be empty. Provide a valid marketplace: a local directory path or a git repository URL (e.g., './my-skills' or 'https://github.com/user/repo')`
     );
   }
   validateSourceFormat(flag.trim(), NAMED_SOURCE_LABEL);
@@ -294,19 +330,19 @@ function readEnvSource() {
   if (!envValue) return void 0;
   const trimmed = envValue.trim();
   if (trimmed === "") {
-    warn(`${SOURCE_ENV_VAR} is set but empty \u2014 ignoring and falling back to next source.`);
+    warn(`${SOURCE_ENV_VAR} is set but empty \u2014 ignoring and falling back to the next rung.`);
     return void 0;
   }
   try {
     validateSourceFormat(trimmed, SOURCE_ENV_VAR);
   } catch (error) {
     warn(
-      `${SOURCE_ENV_VAR} has an invalid value \u2014 ignoring and falling back to next source.
+      `${SOURCE_ENV_VAR} has an invalid value \u2014 ignoring and falling back to the next rung.
 ${getErrorMessage(error)}`
     );
     return void 0;
   }
-  verbose(`Source from ${SOURCE_ENV_VAR} env var: ${trimmed}`);
+  verbose(`Marketplace from ${SOURCE_ENV_VAR} env var: ${trimmed}`);
   return trimmed;
 }
 async function resolvePrimarySourceEntry(projectDir) {
@@ -340,7 +376,7 @@ function validateSourceFormat(source, flagName) {
     throw new Error(
       `${flagName} contains invalid characters.
 
-Source values must not contain null bytes.
+Marketplace values must not contain null bytes.
 Examples:
   ${flagName} ./my-skills
   ${flagName} github:user/repo`
@@ -350,7 +386,7 @@ Examples:
     throw new Error(
       `${flagName} value is too long (${source.length} characters, max ${MAX_SOURCE_LENGTH}).
 
-Provide a shorter source path or URL.
+Provide a shorter marketplace path or URL.
 Examples:
   ${flagName} ./my-skills
   ${flagName} github:user/repo`
@@ -379,7 +415,7 @@ Examples:
     throw new Error(
       `${flagName} contains path traversal in URL: "${source}"
 
-Remote source URLs must not contain '..' sequences.
+Remote marketplace URLs must not contain '..' sequences.
 Examples:
   ${flagName} github:user/repo
   ${flagName} https://github.com/user/repo`
@@ -411,7 +447,7 @@ Examples:
     throw new Error(
       `${flagName} points to a private or reserved IP address: "${source}"
 
-Source URLs must not target private network addresses.
+Marketplace URLs must not target private network addresses.
 Use a public hostname instead.
 Examples:
   ${flagName} https://github.com/user/repo
@@ -424,7 +460,7 @@ function validateGitShorthand(source, repoPath, flagName) {
     throw new Error(
       `${flagName} has an invalid repository reference: "${source}"
 
-Git shorthand sources require an owner/repo format.
+Git shorthand marketplaces require an owner/repo format.
 Examples:
   ${flagName} github:user/repo
   ${flagName} gh:organization/skills`
@@ -437,7 +473,7 @@ function validateLocalPath(source, flagName) {
     throw new Error(
       `${flagName} contains invalid characters: "${source}"
 
-Source paths must not contain control characters.
+Marketplace paths must not contain control characters.
 Examples:
   ${flagName} ./my-skills
   ${flagName} /home/user/skills`
@@ -459,6 +495,24 @@ Examples:
 function isDefaultSource(source) {
   return source === DEFAULT_SOURCE;
 }
+var packageIdentitySchema = z.object({ name: z.string() });
+async function isPublicCatalogueCheckout(basePath) {
+  const raw = await readFileOptional(path3.join(basePath, STANDARD_FILES.PACKAGE_JSON));
+  return declaredPackageName(raw) === PUBLIC_CATALOGUE_PACKAGE;
+}
+function declaredPackageName(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const parsed = packageIdentitySchema.safeParse(json);
+  return parsed.success ? parsed.data.name : null;
+}
+async function offersBuiltInStacks(basePath, source) {
+  return isDefaultSource(source) || await isPublicCatalogueCheckout(basePath);
+}
 function isLocalSource(source) {
   if (source.startsWith("/") || source.startsWith(".")) {
     return true;
@@ -467,7 +521,7 @@ function isLocalSource(source) {
   if (!hasRemoteProtocol) {
     if (source.includes("..") || source.includes("~")) {
       throw new Error(
-        `Invalid source path: ${source}. Path traversal patterns like '..' and '~' are not allowed for security reasons. Use absolute paths or remote URLs instead (e.g., '/home/user/skills' or 'https://github.com/user/repo').`
+        `Invalid marketplace path: ${source}. Path traversal patterns like '..' and '~' are not allowed for security reasons. Use absolute paths or remote URLs instead (e.g., '/home/user/skills' or 'https://github.com/user/repo').`
       );
     }
   }
@@ -478,7 +532,7 @@ function isLocalSource(source) {
 import { groupBy as groupBy2, indexBy, partition } from "remeda";
 
 // ../matrix/src/vendor/generated/source-types.ts
-var SKILL_IDS2 = [
+var SKILL_IDS = [
   "ai-infrastructure-huggingface-inference",
   "ai-infrastructure-litellm",
   "ai-infrastructure-modal",
@@ -822,7 +876,7 @@ var CATEGORIES = [
   "web-ui-kit",
   "web-utilities"
 ];
-var DOMAINS2 = [
+var DOMAINS = [
   "ai",
   "api",
   "cli",
@@ -833,7 +887,7 @@ var DOMAINS2 = [
   "shared",
   "web"
 ];
-var AGENT_NAMES2 = [
+var AGENT_NAMES = [
   "agent-summoner",
   "ai-developer",
   "ai-researcher",
@@ -10517,89 +10571,68 @@ var BUILT_IN_MATRIX2 = {
   generatedAt: "build"
 };
 
-// ../matrix/src/schema.ts
-import { z } from "zod";
-
-// ../matrix/src/vendor/matrix.ts
-var MODEL_NAMES2 = ["sonnet", "opus", "haiku", "fable", "inherit"];
-
-// ../matrix/src/schema.ts
-var DomainIdSchema = z.enum(DOMAINS2);
-var SkillIdSchema = z.enum(SKILL_IDS2);
-var CategorySchema = z.enum(CATEGORIES);
-var AgentNameSchema = z.enum(AGENT_NAMES2);
-var ModelNameSchema = z.enum(MODEL_NAMES2);
-var CategoryDefinitionSchema = z.object({
-  id: CategorySchema,
-  displayName: z.string(),
-  description: z.string(),
+// ../matrix/src/built-in-matrix.ts
+import { z as z2 } from "zod";
+var domainIdSchema = z2.enum(DOMAINS);
+var skillIdSchema = z2.enum(SKILL_IDS);
+var categorySchema = z2.enum(CATEGORIES);
+var agentNameSchema = z2.enum(AGENT_NAMES);
+var categoryDefinitionSchema = z2.object({
+  id: categorySchema,
+  displayName: z2.string(),
+  description: z2.string(),
   // Optional in the CLI's type. Present on all 89 built-in categories today; a category without
   // one cannot be placed in the UI, so the read model drops it rather than failing the whole boot.
-  domain: DomainIdSchema.optional(),
-  exclusive: z.boolean(),
-  required: z.boolean(),
-  order: z.number()
+  domain: domainIdSchema.exactOptional(),
+  exclusive: z2.boolean(),
+  required: z2.boolean(),
+  order: z2.number()
 });
-var SkillRelationSchema = z.object({
-  skillId: SkillIdSchema,
-  reason: z.string()
+var skillRelationSchema = z2.object({
+  skillId: skillIdSchema,
+  reason: z2.string()
 });
-var SkillRequirementSchema = z.object({
-  skillIds: z.array(SkillIdSchema),
-  needsAny: z.boolean(),
-  reason: z.string()
+var skillRequirementSchema = z2.object({
+  skillIds: z2.array(skillIdSchema),
+  needsAny: z2.boolean(),
+  reason: z2.string()
 });
-var ResolvedSkillSchema = z.object({
-  id: SkillIdSchema,
-  slug: z.string(),
-  displayName: z.string(),
-  description: z.string(),
-  category: CategorySchema,
-  conflictsWith: z.array(SkillRelationSchema),
-  discourages: z.array(SkillRelationSchema),
-  requires: z.array(SkillRequirementSchema)
+var resolvedSkillSchema = z2.object({
+  id: skillIdSchema,
+  slug: z2.string(),
+  displayName: z2.string(),
+  description: z2.string(),
+  category: categorySchema,
+  conflictsWith: z2.array(skillRelationSchema),
+  discourages: z2.array(skillRelationSchema),
+  requires: z2.array(skillRequirementSchema)
 });
-var ResolvedStackSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  description: z.string(),
+var resolvedStackSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  description: z2.string(),
   // agent id → category id → skill ids. Partial because a stack names the few
   // agents it staffs, not the whole roster; the category keys are the one level
   // nothing here reads, so they stay unvalidated strings.
-  skills: z.partialRecord(
-    AgentNameSchema,
-    z.record(z.string(), z.array(SkillIdSchema))
+  skills: z2.partialRecord(
+    agentNameSchema,
+    z2.record(z2.string(), z2.array(skillIdSchema))
   ),
-  allSkillIds: z.array(SkillIdSchema),
-  philosophy: z.string(),
+  allSkillIds: z2.array(skillIdSchema),
+  philosophy: z2.string(),
   // Never populated by the CLI today; the stack rail groups by it when it appears.
-  group: z.string().optional()
+  group: z2.string().exactOptional()
 });
-var MatrixSchema = z.object({
+var builtInMatrixSchema = z2.object({
   // Stamped into every seed payload so a consumer can explain skipped ids.
-  version: z.string(),
-  categories: z.record(z.string(), CategoryDefinitionSchema),
-  skills: z.record(z.string(), ResolvedSkillSchema),
-  suggestedStacks: z.array(ResolvedStackSchema)
-});
-var AgentDefinitionSchema = z.object({
-  id: AgentNameSchema,
-  title: z.string(),
-  description: z.string(),
-  model: ModelNameSchema.optional(),
-  tools: z.array(z.string()),
-  // Not narrowed here: which roles are sayable is authored in the read model's
-  // preload table, which reads this file — so the check lives where the list
-  // does, in `flavorOf`, rather than being imported back into the boundary.
-  flavor: z.string()
+  version: z2.string(),
+  categories: z2.record(z2.string(), categoryDefinitionSchema),
+  skills: z2.record(z2.string(), resolvedSkillSchema),
+  suggestedStacks: z2.array(resolvedStackSchema)
 });
-var AgentDefinitionsSchema = z.record(
-  z.string(),
-  AgentDefinitionSchema
-);
 
 // ../matrix/src/read-model/source.ts
-var MATRIX = MatrixSchema.parse(BUILT_IN_MATRIX2);
+var MATRIX = builtInMatrixSchema.parse(BUILT_IN_MATRIX2);
 var MATRIX_VERSION = MATRIX.version;
 
 // ../matrix/src/read-model/domains.ts
@@ -10636,7 +10669,7 @@ var DOMAIN_DESCRIPTIONS = {
   meta: "Design patterns, code review, and research methodology",
   shared: "Shared utilities and methodology"
 };
-var DOMAIN_IDS = new Set(DOMAINS2);
+var DOMAIN_IDS = new Set(DOMAINS);
 var isDomain = (domainId) => DOMAIN_IDS.has(domainId);
 var agentDomainOf = (agentId) => {
   const prefix = agentId.split("-")[0];
@@ -10664,7 +10697,7 @@ var toCatalogSkill = (skill, domainId) => ({
   }))
 });
 var placeableCategories = (categories) => Object.values(categories).filter(
-  (category) => category.domain !== void 0
+  (category) => category.domain !== void 0 && isDomain(category.domain)
 );
 var byDomainThenAuthoredOrder = (a, b) => compareDomains(a.domain, b.domain) || a.order - b.order;
 var toCatalogCategory = (category, skills) => ({
@@ -10686,27 +10719,29 @@ var toCatalogDomain = (id, categories) => ({
     0
   )
 });
-var buildCatalog = () => {
+var buildCatalog = (matrix2) => {
   const skillsByCategory = groupBy(
-    Object.values(MATRIX.skills),
+    Object.values(matrix2.skills),
     (skill) => skill.category
   );
-  const categories = placeableCategories(MATRIX.categories).sort(byDomainThenAuthoredOrder).map(
+  const categories = placeableCategories(matrix2.categories).sort(byDomainThenAuthoredOrder).map(
     (category) => toCatalogCategory(category, skillsByCategory.get(category.id) ?? [])
   );
   const domains = [...groupBy(categories, (category) => category.domainId)].sort(([a], [b]) => compareDomains(a, b)).map(([id, domainCategories]) => toCatalogDomain(id, domainCategories));
   const allSkills2 = categories.flatMap((category) => category.skills);
   return {
     domains,
-    skillsById: indexById(allSkills2),
-    categoriesById: indexById(categories),
+    skillsById: byId(allSkills2),
+    categoriesById: byId(categories),
     skillCount: allSkills2.length
   };
 };
-var CATALOG = buildCatalog();
-var CATALOGUED_IDS = new Set(SKILL_IDS2);
-var isSkillId = (skillId) => CATALOGUED_IDS.has(skillId);
-var skillById = (skillId) => isSkillId(skillId) ? CATALOG.skillsById[skillId] : void 0;
+var byId = (items) => Object.fromEntries(items.map((item) => [item.id, item]));
+var CATALOG = buildCatalog(MATRIX);
+var createSkillLookup = (catalog) => (skillId) => catalog.skillsById[skillId];
+var skillById = createSkillLookup(CATALOG);
+var SHIPPED_IDS = new Set(SKILL_IDS);
+var isShippedSkillId = (skillId) => SHIPPED_IDS.has(skillId);
 
 // ../matrix/src/generated/agents.ts
 var AGENT_DEFINITIONS = {
@@ -10874,6 +10909,31 @@ var AGENT_DEFINITIONS = {
   }
 };
 
+// ../matrix/src/built-in-agents.ts
+import { z as z3 } from "zod";
+
+// ../matrix/src/vendor/matrix.ts
+var MODEL_NAMES2 = ["sonnet", "opus", "haiku", "fable", "inherit"];
+
+// ../matrix/src/built-in-agents.ts
+var agentNameSchema2 = z3.enum(AGENT_NAMES);
+var modelNameSchema = z3.enum(MODEL_NAMES2);
+var agentDefinitionSchema = z3.object({
+  id: agentNameSchema2,
+  title: z3.string(),
+  description: z3.string(),
+  model: modelNameSchema.exactOptional(),
+  tools: z3.array(z3.string()),
+  // Not narrowed here: which roles are sayable is authored in the read model's
+  // preload table — so the check lives where the list does, in `flavorOf`,
+  // rather than the list being imported back into the boundary.
+  flavor: z3.string()
+});
+var agentDefinitionsSchema = z3.record(
+  z3.string(),
+  agentDefinitionSchema
+);
+
 // ../matrix/src/read-model/preload-defaults.ts
 var ROLE_FLAVORS = [
   "developer",
@@ -11036,7 +11096,7 @@ var PRELOAD_DEFAULTS = {
   // Shared — carried across every implementation domain
   "shared-security-auth-security": ["developer", "researcher"]
 };
-var KNOWN_SKILL_IDS = new Set(SKILL_IDS2);
+var KNOWN_SKILL_IDS = new Set(SKILL_IDS);
 var KNOWN_AGENT_IDS = new Set(Object.keys(AGENT_DEFINITIONS));
 var LISTABLE_FLAVORS = new Set(ROLE_FLAVORS);
 var assertKnownSkill = (skillId) => {
@@ -11100,7 +11160,7 @@ var toSubAgentGroup = (domainId, agents) => ({
 });
 var buildSubAgentGroups = () => {
   const agents = Object.values(
-    AgentDefinitionsSchema.parse(AGENT_DEFINITIONS)
+    agentDefinitionsSchema.parse(AGENT_DEFINITIONS)
   ).map(toSubAgent);
   return [...groupBy(agents, (agent) => agent.domainId)].sort(([a], [b]) => compareDomains(a, b)).map(([domainId, domainAgents]) => toSubAgentGroup(domainId, domainAgents));
 };
@@ -11108,7 +11168,9 @@ var SUB_AGENT_GROUPS = buildSubAgentGroups();
 var SUB_AGENTS_BY_ID = indexById(
   SUB_AGENT_GROUPS.flatMap((group) => group.agents)
 );
-var ROSTER_IDS = new Set(AGENT_NAMES2);
+var ROSTER_IDS = new Set(AGENT_NAMES);
+var isAgentName2 = (agentId) => ROSTER_IDS.has(agentId);
+var subAgentById = (agentId) => isAgentName2(agentId) ? SUB_AGENTS_BY_ID[agentId] : void 0;
 
 // ../matrix/src/read-model/assignment-defaults.ts
 var ROSTER = SUB_AGENT_GROUPS.flatMap(
@@ -11129,40 +11191,82 @@ var isRoleCraftFor = (skill, agent) => {
   const craft = CRAFT_CATEGORIES_BY_FLAVOR[agent.flavor];
   return craft !== void 0 && craft.includes(skill.categoryId);
 };
-var metaSkillReach = (defaults, skill) => {
-  const rowFlavors = new Set(defaults[skill.id] ?? []);
+var metaSkillReach = (skill, rowFlavors) => {
+  const listedFlavors = new Set(rowFlavors);
   return ROSTER.filter(
-    (agent) => rowFlavors.has(agent.flavor) || isRoleCraftFor(skill, agent)
+    (agent) => listedFlavors.has(agent.flavor) || isRoleCraftFor(skill, agent)
   );
 };
-var targetsOf = (defaults, skill) => {
-  if (skill.domainId === "meta") return metaSkillReach(defaults, skill);
+var targetsOf = (skill, rowFlavors) => {
+  if (skill.domainId === "meta") return metaSkillReach(skill, rowFlavors);
   if (skill.domainId === "shared") return NON_META_ROSTER;
   return implementationDomainReach(skill.domainId);
 };
+var taxonomyOf = (skill) => typeof skill === "string" ? skillById(skill) : skill;
+var shippedIdOf = (catalogued) => catalogued !== void 0 && isShippedSkillId(catalogued.id) ? catalogued.id : void 0;
+var rowFlavorsOf = (defaults, shippedId) => shippedId === void 0 ? [] : defaults[shippedId] ?? [];
 var createAssignmentResolver = (defaults) => {
   const resolveLoad = createLoadStateResolver(defaults);
-  return (skillId) => {
-    const skill = skillById(skillId);
-    if (!skill) return [];
-    return targetsOf(defaults, skill).map((agent) => ({
-      agentId: agent.id,
-      load: resolveLoad({ skillId: skill.id, agentId: agent.id })
-    }));
+  return (skill) => {
+    const taxonomy = taxonomyOf(skill);
+    if (!taxonomy) return [];
+    const shippedId = shippedIdOf(skillById(taxonomy.id));
+    const loadOn = (agentId) => shippedId === void 0 ? "lazy" : resolveLoad({ skillId: shippedId, agentId });
+    return targetsOf(taxonomy, rowFlavorsOf(defaults, shippedId)).map(
+      (agent) => ({ agentId: agent.id, load: loadOn(agent.id) })
+    );
   };
 };
 var resolveAssignment = createAssignmentResolver(PRELOAD_DEFAULTS);
 
 // ../matrix/src/read-model/stacks.ts
-var parsedStacks = MATRIX.suggestedStacks;
-var STACKS = parsedStacks.map((stack) => ({
+var toCatalogStack = (stack) => ({
   id: stack.id,
   name: stack.name,
   description: stack.description,
   philosophy: stack.philosophy,
   ...stack.group !== void 0 && { group: stack.group },
   skillCount: stack.allSkillIds.length
-}));
+});
+var buildStacks = (matrix2) => matrix2.suggestedStacks.map(toCatalogStack);
+var STACKS = buildStacks(MATRIX);
+var rosteredAgents = (stack) => Object.keys(stack.skills).map((agentId) => subAgentById(agentId)).filter((agent) => agent !== void 0).map((agent) => agent.id);
+var toAgentsBySkill = (stack) => {
+  const agentsBySkill = {};
+  for (const agentId of rosteredAgents(stack)) {
+    for (const skillId of Object.values(stack.skills[agentId] ?? {}).flat()) {
+      const agents = agentsBySkill[skillId] ??= [];
+      if (!agents.includes(agentId)) agents.push(agentId);
+    }
+  }
+  return agentsBySkill;
+};
+var toLoadByAgent = (skillId) => new Map(
+  resolveAssignment(skillId).map(({ agentId, load }) => [agentId, load])
+);
+var toAssignmentsBySkill = (stack) => Object.fromEntries(
+  Object.entries(toAgentsBySkill(stack)).map(([skillId, agentIds]) => {
+    const loadByAgent = toLoadByAgent(skillId);
+    return [
+      skillId,
+      agentIds.map((agentId) => ({
+        agentId,
+        load: loadByAgent.get(agentId) ?? "lazy"
+      }))
+    ];
+  })
+);
+var createStackExpander = (matrix2) => (stackId) => {
+  const stack = matrix2.suggestedStacks.find(
+    (candidate) => candidate.id === stackId
+  );
+  if (!stack) return void 0;
+  return {
+    skillIds: stack.allSkillIds,
+    assignmentsBySkill: toAssignmentsBySkill(stack)
+  };
+};
+var expandStack = createStackExpander(MATRIX);
 
 // ../matrix/src/read-model/selection-defaults.ts
 var DEFAULT_SELECTION_OPTIONS = {
@@ -11301,8 +11405,8 @@ var createSelectionSemantics = (catalog) => {
     };
   };
 };
-var shippedFacts = () => ({
-  skills: Object.values(MATRIX.skills).map((skill) => ({
+var catalogFactsOf = (matrix2) => ({
+  skills: Object.values(matrix2.skills).map((skill) => ({
     id: skill.id,
     categoryId: skill.category,
     conflictsWith: skill.conflictsWith.map((relation) => relation.skillId),
@@ -11316,10 +11420,10 @@ var shippedFacts = () => ({
     }))
   })),
   exclusiveCategoryIds: new Set(
-    Object.values(MATRIX.categories).filter((category) => category.exclusive).map((category) => category.id)
+    Object.values(matrix2.categories).filter((category) => category.exclusive).map((category) => category.id)
   )
 });
-var judgeSelection = createSelectionSemantics(shippedFacts());
+var judgeSelection = createSelectionSemantics(catalogFactsOf(MATRIX));
 
 // ../matrix/src/contract/selection-scenarios.ts
 var DISCOURAGED_PAIRS = Object.values(CATALOG.skillsById).flatMap(
@@ -11327,82 +11431,185 @@ var DISCOURAGED_PAIRS = Object.values(CATALOG.skillsById).flatMap(
 );
 
 // ../matrix/src/seed.ts
-import { z as z2 } from "zod";
-var SEED_VERSION = 3;
-var seedModelSchema = z2.enum(["opus", "fable", "sonnet", "haiku"]);
-var seedEffortSchema = z2.enum([
+import { z as z4 } from "zod";
+var SEED_VERSION = 5;
+var seedModelSchema = z4.enum(["opus", "fable", "sonnet", "haiku"]);
+var seedEffortSchema = z4.enum([
   "low",
   "medium",
   "high",
   "xhigh",
   "max"
 ]);
-var seedLoadStateSchema = z2.enum(["lazy", "preloaded"]);
-var seedSkillSchema = z2.object({
-  install: z2.enum(["plugin", "eject"]),
-  scope: z2.enum(["project", "global"]),
+var seedLoadStateSchema = z4.enum(["lazy", "preloaded"]);
+var seedSkillSchema = z4.object({
+  install: z4.enum(["plugin", "eject"]),
+  scope: z4.enum(["project", "global"]),
   // Sub-agent id → load state; presence is assignment. Per (agent, skill),
   // matching the granularity of the CLI's stack config.
-  assignments: z2.record(z2.string(), seedLoadStateSchema)
+  assignments: z4.record(z4.string(), seedLoadStateSchema)
 });
-var seedAgentSchema = z2.object({
-  on: z2.boolean().optional(),
-  model: seedModelSchema.optional(),
-  effort: seedEffortSchema.optional(),
+var seedAgentSchema = z4.object({
+  on: z4.boolean().exactOptional(),
+  model: seedModelSchema.exactOptional(),
+  effort: seedEffortSchema.exactOptional(),
   // Where this agent's front-matter is written: the project, or the user's own
   // ~/.claude. Absent means the shared selection default — `global`, spelled
   // once in `DEFAULT_SELECTION_OPTIONS` — so the resting choice never travels,
   // exactly as a resting model does not.
-  scope: z2.enum(["project", "global"]).optional()
+  scope: z4.enum(["project", "global"]).exactOptional()
 });
-var seedPayloadSchema = z2.object({
-  v: z2.literal(SEED_VERSION),
+var MAX_EXTERNAL_SKILL_BYTES = 262144;
+var SKILL_MANIFEST = "SKILL.md";
+var treeBytes = (files) => {
+  const encoder = new TextEncoder();
+  return Object.values(files).reduce(
+    (total, text) => total + encoder.encode(text).length,
+    0
+  );
+};
+var seedSkillTreeSchema = z4.record(z4.string().min(1), z4.string()).refine((files) => SKILL_MANIFEST in files, {
+  message: `a skill directory must hold ${SKILL_MANIFEST}`
+}).refine((files) => treeBytes(files) <= MAX_EXTERNAL_SKILL_BYTES, {
+  message: `a skill directory may not exceed ${String(MAX_EXTERNAL_SKILL_BYTES)} bytes`
+});
+var seedExternalSkillSchema = z4.object({
+  displayName: z4.string().min(1),
+  description: z4.string(),
+  // A category of the catalogue this payload names — the placement the user
+  // confirmed. Without it the skill has nowhere to render and no sub-agent
+  // reach, which is the whole difference between a catalogue entry and an
+  // orphan section.
+  categoryId: z4.string().min(1),
+  // GitHub's own `owner/name`.
+  repo: z4.string().min(1),
+  // The skill's DIRECTORY within it — `skills/docx`, never the SKILL.md.
+  path: z4.string().min(1),
+  files: seedSkillTreeSchema
+});
+var seedPayloadSchema = z4.object({
+  v: z4.literal(SEED_VERSION),
   // Diagnostics only. A mismatch with the consumer's matrix must not fail the
   // decode — it explains why some ids were skipped.
-  matrixVersion: z2.string(),
-  stackId: z2.string().nullable(),
+  matrixVersion: z4.string(),
+  stackId: z4.string().nullable(),
+  // Where the skills below are fetched from, in the form `--marketplace` takes
+  // one: `github:acme/skills`, a URL, a local path. The ref alone — the name
+  // its manifest gives it is read from the fetched marketplace.json, so
+  // carrying that too would let a payload disagree with the repository it
+  // names. Absent is the default public catalogue, which is why a payload that
+  // installs from it looks exactly as it did before this field existed.
+  marketplace: z4.string().exactOptional(),
   // Sparse — presence is selection, exactly like the web store. `remembered`
   // is deliberately absent: deselected setup never leaves the browser.
-  skills: z2.record(z2.string(), seedSkillSchema),
+  skills: z4.record(z4.string(), seedSkillSchema),
+  // Skill id → its whole directory, for the ids above that no catalogue can
+  // resolve. Keyed by the same id `skills` uses, so a selection reads one map
+  // whichever kind of skill it names. Absent is the ordinary case — a payload
+  // built from the catalogue alone — which is why one looks exactly as it did
+  // before content travelled. Content is the expensive part of a payload, so an
+  // added skill nobody selected has no entry here either.
+  external: z4.record(z4.string(), seedExternalSkillSchema).exactOptional(),
   // Sparse for the same reason: an agent resting on its own catalogue model
   // with no pin has nothing to say, so it has no entry. Presence is a
   // statement, not an install: what installs is decided by assignments and
   // `on: true` alone, so a derived-off agent can still travel its overrides.
   // Only an agent pinned *off* is omitted outright — with the assignment rows
   // naming it, since the sharer's own counts exclude them.
-  agents: z2.record(z2.string(), seedAgentSchema)
+  agents: z4.record(z4.string(), seedAgentSchema)
+});
+
+// ../matrix/src/matrix-schema.ts
+import { z as z5 } from "zod";
+var idSchema = z5.string().min(1);
+var matrixCategorySchema = z5.object({
+  id: idSchema,
+  displayName: z5.string(),
+  description: z5.string(),
+  // Optional in the CLI's type. A category without one cannot be placed in the
+  // UI, so a consumer drops it rather than failing the whole catalogue.
+  domain: z5.string().exactOptional(),
+  exclusive: z5.boolean(),
+  required: z5.boolean(),
+  order: z5.number()
+});
+var skillRelationSchema2 = z5.object({
+  skillId: idSchema,
+  reason: z5.string()
+});
+var skillRequirementSchema2 = z5.object({
+  skillIds: z5.array(idSchema),
+  needsAny: z5.boolean(),
+  reason: z5.string()
+});
+var matrixSkillSchema = z5.object({
+  id: idSchema,
+  slug: z5.string(),
+  displayName: z5.string(),
+  description: z5.string(),
+  category: idSchema,
+  conflictsWith: z5.array(skillRelationSchema2),
+  discourages: z5.array(skillRelationSchema2),
+  requires: z5.array(skillRequirementSchema2)
+});
+var matrixStackSchema = z5.object({
+  id: idSchema,
+  name: z5.string(),
+  description: z5.string(),
+  // agent id → category id → skill ids. A stack names the few agents it staffs
+  // rather than the whole roster, and the agent roster is as marketplace-owned
+  // as the skills are, so neither level is narrowed.
+  skills: z5.record(z5.string(), z5.record(z5.string(), z5.array(idSchema))),
+  allSkillIds: z5.array(idSchema),
+  philosophy: z5.string(),
+  // Never populated by the CLI today; a stack rail groups by it when it appears.
+  group: z5.string().exactOptional()
+});
+var matrixSchema = z5.object({
+  version: z5.string(),
+  categories: z5.record(z5.string(), matrixCategorySchema),
+  skills: z5.record(z5.string(), matrixSkillSchema),
+  suggestedStacks: z5.array(matrixStackSchema)
 });
 
 // ../matrix/src/skill-index.ts
-import { z as z3 } from "zod";
-var skillIndexEntrySchema = z3.object({
+import { z as z6 } from "zod";
+var skillIndexEntrySchema = z6.object({
   // The skill's own name — its frontmatter `name` where there is one, its
   // directory name where there is not. Never empty: a skill with neither is
   // not addressable and does not make it into the index.
-  name: z3.string().min(1),
+  name: z6.string().min(1),
   // Frontmatter `description`, or the SKILL.md's first heading. Empty when the
   // file offers neither, which is a thin result rather than an invalid one.
-  description: z3.string(),
+  description: z6.string(),
   // GitHub's own `owner/name`, so a result can be attributed and fetched
   // without a second lookup.
-  repo: z3.string().min(1),
+  repo: z6.string().min(1),
   // The skill DIRECTORY within that repo — `skills/docx`, not
   // `skills/docx/SKILL.md`. A skill is a directory in every consumer of this
   // index, and the file is only how the directory proves itself.
-  path: z3.string().min(1),
+  path: z6.string().min(1),
   // The repository's star count when the index was built. A property of the
   // repo rather than the skill, repeated per entry because the dialog ranks
   // and badges individual results.
-  stars: z3.number().int().nonnegative()
+  stars: z6.number().int().nonnegative(),
+  // How much the skill's whole DIRECTORY weighs — the sum over its blobs of the
+  // sizes GitHub reported for them in the tree listing the crawl already made,
+  // never a download. Repeated per entry because the cap it is read against is
+  // per skill: `MAX_EXTERNAL_SKILL_BYTES` decides whether one directory can
+  // ride a shared link, and without this number that decision cannot be made
+  // until the consumer has listed the repository itself. Zero is a real answer,
+  // for a directory GitHub reported no sizes for at all.
+  bytes: z6.number().int().nonnegative()
 });
-var skillIndexSchema = z3.object({
+var skillIndexSchema = z6.object({
   // When this index was assembled, as an ISO 8601 instant. The worker's own
   // freshness check reads it, and it is served so a caller can say how old the
   // list is rather than having to guess.
-  builtAt: z3.iso.datetime(),
-  skills: z3.array(skillIndexEntrySchema)
+  builtAt: z6.iso.datetime(),
+  skills: z6.array(skillIndexEntrySchema)
 });
-var skillIndexFreshnessSchema = z3.enum(["fresh", "stale"]);
+var skillIndexFreshnessSchema = z6.enum(["fresh", "stale"]);
 
 // src/cli/lib/configuration/scope-predicates.ts
 function isActiveAt(entry, scope) {
@@ -11431,25 +11638,8 @@ function effectivelyExcludedSkillIds(skills) {
   return new Set(skills.filter((s) => s.excluded && !activeIds.has(s.id)).map((s) => s.id));
 }
 
-// src/cli/utils/type-guards.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isDomain2(value) {
-  return DOMAINS.includes(value);
-}
-function isAgentName(value) {
-  return AGENT_NAMES.includes(value);
-}
-function isSkillId2(value) {
-  return SKILL_IDS.includes(value);
-}
-function isSkillAssignment(value) {
-  if (typeof value !== "object" || value === null) return false;
-  return typeof value.id === "string";
-}
-
 // src/cli/lib/configuration/config-generator.ts
+var MATRIX_SAMPLE_SIZE = 5;
 function extractCategoryFromPath(categoryPath) {
   if (categoryPath === LOCAL_PSEUDO_CATEGORY) return void 0;
   return categoryPath;
@@ -11463,15 +11653,22 @@ function priorLoadState(existingStack, agent, category, skillId) {
   return prior.preloaded === true ? "preloaded" : "lazy";
 }
 function mappedLoadState(skillId, agent) {
-  if (!isSkillId2(skillId) || !isAgentName(agent)) return "lazy";
+  if (!isSkillId(skillId) || !isAgentName(agent)) return "lazy";
   return resolveLoadState({ skillId, agentId: agent });
 }
-function isRelevantPair(skillId, agent) {
-  return resolveAssignment(skillId).some((target) => target.agentId === agent);
+function taxonomyOrIdOf(skillId, category) {
+  const domainId = getCategoryDomain(category);
+  if (domainId === void 0) return skillId;
+  return { id: skillId, domainId, categoryId: category };
+}
+function isRelevantPair(skillId, category, agent) {
+  return resolveAssignment(taxonomyOrIdOf(skillId, category)).some(
+    (target) => target.agentId === agent
+  );
 }
 function isPreservedOrRelevant(agent, category, skillId, inputs) {
   const hasPriorEntry = priorLoadState(inputs.existingStack, agent, category, skillId) !== void 0;
-  return hasPriorEntry || isRelevantPair(skillId, agent);
+  return hasPriorEntry || isRelevantPair(skillId, category, agent);
 }
 function getScopeOrThrow(map, key, kind) {
   const scope = map.get(key);
@@ -11511,12 +11708,8 @@ function toStackAssignment(id, agent, category, inputs) {
   return load === "preloaded" ? { id, preloaded: true } : { id };
 }
 function inCanonicalCategoryOrder(activeSkillsByCategory) {
-  const declarationRank = new Map(
-    typedKeys(matrix.categories).map((category, rank) => [category, rank])
-  );
-  const afterEveryDeclared = declarationRank.size;
-  const rankOf = (category) => declarationRank.get(category) ?? afterEveryDeclared;
-  return [...activeSkillsByCategory].sort(([a], [b]) => rankOf(a) - rankOf(b));
+  const byDeclaration = byCategoryDeclarationOrder();
+  return [...activeSkillsByCategory].sort(([a], [b]) => byDeclaration(a, b));
 }
 function buildAgentStack(agent, inputs) {
   const agentStack = {};
@@ -11541,28 +11734,31 @@ function buildStackForSelection(inputs) {
   return result;
 }
 function resolveValidSkills(selectedSkillIds, skillConfigs) {
-  const looked = selectedSkillIds.map((skillId) => {
-    const skill = matrix.skills[skillId];
-    if (!skill) warn(`Skill '${skillId}' NOT FOUND in matrix`, { suppressInTest: true });
-    return { skillId, skill };
-  });
+  const looked = selectedSkillIds.map((skillId) => ({ skillId, skill: matrix.skills[skillId] }));
   const found = looked.filter(
     (entry) => entry.skill != null
   );
-  const skippedCount = looked.length - found.length;
-  if (skippedCount > 0) {
-    const matrixSample = typedKeys(matrix.skills).slice(0, 5).join(", ");
-    warn(
-      `${skippedCount}/${selectedSkillIds.length} skills not found in matrix. Matrix keys sample: [${matrixSample}]`,
-      { suppressInTest: true }
-    );
-  }
+  const absentSkillIds = looked.filter((entry) => entry.skill == null).map((entry) => entry.skillId);
+  reportAbsentSkills(absentSkillIds);
   const excludedSkillIds = effectivelyExcludedSkillIds(skillConfigs);
   const validSkills = found.map(({ skillId, skill }) => ({
     skillId,
     category: extractCategoryFromPath(skill.category)
   })).filter((entry) => entry.category != null).filter((entry) => !excludedSkillIds.has(entry.skillId));
-  return { validSkills, foundCount: found.length, skippedCount };
+  return { validSkills, foundCount: found.length, skippedCount: absentSkillIds.length };
+}
+function reportAbsentSkills(absentSkillIds) {
+  if (absentSkillIds.length === 0) return;
+  for (const skillId of absentSkillIds) {
+    warn(absentSkillWarning(skillId), { suppressInTest: true });
+  }
+  const matrixSample = typedKeys(matrix.skills).slice(0, MATRIX_SAMPLE_SIZE).join(", ");
+  verbose(
+    `${absentSkillIds.length} skills absent from the matrix. Matrix keys sample: [${matrixSample}]`
+  );
+}
+function absentSkillWarning(skillId) {
+  return `Skill '${skillId}' is not in this marketplace \u2014 it stays in the configuration and no sub-agent is given it. Run '${CLI_INVOKE_COMMAND} update' to refresh the marketplace, or remove it with '${CLI_INVOKE_COMMAND} edit'.`;
 }
 function buildSkillScopeMap(skillConfigs) {
   const [excludedConfigs, activeConfigs] = partition(skillConfigs, (s) => Boolean(s.excluded));
@@ -11632,7 +11828,7 @@ function generateProjectConfigFromSkills(name, selectedSkillIds, options) {
       scopeEligibilityGained: options.scopeEligibilityGained
     }
   });
-  const skills = options?.skillConfigs ?? selectedSkillIds.map((id) => ({ id, scope: "project", source: EJECT_SOURCE }));
+  const skills = options?.skillConfigs ?? selectedSkillIds.map((id) => ({ id, scope: "project", origin: EJECT_SOURCE }));
   const activeAgentConfigs = resolveActiveAgentConfigs(agentList, options?.agentConfigs);
   const excludedAgentConfigs = agentConfigs.filter((ac) => ac.excluded);
   const finalAgentConfigs = [...activeAgentConfigs, ...excludedAgentConfigs];
@@ -11707,7 +11903,7 @@ function splitConfigByScope(config) {
     name: GLOBAL_CONFIG_NAME,
     agents: globalAgents,
     skills: globalSkills,
-    ...Object.keys(globalStack).length > 0 && { stack: globalStack },
+    stack: globalStack,
     ...config.selectedDomains !== void 0 && { selectedDomains: config.selectedDomains }
   };
   const projectConfig = {
@@ -11715,7 +11911,7 @@ function splitConfigByScope(config) {
     name: config.name,
     agents: projectAgents,
     skills: projectSkills,
-    ...Object.keys(projectStack).length > 0 && { stack: projectStack }
+    stack: projectStack
   };
   return { global: globalConfig, project: projectConfig };
 }
@@ -11725,10 +11921,10 @@ import { indexBy as indexBy2, uniqueBy as uniqueBy2 } from "remeda";
 
 // src/cli/lib/configuration/project-config.ts
 import os4 from "os";
-import path4 from "path";
+import path5 from "path";
 
 // src/cli/lib/stacks/stacks-loader.ts
-import path3 from "path";
+import path4 from "path";
 import { flatMap, groupBy as groupBy3, mapValues, partition as partition2, pipe, unique, uniqueBy } from "remeda";
 var stacksCache = /* @__PURE__ */ new Map();
 function normalizeAgentConfig(agentConfig) {
@@ -11788,7 +11984,7 @@ async function loadStacks(configDir, stacksFile) {
   const cacheKey = `${configDir}:${resolvedStacksFile}`;
   const cached = stacksCache.get(cacheKey);
   if (cached) return cached;
-  const stacksPath = path3.join(configDir, resolvedStacksFile);
+  const stacksPath = path4.join(configDir, resolvedStacksFile);
   try {
     const raw = await loadConfig(stacksPath, stacksConfigSchema);
     if (raw == null) {
@@ -11819,8 +12015,10 @@ async function loadStackById(stackId, configDir, source) {
     verbose(`Found stack: ${stack.name} (${stackId})`);
     return stack;
   }
-  if (!isDefaultSource(source)) {
-    verbose(`Source '${source}' does not ship stack '${stackId}', and gets no built-in stand-in`);
+  if (!await offersBuiltInStacks(configDir, source)) {
+    verbose(
+      `Marketplace '${source}' does not ship stack '${stackId}', and gets no built-in stand-in`
+    );
     return null;
   }
   const defaultStack = defaultStacks.find((s) => s.id === stackId) ?? null;
@@ -11907,7 +12105,7 @@ async function loadProjectConfigFromDir(projectDir) {
   }
   const config = {
     ...parsed,
-    name: parsed.name ?? path4.basename(projectDir),
+    name: parsed.name ?? path5.basename(projectDir),
     skills: parsed.skills ?? [],
     agents: parsed.agents ?? [],
     ...normalizedStack && { stack: normalizedStack }
@@ -11976,8 +12174,8 @@ function mergeConfigs(newConfig, existingConfig, options) {
   if (existingConfig.description) {
     merged.description = existingConfig.description;
   }
-  if (existingConfig.source && !newConfig.source) {
-    merged.source = existingConfig.source;
+  if (existingConfig.marketplace && !newConfig.marketplace) {
+    merged.marketplace = existingConfig.marketplace;
   }
   if (existingConfig.agents.length > 0) {
     const newAgentsByKey = indexBy2(merged.agents, agentKey);
@@ -12026,8 +12224,8 @@ function mergeConfigs(newConfig, existingConfig, options) {
   if (existingConfig.agentsSource) {
     merged.agentsSource = existingConfig.agentsSource;
   }
-  if (existingConfig.marketplace) {
-    merged.marketplace = existingConfig.marketplace;
+  if (existingConfig.marketplaceName) {
+    merged.marketplaceName = existingConfig.marketplaceName;
   }
   if (existingConfig.projects && !newConfig.projects) {
     merged.projects = existingConfig.projects;
@@ -12069,12 +12267,26 @@ async function mergeWithExistingConfig(newConfig, context) {
 }
 
 // src/cli/lib/configuration/config-types-writer.ts
-import path5 from "path";
+import path6 from "path";
 import { groupBy as groupBy4, unique as unique2 } from "remeda";
+
+// src/cli/utils/string.ts
+function truncateText(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 1) + "\u2026";
+}
+function toTitleCase(kebabCase) {
+  return kebabCase.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function bytewise(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/cli/lib/configuration/config-types-writer.ts
 var MULTI_LINE_THRESHOLD = 6;
 var EMPTY_UNION_TYPE = "never";
 async function getGlobalConfigTypesPath() {
-  const globalConfigTypesPath = path5.join(
+  const globalConfigTypesPath = path6.join(
     GLOBAL_INSTALL_ROOT,
     CLAUDE_SRC_DIR,
     STANDARD_FILES.CONFIG_TYPES_TS
@@ -12085,10 +12297,10 @@ async function getGlobalConfigTypesPath() {
   return null;
 }
 function computeGlobalTypesImportPath(projectDir) {
-  const projectClaudeSrc = path5.join(projectDir, CLAUDE_SRC_DIR);
-  const globalClaudeSrc = path5.join(GLOBAL_INSTALL_ROOT, CLAUDE_SRC_DIR);
-  const relativePath = path5.relative(projectClaudeSrc, globalClaudeSrc);
-  return relativePath.split(path5.sep).join("/");
+  const projectClaudeSrc = path6.join(projectDir, CLAUDE_SRC_DIR);
+  const globalClaudeSrc = path6.join(GLOBAL_INSTALL_ROOT, CLAUDE_SRC_DIR);
+  const relativePath = path6.relative(projectClaudeSrc, globalClaudeSrc);
+  return relativePath.split(path6.sep).join("/");
 }
 var STACK_AGENT_CONFIG_INLINE_THRESHOLD = 3;
 function formatLiteralUnion(members) {
@@ -12099,7 +12311,7 @@ var PROJECT_CONFIG_TYPES_BEFORE = `export type InstallMode = "eject" | "plugin"
 export type SkillConfig = {
   id: SkillId;
   scope: "project" | "global";
-  source: string;
+  origin: string;
   excluded?: boolean;
 };
 
@@ -12123,7 +12335,7 @@ var PROJECT_CONFIG_INTERFACE_AFTER = `export interface ProjectConfig {
   /** Per-agent configuration with scope */
   agents: AgentScopeConfig[];
 
-  /** Per-skill configuration with scope and source */
+  /** Per-skill configuration with scope and provenance */
   skills: SkillConfig[];
 
   /** Author handle (e.g., "@vince") */
@@ -12132,12 +12344,12 @@ var PROJECT_CONFIG_INTERFACE_AFTER = `export interface ProjectConfig {
   /** Stack configuration: agent -> category -> skill assignment */
   stack?: Partial<Record<ProjectAgentName, StackAgentConfig>>;
 
-  /** Skills source path or URL */
-  source?: string;
-
-  /** Marketplace identifier for plugin installation */
+  /** The marketplace this install reads skills from, as a path or URL */
   marketplace?: string;
 
+  /** The name that marketplace's manifest gives it, which plugins are registered under */
+  marketplaceName?: string;
+
   /** Agents source path or URL (when agents come from a different source than skills) */
   agentsSource?: string;
 
@@ -12184,7 +12396,7 @@ function generateStackAgentConfig(skillsByCategory, matrix2) {
   if (skillsByCategory.size === 0) {
     return STACK_AGENT_CONFIG_LOOSE_LINE;
   }
-  const properties = [...skillsByCategory.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([category, skills]) => {
+  const properties = [...skillsByCategory.entries()].sort(([a], [b]) => bytewise(a, b)).map(([category, skills]) => {
     const arraySuffix = matrix2.categories[category]?.exclusive === true ? "" : "[]";
     return `  "${category}"?: SkillAssignment<${formatSkillUnion(skills)}>${arraySuffix};`;
   });
@@ -12202,22 +12414,27 @@ function buildSkillsByCategory(skillIds, categories, matrix2) {
     ])
   );
 }
-function collectCustomDomains(matrix2, customCategorySet, extraDomains) {
-  const categories = typedKeys(matrix2.categories).map((key) => ({ key, domain: matrix2.categories[key]?.domain })).filter((c) => c.domain !== void 0);
-  const marketplaceDomains = new Set(
-    categories.filter((c) => !customCategorySet.has(c.key)).map((c) => c.domain)
-  );
-  const customOnlyDomains = categories.filter((c) => customCategorySet.has(c.key)).map((c) => c.domain).filter((domain) => !marketplaceDomains.has(domain));
-  return /* @__PURE__ */ new Set([...customOnlyDomains, ...extraDomains]);
+function isUndeclaredCategory(category, matrix2) {
+  return matrix2.categories[category] === void 0;
+}
+function isCustomSkill(skillId, matrix2) {
+  const declared = matrix2.skills[skillId];
+  return declared === void 0 || declared.custom === true;
+}
+function isCustomAgent(agentName, declared, flaggedCustom) {
+  return !declared.has(agentName) || flaggedCustom.has(agentName);
+}
+function isCustomDomain(domain, declared) {
+  return !declared.has(domain);
 }
 async function regenerateConfigTypes(projectDir, backgroundData, extras) {
   if (isHomeDirectory(projectDir)) {
     throw new GlobalPairWriteViolation(
-      path5.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_TYPES_TS)
+      path6.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_TYPES_TS)
     );
   }
   const data = await backgroundData;
-  const claudeSrcDir = path5.join(projectDir, CLAUDE_SRC_DIR);
+  const claudeSrcDir = path6.join(projectDir, CLAUDE_SRC_DIR);
   const isProjectScope = !isHomeDirectory(projectDir);
   const globalConfigTypes = isProjectScope ? await getGlobalConfigTypesPath() : null;
   const loadedConfig = await loadProjectConfigFromDir(projectDir);
@@ -12245,7 +12462,7 @@ async function regenerateConfigTypes(projectDir, backgroundData, extras) {
       loadedConfig?.config
     );
   }
-  const configTypesPath = path5.join(claudeSrcDir, STANDARD_FILES.CONFIG_TYPES_TS);
+  const configTypesPath = path6.join(claudeSrcDir, STANDARD_FILES.CONFIG_TYPES_TS);
   await writeFile(configTypesPath, source);
   verbose(`Regenerated ${STANDARD_FILES.CONFIG_TYPES_TS}`);
 }
@@ -12277,20 +12494,22 @@ function generateConfigTypesSource(matrix2, agentNames, customAgentNames = [], e
     domains = unique2([...extractDomains(matrix2), ...extraDomainsArr]).sort();
     categories = unique2([...typedKeys(matrix2.categories), ...extraCategoriesArr]).sort();
   }
-  const customSkillSet = /* @__PURE__ */ new Set([
-    ...extraSkillIds,
-    ...typedKeys(matrix2.skills).filter((id) => matrix2.skills[id]?.custom === true)
-  ]);
-  const customAgentSet = /* @__PURE__ */ new Set([...customAgentNames, ...extraAgentNamesArr]);
-  const customCategorySet = /* @__PURE__ */ new Set([
-    ...extraCategoriesArr,
-    ...typedKeys(matrix2.skills).map((id) => matrix2.skills[id]).filter((skill) => skill?.custom === true).map((skill) => skill.category).filter(isNonLocalCategory)
-  ]);
-  const customDomainSet = collectCustomDomains(matrix2, customCategorySet, extraDomainsArr);
-  const skillIdLine = formatMaybeSectionedUnion(skillIds, (id) => customSkillSet.has(id));
-  const agentNameLine = formatMaybeSectionedUnion(sortedAgents, (name) => customAgentSet.has(name));
-  const domainLine = formatMaybeSectionedUnion(domains, (d) => customDomainSet.has(d));
-  const categoryLine = formatMaybeSectionedUnion(categories, (s) => customCategorySet.has(s));
+  const declaredAgents = new Set(agentNames);
+  const flaggedCustomAgents = new Set(customAgentNames);
+  const declaredDomains = new Set(extractDomains(matrix2));
+  const skillIdLine = formatMaybeSectionedUnion(skillIds, (id) => isCustomSkill(id, matrix2));
+  const agentNameLine = formatMaybeSectionedUnion(
+    sortedAgents,
+    (name) => isCustomAgent(name, declaredAgents, flaggedCustomAgents)
+  );
+  const domainLine = formatMaybeSectionedUnion(
+    domains,
+    (domain) => isCustomDomain(domain, declaredDomains)
+  );
+  const categoryLine = formatMaybeSectionedUnion(
+    categories,
+    (category) => isUndeclaredCategory(category, matrix2)
+  );
   const selectedAgents = config?.agents ? activeAgentNames(config.agents) : [];
   const selectedAgentNameLine = selectedAgents.length > 0 ? formatUnion(selectedAgents) : "AgentName";
   const projectScopedAgents = config?.agents ? activeProjectAgentNames(config.agents) : [];
@@ -12400,12 +12619,12 @@ function formatExtendedUnion(globalTypeName, projectMembers) {
 }
 
 // src/cli/lib/skills/skill-metadata.ts
-import path7 from "path";
+import path8 from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 
 // src/cli/lib/versioning.ts
 import { createHash } from "crypto";
-import path6 from "path";
+import path7 from "path";
 var ISO_DATE_LENGTH = 10;
 function getCurrentDate() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, ISO_DATE_LENGTH);
@@ -12422,18 +12641,18 @@ async function computeFileHash(filePath) {
 async function computeSkillFolderHash(skillPath) {
   const contents = [];
   for (const fileName of SKILL_CONTENT_FILES) {
-    const filePath = path6.join(skillPath, fileName);
+    const filePath = path7.join(skillPath, fileName);
     if (await fileExists(filePath)) {
       const content = await readFile(filePath);
       contents.push(`${fileName}:${content}`);
     }
   }
   for (const dirName of SKILL_CONTENT_DIRS) {
-    const dirPath = path6.join(skillPath, dirName);
+    const dirPath = path7.join(skillPath, dirName);
     if (await fileExists(dirPath)) {
       const files = await glob("**/*", dirPath);
       for (const file of files.sort()) {
-        const filePath = path6.join(dirPath, file);
+        const filePath = path7.join(dirPath, file);
         const content = await readFile(filePath);
         contents.push(`${dirName}/${file}:${content}`);
       }
@@ -12516,7 +12735,7 @@ async function readForkedFromMetadata(skillDir) {
   return metadata?.forkedFrom ?? null;
 }
 async function readLocalSkillMetadata(skillDir) {
-  const metadataPath = path7.join(skillDir, STANDARD_FILES.METADATA_YAML);
+  const metadataPath = path8.join(skillDir, STANDARD_FILES.METADATA_YAML);
   if (!await fileExists(metadataPath)) {
     return null;
   }
@@ -12528,8 +12747,8 @@ async function readLocalSkillMetadata(skillDir) {
   }
   return result.data;
 }
-async function injectForkedFromMetadata(destPath, skillId, contentHash, source) {
-  const metadataPath = path7.join(destPath, STANDARD_FILES.METADATA_YAML);
+async function injectForkedFromMetadata(destPath, skillId, contentHash, origin = {}) {
+  const metadataPath = path8.join(destPath, STANDARD_FILES.METADATA_YAML);
   const rawContent = await readFile(metadataPath);
   const { yamlContent } = stripYamlSchemaComment(rawContent);
   const parseResult = localSkillMetadataSchema.safeParse(parseYaml(yamlContent));
@@ -12542,7 +12761,8 @@ async function injectForkedFromMetadata(destPath, skillId, contentHash, source)
       skillId,
       contentHash,
       date: getCurrentDate(),
-      ...source ? { source } : {}
+      ...origin.source !== void 0 && { source: origin.source },
+      ...origin.path !== void 0 && { path: origin.path }
     }
   };
   await writeMetadataYaml(metadataPath, metadata, `${yamlSchemaComment(SCHEMA_PATHS.metadata)}
@@ -12554,7 +12774,7 @@ async function writeMetadataYaml(filePath, metadata, schemaComment = "") {
 }
 
 // src/cli/lib/skills/skill-copier.ts
-import path8 from "path";
+import path9 from "path";
 var NULL_BYTE_PATTERN2 = /\0/;
 function validateSkillPath(resolvedPath, expectedParent, skillPath) {
   if (NULL_BYTE_PATTERN2.test(skillPath)) {
@@ -12562,28 +12782,30 @@ function validateSkillPath(resolvedPath, expectedParent, skillPath) {
   }
   if (!isPathWithin(resolvedPath, expectedParent)) {
     throw new Error(
-      `Invalid skill path: '${skillPath}' escapes expected directory '${path8.resolve(expectedParent)}'`
+      `Invalid skill path: '${skillPath}' escapes expected directory '${path9.resolve(expectedParent)}'`
     );
   }
 }
 function resolveSkillPath(basePath, skillPath) {
-  const resolved = path8.join(basePath, skillPath);
+  const resolved = path9.join(basePath, skillPath);
   validateSkillPath(resolved, basePath, skillPath);
   return resolved;
 }
 function getSkillSourcePath(skill, rootDir) {
-  const srcDir = path8.join(rootDir, SOURCE_SRC_DIR);
+  const srcDir = path9.join(rootDir, SOURCE_SRC_DIR);
   return resolveSkillPath(srcDir, skill.path);
 }
 async function generateSkillHash(skillSourcePath) {
-  const skillMdPath = path8.join(skillSourcePath, STANDARD_FILES.SKILL_MD);
+  const skillMdPath = path9.join(skillSourcePath, STANDARD_FILES.SKILL_MD);
   return computeFileHash(skillMdPath);
 }
 async function copySkillTo(skill, sourcePath, destPath, source) {
   const contentHash = await generateSkillHash(sourcePath);
-  await ensureDir(path8.dirname(destPath));
+  await ensureDir(path9.dirname(destPath));
   await copy(sourcePath, destPath);
-  await injectForkedFromMetadata(destPath, skill.id, contentHash, source);
+  await injectForkedFromMetadata(destPath, skill.id, contentHash, {
+    ...source !== void 0 && { source }
+  });
   return { skillId: skill.id, contentHash, sourcePath, destPath };
 }
 async function resolveLocalCopiedSkill(skill, localPath) {
@@ -12596,6 +12818,32 @@ async function resolveLocalCopiedSkill(skill, localPath) {
     local: true
   };
 }
+async function copyEachSkill(selectedSkillIds, copyOne) {
+  const outcomes = await Promise.all(
+    selectedSkillIds.map(async (skillId) => attemptCopy(skillId, copyOne))
+  );
+  const failures = outcomes.filter(isCopyFailure);
+  if (failures.length > 0) throw new Error(copyFailureMessage(failures, selectedSkillIds.length));
+  return outcomes.filter(isCopySuccess).map((outcome) => outcome.copied);
+}
+async function attemptCopy(skillId, copyOne) {
+  try {
+    return { skillId, copied: await copyOne(skillId) };
+  } catch (error) {
+    return { skillId, problem: getErrorMessage(error) };
+  }
+}
+function isCopyFailure(outcome) {
+  return "problem" in outcome;
+}
+function isCopySuccess(outcome) {
+  return "copied" in outcome;
+}
+function copyFailureMessage(failures, attempted) {
+  const lines = failures.map((failure) => `  ${failure.skillId}: ${failure.problem}`);
+  return `Could not copy ${failures.length} of ${attempted} skills:
+${lines.join("\n")}`;
+}
 function getFlattenedSkillDestPath(skill, localSkillsDir) {
   return resolveSkillPath(localSkillsDir, skill.id);
 }
@@ -12608,34 +12856,30 @@ async function copySkillToLocalFlattened(skill, localSkillsDir, sourceResult) {
   );
 }
 async function copySkillsToLocalFlattened(selectedSkillIds, localSkillsDir, sourceResult, sourceSelections) {
-  const results = await Promise.all(
-    selectedSkillIds.map(async (skillId) => {
-      const skill = getSkillById(skillId);
-      const selectedSource = sourceSelections?.[skillId];
-      const userSelectedRemote = selectedSource && selectedSource !== EJECT_SOURCE;
-      if (skill.local && skill.localPath && !userSelectedRemote) {
-        const destPath = getFlattenedSkillDestPath(skill, localSkillsDir);
-        const alreadyInPlace = path8.resolve(skill.localPath) === path8.resolve(destPath);
-        if (alreadyInPlace) {
-          return resolveLocalCopiedSkill(skill, skill.localPath);
-        }
-        const contentHash = await generateSkillHash(skill.localPath);
-        await ensureDir(path8.dirname(destPath));
-        await copy(skill.localPath, destPath);
-        return { skillId: skill.id, sourcePath: skill.localPath, destPath, contentHash };
-      }
+  return copyEachSkill(selectedSkillIds, async (skillId) => {
+    const skill = getSkillById(skillId);
+    const selectedSource = sourceSelections?.[skillId];
+    const userSelectedRemote = selectedSource && selectedSource !== EJECT_SOURCE;
+    if (!skill.local || !skill.localPath || userSelectedRemote) {
       return copySkillToLocalFlattened(skill, localSkillsDir, sourceResult);
-    })
-  );
-  return results;
+    }
+    const destPath = getFlattenedSkillDestPath(skill, localSkillsDir);
+    if (path9.resolve(skill.localPath) === path9.resolve(destPath)) {
+      return resolveLocalCopiedSkill(skill, skill.localPath);
+    }
+    const contentHash = await generateSkillHash(skill.localPath);
+    await ensureDir(path9.dirname(destPath));
+    await copy(skill.localPath, destPath);
+    return { skillId: skill.id, sourcePath: skill.localPath, destPath, contentHash };
+  });
 }
 
 // src/cli/lib/skills/skill-plugin-compiler.ts
-import path21 from "path";
+import path23 from "path";
 import { parse as parseYaml2 } from "yaml";
 
 // src/cli/lib/plugins/plugin-manifest.ts
-import path9 from "path";
+import path10 from "path";
 var PLUGIN_DIR_NAME = PLUGIN_MANIFEST_DIR;
 var PLUGIN_MANIFEST_FILE2 = STANDARD_FILES.PLUGIN_JSON;
 var AGENT_PLUGIN_PREFIX = "agent-";
@@ -12666,8 +12910,8 @@ function generateAgentPluginManifest(options) {
   };
 }
 async function writePluginManifest(outputDir, manifest) {
-  const pluginDir = path9.join(outputDir, PLUGIN_DIR_NAME);
-  const manifestPath = path9.join(pluginDir, PLUGIN_MANIFEST_FILE2);
+  const pluginDir = path10.join(outputDir, PLUGIN_DIR_NAME);
+  const manifestPath = path10.join(pluginDir, PLUGIN_MANIFEST_FILE2);
   await ensureDir(pluginDir);
   const content = JSON.stringify(manifest, null, 2);
   await writeFile(manifestPath, content);
@@ -12676,20 +12920,20 @@ async function writePluginManifest(outputDir, manifest) {
 
 // src/cli/lib/plugins/plugin-finder.ts
 import os5 from "os";
-import path10 from "path";
+import path11 from "path";
 import { zip } from "remeda";
 function getUserPluginsDir() {
-  return path10.join(os5.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR);
+  return path11.join(os5.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR);
 }
 function getProjectPluginsDir(projectDir) {
   const dir = projectDir ?? process.cwd();
-  return path10.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR);
+  return path11.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR);
 }
 function getPluginAgentsDir(pluginDir) {
-  return path10.join(pluginDir, "agents");
+  return path11.join(pluginDir, "agents");
 }
 function getPluginManifestPath(pluginDir) {
-  return path10.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+  return path11.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
 }
 async function readPluginManifest(pluginDir) {
   const manifestPath = getPluginManifestPath(pluginDir);
@@ -12728,7 +12972,7 @@ import { readdir } from "fs/promises";
 
 // src/cli/lib/installation/installation.ts
 import os6 from "os";
-import path11 from "path";
+import path12 from "path";
 var INSTALL_MODE_LABELS = {
   plugin: "Plugin",
   mixed: "Mixed",
@@ -12743,8 +12987,8 @@ function declaresNoContent(config) {
 }
 function deriveInstallMode(skills) {
   if (skills.length === 0) return "eject";
-  const hasEject = skills.some((s) => s.source === EJECT_SOURCE);
-  const hasPlugin = skills.some((s) => s.source !== EJECT_SOURCE);
+  const hasEject = skills.some((s) => s.origin === EJECT_SOURCE);
+  const hasPlugin = skills.some((s) => s.origin !== EJECT_SOURCE);
   if (hasEject && hasPlugin) return "mixed";
   return hasEject ? "eject" : "plugin";
 }
@@ -12764,10 +13008,10 @@ async function detectInstallationInDir(dir) {
   return {
     mode,
     configPath,
-    agentsDir: path11.join(dir, CLAUDE_DIR, STANDARD_DIRS.AGENTS),
+    agentsDir: path12.join(dir, CLAUDE_DIR, STANDARD_DIRS.AGENTS),
     // Mixed mode has local skills in .claude/skills/ and plugins in cache;
     // use .claude/skills/ as the primary skillsDir (same as eject mode)
-    skillsDir: path11.join(dir, CLAUDE_DIR, mode === "plugin" ? PLUGINS_SUBDIR : "skills"),
+    skillsDir: path12.join(dir, CLAUDE_DIR, mode === "plugin" ? PLUGINS_SUBDIR : "skills"),
     projectDir: dir
   };
 }
@@ -12785,26 +13029,49 @@ async function detectInstallation(projectDir = process.cwd()) {
 
 // src/cli/lib/installation/local-installer.ts
 import os13 from "os";
-import path18 from "path";
-import { unique as unique4 } from "remeda";
+import path20 from "path";
+import { unique as unique5 } from "remeda";
 
 // src/cli/lib/loading/source-fetcher.ts
 import { createHash as createHash2 } from "crypto";
 import { downloadTemplate } from "giget";
 import os7 from "os";
-import path12 from "path";
+import path13 from "path";
+
+// src/cli/lib/validate-kebab-name.ts
+import { unique as unique3 } from "remeda";
+var KEBAB_CASE_CHARACTER = /[a-z0-9-]/;
+function charactersOutsideKebabCase(name) {
+  return unique3([...name].filter((character) => !KEBAB_CASE_CHARACTER.test(character)));
+}
+function validateKebabCaseName(name, noun) {
+  if (!name || name.trim() === "") {
+    return `${noun} name is required`;
+  }
+  if (!KEBAB_CASE_PATTERN.test(name)) {
+    return `${noun} name must be kebab-case (lowercase letters, numbers, and hyphens, starting with a letter)`;
+  }
+  return null;
+}
 
 // src/cli/utils/messages.ts
 var ERROR_MESSAGES = {
   UNKNOWN_ERROR: "Unknown error occurred",
   UNKNOWN_ERROR_SHORT: "Unknown error",
   NO_INSTALLATION: `No installation found. Run '${CLI_INVOKE_COMMAND} init' first to set up ${DEFAULT_BRANDING.NAME}`,
-  NO_SKILLS_FOUND: "No skills found",
-  VALIDATION_FAILED: "Validation failed",
-  FAILED_RESOLVE_SOURCE: "Failed to resolve source",
+  FAILED_RESOLVE_SOURCE: "Failed to resolve marketplace",
   FAILED_LOAD_AGENT_PARTIALS: "Failed to load agent partials",
   FAILED_COMPILE_AGENTS: "Failed to compile agents",
-  CLAUDE_CLI_NOT_FOUND: `Claude CLI not found \u2014 '${CLI_INVOKE_COMMAND} update' refreshes marketplaces through it. Install Claude Code first: https://claude.ai/code`
+  CLAUDE_CLI_NOT_FOUND: `Claude CLI not found \u2014 '${CLI_INVOKE_COMMAND} update' refreshes marketplaces through it. Install Claude Code first: https://claude.ai/code`,
+  /**
+   * What `compile` refuses with when every pass discovered zero skills. It is reached only
+   * after an installation was detected, so the state it describes is a configuration with
+   * nothing installed under it — the same state `doctor` reports as `config-empty` and
+   * names `init` for, because `init` on a config that declares nothing opens the wizard
+   * rather than the dashboard. `edit` is the wrong half of the pair here: it modifies the
+   * currently installed skills, and there are none to modify.
+   */
+  NO_SKILLS_TO_COMPILE: `No skills found. Run '${CLI_INVOKE_COMMAND} init' to choose skills, or add your own under ${LOCAL_SKILLS_PATH}/.`
 };
 var SUCCESS_MESSAGES = {
   UNINSTALL_COMPLETE: "Uninstall complete!",
@@ -12814,23 +13081,29 @@ var SUCCESS_MESSAGES = {
 var STATUS_MESSAGES = {
   INSTALLING_PLUGINS: "Installing skill plugins...",
   LOADING_SKILLS: "Loading skills...",
-  LOADING_MARKETPLACE_SOURCE: "Loading marketplace source...",
+  LOADING_MARKETPLACE_SOURCE: "Loading marketplace...",
   RECOMPILING_AGENTS: "Recompiling agents...",
   COMPILING_AGENTS: "Compiling agents...",
   DISCOVERING_SKILLS: "Discovering skills...",
-  RESOLVING_SOURCE: "Resolving source...",
-  RESOLVING_MARKETPLACE_SOURCE: "Resolving marketplace source...",
+  RESOLVING_SOURCE: "Resolving marketplace...",
+  RESOLVING_MARKETPLACE_SOURCE: "Resolving marketplace...",
   LOADING_AGENT_PARTIALS: "Loading agent partials...",
   FETCHING_REPOSITORY: "Fetching repository...",
   COPYING_SKILLS: "Copying skills...",
-  UPDATING_PLUGIN_SKILLS: "Updating plugin skills...",
   /**
-   * Printed when revalidation found the remote source had moved on. It is the
+   * Printed when revalidation found the remote marketplace had moved on. It is the
    * only warning a user gets that this load costs a download rather than a
    * cache read, so it goes out before the download starts, not after.
    */
   MARKETPLACE_HAS_NEWER_CONTENT: "Marketplace has newer content \u2014 fetching the update..."
 };
+var AGENT_PARTIAL_FILES = [
+  STANDARD_FILES.IDENTITY_MD,
+  STANDARD_FILES.PLAYBOOK_MD,
+  STANDARD_FILES.CRITICAL_REQUIREMENTS_MD,
+  STANDARD_FILES.CRITICAL_REMINDERS_MD,
+  STANDARD_FILES.OUTPUT_MD
+];
 var INFO_MESSAGES = {
   NO_CHANGES_MADE: "No changes made.",
   RUN_COMPILE: `Run '${CLI_INVOKE_COMMAND} compile' to include imported skills in your agents.`,
@@ -12845,7 +13118,9 @@ var INFO_MESSAGES = {
    * their work — this line says so once, as information rather than a warning.
    */
   EJECTED_SKILLS_USER_OWNED: `Ejected skills are yours to own \u2014 '${CLI_INVOKE_COMMAND} update' does not change them.`,
-  NO_PLUGIN_MARKETPLACES: "No plugin marketplaces are configured \u2014 nothing to refresh."
+  NO_PLUGIN_MARKETPLACES: "No plugin marketplaces are configured \u2014 nothing to refresh.",
+  /** Printed under the destination `eject agent-partials` just named, so it names files only. */
+  AGENT_PARTIALS_CUSTOMIZABLE: `Each sub-agent directory there holds ${AGENT_PARTIAL_FILES.join(", ")} \u2014 edit those to customize that sub-agent.`
 };
 function pluginsInstalled(count) {
   return `Installed ${count} skill plugins`;
@@ -12885,6 +13160,31 @@ function marketplacesRefreshFailed(marketplaces) {
   const subject = marketplaces.length === 1 ? "marketplace" : "marketplaces";
   return `${marketplaces.length} ${subject} could not be updated: ${marketplaces.join(", ")}`;
 }
+function marketplaceOwnerHasNoName(packageJsonPath) {
+  return [
+    `A marketplace's owner must have a name, and no name could be read from 'author' in ${packageJsonPath}.`,
+    `Nothing was written: a ${MARKETPLACE_JSON} whose 'owner.name' is empty is refused by this CLI's own reader, so the build would have reported success for a marketplace nobody can install from.`,
+    `Set 'author' in that file \u2014 either "Jane Doe <jane@example.com>" or { "name": "Jane Doe" } \u2014 and build again.`
+  ].join("\n\n");
+}
+function marketplaceHasNoVersion(packageJsonPath) {
+  return [
+    `A marketplace must have a version, and 'version' in ${packageJsonPath} is empty.`,
+    `Nothing was written: a ${MARKETPLACE_JSON} whose 'version' is empty is refused by this CLI's own reader, so the build would have reported success for a marketplace nobody can install from.`,
+    `Set 'version' in that file \u2014 "0.1.0" if this is its first release \u2014 and build again.`
+  ].join("\n\n");
+}
+function marketplaceNameNotPublishable(name, packageJsonPath) {
+  const offenders = charactersOutsideKebabCase(name);
+  return [
+    `Marketplace name '${name}', read from 'name' in ${packageJsonPath}, is not a name a marketplace may publish under.`,
+    ...offenders.length > 0 ? [
+      `It carries ${offenders.map((character) => `'${character}'`).join(" and ")}, which a marketplace name may not.`
+    ] : [],
+    `A marketplace name is kebab-case: lowercase letters, numbers and hyphens, starting with a letter.`,
+    `Publish under a name of your own instead: '${CLI_INVOKE_COMMAND} build marketplace --name <your-marketplace>'.`
+  ].join("\n\n");
+}
 function configTypesRefreshFailed(reason) {
   return `Could not refresh ${STANDARD_FILES.CONFIG_TYPES_TS} \u2014 type unions may be stale: ${reason}`;
 }
@@ -12918,17 +13218,94 @@ function skillMetadataUnusableError(entries) {
 function savedSkillMetadataUnusableError(entries) {
   return [
     metadataUnusableOpening(entries),
-    `A config entry naming a skill this file cannot describe is dropped as one this source does not carry \u2014 and a file that can be repaired must not cost an install its record.`,
+    `A config entry naming a skill this file cannot describe is dropped as one this marketplace does not carry \u2014 and a file that can be repaired must not cost an install its record.`,
     METADATA_UNUSABLE_WAY_OUT
   ].join("\n");
 }
 var SHARED_CONFIG_GREENFIELD_HINT = "installing a shared configuration is a fresh setup, not a merge";
+function sharedConfigDestinations(id) {
+  return [
+    `  Install it:  ${CLI_INVOKE_COMMAND} init --from ${id}`,
+    `  Open it:     ${editorConfigUrl(id)}`
+  ];
+}
 function sharedConfigExistingInstall(configPath) {
   return `An installation already exists at ${configPath}. Run '${CLI_INVOKE_COMMAND} uninstall' first \u2014 ${SHARED_CONFIG_GREENFIELD_HINT}.`;
 }
 function sharedConfigGlobalInstall(configPath) {
   return `This configuration installs global-scoped content, and a global installation already exists at ${configPath}. Run '${CLI_INVOKE_COMMAND} uninstall' from your home directory first \u2014 ${SHARED_CONFIG_GREENFIELD_HINT}.`;
 }
+function sharedConfigProjectScopeAtHome(skillIds, agentNames) {
+  return [
+    "This configuration cannot be installed here: the home directory is the global scope, and a global installation holds only global-scoped content \u2014 so these project-scoped entries have nowhere to be written:",
+    ...skillIds.map((id) => `  skill ${id} (scope: project)`),
+    ...agentNames.map((name) => `  sub-agent ${name} (scope: project)`),
+    "Run this from inside a project directory, or re-share it with each entry above at global scope."
+  ].join("\n");
+}
+function skippedUnknownSkills(skillIds) {
+  return `Skipped ${skillIds.length} skill(s) this catalog does not know: ${skillIds.join(", ")}`;
+}
+function skippedUnknownAgents(agentNames) {
+  return `Skipped ${agentNames.length} unknown sub-agent(s): ${agentNames.join(", ")}`;
+}
+function carriedSkillsWritten(skillIds) {
+  return `Wrote ${skillIds.length} skill(s) this configuration carries: ${skillIds.join(", ")}`;
+}
+var SHARED_CONFIG_APPLY = {
+  PREVIEW_HEADING: "Applying this configuration will remove:",
+  SKILLS_HEADING: "Skills:",
+  AGENTS_HEADING: "Sub-agents:",
+  /**
+   * The two headings a PROJECT run prints instead, for entries that live at global scope. They
+   * exist only there: at the home directory every entry is global, so a heading saying so would
+   * label the whole list with the one fact the location already states.
+   */
+  GLOBAL_SKILLS_HEADING: "Skills installed globally:",
+  GLOBAL_AGENTS_HEADING: "Sub-agents installed globally:",
+  /** Printed in place of the sections when the payload takes nothing away. */
+  NOTHING_REMOVED: "Nothing is removed \u2014 this configuration only adds and re-tunes.",
+  CONFIRM: "Apply this configuration?"
+};
+function sharedConfigNeedsTerminal(id) {
+  return [
+    `Applying configuration '${id}' removes whatever it leaves out, so it has to be confirmed \u2014 and there is no terminal here to confirm it at.`,
+    `Run '${CLI_INVOKE_COMMAND} edit --from ${id}' from a terminal, or '${CLI_INVOKE_COMMAND} init --from ${id}' in a clean directory, which installs without removing anything.`
+  ].join("\n");
+}
+var SHARED_CONFIG_ONE_DIRECTION = "--ui and --from are the two directions of the same round trip: --ui hands this installation to the editor, and --from applies one back. Run one, then the other.";
+function globallyInstalledRemoved(otherProjects) {
+  return [
+    "These are installed globally, and a global install is shared by every project on this machine.",
+    ...globalRemovalReach(otherProjects),
+    `To keep them, answer no and re-share the configuration with them included.`
+  ].join("\n");
+}
+function globalRemovalReach(otherProjects) {
+  if (otherProjects.length === 0) {
+    return [
+      "No other project is registered here, so nothing else changes today \u2014 a project set up later inherits whatever the global install holds then."
+    ];
+  }
+  return [
+    `Also affects ${otherProjects.length} other registered project(s):`,
+    ...otherProjects.map((projectDir) => `  ${projectDir}`)
+  ];
+}
+function authoredHereKept(skillIds) {
+  return [
+    "Kept \u2014 written here rather than installed, so a shared configuration never carried them:",
+    ...skillIds.map((id) => `  skill ${id}`),
+    `Remove them with '${CLI_INVOKE_COMMAND} edit'.`
+  ].join("\n");
+}
+function unplaceableKept(skillIds) {
+  return [
+    "Kept \u2014 named by this configuration, and this catalogue cannot place them:",
+    ...skillIds.map((id) => `  skill ${id}`),
+    `Run '${CLI_INVOKE_COMMAND} update' to refresh this installation's marketplace, then apply the configuration again.`
+  ].join("\n");
+}
 function configUnreadableError(configLoadFailure2) {
   return [
     configLoadFailure2,
@@ -12940,8 +13317,10 @@ function configUnreadableError(configLoadFailure2) {
 function registeredProjectsUpdateFailed(reason) {
   return `Could not update registered projects \u2014 their configs may still reference the uninstalled global content: ${reason}`;
 }
-function compiledAgentsKept(agentsDir) {
-  return `Kept compiled agents in ${agentsDir}/ \u2014 identifying which of them this CLI compiled needs the configuration, and this run has none it could read.`;
+function unmarkedAgentsKept(agentsDir, count) {
+  const subject = count === 1 ? "agent" : "agents";
+  const object = count === 1 ? "it" : "them";
+  return `Kept ${count} ${subject} in ${agentsDir}/ \u2014 no ${DEFAULT_PLUGIN_NAME} marker, so this CLI did not compile ${object}.`;
 }
 var UNINSTALL_PLAN = {
   PREVIEW_HEADING: "The following will be removed:",
@@ -12950,7 +13329,7 @@ var UNINSTALL_PLAN = {
   CONFIG_HEADING: "Config:"
 };
 function localSkillsRemoval(skillsDir) {
-  return `${skillsDir}/ (matching sources)`;
+  return `${skillsDir}/ (matching the marketplace)`;
 }
 function compiledAgentsRemoval(agentsDir) {
   return `${agentsDir}/ (CLI-compiled)`;
@@ -12968,7 +13347,7 @@ function sanitizeSourceForCache(source) {
 }
 function getCacheDir(source) {
   const sanitized = sanitizeSourceForCache(source) || "unknown";
-  return path12.join(CACHE_DIR, "sources", sanitized);
+  return path13.join(CACHE_DIR, "sources", sanitized);
 }
 async function fetchFromSource(source, options = {}) {
   const { subdir } = options;
@@ -12978,19 +13357,19 @@ async function fetchFromSource(source, options = {}) {
   return fetchFromRemoteSource(source, subdir);
 }
 async function fetchFromLocalSource(source, subdir) {
-  const fullPath = subdir ? path12.join(source, subdir) : source;
-  const absolutePath = path12.isAbsolute(fullPath) ? fullPath : path12.resolve(process.cwd(), fullPath);
+  const fullPath = subdir ? path13.join(source, subdir) : source;
+  const absolutePath = path13.isAbsolute(fullPath) ? fullPath : path13.resolve(process.cwd(), fullPath);
   if (!await directoryExists(absolutePath)) {
     throw new Error(
-      `Local source not found: '${absolutePath}'
+      `Local marketplace not found: '${absolutePath}'
 
-Nothing is at that path, and a local source must be a directory holding a skills marketplace.
+Nothing is at that path, and a local marketplace must be a directory holding skills.
 
 Check it for a typo, or name a marketplace that exists:
-  --source ${DEFAULT_SOURCE}`
+  --marketplace ${DEFAULT_SOURCE}`
     );
   }
-  verbose(`Using local source: ${absolutePath}`);
+  verbose(`Using local marketplace: ${absolutePath}`);
   return {
     path: absolutePath,
     fromCache: false,
@@ -13009,8 +13388,8 @@ function getGigetCacheDir(source) {
     return void 0;
   }
   const templateName = uriMatch.groups.repo.replace("/", "-").replace(/[^\da-z-]/gi, "-");
-  const gigetCacheRoot = process.env.XDG_CACHE_HOME ? path12.resolve(process.env.XDG_CACHE_HOME, "giget") : path12.resolve(os7.homedir(), ".cache", "giget");
-  return path12.join(gigetCacheRoot, providerName, templateName);
+  const gigetCacheRoot = process.env.XDG_CACHE_HOME ? path13.resolve(process.env.XDG_CACHE_HOME, "giget") : path13.resolve(os7.homedir(), ".cache", "giget");
+  return path13.join(gigetCacheRoot, providerName, templateName);
 }
 async function clearGigetCache(source) {
   const gigetDir = getGigetCacheDir(source);
@@ -13029,14 +13408,14 @@ async function fetchFromRemoteSource(source, subdir) {
     const verdict = await revalidateCachedCopy(cacheDir, source);
     const cached = { path: cacheDir, fromCache: true, source: fullSource };
     if (verdict === "current" || verdict === "unreachable") {
-      verbose(`Using cached source: ${cacheDir}`);
+      verbose(`Using cached marketplace: ${cacheDir}`);
       return cached;
     }
     announceRefetch(verdict);
     await clearGigetCache(source);
     await remove(cacheDir);
   }
-  await ensureDir(path12.dirname(cacheDir));
+  await ensureDir(path13.dirname(cacheDir));
   try {
     const result = await downloadTemplate(fullSource, {
       dir: cacheDir,
@@ -13111,7 +13490,7 @@ async function readFetchRecord(cacheDir) {
   if (!raw) return void 0;
   const parsed = sourceRevalidationSchema.safeParse(parseJsonOrUndefined(raw));
   if (!parsed.success) {
-    verbose(`Unusable fetch record at ${fetchRecordPath(cacheDir)} \u2014 re-fetching the source`);
+    verbose(`Unusable fetch record at ${fetchRecordPath(cacheDir)} \u2014 re-fetching the marketplace`);
     return void 0;
   }
   return parsed.data;
@@ -13179,23 +13558,25 @@ If you're behind a corporate proxy, you may need to set:
   }
   return new Error(`Failed to fetch ${source}: ${message}`);
 }
+var MarketplaceManifestAbsentError = class extends Error {
+};
 async function fetchMarketplace(source) {
   const result = await fetchFromSource(source, {
     subdir: ""
     // Root of repo
   });
   const marketplacePath = marketplaceManifestPath(result.path);
-  if (!await directoryExists(path12.dirname(marketplacePath))) {
-    throw new Error(
-      `Marketplace not found for source: ${source}
+  if (!await fileExists(marketplacePath)) {
+    throw new MarketplaceManifestAbsentError(
+      `Marketplace not found at: ${source}
 
 The .claude-plugin/marketplace.json file is missing from this repository.
 
 Possible causes:
-  - The source URL may be incorrect
+  - The marketplace URL may be incorrect
   - The repository may not have a marketplace configured
 
-To create a marketplace, add a .claude-plugin/marketplace.json file to your source repository.`
+To create a marketplace, add a .claude-plugin/marketplace.json file to your marketplace repository.`
     );
   }
   const content = await readFileSafe(marketplacePath, MAX_MARKETPLACE_FILE_SIZE);
@@ -13255,22 +13636,26 @@ Too many plugins: ${marketplace.plugins.length} (limit: ${MAX_MARKETPLACE_PLUGIN
 
 // src/cli/lib/loading/multi-source-loader.ts
 import os8 from "os";
+function isLocalOnlySkill(skill) {
+  return skill?.availableSources !== void 0 && !skill.availableSources.some((source) => source.type !== "local");
+}
 function addAvailableSource(skill, source) {
   skill.availableSources = skill.availableSources ?? [];
   skill.availableSources.push(source);
 }
-async function loadSkillsFromAllSources(primaryMatrix, sourceConfig, projectDir, marketplace) {
+async function loadSkillsFromAllSources(primaryMatrix, sourceConfig, projectDir, marketplace, unbackedSkillIds = /* @__PURE__ */ new Set()) {
   const resolvedMarketplace = marketplace ?? sourceConfig.marketplace;
   const primarySourceName = resolvedMarketplace ?? DEFAULT_PUBLIC_SOURCE_NAME;
   const primarySourceType = isDefaultSource(sourceConfig.source) ? "public" : "private";
-  tagPrimarySourceSkills(primaryMatrix, primarySourceName, primarySourceType);
+  tagPrimarySourceSkills(primaryMatrix, primarySourceName, primarySourceType, unbackedSkillIds);
   tagLocalSkills(primaryMatrix);
   await tagPluginSkills(primaryMatrix, projectDir, primarySourceName, primarySourceType);
   setActiveSources(primaryMatrix);
 }
-function tagPrimarySourceSkills(matrix2, sourceName, sourceType) {
-  for (const [, skill] of typedEntries(matrix2.skills)) {
+function tagPrimarySourceSkills(matrix2, sourceName, sourceType, unbackedSkillIds) {
+  for (const [id, skill] of typedEntries(matrix2.skills)) {
     if (!skill) continue;
+    if (unbackedSkillIds.has(id)) continue;
     const source = {
       name: sourceName,
       type: sourceType,
@@ -13409,9 +13794,60 @@ async function resolveAgents(agents, skills, compileConfig, _projectRoot) {
 
 // src/cli/lib/compiler.ts
 import { Liquid } from "liquidjs";
-import path13 from "path";
+import path15 from "path";
 import { pipe as pipe2, flatMap as flatMap2, filter, uniqueBy as uniqueBy3 } from "remeda";
 
+// src/cli/lib/agents/agent-provenance.ts
+import path14 from "path";
+import { z as z7 } from "zod";
+var MARKER_OPEN = `<!-- Generated by ${DEFAULT_PLUGIN_NAME} v`;
+var MARKER_NOTICE = " \u2014 do not edit; compile rewrites this file";
+var MARKER_CLOSE = " -->";
+var FRONTMATTER_FENCE = "---";
+var PACKAGE_JSON_FILE = "package.json";
+var ownPackageJsonSchema = z7.object({ version: z7.string().min(1) });
+function provenanceMarker(version) {
+  return `${MARKER_OPEN}${version}${MARKER_NOTICE}${MARKER_CLOSE}`;
+}
+function isProvenanceMarker(line) {
+  return line.startsWith(MARKER_OPEN) && line.endsWith(MARKER_CLOSE);
+}
+function bodyStartIndex(lines) {
+  if (lines[0] !== FRONTMATTER_FENCE) return 0;
+  const closingFence = lines.indexOf(FRONTMATTER_FENCE, 1);
+  if (closingFence === -1) return 0;
+  return closingFence + 1;
+}
+function hasProvenanceMarker(content) {
+  const lines = content.split("\n");
+  const firstBodyLine = lines[bodyStartIndex(lines)];
+  return firstBodyLine !== void 0 && isProvenanceMarker(firstBodyLine);
+}
+function stampProvenanceMarker(content, version) {
+  const lines = content.split("\n");
+  const bodyStart = bodyStartIndex(lines);
+  const replacedLines = hasProvenanceMarker(content) ? 1 : 0;
+  return [
+    ...lines.slice(0, bodyStart),
+    provenanceMarker(version),
+    ...lines.slice(bodyStart + replacedLines)
+  ].join("\n");
+}
+var ownVersion;
+function cliVersion() {
+  ownVersion ??= readOwnVersion();
+  return ownVersion;
+}
+async function readOwnVersion() {
+  const manifestPath = path14.join(PROJECT_ROOT, PACKAGE_JSON_FILE);
+  const raw = JSON.parse(await readFile(manifestPath));
+  const parsed = ownPackageJsonSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(`Could not read this CLI's own version from ${manifestPath}`);
+  }
+  return parsed.data.version;
+}
+
 // src/cli/lib/validation-result.ts
 function validResult() {
   return { valid: true, errors: [], warnings: [] };
@@ -13490,24 +13926,24 @@ function sanitizeCompiledAgentData(data) {
 async function readAgentFiles(name, agent, projectRoot) {
   const agentSourceRoot = agent.sourceRoot || projectRoot;
   const agentBaseDir = agent.agentBaseDir || DIRS.agents;
-  const agentDir = path13.join(agentSourceRoot, agentBaseDir, agent.path || name);
-  const identity = await readFile(path13.join(agentDir, STANDARD_FILES.IDENTITY_MD));
-  const playbook = await readFile(path13.join(agentDir, STANDARD_FILES.PLAYBOOK_MD));
+  const agentDir = path15.join(agentSourceRoot, agentBaseDir, agent.path || name);
+  const identity = await readFile(path15.join(agentDir, STANDARD_FILES.IDENTITY_MD));
+  const playbook = await readFile(path15.join(agentDir, STANDARD_FILES.PLAYBOOK_MD));
   const criticalRequirementsTop = await readFileOptional(
-    path13.join(agentDir, STANDARD_FILES.CRITICAL_REQUIREMENTS_MD),
+    path15.join(agentDir, STANDARD_FILES.CRITICAL_REQUIREMENTS_MD),
     ""
   );
   const criticalReminders = await readFileOptional(
-    path13.join(agentDir, STANDARD_FILES.CRITICAL_REMINDERS_MD),
+    path15.join(agentDir, STANDARD_FILES.CRITICAL_REMINDERS_MD),
     ""
   );
   const agentPath = agent.path || name;
   const parts = agentPath.split("/");
   const category = parts[0] || name;
-  const categoryDir = path13.join(agentSourceRoot, agentBaseDir, category);
-  let output = await readFileOptional(path13.join(agentDir, STANDARD_FILES.OUTPUT_MD), "");
+  const categoryDir = path15.join(agentSourceRoot, agentBaseDir, category);
+  let output = await readFileOptional(path15.join(agentDir, STANDARD_FILES.OUTPUT_MD), "");
   if (!output) {
-    output = await readFileOptional(path13.join(categoryDir, STANDARD_FILES.OUTPUT_MD), "");
+    output = await readFileOptional(path15.join(categoryDir, STANDARD_FILES.OUTPUT_MD), "");
   }
   return { identity, playbook, output, criticalRequirementsTop, criticalReminders };
 }
@@ -13528,26 +13964,30 @@ function buildAgentTemplateContext(name, agent, files, mapSkill = (skill) => ski
     preloadedSkillIds
   };
 }
+async function renderCompiledAgent(engine, data) {
+  const rendered = await engine.renderFile("agent", sanitizeCompiledAgentData(data));
+  return stampProvenanceMarker(rendered, await cliVersion());
+}
 async function createLiquidEngine(projectDir) {
   const roots = [];
   if (projectDir) {
-    const srcTemplatesDir = path13.join(
+    const srcTemplatesDir = path15.join(
       projectDir,
       CLAUDE_SRC_DIR,
       STANDARD_DIRS.AGENTS,
-      path13.basename(DIRS.templates)
+      path15.basename(DIRS.templates)
     );
     if (await directoryExists(srcTemplatesDir)) {
       roots.push(srcTemplatesDir);
       verbose(`Using local templates from: ${srcTemplatesDir}`);
     }
-    const legacyTemplatesDir = path13.join(projectDir, CLAUDE_DIR, STANDARD_DIRS.TEMPLATES);
+    const legacyTemplatesDir = path15.join(projectDir, CLAUDE_DIR, STANDARD_DIRS.TEMPLATES);
     if (await directoryExists(legacyTemplatesDir)) {
       roots.push(legacyTemplatesDir);
       verbose(`Using legacy templates from: ${legacyTemplatesDir}`);
     }
   }
-  roots.push(path13.join(PROJECT_ROOT, DIRS.templates));
+  roots.push(path15.join(PROJECT_ROOT, DIRS.templates));
   return new Liquid({
     root: roots,
     extname: ".liquid",
@@ -13566,12 +14006,12 @@ async function compileAgentForPlugin(name, agent, fallbackRoot, engine) {
     ...skill,
     ...pluginRefFor(skill)
   }));
-  return engine.renderFile("agent", sanitizeCompiledAgentData(data));
+  return renderCompiledAgent(engine, data);
 }
 
 // src/cli/lib/agents/write-compiled-agents.ts
 import os9 from "os";
-import path14 from "path";
+import path16 from "path";
 async function holdsExactly(filePath, content) {
   return await fileExists(filePath) && await readFile(filePath) === content;
 }
@@ -13584,7 +14024,7 @@ async function writeCompiledAgentsByScope(params) {
       const output = await compileAgentForPlugin(name, agent, params.sourcePath, params.engine);
       const scope = params.agentScopeMap?.get(name) ?? UNROUTED_AGENT_SCOPE;
       const targetDir = scope === "global" ? globalAgentsDir : params.projectAgentsDir;
-      const targetPath = path14.join(targetDir, `${name}.md`);
+      const targetPath = path16.join(targetDir, `${name}.md`);
       const rewritten = !await holdsExactly(targetPath, output);
       if (rewritten) await writeFile(targetPath, output);
       outcomes.push({ name, ok: true, scope, targetDir, rewritten });
@@ -13597,11 +14037,11 @@ async function writeCompiledAgentsByScope(params) {
 
 // src/cli/lib/config-gate/index.ts
 import os12 from "os";
-import path17 from "path";
+import path19 from "path";
 
 // src/cli/lib/configuration/config-writer.ts
 import os10 from "os";
-import path15 from "path";
+import path17 from "path";
 var EXTRACTED_FIELDS = /* @__PURE__ */ new Set(["skills", "agents", "stack", "selectedDomains"]);
 var CANONICAL_FIELD_ORDER = [
   "name",
@@ -13611,8 +14051,8 @@ var CANONICAL_FIELD_ORDER = [
   "author",
   "selectedDomains",
   "stack",
-  "source",
   "marketplace",
+  "marketplaceName",
   "agentsSource",
   "projects"
 ];
@@ -13624,6 +14064,20 @@ function canonicalizeFieldOrder(cleaned) {
   const passthrough = Object.entries(cleaned).filter(([key]) => !CANONICAL_FIELDS.has(key));
   return Object.fromEntries([...inSchemaOrder, ...passthrough]);
 }
+function withKeysOrderedBy(record, compareKeys) {
+  return Object.fromEntries(Object.entries(record).sort(([a], [b]) => compareKeys(a, b)));
+}
+function compareNamesInCodeUnitOrder(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+function canonicalizeStackOrder(stack) {
+  const byDeclaration = byCategoryDeclarationOrder();
+  const withCategoriesInOrder = Object.entries(stack).map(
+    ([agent, categories]) => [agent, withKeysOrderedBy(categories, byDeclaration)]
+  );
+  return withKeysOrderedBy(Object.fromEntries(withCategoriesInOrder), compareNamesInCodeUnitOrder);
+}
 function renderEntryLine(entry) {
   return `  ${JSON.stringify(entry)},`;
 }
@@ -13644,9 +14098,10 @@ function cleanForEmission(config, options) {
     delete cleaned.projects;
   }
   if (cleaned.stack) {
-    cleaned.stack = compactStackAssignments(
+    const compacted = compactStackAssignments(
       cleaned.stack
     );
+    cleaned.stack = canonicalizeStackOrder(compacted);
   }
   return canonicalizeFieldOrder(cleaned);
 }
@@ -13923,7 +14378,7 @@ function compactStackAssignments(stack) {
   );
 }
 function getGlobalConfigImportPath() {
-  return path15.join(os10.homedir(), CLAUDE_SRC_DIR);
+  return path17.join(os10.homedir(), CLAUDE_SRC_DIR);
 }
 function generateBlankGlobalConfigSource() {
   return `import type { ProjectConfig } from "./config-types";
@@ -13992,7 +14447,7 @@ function diffSkills(prev, next) {
   for (const [id, afterEntry] of after) {
     const beforeEntry = before.get(id);
     if (!beforeEntry || isDeepEqual(beforeEntry, afterEntry)) continue;
-    if (beforeEntry.source !== afterEntry.source) sourceChanged.push(id);
+    if (beforeEntry.origin !== afterEntry.origin) sourceChanged.push(id);
     else otherChanged.push(id);
   }
   return { added, removed, sourceChanged, otherChanged };
@@ -14066,16 +14521,16 @@ var NO_AGENTS = Promise.resolve({});
 
 // src/cli/lib/config-gate/pair-writer.ts
 import os11 from "os";
-import path16 from "path";
+import path18 from "path";
 function globalPairPaths() {
-  const dir = path16.join(os11.homedir(), CLAUDE_SRC_DIR);
+  const dir = path18.join(os11.homedir(), CLAUDE_SRC_DIR);
   return {
-    configPath: path16.join(dir, STANDARD_FILES.CONFIG_TS),
-    typesPath: path16.join(dir, STANDARD_FILES.CONFIG_TYPES_TS)
+    configPath: path18.join(dir, STANDARD_FILES.CONFIG_TS),
+    typesPath: path18.join(dir, STANDARD_FILES.CONFIG_TYPES_TS)
   };
 }
 function typesPathFor(configPath) {
-  return path16.join(path16.dirname(configPath), STANDARD_FILES.CONFIG_TYPES_TS);
+  return path18.join(path18.dirname(configPath), STANDARD_FILES.CONFIG_TYPES_TS);
 }
 async function writeIfChanged(filePath, source) {
   assertGateToken(filePath);
@@ -14124,16 +14579,16 @@ async function ensureBlankPair() {
     verbose("Global config already exists, skipping blank creation");
     return false;
   }
-  await ensureDir(path16.dirname(configPath));
+  await ensureDir(path18.dirname(configPath));
   await writeIfChanged(configPath, generateBlankGlobalConfigSource());
   await writeIfChanged(typesPath, generateBlankGlobalConfigTypesSource());
-  verbose(`Created blank global config at ${path16.dirname(configPath)}`);
+  verbose(`Created blank global config at ${path18.dirname(configPath)}`);
   return true;
 }
 
 // src/cli/lib/config-gate/propagate.ts
 import fs2 from "fs";
-import { isDeepEqual as isDeepEqual2, unique as unique3 } from "remeda";
+import { isDeepEqual as isDeepEqual2, unique as unique4 } from "remeda";
 async function writeConfigFile(config, configPath, options) {
   const source = generateConfigSource(config, options);
   await writeFile(configPath, source);
@@ -14197,9 +14652,9 @@ function mergeGlobalConfigs(existing, incoming) {
   const mergedSelectedDomains = [
     .../* @__PURE__ */ new Set([...existing.selectedDomains ?? [], ...incoming.selectedDomains ?? []])
   ];
+  const mergedMarketplaceName = existing.marketplaceName ?? incoming.marketplaceName;
   const mergedMarketplace = existing.marketplace ?? incoming.marketplace;
-  const mergedSource = existing.source ?? incoming.source;
-  const changed = newSkills.length > 0 || newAgents.length > 0 || stackChanged || !isDeepEqual2(existing.selectedDomains ?? [], mergedSelectedDomains) || mergedMarketplace !== existing.marketplace || mergedSource !== existing.source;
+  const changed = newSkills.length > 0 || newAgents.length > 0 || stackChanged || !isDeepEqual2(existing.selectedDomains ?? [], mergedSelectedDomains) || mergedMarketplaceName !== existing.marketplaceName || mergedMarketplace !== existing.marketplace;
   return {
     config: {
       ...existing,
@@ -14207,8 +14662,8 @@ function mergeGlobalConfigs(existing, incoming) {
       agents: mergedAgents,
       stack: mergedStack,
       selectedDomains: mergedSelectedDomains,
-      ...mergedMarketplace !== void 0 && { marketplace: mergedMarketplace },
-      ...mergedSource !== void 0 && { source: mergedSource }
+      ...mergedMarketplaceName !== void 0 && { marketplaceName: mergedMarketplaceName },
+      ...mergedMarketplace !== void 0 && { marketplace: mergedMarketplace }
     },
     changed
   };
@@ -14362,7 +14817,7 @@ function inlinedProjectView(reconciledSplit, effectiveGlobal) {
     ...reconciledSplit,
     skills: [...effectiveGlobal.skills, ...reconciledSplit.skills],
     agents: [...effectiveGlobal.agents, ...reconciledSplit.agents],
-    selectedDomains: unique3([
+    selectedDomains: unique4([
       ...effectiveGlobal.selectedDomains ?? [],
       ...reconciledSplit.selectedDomains ?? []
     ]),
@@ -14426,12 +14881,8 @@ async function pruneGlobalEntriesFromRegisteredProjects(globalConfig, matrix2, a
   };
   return propagateGlobalChangesToProjects(emptiedGlobal, matrix2, agents);
 }
-async function resolveEffectiveGlobalConfig(globalSplit, existingGlobalConfig, projectDir) {
-  const hasGlobalItems = globalSplit.skills.length > 0 || globalSplit.agents.length > 0;
-  const merged = !hasGlobalItems ? {
-    config: existingGlobalConfig ?? { name: GLOBAL_CONFIG_NAME, skills: [], agents: [] },
-    changed: false
-  } : existingGlobalConfig ? mergeGlobalConfigs(existingGlobalConfig, globalSplit) : { config: globalSplit, changed: true };
+async function resolveEffectiveGlobalConfig(globalSplit, existingGlobalConfig, projectDir, authority) {
+  const merged = authority === "all" ? matchGlobalToSession(globalSplit, existingGlobalConfig) : addSessionToGlobal(globalSplit, existingGlobalConfig);
   const registration = await registerProjectPath(merged.config, projectDir);
   return {
     config: registration.config,
@@ -14439,6 +14890,22 @@ async function resolveEffectiveGlobalConfig(globalSplit, existingGlobalConfig, p
     changed: merged.changed || registration.changed
   };
 }
+function addSessionToGlobal(globalSplit, existingGlobalConfig) {
+  const hasGlobalItems = globalSplit.skills.length > 0 || globalSplit.agents.length > 0;
+  if (!hasGlobalItems) {
+    return {
+      config: existingGlobalConfig ?? { name: GLOBAL_CONFIG_NAME, skills: [], agents: [] },
+      changed: false
+    };
+  }
+  if (!existingGlobalConfig) return { config: globalSplit, changed: true };
+  return mergeGlobalConfigs(existingGlobalConfig, globalSplit);
+}
+function matchGlobalToSession(globalSplit, existingGlobalConfig) {
+  if (!existingGlobalConfig) return { config: globalSplit, changed: true };
+  const config = mergeConfigs(globalSplit, existingGlobalConfig, { authoritativeScope: "all" });
+  return { config, changed: !isDeepEqual2(config, existingGlobalConfig) };
+}
 function buildConfigTypesBackgroundData(matrix2, agents) {
   const agentNames = typedKeys(agents);
   const customAgentNames = agentNames.filter((name) => agents[name]?.custom === true);
@@ -14450,13 +14917,13 @@ function stackCategories(stack) {
 function buildProjectTypesExtras(finalConfig, matrix2) {
   const activeSkills = finalConfig.skills.filter((s) => !s.excluded);
   const activeAgents = finalConfig.agents.filter((a) => !a.excluded);
-  const extraSkillIds = unique3(activeSkills.map((s) => s.id));
-  const extraAgentNames = unique3(activeAgents.map((a) => a.name));
-  const extraCategories = unique3([
+  const extraSkillIds = unique4(activeSkills.map((s) => s.id));
+  const extraAgentNames = unique4(activeAgents.map((a) => a.name));
+  const extraCategories = unique4([
     ...deriveCategories(extraSkillIds, matrix2),
     ...stackCategories(finalConfig.stack)
   ]);
-  const extraDomains = unique3([
+  const extraDomains = unique4([
     ...deriveDomains(extraCategories, matrix2),
     ...finalConfig.selectedDomains ?? []
   ]);
@@ -14472,7 +14939,7 @@ var NOTHING_RECOMPILED = {
 };
 async function recompilePropagated(projectDirs) {
   if (projectDirs.length === 0) return NOTHING_RECOMPILED;
-  const { recompilePropagatedProjectAgents } = await import("./recompile-project-agents-VREEPBDV.js");
+  const { recompilePropagatedProjectAgents } = await import("./recompile-project-agents-JE4MM72I.js");
   return recompilePropagatedProjectAgents(projectDirs);
 }
 
@@ -14502,7 +14969,7 @@ async function applyConsequences(globalConfig, changes, deps, currentProjectDir)
 function lazyGateDeps(projectDir) {
   return {
     loadMatrix: async () => {
-      const { loadSkillsMatrixFromSource: loadSkillsMatrixFromSource2 } = await import("./source-loader-OE6EJFPU.js");
+      const { loadSkillsMatrixFromSource: loadSkillsMatrixFromSource2 } = await import("./source-loader-3DL3NYUX.js");
       const { matrix: matrix2 } = await loadSkillsMatrixFromSource2({
         projectDir,
         skipExtraSources: true,
@@ -14511,8 +14978,8 @@ function lazyGateDeps(projectDir) {
       return matrix2;
     },
     loadAgents: async () => {
-      const { loadAgentDefs } = await import("./load-agent-defs-5OT54J5M.js");
-      return (await loadAgentDefs({ projectDir })).agents;
+      const { loadAgentDefs } = await import("./load-agent-defs-X4E57I2U.js");
+      return (await loadAgentDefs()).agents;
     }
   };
 }
@@ -14539,13 +15006,14 @@ async function writeFromProjectContext(args, homeDir, deps) {
   const effective = await resolveEffectiveGlobalConfig(
     globalConfig,
     existingGlobal?.config,
-    projectDir
+    projectDir,
+    args.authoritativeScope
   );
   const effectiveGlobalConfig = effective.config;
   const changes = classifyGlobalChange(existingGlobal?.config, effectiveGlobalConfig);
   let globalWritten = false;
   if (effective.changed) {
-    await ensureDir(path17.dirname(globalConfigPath));
+    await ensureDir(path19.dirname(globalConfigPath));
     globalWritten = await writeGlobalPair(effectiveGlobalConfig, globalConfigPath, matrix2, agents);
     verbose(`Updated global config at ${globalConfigPath}`);
   } else {
@@ -14564,7 +15032,7 @@ async function writeFromProjectContext(args, homeDir, deps) {
   );
   const hasProjectItems = reconciledProjectConfig.skills.length > 0 || reconciledProjectConfig.agents.length > 0;
   if (args.projectInstallationExists || hasProjectItems) {
-    await ensureDir(path17.dirname(projectConfigPath));
+    await ensureDir(path19.dirname(projectConfigPath));
     await writeProjectConfigPair(
       projectDir,
       reconciledProjectConfig,
@@ -14620,9 +15088,9 @@ async function reconcileTypesFromDisk(projectDir, config, deps, options) {
 }
 function withMigratedSource(skill, migratedSources) {
   if (!isActiveAt(skill, "global")) return skill;
-  const source = migratedSources.get(skill.id);
-  if (source === void 0 || source === skill.source) return skill;
-  return { ...skill, source };
+  const origin = migratedSources.get(skill.id);
+  if (origin === void 0 || origin === skill.origin) return skill;
+  return { ...skill, origin };
 }
 function applyMigratedGlobalSources(globalSkills, migratedSources) {
   const skills = globalSkills.map((skill) => withMigratedSource(skill, migratedSources));
@@ -14654,7 +15122,7 @@ function applyMutation(mutation, current) {
       return filtered.length === projects.length ? null : { ...current, projects: filtered };
     }
     case "set-source":
-      return { ...current, source: mutation.source };
+      return { ...current, marketplace: mutation.source };
     default: {
       const _exhaustive = mutation;
       return _exhaustive;
@@ -14711,7 +15179,7 @@ async function writeProjectPartial(projectDir, partial, options = {}) {
     throw new GlobalPairWriteViolation(getProjectConfigPath(projectDir));
   }
   const configPath = getProjectConfigPath(projectDir);
-  await ensureDir(path17.join(projectDir, CLAUDE_SRC_DIR));
+  await ensureDir(path19.join(projectDir, CLAUDE_SRC_DIR));
   await writeFile(
     configPath,
     generateConfigSource(fillRequiredFields(withNormalizedStack(partial), options.fallbackName))
@@ -14722,7 +15190,7 @@ async function writeProjectPartial(projectDir, partial, options = {}) {
 function computeNewlyAddedSkillIds(currentSkills, priorSkills) {
   const priorActiveIds = new Set((priorSkills ?? []).filter((s) => !s.excluded).map((s) => s.id));
   const currentActiveIds = currentSkills.filter((s) => !s.excluded).map((s) => s.id);
-  return unique4(currentActiveIds.filter((id) => !priorActiveIds.has(id)));
+  return unique5(currentActiveIds.filter((id) => !priorActiveIds.has(id)));
 }
 function computeScopeEligibilityGained(currentSkills, currentAgents, priorSkills, priorAgents) {
   const priorSkillScope = activeSkillScopeMap(priorSkills);
@@ -14747,7 +15215,7 @@ function resolveStackProperty(generated, assigned) {
   return generated && assigned ? assigned : generated;
 }
 function configNameFor(projectDir) {
-  return isHomeDirectory(projectDir) ? DEFAULT_PLUGIN_NAME : path18.basename(projectDir);
+  return isHomeDirectory(projectDir) ? DEFAULT_PLUGIN_NAME : path20.basename(projectDir);
 }
 async function loadCuratedStack(projectDir, projectStack) {
   const globalStack = isHomeDirectory(projectDir) ? void 0 : await loadGlobalStack();
@@ -14757,7 +15225,7 @@ async function loadGlobalStack() {
   return (await loadProjectConfigFromDir(os13.homedir()))?.config.stack;
 }
 async function buildEjectConfig(wizardResult, sourceResult, projectDir) {
-  const skillIds = unique4(wizardResult.skills.map((s) => s.id));
+  const skillIds = unique5(wizardResult.skills.map((s) => s.id));
   verbose(
     `buildEjectConfig: selectedStackId='${wizardResult.selectedStackId}', skills=[${skillIds.join(", ")}], selectedAgents=[${wizardResult.selectedAgents.join(", ")}]`
   );
@@ -14816,12 +15284,12 @@ function setConfigMetadata(config, wizardResult, sourceResult, sourceFlag) {
     result.selectedDomains = wizardResult.selectedDomains;
   }
   if (sourceFlag) {
-    result.source = sourceFlag;
+    result.marketplace = sourceFlag;
   } else if (sourceResult.sourceConfig.source) {
-    result.source = sourceResult.sourceConfig.source;
+    result.marketplace = sourceResult.sourceConfig.source;
   }
   if (sourceResult.marketplace) {
-    result.marketplace = sourceResult.marketplace;
+    result.marketplaceName = sourceResult.marketplace;
   }
   return result;
 }
@@ -14846,7 +15314,7 @@ function buildCompileAgents(config, agents) {
   const globalSkillIds = new Set(
     config.skills.filter((s) => isActiveAt(s, "global")).map((s) => s.id)
   );
-  const sourceById = new Map(config.skills.map((s) => [s.id, s.source]));
+  const sourceById = new Map(config.skills.map((s) => [s.id, s.origin]));
   const buildAgentCompileEntry = (agentConfig) => {
     const tuning = {
       ...agentConfig.model !== void 0 && { model: agentConfig.model },
@@ -14872,7 +15340,7 @@ function buildAgentScopeMap(config) {
 
 // src/cli/utils/exec.ts
 import { spawn } from "child_process";
-import { z as z4 } from "zod";
+import { z as z8 } from "zod";
 import os14 from "os";
 var MAX_PLUGIN_PATH_LENGTH = 1024;
 var MAX_PLUGIN_NAME_LENGTH = 256;
@@ -14901,20 +15369,20 @@ Plugin paths may only contain alphanumeric characters, dashes, underscores, dots
 }
 function validateMarketplaceSource(source) {
   if (!source || source.trim().length === 0) {
-    throw new Error("Marketplace source must not be empty.");
+    throw new Error("Marketplace must not be empty.");
   }
   if (source.length > MAX_MARKETPLACE_SOURCE_LENGTH) {
     throw new Error(
-      `Marketplace source is too long (${source.length} characters, max ${MAX_MARKETPLACE_SOURCE_LENGTH}).`
+      `Marketplace is too long (${source.length} characters, max ${MAX_MARKETPLACE_SOURCE_LENGTH}).`
     );
   }
   if (CONTROL_CHAR_PATTERN.test(source)) {
-    throw new Error("Marketplace source contains invalid control characters.");
+    throw new Error("Marketplace contains invalid control characters.");
   }
   if (!SAFE_PLUGIN_PATH_PATTERN.test(source)) {
     throw new Error(
-      `Marketplace source contains invalid characters: "${source}"
-Source may only contain alphanumeric characters, dashes, underscores, dots, slashes, @, and colons.`
+      `Marketplace contains invalid characters: "${source}"
+Marketplaces may only contain alphanumeric characters, dashes, underscores, dots, slashes, @, and colons.`
     );
   }
 }
@@ -14967,11 +15435,15 @@ async function execCommand(command, args, options) {
 function resolvePluginCwd(scope, projectDir) {
   return scope === "user" ? os14.homedir() : projectDir;
 }
-async function claudePluginInstall(pluginPath, scope, projectDir) {
+function configDirEnv(options) {
+  if (options?.configDir === void 0) return {};
+  return { env: { CLAUDE_CONFIG_DIR: options.configDir } };
+}
+async function claudePluginInstall(pluginPath, scope, projectDir, options) {
   validatePluginPath(pluginPath);
   const cwd = resolvePluginCwd(scope, projectDir);
   const args = ["plugin", "install", pluginPath, "--scope", scope];
-  const result = await execCommand("claude", args, { cwd });
+  const result = await execCommand("claude", args, { cwd, ...configDirEnv(options) });
   if (result.exitCode !== 0) {
     const errorMessage = result.stderr || result.stdout || "Unknown error";
     throw new Error(`Plugin installation failed: ${errorMessage.trim()}`);
@@ -14985,17 +15457,21 @@ async function isClaudeCLIAvailable() {
     return false;
   }
 }
-var marketplaceInfoListSchema = z4.array(
-  z4.object({
-    name: z4.string(),
-    source: z4.string(),
-    repo: z4.string().exactOptional(),
-    path: z4.string().exactOptional()
+var marketplaceInfoListSchema = z8.array(
+  z8.object({
+    name: z8.string(),
+    source: z8.string(),
+    repo: z8.string().exactOptional(),
+    path: z8.string().exactOptional()
   })
 );
-async function claudePluginMarketplaceList() {
+async function claudePluginMarketplaceList(options) {
   try {
-    const result = await execCommand("claude", ["plugin", "marketplace", "list", "--json"], {});
+    const result = await execCommand(
+      "claude",
+      ["plugin", "marketplace", "list", "--json"],
+      configDirEnv(options)
+    );
     if (result.exitCode !== 0) {
       return [];
     }
@@ -15016,16 +15492,16 @@ async function claudePluginMarketplaceList() {
     return [];
   }
 }
-async function claudePluginMarketplaceExists(name) {
-  const marketplaces = await claudePluginMarketplaceList();
+async function claudePluginMarketplaceExists(name, options) {
+  const marketplaces = await claudePluginMarketplaceList(options);
   return marketplaces.some((m) => m.name === name);
 }
-async function claudePluginMarketplaceAdd(source) {
+async function claudePluginMarketplaceAdd(source, options) {
   validateMarketplaceSource(source);
   const args = ["plugin", "marketplace", "add", source];
   let result;
   try {
-    result = await execCommand("claude", args, {});
+    result = await execCommand("claude", args, configDirEnv(options));
   } catch (err) {
     throw new Error(`Failed to add marketplace: ${getErrorMessage(err)}`, { cause: err });
   }
@@ -15037,12 +15513,12 @@ async function claudePluginMarketplaceAdd(source) {
     throw new Error(`Failed to add marketplace: ${errorMessage.trim()}`);
   }
 }
-async function claudePluginMarketplaceUpdate(name) {
+async function claudePluginMarketplaceUpdate(name, options) {
   validatePluginName(name);
   const args = ["plugin", "marketplace", "update", name];
   let result;
   try {
-    result = await execCommand("claude", args, {});
+    result = await execCommand("claude", args, configDirEnv(options));
   } catch (err) {
     throw new Error(`Failed to update marketplace: ${getErrorMessage(err)}`, { cause: err });
   }
@@ -15051,11 +15527,11 @@ async function claudePluginMarketplaceUpdate(name) {
     throw new Error(`Failed to update marketplace: ${errorMessage.trim()}`);
   }
 }
-async function claudePluginUninstall(pluginName, scope, projectDir) {
+async function claudePluginUninstall(pluginName, scope, projectDir, options) {
   validatePluginName(pluginName);
   const cwd = resolvePluginCwd(scope, projectDir);
   const args = ["plugin", "uninstall", pluginName, "--scope", scope];
-  const result = await execCommand("claude", args, { cwd });
+  const result = await execCommand("claude", args, { cwd, ...configDirEnv(options) });
   if (result.exitCode !== 0) {
     const errorMessage = result.stderr || result.stdout || "Unknown error";
     if (errorMessage.includes("not installed") || errorMessage.includes("not found")) {
@@ -15064,19 +15540,22 @@ async function claudePluginUninstall(pluginName, scope, projectDir) {
     throw new Error(`Plugin uninstall failed: ${errorMessage.trim()}`);
   }
 }
-async function claudePluginUninstallBestEffort(pluginRef, primaryScope, projectDir) {
+async function claudePluginUninstallBestEffort(pluginRef, primaryScope, projectDir, options) {
   const fallbackScope = primaryScope === "project" ? "user" : "project";
   try {
-    await claudePluginUninstall(pluginRef, primaryScope, projectDir);
+    await claudePluginUninstall(pluginRef, primaryScope, projectDir, options);
   } catch {
   }
   try {
-    await claudePluginUninstall(pluginRef, fallbackScope, projectDir);
+    await claudePluginUninstall(pluginRef, fallbackScope, projectDir, options);
   } catch {
   }
 }
 
 // src/cli/lib/installation/mode-migrator.ts
+function ejectCopyFailureError(failedCount) {
+  return `Failed to copy ${failedCount} skill(s) for eject. Eject intent could not be honored. Check that the destination skills directory is writable, then run '${CLI_INVOKE_COMMAND} edit' again \u2014 or switch the affected skills back to plugin mode.`;
+}
 function detectMigrations(oldSkills, newSkills) {
   const toEject = [];
   const toPlugin = [];
@@ -15087,13 +15566,13 @@ function detectMigrations(oldSkills, newSkills) {
     if (!oldSkill) continue;
     const migration = {
       id: newSkill.id,
-      oldSource: oldSkill.source,
-      newSource: newSkill.source,
+      oldSource: oldSkill.origin,
+      newSource: newSkill.origin,
       oldScope: oldSkill.scope,
       newScope: newSkill.scope
     };
-    const wasEject = oldSkill.source === EJECT_SOURCE;
-    const isEject = newSkill.source === EJECT_SOURCE;
+    const wasEject = oldSkill.origin === EJECT_SOURCE;
+    const isEject = newSkill.origin === EJECT_SOURCE;
     if (wasEject && !isEject) {
       toPlugin.push(migration);
     } else if (!wasEject && isEject) {
@@ -15106,48 +15585,17 @@ function detectMigrations(oldSkills, newSkills) {
   return { toEject, toPlugin, scopeChanges };
 }
 async function executeMigration(plan, projectDir, sourceResult) {
-  const warnings = [];
-  const ejectedSkills = [];
   const pluginInstalls = { installed: [], failed: [] };
-  if (plan.toEject.length > 0) {
-    try {
-      const scopes = ["project", "global"];
-      for (const scope of scopes) {
-        const migrations = plan.toEject.filter(
-          (m) => scope === "global" ? m.newScope === "global" : m.newScope !== "global"
-        );
-        if (migrations.length === 0) continue;
-        const copied = await copySkillsToLocalFlattened(
-          migrations.map((m) => m.id),
-          resolveInstallPaths(projectDir, scope).skillsDir,
-          sourceResult
-        );
-        ejectedSkills.push(...copied.map((skill) => skill.skillId));
-      }
-      if (!sourceResult.marketplace) {
-        warnings.push(
-          ...plan.toEject.filter((m) => !(m.oldScope === "global" && m.newScope === "project")).map((m) => `Could not uninstall plugin for ${m.id}: no marketplace configured`)
-        );
-      } else {
-        for (const migration of plan.toEject) {
-          if (migration.oldScope === "global" && migration.newScope === "project") {
-            verbose(`Keeping global plugin for ${migration.id} (migrated to project-eject)`);
-            continue;
-          }
-          const pluginScope = toClaudePluginScope(migration.oldScope);
-          const pluginRef = buildMarketplacePluginRef(migration.id, sourceResult.marketplace);
-          await claudePluginUninstall(pluginRef, pluginScope, projectDir);
-          verbose(`Uninstalled plugin for ${migration.id}`);
-        }
-      }
-    } catch (error) {
-      warnings.push(`Could not copy skills for eject: ${getErrorMessage(error)}`);
-    }
-  }
+  const ejectCopies = await copyMigratedSkillsToLocal(plan.toEject, projectDir, sourceResult);
+  const warnings = await uninstallMigratedPlugins(
+    migrationsWhoseCopyLanded(plan.toEject, ejectCopies),
+    projectDir,
+    sourceResult
+  );
   if (plan.toPlugin.length > 0) {
     if (!sourceResult.marketplace) {
       throw new Error(
-        `Cannot install skills as plugins: marketplace could not be resolved from source '${sourceResult.sourceConfig.source}'. Plugin install mode requires a marketplace \u2014 fix the source or switch the affected skills to eject mode.`
+        `Cannot install skills as plugins: marketplace could not be resolved from '${sourceResult.sourceConfig.source}'. Plugin install mode requires a marketplace \u2014 fix the marketplace or switch the affected skills to eject mode.`
       );
     }
     for (const migration of plan.toPlugin) {
@@ -15164,7 +15612,50 @@ async function executeMigration(plan, projectDir, sourceResult) {
       await deleteEjectedWorkingCopy(migration, projectDir);
     }
   }
-  return { ejectedSkills, pluginInstalls, warnings };
+  return { ejectCopies, pluginInstalls, warnings };
+}
+async function copyMigratedSkillsToLocal(migrations, projectDir, sourceResult) {
+  const copies = { copied: [], failed: [] };
+  for (const migration of migrations) {
+    const { skillsDir } = resolveInstallPaths(projectDir, migration.newScope);
+    try {
+      const copied = await copySkillsToLocalFlattened([migration.id], skillsDir, sourceResult);
+      copies.copied.push(...copied.map((skill) => skill.skillId));
+    } catch (error) {
+      copies.failed.push({ id: migration.id, error: getErrorMessage(error) });
+    }
+  }
+  return copies;
+}
+function migrationsWhoseCopyLanded(migrations, copies) {
+  const landed = new Set(copies.copied);
+  return migrations.filter((migration) => landed.has(migration.id));
+}
+function keepsGlobalPluginRegistration(migration) {
+  return migration.oldScope === "global" && migration.newScope === "project";
+}
+async function uninstallMigratedPlugins(migrations, projectDir, sourceResult) {
+  const warnings = [];
+  for (const migration of migrations) {
+    if (keepsGlobalPluginRegistration(migration)) {
+      verbose(`Keeping global plugin for ${migration.id} (migrated to project-eject)`);
+      continue;
+    }
+    if (!sourceResult.marketplace) {
+      warnings.push(`Could not uninstall plugin for ${migration.id}: no marketplace configured`);
+      continue;
+    }
+    const pluginScope = toClaudePluginScope(migration.oldScope);
+    const pluginRef = buildMarketplacePluginRef(migration.id, sourceResult.marketplace);
+    try {
+      await claudePluginUninstall(pluginRef, pluginScope, projectDir);
+    } catch (error) {
+      warnings.push(`Could not uninstall plugin for ${migration.id}: ${getErrorMessage(error)}`);
+      continue;
+    }
+    verbose(`Uninstalled plugin for ${migration.id}`);
+  }
+  return warnings;
 }
 async function deleteEjectedWorkingCopy(migration, projectDir) {
   if (migration.oldScope === "global" && migration.newScope === "project") {
@@ -15175,28 +15666,34 @@ async function deleteEjectedWorkingCopy(migration, projectDir) {
 }
 
 // src/cli/lib/plugins/plugin-settings.ts
-import path19 from "path";
-import { z as z5 } from "zod";
-var pluginSettingsSchema = z5.object({
-  enabledPlugins: z5.record(z5.string(), z5.unknown()).optional()
+import path21 from "path";
+import { z as z9 } from "zod";
+var pluginSettingsSchema = z9.object({
+  // The one genuine optional here: a settings.json with no plugin enabled omits the
+  // key entirely, and `getEnabledPluginKeys` says so in its own diagnostic rather than
+  // defaulting it away. `lastUpdated` and `gitCommitSha` used to sit beside the fields
+  // below on the same footing and were decoration — declared, never read, and stripped
+  // by `z.object` either way.
+  enabledPlugins: z9.record(z9.string(), z9.unknown()).exactOptional()
 }).passthrough();
-var pluginInstallationSchema = z5.object({
-  scope: z5.enum(["user", "project", "local"]),
-  projectPath: z5.string().optional(),
-  installPath: z5.string(),
-  version: z5.string(),
-  installedAt: z5.string(),
-  lastUpdated: z5.string().optional(),
-  gitCommitSha: z5.string().optional()
-});
-var installedPluginsSchema = z5.object({
-  version: z5.number(),
-  plugins: z5.record(z5.string(), z5.array(pluginInstallationSchema))
+var installationFields = {
+  installPath: z9.string(),
+  version: z9.string(),
+  installedAt: z9.string()
+};
+var pluginInstallationSchema = z9.discriminatedUnion("scope", [
+  z9.object({ scope: z9.literal("project"), projectPath: z9.string(), ...installationFields }),
+  z9.object({ scope: z9.literal("user"), ...installationFields }),
+  z9.object({ scope: z9.literal("local"), ...installationFields })
+]);
+var installedPluginsSchema = z9.object({
+  version: z9.number(),
+  plugins: z9.record(z9.string(), z9.array(pluginInstallationSchema))
 }).passthrough();
 var SETTINGS_FILE = STANDARD_FILES.SETTINGS_JSON;
 var INSTALLED_PLUGINS_FILE = "installed_plugins.json";
 function getInstalledPluginsRegistryPath(pluginsDir) {
-  return path19.join(pluginsDir, INSTALLED_PLUGINS_FILE);
+  return path21.join(pluginsDir, INSTALLED_PLUGINS_FILE);
 }
 async function listRegisteredPluginInstalls(pluginsDir) {
   const registryPath = getInstalledPluginsRegistryPath(pluginsDir);
@@ -15214,7 +15711,7 @@ async function listRegisteredPluginInstalls(pluginsDir) {
   });
 }
 async function getEnabledPluginKeys(projectDir) {
-  const settingsPath = path19.join(projectDir, CLAUDE_DIR, SETTINGS_FILE);
+  const settingsPath = path21.join(projectDir, CLAUDE_DIR, SETTINGS_FILE);
   if (!await fileExists(settingsPath)) {
     verbose(`No settings.json found at '${settingsPath}'`);
     return [];
@@ -15357,8 +15854,7 @@ async function getInstallationInfo() {
     skillCount,
     agentCount: sumCounts(agentDirCounts),
     configPath: installation.configPath,
-    agentDirs: agentDirCounts.filter(hasEntries).map((scopeCount) => scopeCount.dir),
-    skillsDir: installation.skillsDir
+    agentDirs: agentDirCounts.filter(hasEntries).map((scopeCount) => scopeCount.dir)
   };
 }
 function installedScopes(installation) {
@@ -15427,7 +15923,7 @@ function formatInstallationDisplay(info) {
 }
 
 // src/cli/lib/plugins/plugin-validator.ts
-import path20 from "path";
+import path22 from "path";
 import fg from "fast-glob";
 var PLUGIN_DIR = PLUGIN_MANIFEST_DIR;
 var PLUGIN_MANIFEST = STANDARD_FILES.PLUGIN_JSON;
@@ -15444,15 +15940,15 @@ async function validatePluginStructure(pluginPath) {
   if (!await directoryExists(pluginPath)) {
     return invalidResult(`Plugin directory does not exist: ${pluginPath}`);
   }
-  const pluginDir = path20.join(pluginPath, PLUGIN_DIR);
+  const pluginDir = path22.join(pluginPath, PLUGIN_DIR);
   if (!await directoryExists(pluginDir)) {
     errors.push(`Missing ${PLUGIN_DIR}/ directory`);
   }
-  const manifestPath = path20.join(pluginDir, PLUGIN_MANIFEST);
+  const manifestPath = path22.join(pluginDir, PLUGIN_MANIFEST);
   if (!await fileExists(manifestPath)) {
     errors.push(`Missing ${PLUGIN_DIR}/${PLUGIN_MANIFEST}`);
   }
-  const readmePath = path20.join(pluginPath, STANDARD_FILES.README_MD);
+  const readmePath = path22.join(pluginPath, STANDARD_FILES.README_MD);
   if (!await fileExists(readmePath)) {
     warnings.push("Missing README.md (recommended for documentation)");
   }
@@ -15496,15 +15992,15 @@ async function validatePluginManifest(manifestPath) {
   if (!manifest.description) {
     warnings.push("Missing description field (recommended for discoverability)");
   }
-  const pluginDir = path20.dirname(path20.dirname(manifestPath));
+  const pluginDir = path22.dirname(path22.dirname(manifestPath));
   if (manifest.skills && typeof manifest.skills === "string") {
-    const skillsPath = path20.join(pluginDir, manifest.skills);
+    const skillsPath = path22.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 = path20.join(pluginDir, manifest.agents);
+    const agentsPath = path22.join(pluginDir, manifest.agents);
     if (!await directoryExists(agentsPath)) {
       errors.push(`Agents path does not exist: ${manifest.agents}`);
     }
@@ -15571,7 +16067,7 @@ function prefixResult(result, prefix) {
   };
 }
 async function validatePluginSkillFiles(pluginPath, skillsRelPath) {
-  const skillsDir = path20.join(pluginPath, skillsRelPath);
+  const skillsDir = path22.join(pluginPath, skillsRelPath);
   if (!await directoryExists(skillsDir)) return validResult();
   const files = await fg(`**/${STANDARD_FILES.SKILL_MD}`, { cwd: skillsDir, absolute: true });
   if (files.length === 0) {
@@ -15583,13 +16079,13 @@ async function validatePluginSkillFiles(pluginPath, skillsRelPath) {
   }
   const results = await Promise.all(
     files.map(
-      async (f) => prefixResult(await validateSkillFrontmatter(f), path20.relative(pluginPath, f))
+      async (f) => prefixResult(await validateSkillFrontmatter(f), path22.relative(pluginPath, f))
     )
   );
   return mergeValidationResults(results);
 }
 async function validatePluginAgentFiles(pluginPath, agentsRelPath) {
-  const agentsDir = path20.join(pluginPath, agentsRelPath);
+  const agentsDir = path22.join(pluginPath, agentsRelPath);
   if (!await directoryExists(agentsDir)) return validResult();
   const files = await fg("*.md", { cwd: agentsDir, absolute: true });
   if (files.length === 0) {
@@ -15601,7 +16097,7 @@ async function validatePluginAgentFiles(pluginPath, agentsRelPath) {
   }
   const results = await Promise.all(
     files.map(
-      async (f) => prefixResult(await validateAgentFrontmatter(f), path20.relative(pluginPath, f))
+      async (f) => prefixResult(await validateAgentFrontmatter(f), path22.relative(pluginPath, f))
     )
   );
   return mergeValidationResults(results);
@@ -15643,7 +16139,7 @@ async function validateAllPlugins(pluginsDir) {
   const dirChecks = await Promise.all(
     allDirs.map(async (dirName) => ({
       dirName,
-      isPlugin: await directoryExists(path20.join(pluginsDir, dirName, PLUGIN_DIR))
+      isPlugin: await directoryExists(path22.join(pluginsDir, dirName, PLUGIN_DIR))
     }))
   );
   const pluginDirs = dirChecks.filter((c) => c.isPlugin).map((c) => c.dirName);
@@ -15662,7 +16158,7 @@ async function validateAllPlugins(pluginsDir) {
     };
   }
   for (const pluginName of pluginDirs) {
-    const pluginPath = path20.join(pluginsDir, pluginName);
+    const pluginPath = path22.join(pluginsDir, pluginName);
     const result = await validatePlugin(pluginPath);
     results.push({ name: pluginName, result });
   }
@@ -15685,7 +16181,7 @@ function sanitizeSkillName(name) {
   return name.replace(/\+/g, "-");
 }
 async function readSkillMetadata2(skillPath) {
-  const metadataPath = path21.join(skillPath, STANDARD_FILES.METADATA_YAML);
+  const metadataPath = path23.join(skillPath, STANDARD_FILES.METADATA_YAML);
   if (!await fileExists(metadataPath)) {
     return null;
   }
@@ -15729,8 +16225,8 @@ This skill is automatically available when installed.
 }
 async function compileSkillPlugin(options) {
   const { skillPath, outputDir, skillName: overrideName } = options;
-  const dirBasename = path21.basename(skillPath);
-  const skillMdPath = path21.join(skillPath, STANDARD_FILES.SKILL_MD);
+  const dirBasename = path23.basename(skillPath);
+  const skillMdPath = path23.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}`
@@ -15746,8 +16242,8 @@ async function compileSkillPlugin(options) {
   const skillName = overrideName ?? sanitizeSkillName(frontmatter.name);
   verbose(`Compiling skill plugin: ${skillName} from ${skillPath}`);
   const metadata = await readSkillMetadata2(skillPath);
-  const pluginDir = path21.join(outputDir, skillName);
-  const skillsDir = path21.join(pluginDir, "skills", skillName);
+  const pluginDir = path23.join(outputDir, skillName);
+  const skillsDir = path23.join(pluginDir, "skills", skillName);
   await ensureDir(pluginDir);
   await ensureDir(skillsDir);
   const newHash = await computeSkillFolderHash(skillPath);
@@ -15766,26 +16262,26 @@ async function compileSkillPlugin(options) {
   await writePluginManifest(pluginDir, manifest);
   await writeContentHash(pluginDir, contentHash, getPluginManifestPath);
   verbose(`  Wrote plugin.json for ${skillName} (v${version})`);
-  await writeFile(path21.join(skillsDir, STANDARD_FILES.SKILL_MD), skillMdContent);
+  await writeFile(path23.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 = path21.join(skillPath, fileName);
+    const sourcePath = path23.join(skillPath, fileName);
     if (await fileExists(sourcePath)) {
       const content = await readFile(sourcePath);
-      await writeFile(path21.join(skillsDir, fileName), content);
+      await writeFile(path23.join(skillsDir, fileName), content);
       verbose(`  Copied ${fileName}`);
     }
   }
   for (const dirName of SKILL_CONTENT_DIRS) {
-    const sourceDir = path21.join(skillPath, dirName);
+    const sourceDir = path23.join(skillPath, dirName);
     if (await fileExists(sourceDir)) {
-      await copy(sourceDir, path21.join(skillsDir, dirName));
+      await copy(sourceDir, path23.join(skillsDir, dirName));
       verbose(`  Copied ${dirName}/`);
     }
   }
   const readme = generateReadme(skillName, frontmatter);
-  await writeFile(path21.join(pluginDir, STANDARD_FILES.README_MD), readme);
+  await writeFile(path23.join(pluginDir, STANDARD_FILES.README_MD), readme);
   verbose("  Generated README.md");
   return {
     pluginPath: pluginDir,
@@ -15798,7 +16294,7 @@ async function compileAllSkillPlugins(skillsDir, outputDir) {
   const failed = [];
   const skillMdFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir);
   for (const skillMdFile of skillMdFiles) {
-    const skillPath = path21.join(skillsDir, path21.dirname(skillMdFile));
+    const skillPath = path23.join(skillsDir, path23.dirname(skillMdFile));
     try {
       const result = await compileSkillPlugin({
         skillPath,
@@ -15808,7 +16304,7 @@ async function compileAllSkillPlugins(skillsDir, outputDir) {
       log(`  [OK] ${result.skillName}`);
     } catch (error) {
       const errorMessage = getErrorMessage(error);
-      const dirBasename = path21.basename(skillPath);
+      const dirBasename = path23.basename(skillPath);
       failed.push(dirBasename);
       warn(`Failed to compile skill from '${dirBasename}': ${errorMessage}`);
     }
@@ -15824,9 +16320,9 @@ Compiled ${results.length} skill plugins:`);
 }
 
 // src/cli/lib/skills/local-skill-loader.ts
-import path22 from "path";
+import path24 from "path";
 async function discoverLocalSkills(projectDir) {
-  const localSkillsPath = path22.join(projectDir, LOCAL_SKILLS_PATH);
+  const localSkillsPath = path24.join(projectDir, LOCAL_SKILLS_PATH);
   if (!await directoryExists(localSkillsPath)) {
     verbose(`Local skills directory not found: ${localSkillsPath}`);
     return null;
@@ -15843,9 +16339,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 = path24.join(localSkillsPath, skillDirName);
+  const metadataPath = path24.join(skillDir, STANDARD_FILES.METADATA_YAML);
+  const skillMdPath = path24.join(skillDir, STANDARD_FILES.SKILL_MD);
   if (!await fileExists(metadataPath)) {
     verbose(`Skipping local skill '${skillDirName}': No metadata.yaml found`);
     return null;
@@ -15862,6 +16358,12 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
     return null;
   }
   const metadata = read.metadata;
+  if (metadata.category === LOCAL_PSEUDO_CATEGORY) {
+    warn(
+      `Skipping local skill '${skillDirName}': ${METADATA_KEYS.CATEGORY} '${LOCAL_PSEUDO_CATEGORY}' is a placeholder, not a real category, so no sub-agent can be given this skill. Set ${METADATA_KEYS.CATEGORY} in ${metadataPath} to a real one.`
+    );
+    return null;
+  }
   const skillMdContent = await readFile(skillMdPath);
   const frontmatter = parseFrontmatter(skillMdContent, skillMdPath);
   if (!frontmatter) {
@@ -15869,7 +16371,7 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
     return null;
   }
   const relativePath = `${LOCAL_SKILLS_PATH}/${skillDirName}/`;
-  const absolutePath = path22.join(localSkillsPath, skillDirName) + path22.sep;
+  const absolutePath = path24.join(localSkillsPath, skillDirName) + path24.sep;
   const skillId = frontmatter.name;
   const extracted = {
     id: skillId,
@@ -15891,7 +16393,7 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
 }
 
 // src/cli/lib/skills/unresolved-skill-entries.ts
-import path23 from "path";
+import path25 from "path";
 async function findUnusableSavedSkillMetadata(unresolvedIds, savedSkills, projectDir) {
   const classified = await classifyUnresolvedSkills(unresolvedIds, savedSkills, projectDir);
   return classified.flatMap(({ fate }) => fate.kind === "unusable-metadata" ? [fate.detail] : []);
@@ -15914,10 +16416,10 @@ async function classifyUnresolvedSkills(unresolvedIds, savedSkills, projectDir)
   );
 }
 async function classifySavedSkill(id, saved, projectDir) {
-  if (saved?.source !== EJECT_SOURCE) return { kind: "dropped-by-source" };
-  const skillDir = path23.join(resolveInstallPaths(projectDir, saved.scope).skillsDir, id);
+  if (saved?.origin !== EJECT_SOURCE) return { kind: "dropped-by-source" };
+  const skillDir = path25.join(resolveInstallPaths(projectDir, saved.scope).skillsDir, id);
   if (!await directoryExists(skillDir)) return { kind: "files-gone", skillDir };
-  const metadataPath = path23.join(skillDir, STANDARD_FILES.METADATA_YAML);
+  const metadataPath = path25.join(skillDir, STANDARD_FILES.METADATA_YAML);
   if (!await fileExists(metadataPath)) return { kind: "not-installed-there", skillDir };
   const read = await readSkillMetadata(metadataPath);
   if (!read.usable) {
@@ -15930,7 +16432,7 @@ async function classifySavedSkill(id, saved, projectDir) {
   return { kind: "unplaceable-category", skillDir, category: read.metadata.category };
 }
 async function skillMdNames(skillDir, id) {
-  const skillMdPath = path23.join(skillDir, STANDARD_FILES.SKILL_MD);
+  const skillMdPath = path25.join(skillDir, STANDARD_FILES.SKILL_MD);
   if (!await fileExists(skillMdPath)) return false;
   const frontmatter = parseFrontmatter(await readFile(skillMdPath), skillMdPath);
   return frontmatter?.name === id;
@@ -15955,7 +16457,7 @@ function removalReason(id, fate, sourceLabel) {
 }
 
 // src/cli/lib/skills/local-skill-mover.ts
-import path24 from "path";
+import path26 from "path";
 function validateSkillId(skillId) {
   return !(skillId.length === 0 || skillId.includes("\0") || skillId.includes("..") || skillId.includes("/") || skillId.includes("\\"));
 }
@@ -15964,8 +16466,8 @@ async function deleteLocalSkill(projectDir, skillId) {
     warn(`Invalid skill ID for deletion: '${skillId}'`);
     return;
   }
-  const skillPath = path24.resolve(path24.join(projectDir, LOCAL_SKILLS_PATH, skillId));
-  const skillsDir = path24.resolve(path24.join(projectDir, LOCAL_SKILLS_PATH));
+  const skillPath = path26.resolve(path26.join(projectDir, LOCAL_SKILLS_PATH, skillId));
+  const skillsDir = path26.resolve(path26.join(projectDir, LOCAL_SKILLS_PATH));
   if (!isPathWithin(skillPath, skillsDir)) {
     warn(`Skill ID '${skillId}' resolves outside the skills directory.`);
     return;
@@ -15985,10 +16487,10 @@ async function migrateLocalSkillScope(skillId, fromScope, projectDir) {
   const toScope = fromScope === "global" ? "project" : "global";
   const fromBaseDir = installBaseDir(projectDir, fromScope);
   const toBaseDir = installBaseDir(projectDir, toScope);
-  const fromPath = path24.resolve(path24.join(fromBaseDir, LOCAL_SKILLS_PATH, skillId));
-  const toPath = path24.resolve(path24.join(toBaseDir, LOCAL_SKILLS_PATH, skillId));
-  const fromSkillsDir = path24.resolve(path24.join(fromBaseDir, LOCAL_SKILLS_PATH));
-  const toSkillsDir = path24.resolve(path24.join(toBaseDir, LOCAL_SKILLS_PATH));
+  const fromPath = path26.resolve(path26.join(fromBaseDir, LOCAL_SKILLS_PATH, skillId));
+  const toPath = path26.resolve(path26.join(toBaseDir, LOCAL_SKILLS_PATH, skillId));
+  const fromSkillsDir = path26.resolve(path26.join(fromBaseDir, LOCAL_SKILLS_PATH));
+  const toSkillsDir = path26.resolve(path26.join(toBaseDir, LOCAL_SKILLS_PATH));
   if (!isPathWithin(fromPath, fromSkillsDir)) {
     warn(`Skill ID '${skillId}' resolves outside the source skills directory.`);
     return;
@@ -16015,21 +16517,94 @@ async function migrateLocalSkillScope(skillId, fromScope, projectDir) {
 
 // src/cli/lib/matrix/matrix-loader.ts
 import { parse as parseYaml3 } from "yaml";
-import path25 from "path";
-
-// src/cli/lib/matrix/skill-resolution.ts
-import { uniqueBy as uniqueBy4 } from "remeda";
-
-// src/cli/utils/string.ts
-function truncateText(text, maxLength) {
-  if (text.length <= maxLength) return text;
-  return text.slice(0, maxLength - 1) + "\u2026";
+import path27 from "path";
+async function loadSkillCategories(configPath) {
+  const data = await loadConfig(configPath, skillCategoriesFileSchema);
+  if (!data) {
+    throw new Error(`Invalid skill categories at '${configPath}': failed to load or validate`);
+  }
+  verbose(`Loaded skill categories: ${configPath}`);
+  return data.categories;
 }
-function toTitleCase(kebabCase) {
-  return kebabCase.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+async function loadSkillRules(configPath) {
+  const data = await loadConfig(configPath, skillRulesFileSchema);
+  if (!data) {
+    throw new Error(`Invalid skill rules at '${configPath}': failed to load or validate`);
+  }
+  const config = {
+    version: data.version,
+    relationships: data.relationships ?? {
+      conflicts: [],
+      discourages: [],
+      requires: [],
+      alternatives: []
+    }
+  };
+  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 = path27.dirname(metadataFile);
+    const skillMdPath = path27.join(skillsDir, skillDir, STANDARD_FILES.SKILL_MD);
+    const metadataPath = path27.join(skillsDir, metadataFile);
+    if (!await fileExists(skillMdPath)) {
+      verbose(`Skipping ${metadataFile}: No ${STANDARD_FILES.SKILL_MD} found`);
+      continue;
+    }
+    const metadataContent = await readFile(metadataPath);
+    let rawMetadata;
+    try {
+      rawMetadata = parseYaml3(metadataContent);
+    } catch (error) {
+      warn(
+        `Skipping '${metadataFile}': unparseable ${STANDARD_FILES.METADATA_YAML} at ${metadataPath} \u2014 ${getErrorMessage(error)}`
+      );
+      continue;
+    }
+    const metadataResult = matrixRawMetadataSchema.safeParse(rawMetadata);
+    if (!metadataResult.success) {
+      warn(
+        `Skipping '${metadataFile}': invalid metadata.yaml \u2014 ${formatZodIssues(metadataResult.error.issues)}`
+      );
+      continue;
+    }
+    const metadata = metadataResult.data;
+    const skillMdContent = await readFile(skillMdPath);
+    const frontmatter = parseFrontmatter(skillMdContent, skillMdPath);
+    if (!frontmatter) {
+      verbose(`Skipping ${metadataFile}: Invalid SKILL.md frontmatter`);
+      continue;
+    }
+    if (!metadata.displayName) {
+      throw new Error(
+        `Skill at ${metadataFile} is missing required '${METADATA_KEYS.DISPLAY_NAME}' field in metadata.yaml`
+      );
+    }
+    const skillId = frontmatter.name;
+    const extracted = {
+      id: skillId,
+      directoryPath: skillDir,
+      description: metadata.cliDescription || frontmatter.description,
+      ...metadata.usageGuidance !== void 0 && { usageGuidance: metadata.usageGuidance },
+      category: metadata.category,
+      author: metadata.author,
+      path: `skills/${skillDir}/`,
+      domain: metadata.domain,
+      displayName: metadata.displayName,
+      slug: metadata.slug,
+      ...metadata.custom === true ? { custom: true } : {}
+    };
+    skills.push(extracted);
+    verbose(`Extracted skill: ${skillId}`);
+  }
+  return skills;
 }
 
 // src/cli/lib/matrix/skill-resolution.ts
+import { unique as unique6, uniqueBy as uniqueBy4 } from "remeda";
 var AUTO_SYNTH_ORDER = 999;
 function synthesizeCategory(category, domain) {
   verbose(
@@ -16046,21 +16621,36 @@ function synthesizeCategory(category, domain) {
     order: AUTO_SYNTH_ORDER
   };
 }
+function claimSlug(slugMap, slug, id) {
+  const incumbent = slugMap.slugToId[slug];
+  if (incumbent === id) return;
+  if (incumbent !== void 0) {
+    warn(`Duplicate slug '${slug}': already mapped to '${incumbent}', ignoring '${id}'`);
+    return;
+  }
+  slugMap.slugToId[slug] = id;
+  slugMap.idToSlug[id] = slug;
+}
 function buildSlugMap(skills) {
-  const slugToId = {};
-  const idToSlug = {};
+  const slugMap = { slugToId: {}, idToSlug: {} };
+  for (const skill of skills) {
+    claimSlug(slugMap, skill.slug, skill.id);
+  }
+  return slugMap;
+}
+function buildResolvedSkillMap(skills, categories, relationships, slugMap) {
+  const resolvedSkills = {};
   for (const skill of skills) {
-    const existingId = slugToId[skill.slug];
-    if (existingId) {
+    const existing = resolvedSkills[skill.id];
+    if (existing) {
       warn(
-        `Duplicate slug '${skill.slug}': already mapped to '${existingId}', ignoring '${skill.id}'`
+        `Duplicate skill id '${skill.id}': already resolved from '${existing.path}', ignoring '${skill.path}'`
       );
       continue;
     }
-    slugToId[skill.slug] = skill.id;
-    idToSlug[skill.id] = skill.slug;
+    resolvedSkills[skill.id] = buildResolvedSkill(skill, categories, relationships, slugMap);
   }
-  return { slugToId, idToSlug };
+  return resolvedSkills;
 }
 function resolveToCanonicalId(slug, slugToId, context) {
   const slugResult = slugToId[slug];
@@ -16071,13 +16661,48 @@ function resolveToCanonicalId(slug, slugToId, context) {
   warn(`Unresolved slug '${slug}'${location} \u2014 skipping`);
   return null;
 }
+function slugsNamedByRules(relationships) {
+  return [
+    ...relationships.conflicts.flatMap((rule) => rule.skills),
+    ...relationships.discourages.flatMap((rule) => rule.skills),
+    ...relationships.requires.flatMap((rule) => [rule.skill, ...rule.needs]),
+    ...relationships.alternatives.flatMap((rule) => rule.skills)
+  ];
+}
+function collectUnresolvedSlugs(relationships, slugToId) {
+  return unique6(slugsNamedByRules(relationships).filter((slug) => slugToId[slug] === void 0));
+}
+function mergeRelationships(source, defaults) {
+  return {
+    conflicts: [...source.conflicts, ...defaults.conflicts],
+    discourages: [...source.discourages, ...defaults.discourages],
+    requires: [...source.requires, ...defaults.requires],
+    alternatives: [...source.alternatives, ...defaults.alternatives]
+  };
+}
+var MIN_RELATABLE_GROUP_MEMBERS = 2;
+function narrowGroupsToSlugs(rules, shipped) {
+  return rules.map((rule) => ({ ...rule, skills: rule.skills.filter((slug) => shipped.has(slug)) })).filter((rule) => rule.skills.length >= MIN_RELATABLE_GROUP_MEMBERS);
+}
+function narrowRequirementsToSlugs(rules, shipped) {
+  return rules.filter((rule) => shipped.has(rule.skill)).map((rule) => ({ ...rule, needs: rule.needs.filter((slug) => shipped.has(slug)) })).filter((rule) => rule.needs.length > 0);
+}
+function narrowToShippedSlugs(rules, shipped) {
+  return {
+    conflicts: narrowGroupsToSlugs(rules.conflicts, shipped),
+    discourages: narrowGroupsToSlugs(rules.discourages, shipped),
+    requires: narrowRequirementsToSlugs(rules.requires, shipped),
+    alternatives: narrowGroupsToSlugs(rules.alternatives, shipped)
+  };
+}
+function relationshipsForSource(skills, sourceRules) {
+  const shipped = new Set(skills.map((skill) => skill.slug));
+  const builtIn = narrowToShippedSlugs(defaultRules.relationships, shipped);
+  return sourceRules ? mergeRelationships(sourceRules.relationships, builtIn) : builtIn;
+}
 function mergeMatrixWithSkills(categories, relationships, skills) {
   const slugMap = buildSlugMap(skills);
-  const resolvedSkills = {};
-  for (const skill of skills) {
-    const resolved = buildResolvedSkill(skill, categories, relationships, slugMap);
-    resolvedSkills[skill.id] = resolved;
-  }
+  const resolvedSkills = buildResolvedSkillMap(skills, categories, relationships, slugMap);
   const synthesizedCategories = { ...categories };
   for (const skill of skills) {
     if (skill.category === LOCAL_PSEUDO_CATEGORY) continue;
@@ -16087,12 +16712,14 @@ function mergeMatrixWithSkills(categories, relationships, skills) {
       verbose(`Auto-synthesized category '${skill.category}' for skill '${skill.id}'`);
     }
   }
+  const unresolvedSlugs = collectUnresolvedSlugs(relationships, slugMap.slugToId);
   const merged = {
     version: DEFAULT_VERSION,
     categories: synthesizedCategories,
     skills: resolvedSkills,
     suggestedStacks: [],
     slugMap,
+    ...unresolvedSlugs.length > 0 && { unresolvedSlugs },
     generatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   return merged;
@@ -16100,6 +16727,11 @@ function mergeMatrixWithSkills(categories, relationships, skills) {
 function resolveSlugsOrSkip(slugs, resolve, context) {
   return slugs.map((slug) => resolve(slug, context)).filter((id) => id !== null);
 }
+function resolveEveryNeed(needs, resolve) {
+  if (needs.length === 0) return null;
+  const resolved = resolveSlugsOrSkip(needs, resolve, "requires.needs");
+  return resolved.length === needs.length ? resolved : null;
+}
 function collectSymmetricGroupMembers(rules, skillId, resolve, context) {
   const members = rules.flatMap((rule) => {
     const resolved = resolveSlugsOrSkip(rule.skills, resolve, context);
@@ -16131,8 +16763,8 @@ function resolveRelationships(skillId, relationships, resolve) {
   for (const rule of relationships.requires) {
     const ruleSkillId = resolve(rule.skill, "requires.skill");
     if (ruleSkillId !== skillId) continue;
-    const resolvedNeeds = resolveSlugsOrSkip(rule.needs, resolve, "requires.needs");
-    if (resolvedNeeds.length === 0) continue;
+    const resolvedNeeds = resolveEveryNeed(rule.needs, resolve);
+    if (!resolvedNeeds) continue;
     requires.push({
       skillIds: resolvedNeeds,
       needsAny: rule.needsAny ?? false,
@@ -16164,84 +16796,6 @@ function buildResolvedSkill(skill, _categories, relationships, slugMap) {
   };
 }
 
-// src/cli/lib/matrix/matrix-loader.ts
-async function loadSkillCategories(configPath) {
-  const data = await loadConfig(configPath, skillCategoriesFileSchema);
-  if (!data) {
-    throw new Error(`Invalid skill categories at '${configPath}': failed to load or validate`);
-  }
-  verbose(`Loaded skill categories: ${configPath}`);
-  return data.categories;
-}
-async function loadSkillRules(configPath) {
-  const data = await loadConfig(configPath, skillRulesFileSchema);
-  if (!data) {
-    throw new Error(`Invalid skill rules at '${configPath}': failed to load or validate`);
-  }
-  const config = {
-    version: data.version,
-    relationships: data.relationships ?? {
-      conflicts: [],
-      discourages: [],
-      requires: [],
-      alternatives: []
-    }
-  };
-  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 = path25.dirname(metadataFile);
-    const skillMdPath = path25.join(skillsDir, skillDir, STANDARD_FILES.SKILL_MD);
-    const metadataPath = path25.join(skillsDir, metadataFile);
-    if (!await fileExists(skillMdPath)) {
-      verbose(`Skipping ${metadataFile}: No ${STANDARD_FILES.SKILL_MD} found`);
-      continue;
-    }
-    const metadataContent = await readFile(metadataPath);
-    const rawMetadata = parseYaml3(metadataContent);
-    const metadataResult = matrixRawMetadataSchema.safeParse(rawMetadata);
-    if (!metadataResult.success) {
-      warn(
-        `Skipping '${metadataFile}': invalid metadata.yaml \u2014 ${formatZodIssues(metadataResult.error.issues)}`
-      );
-      continue;
-    }
-    const metadata = metadataResult.data;
-    const skillMdContent = await readFile(skillMdPath);
-    const frontmatter = parseFrontmatter(skillMdContent, skillMdPath);
-    if (!frontmatter) {
-      verbose(`Skipping ${metadataFile}: Invalid SKILL.md frontmatter`);
-      continue;
-    }
-    if (!metadata.displayName) {
-      throw new Error(
-        `Skill at ${metadataFile} is missing required '${METADATA_KEYS.DISPLAY_NAME}' field in metadata.yaml`
-      );
-    }
-    const skillId = frontmatter.name;
-    const extracted = {
-      id: skillId,
-      directoryPath: skillDir,
-      description: metadata.cliDescription || frontmatter.description,
-      ...metadata.usageGuidance !== void 0 && { usageGuidance: metadata.usageGuidance },
-      category: metadata.category,
-      author: metadata.author,
-      path: `skills/${skillDir}/`,
-      domain: metadata.domain,
-      displayName: metadata.displayName,
-      slug: metadata.slug,
-      ...metadata.custom === true ? { custom: true } : {}
-    };
-    skills.push(extracted);
-    verbose(`Extracted skill: ${skillId}`);
-  }
-  return skills;
-}
-
 // src/cli/lib/matrix/matrix-resolver.ts
 import { groupBy as groupBy5 } from "remeda";
 function getLabel(skill) {
@@ -18045,6 +18599,7 @@ function checkMatrixHealth(matrix2) {
     ...checkCategoryDomains(matrix2),
     ...checkSkillCategories(matrix2),
     ...checkSkillRelationRefs(matrix2),
+    ...checkUnresolvedRuleSlugs(matrix2),
     ...checkAuditVerdictContradictions(matrix2),
     ...checkUnauditedSkills(matrix2)
   ];
@@ -18093,6 +18648,13 @@ function checkSkillRelationRefs(matrix2) {
     )
   );
 }
+function checkUnresolvedRuleSlugs(matrix2) {
+  return (matrix2.unresolvedSlugs ?? []).map((slug) => ({
+    severity: "error",
+    finding: "rule-unresolved-slug",
+    details: `Unresolved slug '${slug}' in the relationship rules \u2014 no skill carries it, so every rule naming it states nothing`
+  }));
+}
 function isExclusiveCategory3(matrix2, category) {
   if (category === LOCAL_PSEUDO_CATEGORY) return false;
   const definition = matrix2.categories[category];
@@ -18125,12 +18687,12 @@ function checkUnauditedSkills(matrix2) {
   return typedEntries(matrix2.skills).filter(
     ([skillId, skill]) => (
       // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- typedEntries/Object.entries launders the `| undefined` a Partial<Record> admits out of its result type, so this guard reads as dead while still covering an explicitly-undefined slot
-      skill !== void 0 && !skill.local && auditEntryFor(skillId) === void 0
+      skill !== void 0 && !skill.local && isSkillId(skillId) && auditEntryFor(skillId) === void 0
     )
   ).map(([skillId]) => ({
     severity: "warning",
     finding: "skill-unaudited",
-    details: `Skill '${skillId}' has no audit verdict \u2014 source-provided skills are outside the built-in audit manifest`
+    details: `Skill '${skillId}' has no audit verdict \u2014 the built-in audit manifest is missing an entry it is meant to carry`
   }));
 }
 
@@ -18148,6 +18710,7 @@ async function loadSkillsMatrixFromSource(options = {}) {
   verbose(`Loading skills from source: ${source}`);
   const result = await resolveBaseResult(source, sourceConfig, devMode, matrixOnly);
   const resolvedProjectDir = projectDir || process.cwd();
+  const marketplaceSkillIds = new Set(typedKeys(result.matrix.skills));
   const homeDir = os15.homedir();
   if (!isHomeDirectory(resolvedProjectDir)) {
     result.matrix = await mergeDiscoveredLocalSkills(result.matrix, homeDir, "global");
@@ -18158,23 +18721,34 @@ async function loadSkillsMatrixFromSource(options = {}) {
       result.matrix,
       sourceConfig,
       resolvedProjectDir,
-      result.marketplace
+      result.marketplace,
+      idsOutsideMarketplace(result.matrix, marketplaceSkillIds)
     );
   }
   checkMatrixHealth(result.matrix);
   initializeMatrix(result.matrix);
   return result;
 }
+function idsOutsideMarketplace(matrix2, marketplaceSkillIds) {
+  return new Set(typedKeys(matrix2.skills).filter((id) => !marketplaceSkillIds.has(id)));
+}
+function copyOfBuiltInMatrix() {
+  return {
+    ...BUILT_IN_MATRIX,
+    skills: { ...BUILT_IN_MATRIX.skills },
+    categories: { ...BUILT_IN_MATRIX.categories },
+    suggestedStacks: [...BUILT_IN_MATRIX.suggestedStacks],
+    slugMap: {
+      slugToId: { ...BUILT_IN_MATRIX.slugMap.slugToId },
+      idToSlug: { ...BUILT_IN_MATRIX.slugMap.idToSlug }
+    }
+  };
+}
 async function resolveBaseResult(source, sourceConfig, devMode, matrixOnly) {
   if (isDefaultSource(source) && !devMode) {
     const sourcePath = matrixOnly ? "" : (await fetchFromSource(source)).path;
     return {
-      matrix: {
-        ...BUILT_IN_MATRIX,
-        skills: { ...BUILT_IN_MATRIX.skills },
-        categories: { ...BUILT_IN_MATRIX.categories },
-        suggestedStacks: [...BUILT_IN_MATRIX.suggestedStacks]
-      },
+      matrix: copyOfBuiltInMatrix(),
       sourceConfig,
       sourcePath,
       isLocal: false,
@@ -18184,44 +18758,40 @@ async function resolveBaseResult(source, sourceConfig, devMode, matrixOnly) {
   const isLocal = isLocalSource(source) || devMode === true;
   return isLocal ? loadFromLocal(source, sourceConfig) : loadFromRemote(source, sourceConfig);
 }
-async function resolveMarketplaceLabels(source, sourceConfig) {
+async function readManifestState(source) {
   try {
-    const marketplaceResult = await fetchMarketplace(source);
-    const marketplace = sourceConfig.marketplace ?? marketplaceResult.marketplace.name;
-    verbose(`Using marketplace name from marketplace.json: ${marketplace}`);
-    return { marketplace };
-  } catch {
-    verbose(`Source does not have a marketplace.json \u2014 using source name as label`);
-    return sourceConfig.marketplace === void 0 ? {} : { marketplace: sourceConfig.marketplace };
+    const { marketplace } = await fetchMarketplace(source);
+    return { kind: "named", name: marketplace.name };
+  } catch (error) {
+    if (error instanceof MarketplaceManifestAbsentError) return { kind: "absent" };
+    return { kind: "unreadable", reason: getErrorMessage(error) };
   }
 }
-function mergeRelationships(source, defaults) {
-  return {
-    conflicts: [...source.conflicts, ...defaults.conflicts],
-    discourages: [...source.discourages, ...defaults.discourages],
-    requires: [...source.requires, ...defaults.requires],
-    alternatives: [...source.alternatives, ...defaults.alternatives]
-  };
-}
-var MIN_RELATABLE_GROUP_MEMBERS = 2;
-function narrowGroupsToSlugs(rules, shipped) {
-  return rules.map((rule) => ({ ...rule, skills: rule.skills.filter((slug) => shipped.has(slug)) })).filter((rule) => rule.skills.length >= MIN_RELATABLE_GROUP_MEMBERS);
-}
-function narrowRequirementsToSlugs(rules, shipped) {
-  return rules.filter((rule) => shipped.has(rule.skill)).map((rule) => ({ ...rule, needs: rule.needs.filter((slug) => shipped.has(slug)) })).filter((rule) => rule.needs.length > 0);
+function configuredLabel(sourceConfig) {
+  return sourceConfig.marketplace === void 0 ? {} : { marketplace: sourceConfig.marketplace };
 }
-function narrowToShippedSlugs(rules, shipped) {
-  return {
-    conflicts: narrowGroupsToSlugs(rules.conflicts, shipped),
-    discourages: narrowGroupsToSlugs(rules.discourages, shipped),
-    requires: narrowRequirementsToSlugs(rules.requires, shipped),
-    alternatives: narrowGroupsToSlugs(rules.alternatives, shipped)
-  };
-}
-function relationshipsForSource(sourceRules, skills) {
-  const shipped = new Set(skills.map((skill) => skill.slug));
-  const builtIn = narrowToShippedSlugs(defaultRules.relationships, shipped);
-  return sourceRules ? mergeRelationships(sourceRules.relationships, builtIn) : builtIn;
+async function resolveMarketplaceLabels(source, sourceConfig) {
+  const state = await readManifestState(source);
+  switch (state.kind) {
+    case "named": {
+      const marketplace = sourceConfig.marketplace ?? state.name;
+      verbose(`Using marketplace name from ${MARKETPLACE_JSON}: ${marketplace}`);
+      return { marketplace };
+    }
+    case "absent":
+      verbose(`Marketplace has no ${MARKETPLACE_JSON} \u2014 using its ref as the label`);
+      return configuredLabel(sourceConfig);
+    case "unreadable":
+      warn(
+        `Marketplace has a ${MARKETPLACE_JSON} this CLI cannot read, so its ref is the label instead:
+${state.reason}`
+      );
+      return configuredLabel(sourceConfig);
+    default: {
+      const exhaustive = state;
+      return exhaustive;
+    }
+  }
 }
 async function mergeDiscoveredLocalSkills(matrix2, dir, label) {
   const discovered = await discoverLocalSkills(dir);
@@ -18258,12 +18828,15 @@ async function loadFromRemote(source, sourceConfig) {
     ...labels
   };
 }
+async function loadMarketplaceMatrix(marketplaceDir) {
+  return loadAndMergeFromBasePath(marketplaceDir, marketplaceDir);
+}
 async function loadAndMergeFromBasePath(basePath, source) {
   const sourceProjectConfig = await loadProjectSourceConfig(basePath);
   const skillsDirRelPath = sourceProjectConfig?.skillsDir ?? SKILLS_DIR_PATH;
   const stacksRelFile = sourceProjectConfig?.stacksFile;
-  const sourceCategoriesPath = path26.join(basePath, SKILL_CATEGORIES_PATH);
-  const sourceRulesPath = path26.join(basePath, SKILL_RULES_PATH);
+  const sourceCategoriesPath = path28.join(basePath, SKILL_CATEGORIES_PATH);
+  const sourceRulesPath = path28.join(basePath, SKILL_RULES_PATH);
   const hasSourceCategories = await fileExists(sourceCategoriesPath);
   const hasSourceRules = await fileExists(sourceRulesPath);
   const sourceCategories = hasSourceCategories ? await loadSkillCategories(sourceCategoriesPath) : void 0;
@@ -18282,10 +18855,11 @@ async function loadAndMergeFromBasePath(basePath, source) {
   } else {
     verbose(`Matrix from CLI only (source has no categories/rules files)`);
   }
-  const skillsDir = path26.join(basePath, skillsDirRelPath);
+  const skillsDir = path28.join(basePath, skillsDirRelPath);
   verbose(`Skills from source: ${skillsDir}`);
   const skills = await extractAllSkills(skillsDir);
-  const relationships = relationshipsForSource(sourceRules, skills);
+  await refuseCatalogueCollisions(basePath, source, skills);
+  const relationships = relationshipsForSource(skills, sourceRules);
   const mergedMatrix = mergeMatrixWithSkills(categories, relationships, skills);
   initializeMatrix(mergedMatrix);
   const stacks = await resolveOfferedStacks(basePath, stacksRelFile, source);
@@ -18303,18 +18877,38 @@ async function loadAndMergeFromBasePath(basePath, source) {
   }
   return mergedMatrix;
 }
+var CATALOGUE_SKILL_IDS = new Set(typedKeys(BUILT_IN_MATRIX.skills));
+var MAX_REPORTED_COLLISIONS = 10;
+async function refuseCatalogueCollisions(basePath, source, skills) {
+  const collidingIds = skills.map((skill) => skill.id).filter((id) => CATALOGUE_SKILL_IDS.has(id));
+  if (collidingIds.length === 0) return;
+  if (await isPublicCatalogueCheckout(basePath)) return;
+  throw new Error(catalogueCollisionError(collidingIds, source));
+}
+function catalogueCollisionError(collidingIds, source) {
+  const listed = collidingIds.slice(0, MAX_REPORTED_COLLISIONS).map((id) => `  ${id}`);
+  const unlisted = collidingIds.length - listed.length;
+  return [
+    `Marketplace '${source}' ships ${collidingIds.length} skill id(s) the public catalogue already owns:`,
+    ...listed,
+    ...unlisted > 0 ? [`  ... and ${unlisted} more`] : [],
+    `A skill id is the directory the skill installs into, so these would shadow the public catalogue's own skills. Every id must carry its marketplace's name as a namespace \u2014 '<marketplace>-<id>'. Rename each skill and the 'name' in its SKILL.md, then re-run 'build marketplace', which refuses the same ids before they are published.`
+  ].join("\n");
+}
 async function resolveOfferedStacks(basePath, stacksFile, source) {
   const sourceStacks = await loadStacks(basePath, stacksFile);
   if (sourceStacks.length > 0) {
     verbose(`Offering the ${sourceStacks.length} stacks the source ships`);
     return sourceStacks;
   }
-  if (!isDefaultSource(source)) {
-    verbose(`Source '${source}' ships no stacks, and gets no built-in stand-in \u2014 offering none`);
-    return [];
+  if (await offersBuiltInStacks(basePath, source)) {
+    verbose(
+      `The public catalogue ships no stacks \u2014 offering the ${defaultStacks.length} built-in stacks`
+    );
+    return defaultStacks;
   }
-  verbose(`Default source ships no stacks \u2014 offering the ${defaultStacks.length} built-in stacks`);
-  return defaultStacks;
+  verbose(`Marketplace '${source}' ships no stacks, and gets no built-in stand-in \u2014 offering none`);
+  return [];
 }
 function convertStackToResolvedStack(stack) {
   const agentConfigs = typedKeys(stack.agents).flatMap((agentId) => {
@@ -18326,7 +18920,7 @@ function convertStackToResolvedStack(stack) {
       ({ agentId, agentConfig }) => [agentId, resolveStackAgentSkills(agentConfig)]
     )
   );
-  const allSkillIds = unique5(
+  const allSkillIds = unique7(
     agentConfigs.flatMap(
       ({ agentConfig }) => resolveAgentConfigToSkills(agentConfig).map((ref) => ref.id)
     )
@@ -18358,12 +18952,23 @@ function extractSourceName(source) {
   const firstSegment = withoutUrl.split("/")[0];
   return firstSegment || source;
 }
+function declaresCategory(matrix2, category) {
+  return category !== LOCAL_PSEUDO_CATEGORY && matrix2.categories[category] !== void 0;
+}
+function undeclaredCategoryRefusal(metadata, category) {
+  const metadataPath = path28.join(metadata.path, STANDARD_FILES.METADATA_YAML);
+  return `Skipping local skill '${metadata.id}': ${METADATA_KEYS.CATEGORY} '${category}' is not one this installation declares, so the skill belongs in no grid tab and can be given to no sub-agent. Set ${METADATA_KEYS.CATEGORY} in ${metadataPath} to a category that already exists \u2014 a skill is placed in the taxonomy, it does not extend it.`;
+}
 function mergeLocalSkillsIntoMatrix(matrix2, localResult) {
   for (const metadata of localResult.skills) {
     const existingSkill = matrix2.skills[metadata.id];
     const category = existingSkill?.category ?? metadata.category;
     const slug = existingSkill?.slug ?? metadata.slug;
     const displayName = existingSkill?.displayName ?? metadata.displayName;
+    if (metadata.custom === true && !declaresCategory(matrix2, category)) {
+      warn(undeclaredCategoryRefusal(metadata, category));
+      continue;
+    }
     const resolvedSkill = {
       id: metadata.id,
       slug,
@@ -18382,6 +18987,7 @@ function mergeLocalSkillsIntoMatrix(matrix2, localResult) {
       ...metadata.custom !== void 0 && { custom: metadata.custom }
     };
     matrix2.skills[metadata.id] = resolvedSkill;
+    claimSlug(matrix2.slugMap, slug, metadata.id);
     if (category !== LOCAL_PSEUDO_CATEGORY && !matrix2.categories[category]) {
       matrix2.categories[category] = {
         id: category,
@@ -18400,6 +19006,7 @@ function mergeLocalSkillsIntoMatrix(matrix2, localResult) {
 }
 
 export {
+  validateKebabCaseName,
   ERROR_MESSAGES,
   SUCCESS_MESSAGES,
   STATUS_MESSAGES,
@@ -18414,17 +19021,31 @@ export {
   marketplacesRefreshed,
   marketplaceRefreshFailed,
   marketplacesRefreshFailed,
+  marketplaceOwnerHasNoName,
+  marketplaceHasNoVersion,
+  marketplaceNameNotPublishable,
   configTypesRefreshFailed,
   registeredProjectsUpdated,
   registeredProjectUpdateSkipped,
   skillMetadataUnusableDetail,
   skillMetadataUnusableError,
   savedSkillMetadataUnusableError,
+  sharedConfigDestinations,
   sharedConfigExistingInstall,
   sharedConfigGlobalInstall,
+  sharedConfigProjectScopeAtHome,
+  skippedUnknownSkills,
+  skippedUnknownAgents,
+  carriedSkillsWritten,
+  SHARED_CONFIG_APPLY,
+  sharedConfigNeedsTerminal,
+  SHARED_CONFIG_ONE_DIRECTION,
+  globallyInstalledRemoved,
+  authoredHereKept,
+  unplaceableKept,
   configUnreadableError,
   registeredProjectsUpdateFailed,
-  compiledAgentsKept,
+  unmarkedAgentsKept,
   UNINSTALL_PLAN,
   localSkillsRemoval,
   compiledAgentsRemoval,
@@ -18434,9 +19055,7 @@ export {
   activeAgentNames,
   activeAgentScopeMap,
   effectivelyExcludedSkillIds,
-  isRecord,
-  isDomain2 as isDomain,
-  isAgentName,
+  ConfigDefaultExportError,
   loadConfig,
   installBaseDir,
   getProjectConfigPath,
@@ -18454,10 +19073,22 @@ export {
   findConfigLoadFailures,
   loadProjectConfig,
   validateProjectConfig,
+  INSTALL_MODE_LABELS,
+  INSTALL_MODE_DESCRIPTIONS,
+  declaresNoContent,
+  deriveInstallMode,
+  detectProjectInstallation,
+  detectGlobalInstallation,
+  detectInstallation,
   computeStringHash,
+  computeFileHash,
   determinePluginVersion,
   writeContentHash,
   readForkedFromMetadata,
+  readLocalSkillMetadata,
+  injectForkedFromMetadata,
+  writeMetadataYaml,
+  validateSkillPath,
   copySkillsToLocalFlattened,
   generateAgentPluginManifest,
   writePluginManifest,
@@ -18469,39 +19100,56 @@ export {
   buildMarketplacePluginRef,
   parseMarketplacePluginRef,
   toClaudePluginScope,
+  MATRIX_VERSION,
   DOMAIN_ORDER,
   DOMAIN_DESCRIPTIONS,
   DEFAULT_SELECTION_OPTIONS,
+  SEED_VERSION,
+  seedModelSchema,
+  seedExternalSkillSchema,
   seedPayloadSchema,
   isScopePairCompatible,
-  fetchFromSource,
-  fetchMarketplace,
   truncateText,
   toTitleCase,
+  fetchFromSource,
+  fetchMarketplace,
+  isLocalOnlySkill,
+  claimSlug,
   getUnmetRequiredBy,
   getCellState,
   validateSelection,
   getAvailableSkills,
   checkMatrixHealth,
   loadSkillsMatrixFromSource,
+  loadMarketplaceMatrix,
   convertStackToResolvedStack,
   extractSourceName,
   mergeLocalSkillsIntoMatrix,
-  INSTALL_MODE_LABELS,
-  INSTALL_MODE_DESCRIPTIONS,
-  declaresNoContent,
-  deriveInstallMode,
-  detectProjectInstallation,
-  detectGlobalInstallation,
-  detectInstallation,
-  resolveAgents,
-  createLiquidEngine,
-  writeCompiledAgentsByScope,
   getInstalledPluginsRegistryPath,
   listRegisteredPluginInstalls,
   getVerifiedPluginInstallPaths,
   discoverAllPluginSkills,
   listPluginNames,
+  getInstallationInfo,
+  formatInstallationDisplay,
+  validateSkillFrontmatter,
+  validateAgentFrontmatter,
+  validatePlugin,
+  validateAllPlugins,
+  compileSkillPlugin,
+  compileAllSkillPlugins,
+  printCompilationSummary,
+  discoverLocalSkills,
+  findUnusableSavedSkillMetadata,
+  unresolvedSkillRemovalReasons,
+  deleteLocalSkill,
+  migrateLocalSkillScope,
+  resolveAgents,
+  hasProvenanceMarker,
+  createLiquidEngine,
+  writeCompiledAgentsByScope,
+  normalizeProjectPath,
+  execCommand,
   claudePluginInstall,
   isClaudeCLIAvailable,
   claudePluginMarketplaceExists,
@@ -18520,21 +19168,8 @@ export {
   buildAndMergeConfig,
   buildCompileAgents,
   buildAgentScopeMap,
+  ejectCopyFailureError,
   detectMigrations,
-  executeMigration,
-  getInstallationInfo,
-  formatInstallationDisplay,
-  validateSkillFrontmatter,
-  validateAgentFrontmatter,
-  validatePlugin,
-  validateAllPlugins,
-  compileSkillPlugin,
-  compileAllSkillPlugins,
-  printCompilationSummary,
-  discoverLocalSkills,
-  findUnusableSavedSkillMetadata,
-  unresolvedSkillRemovalReasons,
-  deleteLocalSkill,
-  migrateLocalSkillScope
+  executeMigration
 };
-//# sourceMappingURL=chunk-CBF4ZYV3.js.map
+//# sourceMappingURL=chunk-WCAUUBHO.js.map