agents-inc 0.167.0 → 0.170.0

package/dist/{chunk-A4KDXNOT.js → chunk-MQ6CGZNJ.js}

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import {
   BUILT_IN_MATRIX,
-  allSkills,
   getSkillById,
   initializeMatrix,
   matrix,
@@ -9,7 +8,7 @@ import {
   typedFromEntries,
   typedKeys,
   typedValues
-} from "./chunk-V5WXIM2F.js";
+} from "./chunk-52HDHJ7I.js";
 import {
   AGENT_NAMES,
   AUTHOR_HANDLE_PATTERN,
@@ -17,6 +16,7 @@ import {
   CACHE_READABLE_PREFIX_LENGTH,
   CLAUDE_DIR,
   CLI_INVOKE_COMMAND,
+  CODEX_MODEL_NAMES,
   DEFAULT_BRANDING,
   DEFAULT_PLUGIN_NAME,
   DEFAULT_PUBLIC_SOURCE_NAME,
@@ -64,11 +64,11 @@ import {
   bytewise,
   cacheRoot,
   categoryDomain,
-  createSelectionSemantics,
   diagnostics,
   editorConfigUrl,
   effectivelyExcludedSkillIds,
   globalInstallRoot,
+  inAnEnglishList,
   isActiveAt,
   isExclusiveCategory,
   isGlobalTombstone,
@@ -78,16 +78,17 @@ import {
   orderDomains,
   resolveAssignment,
   resolveLoadState,
+  seatDiagnostics,
   seatedCatalog,
   seedAgentScope,
   sourceDirName,
   validateSelection
-} from "./chunk-ENGYJCTF.js";
+} from "./chunk-PJWGTNOX.js";
 import {
   defaultCategories,
   defaultRules,
   defaultStacks
-} from "./chunk-OI2H6M5I.js";
+} from "./chunk-NQW25DCF.js";
 
 // src/cli/lib/loading/source-loader.ts
 import os14 from "os";
@@ -168,21 +169,33 @@ function renderAgentRoleToml(agent, body) {
   refuseBlankInstructions(agent.name, body);
   return [
     ...scalarLines(agent, body),
-    // Last, always: every bare key after a table header belongs to that table, so a scalar
-    // emitted below `[features]` would become `features.model` and take the file with it.
+    // Last: every bare key after a table header belongs to that table.
     ...shellToolTable(agent)
   ].join("\n");
 }
 var CODEX_DEVELOPER_INSTRUCTIONS_OPENER = `developer_instructions = """`;
 var CODEX_EFFORT_KEY = "model_reasoning_effort";
+var PINNED_MODEL_RESTING_EFFORT = "medium";
 function scalarLines(agent, body) {
   return [
     `name = ${basicString(agent.name)}`,
     `description = ${basicString(agent.description)}`,
-    ...agent.effort === void 0 ? [] : [`${CODEX_EFFORT_KEY} = ${basicString(agent.effort)}`],
+    ...modelLines(agent),
     developerInstructions(body)
   ];
 }
+function modelLines(agent) {
+  if (agent.codexModel === void 0) {
+    return agent.effort === void 0 ? [] : [effortLine(agent.effort)];
+  }
+  return [
+    `model = ${basicString(agent.codexModel)}`,
+    effortLine(agent.effort ?? PINNED_MODEL_RESTING_EFFORT)
+  ];
+}
+function effortLine(effort) {
+  return `${CODEX_EFFORT_KEY} = ${basicString(effort)}`;
+}
 function developerInstructions(body) {
   return `${CODEX_DEVELOPER_INSTRUCTIONS_OPENER}
 ${asMultilineString(body)}
@@ -259,12 +272,6 @@ function agentsLeftOutOfCodexMessage() {
 function unexpressibleOnCodexMessage() {
   return `Codex cannot express ${inAnEnglishList(UNEXPRESSIBLE_ON_CODEX)}, so the agent role files it wrote carry none of them.`;
 }
-function inAnEnglishList(items) {
-  const last = items.at(-1);
-  if (last === void 0) return "";
-  if (items.length === 1) return last;
-  return `${items.slice(0, -1).join(", ")} and ${last}`;
-}
 
 // ../compile/src/agent-source.ts
 var LIQUID_SYNTAX_PATTERN = /\{\{|\}\}|\{%|%\}/g;
@@ -862,6 +869,7 @@ async function grantOwnerWrite(target) {
 }
 
 // src/cli/utils/logger.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 var verboseMode = false;
 function setVerbose(enabled) {
   verboseMode = enabled;
@@ -876,6 +884,8 @@ function log(msg) {
 }
 var bufferMode = false;
 var messageBuffer = [];
+var alreadySaid = /* @__PURE__ */ new Set();
+var eachWarningOnce = new AsyncLocalStorage2();
 function enableBuffering() {
   bufferMode = true;
   messageBuffer = [];
@@ -890,17 +900,23 @@ function disableBuffering() {
   messageBuffer = [];
 }
 function warn(msg) {
+  if (isARepeatToHoldBack(msg)) return;
   if (bufferMode) {
     messageBuffer.push({ level: "warn", text: msg });
     return;
   }
+  alreadySaid.add(msg);
   console.warn(`  Warning: ${msg}`);
 }
-var alreadySaid = /* @__PURE__ */ new Set();
+function isARepeatToHoldBack(msg) {
+  if (eachWarningOnce.getStore() !== true) return false;
+  return alreadySaid.has(msg) || messageBuffer.some((message) => message.text === msg);
+}
+function sayingEachWarningOnce(body) {
+  return eachWarningOnce.run(true, body);
+}
 function warnOnce(msg) {
-  if (alreadySaid.has(msg)) return;
-  alreadySaid.add(msg);
-  warn(msg);
+  sayingEachWarningOnce(() => warn(msg));
 }
 
 // src/cli/lib/validate-kebab-name.ts
@@ -931,7 +947,7 @@ var ERROR_MESSAGES = {
    * 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
+   * names `init` for, because `init` on a config that declares nothing opens the editor
    * 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.
    */
@@ -1041,7 +1057,7 @@ function scopeBlockedStackAssignment(agentNames, skillId) {
 }
 function globalScopedAgentsHint(count) {
   const [subject, object] = count === 1 ? ["agent is", "it"] : ["agents are", "them"];
-  return `${count} ${subject} global-scoped \u2014 run '${CLI_INVOKE_COMMAND} compile' from your home directory, or edit from this project, to recompile ${object}.`;
+  return `${count} ${subject} global-scoped \u2014 run '${CLI_INVOKE_COMMAND} compile' from your home directory to recompile ${object}.`;
 }
 function marketplacesRefreshed(count) {
   return `Refreshed ${plural(count, "marketplace listing")}. Installed plugins were not changed.`;
@@ -1148,6 +1164,13 @@ function savedSkillMetadataUnusableError(entries) {
     METADATA_UNUSABLE_WAY_OUT
   ].join("\n");
 }
+function editorSkillMetadataUnusableError(entries) {
+  return [
+    metadataUnusableOpening(entries),
+    `The editor opens on what these files describe, so no link is made until each one describes its skill.`,
+    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 [
@@ -1213,27 +1236,14 @@ function sharedConfigNeedsTerminal(id) {
 function nothingInstalledToApplyTo(id) {
   return `No installation found. Run '${CLI_INVOKE_COMMAND} init --from ${id}' to install configuration '${id}' here.`;
 }
-var RUNS_WITHOUT_A_TERMINAL = {
-  init: `'${CLI_INVOKE_COMMAND} init --from <id>' installs a configuration built in the editor without one`,
-  edit: `'${CLI_INVOKE_COMMAND} edit --ui' opens this installation in the editor without one`
-};
-function wizardNeedsTerminal(command) {
-  return [
-    `'${CLI_INVOKE_COMMAND} ${command}' opens a wizard, and there is no terminal here to open it in.`,
-    `Run it from a terminal \u2014 ${RUNS_WITHOUT_A_TERMINAL[command]}.`
-  ].join("\n");
-}
 function uninstallNeedsTerminal() {
   return [
     "Uninstalling removes files, so it has to be confirmed \u2014 and there is no terminal here to confirm it at.",
     `Run '${CLI_INVOKE_COMMAND} uninstall' from a terminal, or '${CLI_INVOKE_COMMAND} uninstall --yes' to remove it without being asked.`
   ].join("\n");
 }
-function editorLoadsItsOwnMarketplace(named) {
-  return `--marketplace '${named}' cannot be handed to the editor: the editor loads marketplaces itself. Run '${CLI_INVOKE_COMMAND} init --ui' and load it there.`;
-}
-function marketplaceFixedAtInstall(stored, named) {
-  return `This folder's installation was made from the marketplace '${stored}', and an installation's marketplace is chosen once, when it is made \u2014 so --marketplace '${named}' was not used. Run '${CLI_INVOKE_COMMAND} init' without it to open this installation, or '${CLI_INVOKE_COMMAND} uninstall' first to set this folder up from another.`;
+function addMarketplaceInTheEditor(ref, isFolder) {
+  return isFolder ? `${ref} is a folder on this machine, which the editor cannot read \u2014 push it to GitHub, then add it from the editor's Marketplace button.` : `Add ${ref} from the editor's Marketplace button.`;
 }
 var SHARED_CONFIG_ARRIVALS = {
   PROJECT_HEADING: "Into this project:",
@@ -1249,11 +1259,18 @@ function keptAsInstalledGlobally(skillIds, agentNames) {
     `Change them with '${CLI_INVOKE_COMMAND} edit' from your home directory.`
   ].join("\n");
 }
+function addedToGlobalSubAgents(joined) {
+  return [
+    "Added to sub-agents in the global install \u2014 each keeps everything it already has, since a project run only adds to the global install:",
+    ...joined.map(
+      ({ agentName, skillIds }) => `  sub-agent ${agentName}: + ${skillIds.join(", ")}`
+    )
+  ].join("\n");
+}
 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'.`
+    ...skillIds.map((id) => `  skill ${id}`)
   ].join("\n");
 }
 function unplaceableKept(skillIds) {
@@ -1266,35 +1283,30 @@ function unplaceableKept(skillIds) {
 function keptUnassigned(skillId, agentName, category) {
   return `${skillId}: kept, no longer assigned to ${agentName}'s ${category}`;
 }
-function otherWaysPastUnreadableConfigs(count) {
-  return [
-    `Or build one at ${EDITOR_URL} and install it with '${CLI_INVOKE_COMMAND} init --from <id>'.`,
-    `'${CLI_INVOKE_COMMAND} doctor' reports the same ${count === 1 ? "file" : "files"}, alongside whatever else is wrong here.`
-  ];
+function doctorReportsTheSame(count) {
+  return `'${CLI_INVOKE_COMMAND} doctor' reports the same ${count === 1 ? "file" : "files"}, alongside whatever else is wrong here.`;
 }
 function installationConfigsUnreadable(failures) {
-  return [
-    ...failures.flatMap(whoseConfigAndItsWayOut),
-    ...otherWaysPastUnreadableConfigs(failures.length)
-  ].join("\n");
+  return [...failures.flatMap(whoseConfigAndItsWayOut), doctorReportsTheSame(failures.length)].join(
+    "\n"
+  );
 }
 function whoseConfigAndItsWayOut(failure) {
   return [
     `${scopeLabel(failure.scope)}'s config at '${failure.configPath}' could not be loaded: ${failure.reason}`,
-    `There is no automatic repair for this \u2014 recreate the configuration by running ${recreateConfigFrom(failure.scopeRoot)}.`
+    `There is no automatic repair for this \u2014 fix the file, or recreate the configuration by running ${recreateConfigFrom(failure.scopeRoot)}.`
   ];
 }
 function uninstallConfigUnreadable(failure) {
   return `Could not read the ${failure.scope} config \u2014 plugins and compiled agents it lists may be left behind: ${failure.message}`;
 }
 function recreateConfigFrom(scopeRoot) {
-  return `'${CLI_INVOKE_COMMAND} uninstall', which still works on a config it cannot read, then '${CLI_INVOKE_COMMAND} init', from '${scopeRoot}'`;
+  return `'${CLI_INVOKE_COMMAND} uninstall' from '${scopeRoot}', which still works on a config it cannot read, then '${CLI_INVOKE_COMMAND} init --from <id>' with an id from ${EDITOR_URL}`;
 }
 function configUnreadableError(configLoadFailure2) {
   return [
     configLoadFailure2,
-    `There is no automatic repair for this \u2014 recreate the configuration: '${CLI_INVOKE_COMMAND} uninstall' still works on a config it cannot read, then '${CLI_INVOKE_COMMAND} init'.`,
-    ...otherWaysPastUnreadableConfigs(1)
+    "This is the marketplace's own config rather than an installation's, so it is fixed in the marketplace repository it comes from."
   ].join("\n");
 }
 function registeredProjectsUpdateFailed(reason) {
@@ -1918,17 +1930,6 @@ var CATEGORIES = [
   "web-ui-kit",
   "web-utilities"
 ];
-var DOMAINS = [
-  "ai",
-  "api",
-  "cli",
-  "desktop",
-  "infra",
-  "meta",
-  "mobile",
-  "shared",
-  "web"
-];
 var AGENT_NAMES2 = [
   "agent-summoner",
   "ai-developer",
@@ -1954,9 +1955,6 @@ var AGENT_NAMES2 = [
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isDomain(value) {
-  return DOMAINS.includes(value);
-}
 function isAgentName(value) {
   return AGENT_NAMES2.includes(value);
 }
@@ -1992,6 +1990,12 @@ function formatZodErrors(error) {
 
 // src/cli/types/matrix.ts
 var MODEL_NAMES2 = ["sonnet", "opus", "haiku", "fable", "inherit"];
+var CODEX_MODEL_NAMES2 = [
+  "gpt-6-astra",
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-5.6-luna"
+];
 var EFFORT_NAMES2 = ["low", "medium", "high", "xhigh", "max"];
 var PERMISSION_MODES = [
   "default",
@@ -2006,6 +2010,7 @@ var CACHE_TTLS = ["5m", "1h"];
 
 // src/cli/lib/schemas.ts
 var modelNameSchema = z2.enum(MODEL_NAMES2);
+var codexModelNameSchema = z2.enum(CODEX_MODEL_NAMES2);
 var effortLevelSchema = z2.enum(EFFORT_NAMES2);
 var permissionModeSchema = z2.enum(PERMISSION_MODES);
 var skillSlugSchema = z2.enum(SKILL_SLUGS);
@@ -2049,7 +2054,7 @@ var skillAssignmentSchema = z2.object({
   path: z2.string().exactOptional()
 });
 var skillFrontmatterLoaderSchema = z2.object({
-  /** Lenient (any string): local/custom skills have non-builtin IDs */
+  /** Lenient: local/custom skills have non-builtin IDs. */
   name: z2.string(),
   description: z2.string(),
   model: modelNameSchema.exactOptional()
@@ -2080,7 +2085,7 @@ var pluginManifestObjectSchema = z2.object({
   version: z2.string().exactOptional(),
   description: z2.string().exactOptional(),
   author: pluginAuthorSchema.exactOptional(),
-  /** Lenient: a plugin authored elsewhere may carry any category string or none at all */
+  /** A plugin authored elsewhere may carry any category, or none. */
   category: z2.string().exactOptional(),
   keywords: z2.array(z2.string()).exactOptional(),
   commands: z2.union([z2.string(), z2.array(z2.string())]).exactOptional(),
@@ -2100,14 +2105,7 @@ var agentYamlConfigSchema = z2.object({
   disallowedTools: z2.array(z2.string()).exactOptional(),
   permissionMode: permissionModeSchema.exactOptional(),
   isolation: agentIsolationSchema.exactOptional(),
-  /**
-   * The same contract `agentFrontmatterValidationSchema` reads the compiled agent back through.
-   * The lenient {@link hooksRecordSchema} used to sit here, and every key its definition declares
-   * is optional — so a block written with its actions one level flat was stripped to `{}` with no
-   * error, `agent.liquid` emitted the empty definition, and the refusal arrived from the
-   * frontmatter reader against a compiled `.md` the user never wrote. This is the last boundary
-   * that still knows which `metadata.yaml` the value came from.
-   */
+  /** Strict, like the frontmatter reader: a lenient read silently emptied malformed hooks. */
   hooks: strictHooksRecordSchema.exactOptional(),
   experimental: agentExperimentalSchema.exactOptional(),
   outputFormat: z2.string().exactOptional(),
@@ -2149,21 +2147,18 @@ function refuseRenamedFields(config, ctx) {
 }
 var renamedFieldGuard = z2.unknown().superRefine(refuseRenamedFields);
 var projectConfigFields = z2.object({
-  /** Project/plugin name in kebab-case */
   name: z2.string().exactOptional(),
   description: z2.string().exactOptional(),
-  /** Per-agent configuration with scope (e.g., [{ name: "web-developer", scope: "project" }]) */
   agents: z2.array(
     z2.object({
       name: z2.string(),
       scope: z2.enum(["project", "global"]),
-      /** Per-agent overrides of the agent's own metadata defaults */
       model: modelNameSchema.exactOptional(),
+      codexModel: codexModelNameSchema.exactOptional(),
       effort: effortLevelSchema.exactOptional(),
       excluded: z2.boolean().exactOptional()
     })
   ).exactOptional(),
-  /** Per-skill configuration with scope and provenance */
   skills: z2.array(
     z2.object({
       id: z2.string(),
@@ -2172,19 +2167,15 @@ var projectConfigFields = z2.object({
       excluded: z2.boolean().exactOptional()
     })
   ).exactOptional(),
-  /** Author handle (e.g., "@vince") */
   author: z2.string().exactOptional(),
-  /** Selected domains from the wizard (persisted for edit mode restoration) */
   selectedDomains: z2.array(z2.string()).exactOptional(),
-  /** Agent-to-category-to-skill mappings from selected stack (accepts same formats as stacks.ts) */
   stack: z2.record(z2.string(), stackAgentConfigSchema).exactOptional(),
-  /** The marketplace this install reads skills from, as a path or URL (e.g., "github:my-org/skills") */
+  /** A path or URL (e.g., "github:my-org/skills") */
   marketplace: z2.string().exactOptional(),
-  /** The name that marketplace's manifest gives it, which plugins are registered under */
+  /** The name the marketplace's manifest gives it, which plugins are registered under */
   marketplaceName: z2.string().exactOptional(),
-  /** Separate source for agents when different from skills source */
   agentsSource: z2.string().exactOptional(),
-  /** Tracked project installation paths (global config only) */
+  /** Global config only */
   projects: z2.array(z2.string()).exactOptional()
 }).passthrough();
 var projectConfigLoaderSchema = renamedFieldGuard.pipe(projectConfigFields);
@@ -2235,30 +2226,22 @@ var skillRulesFileSchema = z2.object({
   relationships: relationshipDefinitionsSchema.exactOptional()
 });
 var localRawMetadataSchema = z2.object({
-  /** Short name shown in the wizard grid (e.g., "my-custom-react") */
   displayName: z2.string(),
-  /** Kebab-case short key for alias resolution (e.g., "react") */
   slug: z2.string(),
-  /** One-line description for the wizard */
   cliDescription: z2.string().exactOptional(),
-  /** Category to place this skill in (e.g., "web-framework") */
   category: categoryPathSchema,
-  /** When an AI agent should invoke this skill */
   usageGuidance: z2.string().exactOptional(),
-  /** Domain this skill belongs to (e.g., "web", "api", "cli") */
   domain: z2.string(),
   /** True if this skill was created outside the CLI's built-in vocabulary */
   custom: z2.boolean().exactOptional()
 }).passthrough();
 var localSkillMetadataSchema = z2.object({
   forkedFrom: z2.object({
-    /** Original skill ID before forking — lenient (any string) since custom/extra-source skills have non-builtin IDs */
+    /** Lenient: custom and extra-source skills have non-builtin IDs */
     skillId: z2.string(),
     /** SHA hash of the original content at fork time (for diff detection) */
     contentHash: z2.string(),
-    /** ISO date when the fork was created */
     date: z2.string(),
-    /** Source URL the skill was installed from (e.g., "github:agents-inc/skills") */
     source: z2.string().exactOptional(),
     /** Directory inside that repository, for a skill only its own bytes can install again */
     path: z2.string().exactOptional()
@@ -2268,9 +2251,7 @@ var stackSchema = z2.object({
   id: z2.string().min(1),
   name: z2.string().min(1),
   description: z2.string(),
-  /** Maps agent IDs to their category-to-skill assignments */
   agents: z2.record(z2.string(), stackAgentConfigSchema),
-  /** High-level philosophy guiding this stack's technology choices */
   philosophy: z2.string().exactOptional()
 });
 var stacksConfigSchema = z2.object({
@@ -2301,11 +2282,7 @@ var marketplaceMetadataSchema = z2.object({
 var MARKETPLACE_NAME_REFUSAL = "A marketplace name is kebab-case: lowercase letters, numbers and hyphens, starting with a letter (e.g. 'acme-skills'). Rename it in this manifest \u2014 Claude Code registers every plugin under it and accepts no other shape.";
 var marketplaceSchema = z2.object({
   $schema: z2.string().exactOptional(),
-  /**
-   * Kebab-case, because this name is the namespace Claude Code registers plugins under and the
-   * CLI piggybacks on what Claude Code accepts (owner ruling 2026-08-20). Held to the same rule
-   * `build marketplace` refuses to publish under, so what this CLI emits is what it can read back.
-   */
+  /** Kebab-case: the namespace Claude Code registers plugins under (owner ruling 2026-08-20). */
   name: z2.string().min(1).regex(KEBAB_CASE_PATTERN, { message: MARKETPLACE_NAME_REFUSAL }),
   version: z2.string().min(1),
   description: z2.string().exactOptional(),
@@ -2319,28 +2296,22 @@ var sourceRevalidationSchema = z2.object({
   etag: z2.string().min(1).exactOptional()
 });
 var permissionConfigSchema = z2.object({
-  /** Tool names or patterns to explicitly allow */
   allow: z2.array(z2.string()).exactOptional(),
-  /** Tool names or patterns to explicitly deny */
   deny: z2.array(z2.string()).exactOptional()
 });
 var settingsFileSchema = z2.object({
   permissions: permissionConfigSchema.exactOptional()
 }).passthrough();
 var brandingConfigSchema = z2.object({
-  /** Custom CLI name (e.g., "Acme Dev Tools") */
   name: z2.string().exactOptional()
 });
 var projectSourceConfigFields = z2.object({
-  /** The marketplace this install reads skills from, as a path or URL */
+  /** A path or URL */
   marketplace: z2.string().exactOptional(),
-  /** Author handle for this project's config */
   author: z2.string().exactOptional(),
-  /** The name that marketplace's manifest gives it, which plugins are registered under */
+  /** The name the marketplace's manifest gives it, which plugins are registered under */
   marketplaceName: z2.string().exactOptional(),
-  /** Separate source for agent definitions (when different from skills) */
   agentsSource: z2.string().exactOptional(),
-  /** Branding overrides for white-labeling the CLI */
   branding: brandingConfigSchema.exactOptional(),
   /** Custom skills directory override (default: "src/skills") */
   skillsDir: z2.string().exactOptional(),
@@ -2406,36 +2377,23 @@ var skillFrontmatterValidationSchema = z2.object({
   "argument-hint": z2.string().exactOptional()
 }).strict();
 var forkedFromSchema = z2.object({
-  /** Original skill ID */
   skillId: z2.string(),
-  /** Version of the original at fork time */
   version: z2.number().int().min(1).exactOptional(),
-  /** Content hash of the original at fork time */
   contentHash: z2.string(),
-  /** Source URL or identifier */
   source: z2.string().exactOptional(),
   /** Directory inside that source, for a skill only its own bytes can install again */
   path: z2.string().exactOptional(),
-  /** ISO date of the fork */
   date: z2.string()
 });
 var CLI_DESCRIPTION_MAX_LENGTH = 60;
 var skillMetadataBaseSchema = z2.object({
-  /** Author handle — must start with @ (e.g., "@vince") */
   author: z2.string().regex(AUTHOR_HANDLE_PATTERN),
-  /** Short display name for the wizard grid (max 30 chars) */
   displayName: z2.string().min(1).max(30),
-  /** One-line description for the wizard (max 60 chars recommended; over-length is a validation warning) */
   cliDescription: z2.string().min(1).max(CLI_DESCRIPTION_MAX_LENGTH),
-  /** When an AI agent should invoke this skill (min 10 chars to ensure usefulness) */
   usageGuidance: z2.string().min(10),
-  /** 7-char hex SHA of skill content (for change detection) */
   contentHash: z2.string().regex(/^[a-f0-9]{7}$/).exactOptional(),
-  /** ISO date of last update */
   updated: z2.string().exactOptional(),
-  /** Provenance tracking when skill was forked from another */
   forkedFrom: forkedFromSchema.exactOptional(),
-  /** Domain assignment from metadata */
   domain: z2.string().exactOptional(),
   /** True if this skill was created outside the CLI's built-in vocabulary */
   custom: z2.boolean().exactOptional()
@@ -2445,7 +2403,6 @@ function unknownMetadataSlugRefusal(input) {
   return `${named} is not a slug the public catalogue carries. A published skill's slug is held to that catalogue unless the skill declares it is not from it \u2014 add '${METADATA_KEYS.CUSTOM}: true' beside it in this ${STANDARD_FILES.METADATA_YAML} and the slug is read as your marketplace's own, any kebab-case name. That declaration is how a skill outside the catalogue's vocabulary is carried; a skill the catalogue does carry names its catalogue slug and leaves it off.`;
 }
 var metadataValidationSchema = skillMetadataBaseSchema.extend({
-  /** Domain-prefixed category — must be a known built-in category */
   category: z2.enum(CATEGORIES),
   /**
    * Kebab-case short key — must be a known built-in slug, unless the file declares
@@ -2456,9 +2413,7 @@ var metadataValidationSchema = skillMetadataBaseSchema.extend({
   })
 }).strict();
 var customMetadataValidationSchema = skillMetadataBaseSchema.extend({
-  /** Any string category — custom skills may define their own categories */
   category: z2.string(),
-  /** Kebab-case short key for alias resolution, search, and relationship rules */
   slug: z2.string().regex(KEBAB_CASE_PATTERN).min(1).max(50)
 });
 var stackSkillAssignmentSchema = z2.object({
@@ -2467,45 +2422,31 @@ var stackSkillAssignmentSchema = z2.object({
   preloaded: z2.boolean().exactOptional()
 }).strict();
 var stackConfigValidationSchema = z2.object({
-  /** Unique stack identifier in kebab-case */
   id: z2.string().regex(KEBAB_CASE_PATTERN).exactOptional(),
   name: z2.string().min(1),
   version: z2.string(),
   author: z2.string().min(1),
   description: z2.string().exactOptional(),
-  /** ISO date when this stack was first created */
   created: z2.string().exactOptional(),
-  /** ISO date of last update */
   updated: z2.string().exactOptional(),
-  /** Primary framework this stack is designed for (e.g., "nextjs", "remix") */
   framework: z2.string().exactOptional(),
-  /** All skills used in this stack (flat list, at least one required) */
   skills: z2.array(stackSkillAssignmentSchema).min(1),
-  /** Agent IDs this stack compiles (at least one required) */
   agents: z2.array(z2.string().regex(KEBAB_CASE_PATTERN)).min(1),
-  /** Per-agent skill assignments: { agentId: { category: [skillAssignment] } } */
   agentSkills: z2.record(z2.string(), z2.record(z2.string(), z2.array(stackSkillAssignmentSchema))).exactOptional(),
-  /** High-level philosophy guiding technology choices */
   philosophy: z2.string().exactOptional(),
-  /** Guiding principles for agents using this stack */
   principles: z2.array(z2.string().min(1)).exactOptional(),
   tags: z2.array(z2.string().regex(KEBAB_CASE_PATTERN)).exactOptional(),
-  /** Per-skill overrides: alternative suggestions and lock status */
   overrides: z2.record(
     z2.string(),
     z2.object({
-      /** Suggested alternative skill IDs if this one is swapped */
       alternatives: z2.array(z2.string().min(1)).exactOptional(),
-      /** If true, this skill cannot be swapped by the user */
       locked: z2.boolean().exactOptional()
     }).strict()
   ).exactOptional(),
-  /** Community metrics for sorting/ranking */
   metrics: z2.object({
     upvotes: z2.number().int().min(0).exactOptional(),
     downloads: z2.number().int().min(0).exactOptional()
   }).strict().exactOptional(),
-  /** Lifecycle hooks triggered by file changes or commands */
   hooks: strictHooksRecordSchema.exactOptional()
 }).strict();
 function formatZodIssues(issues) {
@@ -2992,12 +2933,9 @@ function isLocalSource(source) {
   }
   return true;
 }
-function isSameMarketplace(a, b, fromDir) {
-  if (isLocalSource(a) && isLocalSource(b)) {
-    return path5.resolve(fromDir, a) === path5.resolve(fromDir, b);
-  }
-  return a === b;
-}
+
+// src/cli/lib/compile-seat.ts
+seatDiagnostics({ warn, verbose });
 
 // ../compile/src/seed-to-config.ts
 import { groupBy, indexBy, omit as omit2, partition as partition2 } from "remeda";
@@ -3196,6 +3134,7 @@ var CANONICAL_AGENT_ENTRY_ORDER = [
   "name",
   "scope",
   "model",
+  "codexModel",
   "effort",
   "excluded"
 ];
@@ -3329,7 +3268,6 @@ function generateProjectConfigWithGlobalImport(cleaned, globalImportPath) {
   const hasProjectDomains = selectedDomains.length > 0;
   const hasStack = stack != null && Object.keys(stack).length > 0;
   const typeImports = buildTypeImports({
-    // Always present, spread from global.
     hasSkills: true,
     hasAgents: true,
     hasStack,
@@ -3960,11 +3898,6 @@ var KNOWN_AGENTS = new Set(AGENT_NAMES);
 function sourceForSkill(skill) {
   return skill.availableSources?.find((s) => s.primary)?.name ?? DEFAULT_PUBLIC_SOURCE_NAME;
 }
-function addToDomainSelections(selections, domain, category, skillId) {
-  const categorySelections = selections[domain] ??= {};
-  const skillList = categorySelections[category] ??= [];
-  if (!skillList.includes(skillId)) skillList.push(skillId);
-}
 function addToAgentStack(stack, agent, category, assignment) {
   const agentStack = stack[agent] ??= {};
   const assignments = agentStack[category] ??= [];
@@ -3989,9 +3922,23 @@ function agentScopeConfig(name, entry) {
     name,
     scope: seedAgentScope(entry),
     ...entry?.model !== void 0 && { model: entry.model },
+    ...offeredCodexModel(name, entry?.codexModel),
     ...entry?.effort !== void 0 && { effort: entry.effort }
   };
 }
+var OFFERED_CODEX_MODELS = new Set(CODEX_MODEL_NAMES);
+function isOfferedCodexModel(id) {
+  return OFFERED_CODEX_MODELS.has(id);
+}
+function offeredCodexModel(agent, id) {
+  if (id === void 0) return {};
+  if (isOfferedCodexModel(id)) return { codexModel: id };
+  diagnostics().warn(codexModelNotOfferedWarning(agent, id));
+  return {};
+}
+function codexModelNotOfferedWarning(agent, id) {
+  return `Sub-agent '${agent}' asks for Codex model '${id}', which this version of the CLI does not offer, so it runs on the session's model. Offered: ${inAnEnglishList(CODEX_MODEL_NAMES)}.`;
+}
 function unwritableAssignmentsError(assignments) {
   return [
     "This configuration cannot be installed: a project-scoped skill never reaches a sub-agent that rests at global scope, so these assignments have nowhere to be written:",
@@ -3999,8 +3946,8 @@ function unwritableAssignmentsError(assignments) {
     "Re-share it with each sub-agent above pinned to the project, or each skill above at global scope."
   ].join("\n");
 }
-function seedToWizardResult(payload, catalog) {
-  const domainSelections = {};
+function seedToInstallSelection(payload, catalog) {
+  const domains = /* @__PURE__ */ new Set();
   const assignedStack = {};
   const skills = [];
   const skippedSkillIds = [];
@@ -4017,11 +3964,10 @@ function seedToWizardResult(payload, catalog) {
     }
     const id = skillId;
     const category = skill.category;
-    addToDomainSelections(domainSelections, domain, category, id);
+    domains.add(domain);
     skills.push({
       id,
       scope: entry.scope,
-      // "eject" is an origin in its own right; anything else names the marketplace it came from.
       origin: entry.install === "eject" ? EJECT_SOURCE : sourceForSkill(skill)
     });
     for (const [agentName, load] of Object.entries(entry.assignments)) {
@@ -4062,22 +4008,12 @@ function seedToWizardResult(payload, catalog) {
       ),
       assignedStack,
       selectedStackId: payload.stackId,
-      // Spread-conditional rather than passed through, because absent and present-holding-undefined
-      // are different files on disk: a config describing itself with no key is not one describing
-      // itself with an empty sentence, and the writer emits whichever key it is handed.
+      // Absent and empty are different files on disk.
       ...payload.description !== void 0 && {
         description: payload.description
       },
-      domainSelections,
-      selectedDomains: orderDomains(typedKeys2(domainSelections)),
-      // Nothing was dropped from a *saved config* — the skipped ids came off the wire and are
-      // reported to the user directly, so there is no config removal to explain.
-      unresolvableSkillIds: [],
-      cancelled: false,
-      // Revalidated here rather than taken on trust from the app that built the payload. That app
-      // validated against ITS catalog; this one skips ids it does not know and carries its own
-      // relationship rules, so a configuration that was consistent where it was authored can
-      // arrive with a requirement genuinely unmet.
+      selectedDomains: orderDomains([...domains]),
+      // Revalidated: the payload was consistent against the authoring app's catalog, not this one.
       validation: validateSelection(
         skills.map((skill) => skill.id),
         catalog
@@ -4461,6 +4397,7 @@ export type AgentScopeConfig = {
   name: AgentName
   scope: 'project' | 'global'
   model?: ${formatLiteralUnion(MODEL_NAMES)}
+  codexModel?: ${formatLiteralUnion(CODEX_MODEL_NAMES)}
   effort?: ${formatLiteralUnion(EFFORT_NAMES)}
   excluded?: boolean
 }
@@ -4495,7 +4432,7 @@ var PROJECT_CONFIG_INTERFACE_AFTER = `export interface ProjectConfig {
   /** Agents source path or URL (when agents come from a different source than skills) */
   agentsSource?: string
 
-  /** Selected domains from the wizard */
+  /** Selected domains */
   selectedDomains?: Domain[]
 
   /** Branding overrides for white-labeling the CLI */
@@ -4612,9 +4549,8 @@ function renderStackProperty(category, skills, catalog) {
 function buildSkillsByCategory(skillIds, categories, catalog) {
   const categorySet = new Set(categories);
   const eligible = [...new Set(skillIds)].map((id) => ({ id, category: catalog.skills[id]?.category })).filter(
-    (entry) => entry.category !== void 0 && entry.category !== LOCAL_PSEUDO_CATEGORY && // Boundary cast: a catalogue skill's `category` is a Category, typed `string` on the
-    // narrow catalogue shape so the wire `Matrix` satisfies it too. The `has` below IS the
-    // runtime check the predicate rests on, so the cast only lets the probe be written.
+    (entry) => entry.category !== void 0 && entry.category !== LOCAL_PSEUDO_CATEGORY && // Boundary cast: typed `string` on the narrow catalogue shape; the `has` is the runtime
+    // check.
     categorySet.has(entry.category)
   );
   return new Map(
@@ -6123,11 +6059,10 @@ function assembleAgentConfig(agentName, definition, agentConfig, resolvedSkills)
     title: definition.title,
     description: definition.description,
     ...model !== void 0 && { model },
+    ...agentConfig.codexModel !== void 0 && { codexModel: agentConfig.codexModel },
     ...effort !== void 0 && { effort },
     tools: definition.tools,
-    // Every optional frontmatter field `agent.liquid` reads. Spread conditionally rather
-    // than unconditionally, because the template branches on presence — an explicit
-    // `undefined` renders as an empty key.
+    // Spread conditionally: the template branches on presence, and `undefined` renders a key.
     ...definition.disallowedTools !== void 0 && {
       disallowedTools: definition.disallowedTools
     },
@@ -6167,7 +6102,7 @@ function wereScopeCompatible(priorSkillScope, priorAgentScope) {
   return priorSkillScope !== void 0 && priorAgentScope !== void 0 && isScopePairCompatible(priorSkillScope, priorAgentScope);
 }
 function resolveStackProperty(generated, assigned) {
-  return generated && assigned ? assigned : generated;
+  return generated === void 0 ? void 0 : assigned;
 }
 function resolveDescription(loadedStack, shared) {
   return loadedStack === null ? shared : loadedStack.description;
@@ -6182,22 +6117,22 @@ async function loadCuratedStack(projectDir, projectStack) {
 async function loadGlobalStack() {
   return (await loadInstalledConfig(os10.homedir()))?.config.stack;
 }
-async function buildInstallConfig(wizardResult, sourceResult, projectDir) {
-  const skillIds = unique4(wizardResult.skills.map((s) => s.id));
+async function buildInstallConfig(selection, sourceResult, projectDir) {
+  const skillIds = unique4(selection.skills.map((s) => s.id));
   verbose(
-    `buildInstallConfig: selectedStackId='${wizardResult.selectedStackId}', skills=[${skillIds.join(", ")}], selectedAgents=[${wizardResult.selectedAgents.join(", ")}]`
+    `buildInstallConfig: selectedStackId='${selection.selectedStackId}', skills=[${skillIds.join(", ")}], selectedAgents=[${selection.selectedAgents.join(", ")}]`
   );
-  const loadedStack = await loadSelectedStack(wizardResult.selectedStackId, sourceResult);
+  const loadedStack = await loadSelectedStack(selection.selectedStackId, sourceResult);
   const existing = await loadProjectConfig(projectDir);
   const existingStack = await loadCuratedStack(projectDir, existing?.config.stack);
   const options = generatorOptionsFor(
-    wizardResult,
+    selection,
     existing?.config,
     stackToPreserve(loadedStack, existingStack)
   );
   const generated = generateProjectConfigFromSkills(configNameFor(projectDir), skillIds, options);
-  const stack = resolveStackProperty(generated.stack, wizardResult.assignedStack);
-  const description = resolveDescription(loadedStack, wizardResult.description);
+  const stack = resolveStackProperty(generated.stack, selection.assignedStack);
+  const description = resolveDescription(loadedStack, selection.description);
   const localConfig = {
     ...generated,
     ...stack && { stack },
@@ -6225,30 +6160,30 @@ function stackToPreserve(loadedStack, curatedStack) {
   if (loadedStack === null) return curatedStack;
   return { ...buildStackProperty(loadedStack), ...curatedStack };
 }
-function generatorOptionsFor(wizardResult, persisted, existingStack) {
+function generatorOptionsFor(selection, persisted, existingStack) {
   return {
-    skillConfigs: wizardResult.skills,
-    agentConfigs: wizardResult.agentConfigs,
+    skillConfigs: selection.skills,
+    agentConfigs: selection.agentConfigs,
     existingStack,
-    newlyAddedSkillIds: computeNewlyAddedSkillIds(wizardResult.skills, persisted?.skills),
+    newlyAddedSkillIds: computeNewlyAddedSkillIds(selection.skills, persisted?.skills),
     scopeEligibilityGained: computeScopeEligibilityGained(
-      wizardResult.skills,
-      wizardResult.agentConfigs,
+      selection.skills,
+      selection.agentConfigs,
       persisted?.skills,
       persisted?.agents
     ),
-    ...wizardResult.selectedAgents.length > 0 && {
-      selectedAgents: wizardResult.selectedAgents
+    ...selection.selectedAgents.length > 0 && {
+      selectedAgents: selection.selectedAgents
     }
   };
 }
 function stackSizeForLog(stack) {
   return stack ? `${Object.keys(stack).length} agents` : "UNDEFINED";
 }
-function setConfigMetadata(config, wizardResult, sourceResult, sourceFlag) {
+function setConfigMetadata(config, selection, sourceResult, sourceFlag) {
   const result = { ...config };
-  if (wizardResult.selectedDomains.length > 0) {
-    result.selectedDomains = wizardResult.selectedDomains;
+  if (selection.selectedDomains.length > 0) {
+    result.selectedDomains = selection.selectedDomains;
   }
   if (sourceFlag) {
     result.marketplace = sourceFlag;
@@ -6260,10 +6195,10 @@ function setConfigMetadata(config, wizardResult, sourceResult, sourceFlag) {
   }
   return result;
 }
-async function buildAndMergeConfig(wizardResult, sourceResult, projectDir, sourceFlag, authoritativeScope) {
-  const { config } = await buildInstallConfig(wizardResult, sourceResult, projectDir);
+async function buildAndMergeConfig(selection, sourceResult, projectDir, sourceFlag, authoritativeScope) {
+  const { config } = await buildInstallConfig(selection, sourceResult, projectDir);
   verbose(`buildAndMergeConfig: before merge \u2014 stack=${stackSizeForLog(config.stack)}`);
-  const configWithMetadata = setConfigMetadata(config, wizardResult, sourceResult, sourceFlag);
+  const configWithMetadata = setConfigMetadata(config, selection, sourceResult, sourceFlag);
   const result = await mergeWithExistingConfig(configWithMetadata, {
     projectDir,
     ...authoritativeScope !== void 0 && { authoritativeScope }
@@ -6292,6 +6227,7 @@ function buildCompileAgents(config, agents) {
   const buildAgentCompileEntry = (agentConfig) => {
     const tuning = {
       ...agentConfig.model !== void 0 && { model: agentConfig.model },
+      ...agentConfig.codexModel !== void 0 && { codexModel: agentConfig.codexModel },
       ...agentConfig.effort !== void 0 && { effort: agentConfig.effort }
     };
     const agentStack = config.stack?.[agentConfig.name];
@@ -6996,7 +6932,7 @@ function hostAt(root) {
 
 // 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.`;
+  return `Failed to copy ${failedCount} skill(s) for eject. Eject intent could not be honored. Check that the destination skills directory is writable, then apply the same id again with '${CLI_INVOKE_COMMAND} edit --from <id>' \u2014 or switch the affected skills back to plugin mode.`;
 }
 function detectMigrations(oldSkills, newSkills) {
   const oldById = new Map(oldSkills.map((s) => [s.id, s]));
@@ -7504,13 +7440,13 @@ async function loadSkillsOfPlugin({
   }
 }
 function mergeInPluginOrder(perPluginSkills) {
-  const allSkills2 = {};
+  const allSkills = {};
   for (const pluginSkills of perPluginSkills) {
     for (const [id, skill] of typedEntries(pluginSkills)) {
-      if (skill) allSkills2[id] = skill;
+      if (skill) allSkills[id] = skill;
     }
   }
-  return allSkills2;
+  return allSkills;
 }
 async function listPluginNames(projectDir) {
   try {
@@ -7741,66 +7677,25 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
 
 // src/cli/lib/skills/unresolved-skill-entries.ts
 import path26 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] : []);
-}
-async function unresolvedSkillRemovalReasons(unresolvedIds, savedSkills, projectDir, sourceLabel) {
-  const classified = await classifyUnresolvedSkills(unresolvedIds, savedSkills, projectDir);
-  return new Map(
-    classified.flatMap(({ id, fate }) => {
-      const reason = removalReason(id, fate, sourceLabel);
-      return reason === null ? [] : [[id, reason]];
-    })
+async function findUnusableSavedSkillMetadata(savedSkills, projectDir) {
+  const verdicts = await Promise.all(
+    savedSkills.map((saved) => unusableMetadataOf(saved, projectDir))
   );
+  return verdicts.filter((verdict) => verdict !== null);
 }
-async function classifyUnresolvedSkills(unresolvedIds, savedSkills, projectDir) {
-  return Promise.all(
-    unresolvedIds.map(async (id) => {
-      const saved = savedSkills.find((entry) => entry.id === id);
-      return { id, fate: await classifySavedSkill(id, saved, projectDir) };
-    })
-  );
-}
-async function classifySavedSkill(id, saved, projectDir) {
-  if (saved?.origin !== EJECT_SOURCE) return { kind: "dropped-by-source" };
-  const skillDir = path26.join(resolveInstallPaths(projectDir, saved.scope).skillsDir, id);
-  if (!await directoryExists2(skillDir)) return { kind: "files-gone", skillDir };
-  const metadataPath = path26.join(skillDir, STANDARD_FILES.METADATA_YAML);
-  if (!await fileExists(metadataPath)) return { kind: "not-installed-there", skillDir };
+async function unusableMetadataOf(saved, projectDir) {
+  if (!claimsLocalCopy(saved)) return null;
+  const metadataPath = installedMetadataPath(saved, projectDir);
+  if (!await fileExists(metadataPath)) return null;
   const read = await readSkillMetadata(metadataPath);
-  if (!read.usable) {
-    return {
-      kind: "unusable-metadata",
-      detail: { skillDirName: id, metadataPath, reason: read.reason }
-    };
-  }
-  if (!await skillMdNames(skillDir, id)) return { kind: "not-installed-there", skillDir };
-  return { kind: "unplaceable-category", skillDir, category: read.metadata.category };
-}
-async function skillMdNames(skillDir, id) {
-  const skillMdPath = path26.join(skillDir, STANDARD_FILES.SKILL_MD);
-  if (!await fileExists(skillMdPath)) return false;
-  const frontmatter = parseFrontmatter(await readFile(skillMdPath), skillMdPath);
-  return frontmatter?.name === id;
-}
-function removalReason(id, fate, sourceLabel) {
-  switch (fate.kind) {
-    case "dropped-by-source":
-      return `not present in ${sourceLabel}`;
-    case "files-gone":
-      return `skill files no longer exist at ${fate.skillDir}`;
-    case "not-installed-there":
-      return `no skill named '${id}' is installed at ${fate.skillDir}`;
-    case "unplaceable-category":
-      return `installed at ${fate.skillDir}, but its category '${fate.category}' is not one this source knows`;
-    case "unusable-metadata":
-      return null;
-    default: {
-      const exhaustive = fate;
-      return exhaustive;
-    }
-  }
+  return read.usable ? null : { skillDirName: saved.id, metadataPath, reason: read.reason };
+}
+function claimsLocalCopy(saved) {
+  return !saved.excluded && saved.origin === EJECT_SOURCE;
+}
+function installedMetadataPath(saved, projectDir) {
+  const { skillsDir: skillsDir2 } = resolveInstallPaths(projectDir, saved.scope);
+  return path26.join(skillsDir2, saved.id, STANDARD_FILES.METADATA_YAML);
 }
 
 // src/cli/lib/skills/local-skill-mover.ts
@@ -7859,10 +7754,6 @@ async function migrateLocalSkillScope(skillId, fromScope, projectDir) {
   }
   verbose(`Migrated skill '${skillId}' from ${fromScope} to ${toScope}`);
 }
-async function foldLocalSkillIntoGlobal(projectDir, skillId) {
-  await deleteLocalSkill(projectDir, skillId, "global");
-  await migrateLocalSkillScope(skillId, "project", projectDir);
-}
 
 // src/cli/lib/matrix/matrix-loader.ts
 import { parse as parseYaml5 } from "yaml";
@@ -8161,233 +8052,6 @@ function buildResolvedSkill(skill, _categories, relationships, slugMap) {
   };
 }
 
-// src/cli/lib/matrix/matrix-resolver.ts
-import { groupBy as groupBy4 } from "remeda";
-function getLabel(skill) {
-  return stripTerminalControls(skill.displayName);
-}
-function joinWithConjunction(items, conjunction) {
-  if (items.length <= 1) return items[0] ?? "";
-  if (items.length === 2) return `${items[0]} ${conjunction} ${items[1]}`;
-  return `${items.slice(0, -1).join(", ")} ${conjunction} ${items[items.length - 1]}`;
-}
-function initializeSelectionContext(currentSelections) {
-  const resolvedSelections = currentSelections.map((s) => getSkillById(s).id);
-  const selectedSet = new Set(resolvedSelections);
-  return { resolvedSelections, selectedSet };
-}
-function toSelectionFacts(source) {
-  return {
-    skills: typedValues(source.skills).map((skill) => ({
-      id: skill.id,
-      categoryId: skill.category,
-      conflictsWith: skill.conflictsWith.map((relation) => relation.skillId),
-      discourages: skill.discourages.map((relation) => ({
-        skillId: relation.skillId,
-        // The one author string that leaves this module without being re-rendered: the shared
-        // semantics carry it through and `getCellState` hands the verdict back whole, so a
-        // discouraged cell prints exactly what was put in here. Made inert on the way in, which
-        // is the only point on that route this package owns.
-        reason: stripTerminalControls(relation.reason)
-      })),
-      requires: skill.requires.map((requirement) => ({
-        skillIds: requirement.skillIds,
-        needsAny: requirement.needsAny
-      }))
-    })),
-    exclusiveCategoryIds: new Set(
-      typedValues(source.categories).filter((category) => category.exclusive !== false).map((category) => category.id)
-    )
-  };
-}
-var boundSemantics;
-var boundTo;
-function judgeSelections(resolvedSelections) {
-  if (!boundSemantics || boundTo !== matrix) {
-    boundSemantics = createSelectionSemantics(toSelectionFacts(matrix));
-    boundTo = matrix;
-  }
-  return boundSemantics(resolvedSelections);
-}
-function renderIncompatibility(cause) {
-  switch (cause.kind) {
-    case "conflict":
-      return `conflicts with ${labelOf(cause.skillId)}`;
-    case "unreachableRequirement": {
-      if (cause.requirement.needsAny) {
-        const labels = cause.requirement.skillIds.map(labelOf);
-        return `requires ${joinWithConjunction(labels, "or")} (all conflict with current selection)`;
-      }
-      const lostLabels = cause.lostIds.map(labelOf);
-      return `requires ${joinWithConjunction(lostLabels, "and")} which conflicts with current selection`;
-    }
-  }
-}
-function labelOf(skillId) {
-  return getLabel(getSkillById(skillId));
-}
-function isRequirementMet(req, selectedSet) {
-  return req.needsAny ? req.skillIds.some((id) => selectedSet.has(id)) : req.skillIds.every((id) => selectedSet.has(id));
-}
-function missingRequirementIds(req, selectedSet) {
-  if (isRequirementMet(req, selectedSet)) return [];
-  return req.needsAny ? [...req.skillIds] : req.skillIds.filter((id) => !selectedSet.has(id));
-}
-function getUnmetRequiredBy(skillId, currentSelections) {
-  getSkillById(skillId);
-  const { resolvedSelections, selectedSet } = initializeSelectionContext(currentSelections);
-  if (selectedSet.has(skillId)) return void 0;
-  for (const selectedId of resolvedSelections) {
-    const selectedSkill = matrix.skills[selectedId];
-    if (!selectedSkill) continue;
-    for (const req of selectedSkill.requires) {
-      if (!req.skillIds.includes(skillId)) continue;
-      if (req.needsAny) {
-        if (!req.skillIds.some((id) => selectedSet.has(id))) {
-          return getLabel(selectedSkill);
-        }
-      } else {
-        return getLabel(selectedSkill);
-      }
-    }
-  }
-  return void 0;
-}
-function hasUnmetRequirements(skillId, currentSelections) {
-  return getUnmetRequirementsReason(skillId, currentSelections) !== void 0;
-}
-function getCellState(skillId, currentSelections) {
-  const skill = getSkillById(skillId);
-  const { resolvedSelections } = initializeSelectionContext(currentSelections);
-  const verdict = judgeSelections(resolvedSelections).verdictOf(skill.id);
-  return verdict.status === "incompatible" ? { status: "incompatible", reason: renderIncompatibility(verdict.cause) } : verdict;
-}
-function getUnmetRequirementsReason(skillId, currentSelections) {
-  const skill = getSkillById(skillId);
-  const { selectedSet } = initializeSelectionContext(currentSelections);
-  for (const requirement of skill.requires) {
-    const missing = missingRequirementIds(requirement, selectedSet);
-    if (missing.length === 0) continue;
-    const names = missing.map((id) => {
-      const s = matrix.skills[id];
-      return s ? getLabel(s) : stripTerminalControls(id);
-    });
-    return withAuthorsReason(namesTheMissing(names, requirement.needsAny), requirement.reason);
-  }
-  return void 0;
-}
-function namesTheMissing(names, needsAny) {
-  return `requires ${joinWithConjunction(names, needsAny ? "or" : "and")}`;
-}
-var REASON_BUDGET = 60;
-function withAuthorsReason(synthesised, reason) {
-  const stated = reason.trim();
-  if (stated === "") return synthesised;
-  return `${synthesised} \u2014 ${truncateText(stated, REASON_BUDGET)}`;
-}
-function unmetRequirementsReasonFor(isSelected, skillId, currentSelections) {
-  if (!isSelected) return {};
-  const reason = getUnmetRequirementsReason(skillId, currentSelections);
-  return reason === void 0 ? {} : { unmetRequirementsReason: reason };
-}
-function validateConflicts(resolvedSelections) {
-  const errors = [];
-  for (const [index, skillAId] of resolvedSelections.entries()) {
-    const skillA = matrix.skills[skillAId];
-    if (!skillA) continue;
-    for (const skillBId of resolvedSelections.slice(index + 1)) {
-      const conflict = skillA.conflictsWith.find((c) => c.skillId === skillBId);
-      if (conflict) {
-        errors.push({
-          type: "conflict",
-          // The author's own sentence, made inert but not shortened: this message is reported on
-          // its own line rather than into a fixed-height cell, so it needs no budget the way
-          // `withAuthorsReason` does — only the guarantee that a terminal will print it.
-          message: `${getLabel(skillA)} conflicts with ${getLabel(getSkillById(skillBId))}: ${stripTerminalControls(conflict.reason)}`,
-          skills: [skillA.id, skillBId]
-        });
-      }
-    }
-  }
-  return errors;
-}
-function validateRequirements(resolvedSelections, selectedSet) {
-  const errors = [];
-  for (const skillId of resolvedSelections) {
-    const skill = matrix.skills[skillId];
-    if (!skill) continue;
-    for (const requirement of skill.requires) {
-      if (requirement.needsAny) {
-        const hasAny = requirement.skillIds.some((reqId) => selectedSet.has(reqId));
-        if (!hasAny) {
-          errors.push({
-            type: "missingRequirement",
-            message: `${getLabel(skill)} requires one of: ${requirement.skillIds.map((id) => getLabel(getSkillById(id))).join(", ")}`,
-            skills: [skillId, ...requirement.skillIds]
-          });
-        }
-      } else {
-        const missingIds = requirement.skillIds.filter((reqId) => !selectedSet.has(reqId));
-        if (missingIds.length > 0) {
-          errors.push({
-            type: "missingRequirement",
-            message: `${getLabel(skill)} requires: ${missingIds.map((id) => getLabel(getSkillById(id))).join(", ")}`,
-            skills: [skillId, ...missingIds]
-          });
-        }
-      }
-    }
-  }
-  return errors;
-}
-function validateExclusivity(resolvedSelections) {
-  const errors = [];
-  const validSkills = resolvedSelections.map((skillId) => ({ skillId, skill: matrix.skills[skillId] })).filter((entry) => entry.skill != null);
-  const categorySelections = groupBy4(validSkills, (entry) => entry.skill.category);
-  for (const [categoryId, entries] of typedEntries(categorySelections)) {
-    if (entries.length > 1) {
-      const skillIds = entries.map((e) => e.skillId);
-      if (categoryId === LOCAL_PSEUDO_CATEGORY) continue;
-      const category = matrix.categories[categoryId];
-      if (category?.exclusive) {
-        errors.push({
-          type: "categoryExclusive",
-          message: `Category "${stripTerminalControls(category.displayName)}" only allows one selection, but multiple selected: ${skillIds.map((id) => getLabel(getSkillById(id))).join(", ")}`,
-          skills: skillIds
-        });
-      }
-    }
-  }
-  return errors;
-}
-function validateSelection2(selections) {
-  const { resolvedSelections, selectedSet } = initializeSelectionContext(selections);
-  const errors = [
-    ...validateConflicts(resolvedSelections),
-    ...validateRequirements(resolvedSelections, selectedSet),
-    ...validateExclusivity(resolvedSelections)
-  ];
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-function getAvailableSkills(categoryId, currentSelections) {
-  const { selectedSet } = initializeSelectionContext(currentSelections);
-  return getSkillsByCategory(categoryId).map((skill) => {
-    const isSelected = selectedSet.has(skill.id);
-    return {
-      id: skill.id,
-      selected: isSelected,
-      hasUnmetRequirements: isSelected && hasUnmetRequirements(skill.id, currentSelections),
-      ...unmetRequirementsReasonFor(isSelected, skill.id, currentSelections)
-    };
-  });
-}
-function getSkillsByCategory(categoryId) {
-  return allSkills().filter((skill) => skill.category === categoryId);
-}
-
 // src/cli/lib/configuration/skill-audit.ts
 var skillAudit = {
   // ── B1 — web core: frameworks, meta-frameworks, routing, server state (20) ──
@@ -9930,7 +9594,7 @@ var skillAudit = {
     batch: "shared-meta",
     classification: { class: "B", frameworks: ["react"] },
     sources: [
-      'skill body self-scope (description "Use when reviewing React components"; When-to-use ".tsx/.jsx with JSX"; "React PR review" auto-detection) plus a React-keyed majority (4 of 5 MUSTs, 6 of 7 patterns)'
+      'skill body self-scope (description "Load when reviewing a diff that adds or changes React components or hooks"; Applies-to "Diffs that add or change React components or custom hooks"; "React PR review" auto-detection) plus a React-keyed majority (4 of 5 critical requirements, 6 of 7 patterns)'
     ]
   },
   "meta-reviewing-api-reviewing": {
@@ -9961,8 +9625,8 @@ var skillAudit = {
 var auditVerdictsPendingApply = {};
 
 // src/cli/lib/matrix/matrix-health-check.ts
-function checkMatrixHealth(matrix2) {
-  const issues = [
+function matrixHealthIssues(matrix2) {
+  return [
     ...checkCategoryDomains(matrix2),
     ...checkSkillCategories(matrix2),
     ...checkSkillRelationRefs(matrix2),
@@ -9970,6 +9634,9 @@ function checkMatrixHealth(matrix2) {
     ...checkAuditVerdictContradictions(matrix2),
     ...checkUnauditedSkills(matrix2)
   ];
+}
+function checkMatrixHealth(matrix2) {
+  const issues = matrixHealthIssues(matrix2);
   for (const issue of issues) {
     warn(`[matrix] ${issue.details}`);
   }
@@ -9979,7 +9646,7 @@ function checkCategoryDomains(matrix2) {
   return typedEntries(matrix2.categories).filter(([, cat]) => cat !== void 0 && !cat.domain).map(([catId]) => ({
     severity: "warning",
     finding: "category-missing-domain",
-    details: `Category '${catId}' has no domain \u2014 it won't appear in any wizard domain view`
+    details: `Category '${catId}' has no domain \u2014 it won't appear under any domain`
   }));
 }
 function checkSkillCategories(matrix2) {
@@ -10064,7 +9731,10 @@ function checkUnauditedSkills(matrix2) {
 }
 
 // src/cli/lib/loading/source-loader.ts
-async function loadSkillsMatrixFromSource(options = {}) {
+function loadSkillsMatrixFromSource(options = {}) {
+  return sayingEachWarningOnce(() => loadCatalogue(options));
+}
+async function loadCatalogue(options) {
   const {
     purpose = "fetch",
     caller = "stored",
@@ -10307,12 +9977,6 @@ async function loadAndMergeFromBasePath(basePath, source) {
   initializeMatrix(mergedMatrix);
   const stacks = await resolveOfferedStacks(basePath, stacksRelFile, source);
   mergedMatrix.suggestedStacks = stacks.map((stack) => convertStackToResolvedStack(stack));
-  const agentDefinedDomains = domainsDeclaredBy(await loadAllAgents(basePath));
-  const domainCount = typedKeys(agentDefinedDomains).length;
-  if (domainCount > 0) {
-    mergedMatrix.agentDefinedDomains = agentDefinedDomains;
-    verbose(`Loaded ${domainCount} agent domain definition(s)`);
-  }
   return mergedMatrix;
 }
 async function loadSourceTaxonomy(basePath) {
@@ -10338,13 +10002,6 @@ async function loadSourceTaxonomy(basePath) {
   }
   return { categories, sourceRules };
 }
-function domainsDeclaredBy(agents) {
-  return typedFromEntries(
-    typedEntries(agents).flatMap(
-      ([agentId, agentDef]) => agentDef.domain ? [[agentId, agentDef.domain]] : []
-    )
-  );
-}
 var CATALOGUE_SKILL_IDS = new Set(typedKeys(BUILT_IN_MATRIX.skills));
 var MAX_REPORTED_COLLISIONS = 10;
 async function refuseCatalogueCollisions(basePath, source, skills) {
@@ -10498,7 +10155,6 @@ export {
   stripTerminalControls,
   truncateText,
   plural,
-  toTitleCase,
   getErrorMessage,
   setVerbose,
   verbose,
@@ -10507,6 +10163,7 @@ export {
   drainBuffer,
   disableBuffering,
   warn,
+  sayingEachWarningOnce,
   renderAgentRoleToml,
   agentsLeftOutOfCodexMessage,
   unexpressibleOnCodexMessage,
@@ -10565,6 +10222,7 @@ export {
   skillMetadataUnusableDetail,
   skillMetadataUnusableError,
   savedSkillMetadataUnusableError,
+  editorSkillMetadataUnusableError,
   sharedConfigDestinations,
   applySharedConfigHere,
   shareRefusesEjectedSkills,
@@ -10579,12 +10237,11 @@ export {
   projectCopyRemoved,
   sharedConfigNeedsTerminal,
   nothingInstalledToApplyTo,
-  wizardNeedsTerminal,
   uninstallNeedsTerminal,
-  editorLoadsItsOwnMarketplace,
-  marketplaceFixedAtInstall,
+  addMarketplaceInTheEditor,
   SHARED_CONFIG_ARRIVALS,
   keptAsInstalledGlobally,
+  addedToGlobalSubAgents,
   authoredHereKept,
   unplaceableKept,
   keptUnassigned,
@@ -10618,7 +10275,6 @@ export {
   copy,
   formatZodErrors,
   isRecord,
-  isDomain,
   isAgentName,
   skillCategoriesFileSchema,
   skillRulesFileSchema,
@@ -10644,7 +10300,6 @@ export {
   resolveBranding,
   resolvePrimarySourceEntry,
   isLocalSource,
-  isSameMarketplace,
   normalizeStackRecord,
   defaultUsageGuidance,
   resolveAgentConfigToSkills,
@@ -10671,7 +10326,7 @@ export {
   typedEntries2 as typedEntries,
   isScopePairCompatible,
   splitConfigByScope,
-  seedToWizardResult,
+  seedToInstallSelection,
   mergeConfigs,
   generateConfigTypesSource,
   deriveCategories,
@@ -10727,16 +10382,10 @@ export {
   printCompilationSummary,
   discoverLocalSkills,
   findUnusableSavedSkillMetadata,
-  unresolvedSkillRemovalReasons,
   deleteLocalSkill,
   migrateLocalSkillScope,
-  foldLocalSkillIntoGlobal,
   claimSlug,
-  getUnmetRequiredBy,
-  getCellState,
-  validateSelection2 as validateSelection,
-  getAvailableSkills,
-  checkMatrixHealth,
+  matrixHealthIssues,
   generateMarketplace,
   validateMarketplaceName,
   validateSkillIdNamespace,
@@ -10762,4 +10411,4 @@ export {
   detectMigrations,
   executeMigration
 };
-//# sourceMappingURL=chunk-A4KDXNOT.js.map
+//# sourceMappingURL=chunk-MQ6CGZNJ.js.map