agents-inc 0.175.0 → 0.176.0

package/dist/{chunk-YM3VEDAP.js → chunk-ENET4IF6.js}

@@ -13,7 +13,7 @@ import {
   typedFromEntries,
   typedKeys,
   typedValues
-} from "./chunk-TG3SPPZY.js";
+} from "./chunk-UE4Z3YMB.js";
 import {
   AGENT_NAMES,
   AUTHOR_HANDLE_PATTERN,
@@ -91,7 +91,7 @@ import {
 
 // src/cli/lib/loading/source-loader.ts
 import os14 from "os";
-import { partition as partition5, unique as unique6 } from "remeda";
+import { partition as partition6, unique as unique6 } from "remeda";
 import path28 from "path";
 
 // src/cli/lib/installation/is-home-directory.ts
@@ -481,6 +481,9 @@ function chooseProviderForThisRun(provider) {
 function forgetTheProviderChosenForThisRun() {
   providerChosenForThisRun = void 0;
 }
+function declaresNoContent(config) {
+  return config.skills.length === 0 && config.agents.length === 0;
+}
 var declaresNothingAsRead = /* @__PURE__ */ new Map();
 function recordWhetherItDeclaresNothing(configPath, declaresNothing) {
   const stamp = stampOf(configPath);
@@ -505,9 +508,7 @@ function providerInUse(root) {
   return providerOnDisk(root);
 }
 function inheritedGlobalProvider(projectDir, own = providerInUse(projectDir)) {
-  const home = os2.homedir();
-  const inheritsItsOwn = holdsAnInstallation(projectDir, own) && holdsAnInstallation(home, own);
-  return inheritsItsOwn ? own : providerInUse(home);
+  return holdsAnInstallation(projectDir, own) ? own : providerInUse(os2.homedir());
 }
 function providerAtScope(projectDir, scope) {
   return scope === "global" ? inheritedGlobalProvider(projectDir) : providerInUse(projectDir);
@@ -984,8 +985,16 @@ var INFO_MESSAGES = {
   CONFIG_TYPES_REFRESHED: `Refreshed ${STANDARD_FILES.CONFIG_TYPES_TS}`,
   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.",
-  /** The owner's words (2026-10-24), on stderr before the command's own output. */
+  /**
+   * The owner's words (2026-10-24), on stderr before the command's own output. The lines after it
+   * are each true of a run this one is not (owner, 2026-10-26: "A line worded for each").
+   */
   GLOBAL_INSTALLATION_STANDS_IN: "This project's config declares nothing, so this works on your global installation.",
+  NO_GLOBAL_INSTALLATION_STANDS_IN: "This project's config declares nothing, and there is no global installation for this to work on.",
+  DECLARES_NOTHING_TO_UNINSTALL: "This project's config declares nothing, so there is nothing to uninstall in this project.",
+  DECLARES_NOTHING_TO_EJECT_FROM: "This project's config declares nothing; eject works on this project, not on a global installation.",
+  DECLARES_NOTHING_TO_INIT_OVER: "This project's config declares nothing, so init treats this project as holding no installation.",
+  DECLARES_NOTHING_TO_SEARCH_FROM: "This project's config declares nothing; search reads the marketplace it names, else the global installation's, else the default one.",
   /** Under doctor's marketplace row, when its download replaced a saved copy whose files differed. */
   SAVED_COPY_REPLACED: "The saved copy differed from the marketplace and has been replaced",
   /** Printed under the destination already named, so it names files only. */
@@ -1024,21 +1033,18 @@ function propagatedRecompileSummary(recompiled, failed) {
   const failureSuffix = failed > 0 ? ` (${failed} failed)` : "";
   return `Registered projects: ${recompiled} recompiled${failureSuffix}`;
 }
-function skillAssignedToNoAgent(skillId) {
-  return `Skill '${skillId}' is assigned to no sub-agent \u2014 nothing will load it.`;
+function skillAssignedToNoAgent(skillId, namedBy) {
+  return `Skill '${skillName(skillId, namedBy)}' is assigned to no sub-agent \u2014 nothing will load it.`;
 }
-function scopeBlockedStackAssignment(agentNames, skillId) {
+function scopeBlockedStackAssignment(agentNames, skillId, namedBy) {
   const subject = agentNames.length === 1 ? "Sub-agent" : "Sub-agents";
   const named = agentNames.map((name) => `'${name}'`).join(", ");
-  return `${subject} ${named} cannot carry project-scoped skill '${skillId}' \u2014 global-scoped sub-agents only carry global-scoped skills.`;
+  return `${subject} ${named} cannot carry project-scoped skill '${skillName(skillId, namedBy)}' \u2014 global-scoped sub-agents only carry global-scoped skills.`;
 }
 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 to recompile ${object}.`;
 }
-function marketplacesRefreshed(count) {
-  return `Refreshed ${plural(count, "marketplace listing")}. Installed plugins were not changed.`;
-}
 function marketplaceRefreshFailed(marketplace, reason) {
   return `Could not update marketplace ${marketplace}: ${reason}`;
 }
@@ -1051,6 +1057,13 @@ function sourceRefusedUsingCache(source, status) {
 function marketplacesRefreshFailed(marketplaces) {
   return `${plural(marketplaces.length, "marketplace")} could not be updated: ${marketplaces.join(", ")}`;
 }
+function codexPluginLeftSwitchedOn(pluginKey, configFile, reason) {
+  return `Codex switched plugin ${pluginKey} back on when it was updated, and it could not be switched off again in ${configFile}: ${reason}. To switch it off, set enabled = false in that file, in the table it already has for ${pluginKey}.`;
+}
+function pluginsLeftSwitchedOn(pluginKeys) {
+  const are = pluginKeys.length === 1 ? "is" : "are";
+  return `${plural(pluginKeys.length, "plugin")} you had switched off ${are} switched on again: ${pluginKeys.join(", ")}`;
+}
 function marketplaceOwnerHasNoName(packageJsonPath) {
   return [
     `A marketplace's owner must have a name, and no name could be read from 'author' in ${packageJsonPath}.`,
@@ -1118,6 +1131,10 @@ function registeredProjectOnAnotherProvider(projectPath) {
 function registeredProjectUpdateFailed(projectPath) {
   return `Skipped ${projectPath}: updating it failed.`;
 }
+function unregisteredSkillsSkipped(count, folder) {
+  const are = count === 1 ? "isn't" : "aren't";
+  return `Skipped ${plural(count, "skill")} in '${folder}' that ${are} registered with the CLI (no ${STANDARD_FILES.METADATA_YAML}).`;
+}
 function skillMetadataUnusableDetail({
   skillDirName,
   metadataPath,
@@ -1166,26 +1183,26 @@ function applySharedConfigHere(id, installedHere, provider) {
   const named = providerArgument(provider);
   return id === void 0 ? `Then ${verb} what it gives you with '${command} <id>${named}'.` : `To ${verb} it here instead, run '${command} ${id}${named}'.`;
 }
-function shareRefusesEjectedSkills(skillIds) {
+function shareRefusesEjectedSkills(skillIds, namedBy) {
   return [
     "This installation holds ejected skills, and ejected skills cannot be shared:",
-    ...skillIds.map((id) => `  ${id}`),
+    ...skillIds.map((id) => `  ${skillName(id, namedBy)}`),
     "Only plugins can be shared."
   ].join("\n");
 }
 function sharedIdNamesAFolder(folder) {
   return `This id names the marketplace folder ${folder}, so it installs only where that folder exists.`;
 }
-function sharedSkillsLeftBehind(skillIds) {
-  return `A shared id names one marketplace, and these skill(s) come from another, so they will not install elsewhere: ${skillIds.join(", ")}`;
+function sharedSkillsLeftBehind(skillIds, namedBy) {
+  return `A shared id names one marketplace, and these skill(s) come from another, so they will not install elsewhere: ${skillNames(skillIds, namedBy)}`;
 }
 function sharedConfigExistingInstall(configPath, id, provider) {
   return `An installation already exists at ${configPath}. Run '${CLI_INVOKE_COMMAND} uninstall${providerArgument(provider)}' first \u2014 ${SHARED_CONFIG_GREENFIELD_HINT}. ${applySharedConfigHere(id, true, provider)}`;
 }
-function sharedConfigProjectScopeAtHome(skillIds, agentNames, installedHere, provider) {
+function sharedConfigProjectScopeAtHome(skillIds, agentNames, installedHere, provider, namedBy) {
   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)`),
+    ...skillIds.map((id) => `  skill ${skillName(id, namedBy)} (scope: project)`),
     ...agentNames.map((name) => `  sub-agent ${name} (scope: project)`),
     installedHere ? changeTheGlobalInstallFromHome(providerArgument(provider)) : "Run this from inside a project directory, or re-share it with each entry above at global scope."
   ].join("\n");
@@ -1220,12 +1237,21 @@ function subAgentsInstalledWithout({ skillId, agentNames }) {
 function skippedUnknownAgents(agentNames) {
   return `Skipped ${agentNames.length} unknown sub-agent(s): ${unknownKeys(agentNames)}`;
 }
-function carriedSkillsWritten(skillIds) {
-  return `Wrote ${skillIds.length} skill(s) this configuration carries: ${skillIds.join(", ")}`;
+function carriedSkillsWritten(skillIds, namedBy) {
+  return `Wrote ${skillIds.length} skill(s) this configuration carries: ${skillNames(skillIds, namedBy)}`;
+}
+function copiedSkillsRemovedAfterRefusedSave(count) {
+  return `Removed the ${plural(count, "skill")} it copied, since the configuration could not be saved`;
+}
+function carriedSkillsRemovedAfterRefusedSave(count) {
+  return `Removed the ${plural(count, "skill")} this configuration carried, since the configuration could not be saved`;
 }
 var SHARED_CONFIG_APPLY = {
   CONFIRM: "Apply this configuration?"
 };
+function idNamesAnotherMarketplace(named, used) {
+  return `This id names the marketplace ${inertLine(named)}; its skills come from this installation's marketplace, ${used}.`;
+}
 function registeredProjectsRecompiled(projectPaths) {
   return [
     "Each project registered with this global install is recompiled to match:",
@@ -1257,6 +1283,9 @@ var SHARED_CONFIG_ARRIVALS = {
 function skillName(id, namedBy) {
   return getSkillEntryDisplayName(namedBy[id] ?? { id });
 }
+function skillNames(skillIds, namedBy) {
+  return skillIds.map((id) => skillName(id, namedBy)).join(", ");
+}
 function keptAsInstalledGlobally(skillIds, agentNames, idAppliedAtHome, provider, namedBy) {
   return [
     "Kept as installed in the global install \u2014 this configuration states them differently or leaves them out, and a project run only adds to the global install:",
@@ -1269,15 +1298,11 @@ function keptAsInstalledGlobally(skillIds, agentNames, idAppliedAtHome, provider
 }
 function skillsMoved(verb, skillIds, namedBy) {
   const names = skillIds.map((id) => skillName(id, namedBy));
-  return names.length === 0 ? [] : [`${verb} ${listed(names)}`];
+  return names.length === 0 ? [] : [`${verb} ${inAnEnglishList(names)}`];
 }
 function settingMoved({ setting, from, to }) {
   return `${setting} ${from ?? "default"} \u2192 ${to ?? "default"}`;
 }
-function listed(names) {
-  if (names.length <= 1) return names.join("");
-  return `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
-}
 var SKILLS_REASSIGNED = "skills reassigned";
 function subAgentChanged({
   name,
@@ -1296,10 +1321,11 @@ function subAgentChanged({
   return `~ ${name}${where}: ${details.length > 0 ? details.join(", ") : SKILLS_REASSIGNED}`;
 }
 function addedToGlobalSubAgents(joined, namedBy) {
-  const gains = (skillIds) => skillIds.map((id) => skillName(id, namedBy)).join(", ");
   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}: + ${gains(skillIds)}`)
+    ...joined.map(
+      ({ agentName, skillIds }) => `  sub-agent ${agentName}: + ${skillNames(skillIds, namedBy)}`
+    )
   ].join("\n");
 }
 function authoredHereKept(skillIds, namedBy) {
@@ -2583,6 +2609,14 @@ var ConfigDefaultExportError = class extends Error {
   }
   configPath;
 };
+var ConfigEvaluationError = class extends Error {
+  constructor(configPath, reason, options) {
+    super(configLoadFailure(configPath, reason), options);
+    this.configPath = configPath;
+    this.name = "ConfigEvaluationError";
+  }
+  configPath;
+};
 var ES_MODULE_MARKER = "__esModule";
 function unwrapDefaultExport(namespace) {
   if (isRecord(namespace) && "default" in namespace) return namespace.default;
@@ -2628,7 +2662,7 @@ async function importConfigModule(configPath) {
     });
     return await jiti.import(configPath);
   } catch (error) {
-    throw new Error(configLoadFailure(configPath, getErrorMessage(error)), { cause: error });
+    throw new ConfigEvaluationError(configPath, getErrorMessage(error), { cause: error });
   }
 }
 
@@ -2664,7 +2698,7 @@ function initProviderToNameAt(root, provider) {
 
 // src/cli/lib/configuration/config.ts
 var SOURCE_ENV_VAR = "CC_MARKETPLACE";
-async function loadSourceConfig(dir, scope, provider) {
+async function readStoredConfig(dir, scope, provider) {
   const scopeLabel2 = scope === "project" ? "Project" : "Global";
   const configPath = storedConfigPath(dir, provider);
   if (!await fileExists(configPath)) {
@@ -2681,7 +2715,17 @@ async function loadSourceConfig(dir, scope, provider) {
   if (installation === null) throw unreadable(NO_VALID_DEFAULT_EXPORT);
   const settings = readSettings(configPath, installation);
   verbose(`Loaded ${scope} config from ${dir}`);
-  return settings;
+  return {
+    settings,
+    declaresNothing: declaresNoContent({
+      skills: installation.skills ?? [],
+      agents: installation.agents ?? []
+    })
+  };
+}
+async function loadSourceConfig(dir, scope, provider) {
+  const stored = await readStoredConfig(dir, scope, provider);
+  return stored === null ? null : stored.settings;
 }
 function refuseInstallationConfig(configPath, scope, scopeRoot, provider) {
   const providerToName = providerToNameAt(scopeRoot, provider);
@@ -2738,14 +2782,23 @@ async function loadGlobalSourceConfig(provider) {
 async function loadEffectiveSourceConfig(projectDir, provider) {
   const ownDir = ownProjectDir(projectDir);
   const own = ownDir === null ? null : await readStoredRung(ownDir, "project", provider);
-  return own ?? await readStoredRung(os4.homedir(), "global", provider ?? inheritedBy(projectDir));
+  if (own !== null && !readsAsNoConfig(own)) return own;
+  return readStoredRung(os4.homedir(), "global", provider ?? inheritedBy(projectDir));
+}
+function readsAsNoConfig(own) {
+  return own.declaresNothing && own.config.marketplace === void 0;
 }
 function inheritedBy(projectDir) {
   return inheritedGlobalProvider(projectDir ?? os4.homedir());
 }
 async function readStoredRung(dir, origin, provider) {
-  const config = await loadSourceConfig(dir, origin, provider);
-  return config && { config, origin, configPath: storedConfigPath(dir, provider) };
+  const stored = await readStoredConfig(dir, origin, provider);
+  return stored && {
+    config: stored.settings,
+    declaresNothing: stored.declaresNothing,
+    origin,
+    configPath: storedConfigPath(dir, provider)
+  };
 }
 function storedConfigPath(dir, provider) {
   return provider === void 0 ? getInstalledConfigPath(dir) : getProjectConfigPath(dir, provider);
@@ -2779,7 +2832,7 @@ async function resolveSource(request) {
   if (envSource !== void 0) {
     return { source: envSource, sourceOrigin: "env", ...labelFor(envSource) };
   }
-  if (effective?.config.marketplace) {
+  if (caller === "stored" && effective?.config.marketplace) {
     assertStoredSourceUsable(effective.config.marketplace, effective.configPath);
     verbose(`Marketplace from ${effective.origin} config: ${effective.config.marketplace}`);
     return {
@@ -3218,9 +3271,6 @@ function valueEntries(values) {
 function commentEntry(text) {
   return { kind: "comment", text };
 }
-function sourceEntry(source) {
-  return { kind: "source", source };
-}
 function renderValueLine(value, position) {
   return line(
     renderValue(value, position),
@@ -3301,8 +3351,6 @@ function renderEntryLine(entry, indent) {
   switch (entry.kind) {
     case "comment":
       return `${spaces(indent)}// ${entry.text}`;
-    case "source":
-      return `${spaces(indent)}${entry.source},`;
     case "value":
       return renderValueLine(entry.value, { indent, prefix: "", suffix: "," });
     default: {
@@ -3340,8 +3388,6 @@ function flatEntry(entry) {
     // A `//` line cannot fold onto one line.
     case "comment":
       return void 0;
-    case "source":
-      return entry.source;
     case "value":
       return flatValue(entry.value);
     default: {
@@ -3526,62 +3572,16 @@ function generateConfigSource(config, catalog, options) {
 }
 function generateProjectConfig(config, catalog, options) {
   const cleaned = cleanForEmission(config, catalog, { dropProjects: true });
-  if (options.globalConfig) {
-    return generateProjectConfigWithInlinedGlobal(
-      cleaned,
-      cleanForEmission(options.globalConfig, catalog, { dropProjects: true })
-    );
-  }
-  if (options.globalImportPath !== void 0) {
-    return generateProjectConfigWithGlobalImport(
-      cleaned,
-      options.globalImportPath
+  if (!options.globalConfig) {
+    throw new Error(
+      "A project config needs the global config it extends: pass `globalConfig` to inline its entries."
     );
   }
-  throw new Error(
-    "A project config needs the global config it extends: pass `globalConfig` to inline its entries, or `globalImportPath` to import and spread them. Neither was given."
+  return generateProjectConfigWithInlinedGlobal(
+    cleaned,
+    cleanForEmission(options.globalConfig, catalog, { dropProjects: true })
   );
 }
-function generateProjectConfigWithGlobalImport(cleaned, globalImportPath) {
-  const { skills, agents, stack, selectedDomains } = extractConfigArrays(cleaned);
-  const emitted = {
-    hasSkills: true,
-    hasAgents: true,
-    hasStack: hasStackEntries(stack),
-    hasSelectedDomains: selectedDomains.length > 0
-  };
-  const scalarFields = Object.entries(cleaned).filter(([key]) => isCopiedScalarField(key)).map(([key, value]) => renderScalarField(key, value));
-  return assembleConfigSource({
-    imports: [
-      `import globalConfig from ${quoteText(`${globalImportPath}/config`)}`,
-      renderTypeImportLine(buildTypeImports(emitted), CONFIG_TYPES_SPECIFIER)
-    ],
-    declarations: [
-      ...entryDeclaration("skills", "SkillConfig[]", [
-        sourceEntry("...globalConfig.skills"),
-        ...valueEntries(skills)
-      ]),
-      ...entryDeclaration("agents", "AgentScopeConfig[]", [
-        sourceEntry("...globalConfig.agents"),
-        ...valueEntries(agents)
-      ]),
-      ...emitted.hasStack ? declaration("stack", STACK_TYPE, stack) : [],
-      ...emitted.hasSelectedDomains ? entryDeclaration("selectedDomains", "Domain[]", [
-        sourceEntry("...(globalConfig.selectedDomains ?? [])"),
-        ...valueEntries(selectedDomains)
-      ]) : []
-    ],
-    exportFields: [
-      `  ...globalConfig,`,
-      renderScalarField("name", resolveProjectName(cleaned)),
-      `  skills,`,
-      `  agents,`,
-      ...emitted.hasStack ? [`  stack,`] : [],
-      ...emitted.hasSelectedDomains ? [`  selectedDomains,`] : [],
-      ...scalarFields
-    ]
-  });
-}
 function generateStandaloneConfig(cleaned) {
   const { skills, agents, stack, selectedDomains } = extractConfigArrays(cleaned);
   const emitted = {
@@ -3697,18 +3697,25 @@ function stackOfAgents(stack, agents) {
 function mergeInlinedScalarFields(cleaned, cleanedGlobal) {
   return Object.entries(
     canonicalizeFieldOrder({
-      ...omit(cleanedGlobal, GLOBAL_IDENTITY_FIELDS),
+      ...globalScalarsLentTo(cleaned, cleanedGlobal),
       ...cleaned
     })
   ).filter(([key]) => isCopiedScalarField(key));
 }
+function globalScalarsLentTo(cleaned, cleanedGlobal) {
+  const lent = omit(cleanedGlobal, GLOBAL_IDENTITY_FIELDS);
+  return recordsAnotherMarketplace(cleaned, cleanedGlobal) ? omit(lent, ["marketplaceName"]) : lent;
+}
+function recordsAnotherMarketplace(cleaned, cleanedGlobal) {
+  return cleaned.marketplace !== void 0 && cleaned.marketplace !== cleanedGlobal.marketplace;
+}
 function generateProjectConfigWithInlinedGlobal(cleaned, cleanedGlobal) {
-  const partition6 = partitionInlinedConfigEntries(cleaned, cleanedGlobal);
+  const partition7 = partitionInlinedConfigEntries(cleaned, cleanedGlobal);
   const emitted = {
-    hasSkills: partition6.globalSkills.length > 0 || partition6.projectSkills.length > 0,
-    hasAgents: partition6.globalAgents.length > 0 || partition6.projectAgents.length > 0,
-    hasStack: hasStackEntries(partition6.filteredStack),
-    hasSelectedDomains: partition6.selectedDomains.length > 0
+    hasSkills: partition7.globalSkills.length > 0 || partition7.projectSkills.length > 0,
+    hasAgents: partition7.globalAgents.length > 0 || partition7.projectAgents.length > 0,
+    hasStack: hasStackEntries(partition7.filteredStack),
+    hasSelectedDomains: partition7.selectedDomains.length > 0
   };
   const scalarFields = mergeInlinedScalarFields(cleaned, cleanedGlobal);
   return assembleConfigSource({
@@ -3719,15 +3726,15 @@ function generateProjectConfigWithInlinedGlobal(cleaned, cleanedGlobal) {
       ...emitted.hasSkills ? entryDeclaration(
         "skills",
         "SkillConfig[]",
-        scopeSectionEntries(partition6.globalSkills, partition6.projectSkills)
+        scopeSectionEntries(partition7.globalSkills, partition7.projectSkills)
       ) : [],
       ...emitted.hasAgents ? entryDeclaration(
         "agents",
         "AgentScopeConfig[]",
-        scopeSectionEntries(partition6.globalAgents, partition6.projectAgents)
+        scopeSectionEntries(partition7.globalAgents, partition7.projectAgents)
       ) : [],
-      ...emitted.hasStack ? declaration("stack", STACK_TYPE, partition6.filteredStack) : [],
-      ...emitted.hasSelectedDomains ? declaration("selectedDomains", "Domain[]", partition6.selectedDomains) : []
+      ...emitted.hasStack ? declaration("stack", STACK_TYPE, partition7.filteredStack) : [],
+      ...emitted.hasSelectedDomains ? declaration("selectedDomains", "Domain[]", partition7.selectedDomains) : []
     ],
     exportFields: [
       renderScalarField("name", resolveProjectName(cleaned)),
@@ -4220,14 +4227,14 @@ function agentsOnlyItCarried(skill, agentMap, carried) {
 }
 function readAgentMap(agents) {
   const known = /* @__PURE__ */ new Map();
-  const switchedOff = /* @__PURE__ */ new Set();
+  const switchedOff2 = /* @__PURE__ */ new Set();
   const unknown = [];
   for (const [name, entry] of Object.entries(agents)) {
     if (!isAgentName2(name)) unknown.push(name);
-    else if (entry.on === false) switchedOff.add(name);
+    else if (entry.on === false) switchedOff2.add(name);
     else known.set(name, entry);
   }
-  return { known, switchedOff, unknown };
+  return { known, switchedOff: switchedOff2, unknown };
 }
 function agentsSwitchedOn(agentMap) {
   return [...agentMap.known].filter(([, entry]) => entry.on === true).map(([name]) => name);
@@ -4389,6 +4396,12 @@ function normalizeStackRecord(rawStack) {
     (agentConfig) => rekeyToLiveCategories(normalizeAgentConfig(agentConfig))
   );
 }
+var StacksLoadError = class extends Error {
+  constructor(stacksPath, reason, options) {
+    super(`Failed to load stacks from '${stacksPath}': ${reason}`, options);
+    this.name = "StacksLoadError";
+  }
+};
 async function loadStacks(configDir, stacksFile) {
   const resolvedStacksFile = stacksFile ?? STACKS_FILE_PATH;
   const cacheKey = `${configDir}:${resolvedStacksFile}`;
@@ -4412,14 +4425,12 @@ async function loadStacks(configDir, stacksFile) {
     verbose(`Loaded ${stacks.length} stacks from ${stacksPath}`);
     return stacks;
   } catch (error) {
-    const errorMessage = getErrorMessage(error);
-    throw new Error(`Failed to load stacks from '${stacksPath}': ${errorMessage}`, {
-      cause: error
-    });
+    throw new StacksLoadError(stacksPath, getErrorMessage(error), { cause: error });
   }
 }
 async function loadStackById(stackId, configDir, source) {
-  const stacks = await loadStacks(configDir);
+  const declared = await loadSourceRepoConfig(configDir);
+  const stacks = await loadStacks(configDir, declared?.stacksFile);
   const stack = stacks.find((s) => s.id === stackId);
   if (stack) {
     verbose(`Found stack: ${stack.name} (${stackId})`);
@@ -4439,8 +4450,15 @@ async function loadStackById(stackId, configDir, source) {
   verbose(`Found default stack: ${defaultStack.name} (${stackId})`);
   return defaultStack;
 }
-function stackNotOfferedMessage(stackId, source) {
-  return `Stack '${inertLine(stackId)}' is not a stack the source '${source}' offers. A marketplace ships its own stacks; the CLI's built-in ones belong to the default public marketplace alone.`;
+function stackNotOfferedMessage(stackId, source, shippedStackIds) {
+  return `Stack '${inertLine(stackId)}' is not a stack the source '${source}' offers. A marketplace ships its own stacks; the CLI's built-in ones belong to the default public marketplace alone. ${whatItShips(shippedStackIds)}`;
+}
+function whatItShips(stackIds) {
+  if (stackIds.length === 0) return "It ships no stacks.";
+  return withClosingFullStop(`It ships: ${inAnEnglishList(stackIds.map(inertLine))}`);
+}
+function withClosingFullStop(sentence) {
+  return sentence.endsWith(".") ? sentence : `${sentence}.`;
 }
 function defaultUsageGuidance(category) {
   return `Use when working with ${category}.`;
@@ -4491,9 +4509,6 @@ var ConfigLoadError = class extends Error {
   /** Named in the remedy's `init --from` half, which a bare run would answer with another one. */
   initProviderToName;
 };
-function declaresNoContent(config) {
-  return config.skills.length === 0 && config.agents.length === 0;
-}
 async function configDeclaresNothing(projectDir, provider) {
   const configPath = getProjectConfigPath(projectDir, provider);
   const parsed = await parseConfigFile(configPath, refusalAt(configPath, projectDir, provider));
@@ -4635,6 +4650,16 @@ function editDrops(incoming, existing, identity, authoritativeScope) {
     incomingIdentities.has(identity.identityOf(entry)) || dualScopeIdentities.has(identity.identityOf(entry)) || authoritativeScope !== void 0 && isWithinSessionAuthority(entry, authoritativeScope)
   );
 }
+function marketplaceNameBeside(merged, existing) {
+  if (merged.marketplace === existing.marketplace) {
+    return existing.marketplaceName ?? merged.marketplaceName;
+  }
+  if (wouldBorrowAnotherMarketplaceName(merged, existing)) return DEFAULT_PUBLIC_SOURCE_NAME;
+  return merged.marketplaceName;
+}
+function wouldBorrowAnotherMarketplaceName(merged, existing) {
+  return merged.marketplace === DEFAULT_SOURCE && merged.marketplaceName === void 0 && existing.marketplaceName !== void 0;
+}
 function mergeConfigs(newConfig, existingConfig, options) {
   const merged = { ...newConfig };
   if (existingConfig.name) {
@@ -4664,8 +4689,9 @@ function mergeConfigs(newConfig, existingConfig, options) {
   if (existingConfig.author) {
     merged.author = existingConfig.author;
   }
-  if (existingConfig.marketplaceName && merged.marketplace === existingConfig.marketplace) {
-    merged.marketplaceName = existingConfig.marketplaceName;
+  const marketplaceName = marketplaceNameBeside(merged, existingConfig);
+  if (marketplaceName !== void 0) {
+    merged.marketplaceName = marketplaceName;
   }
   Object.assign(merged, pick(existingConfig, HAND_WRITTEN_FIELDS));
   if (existingConfig.projects && !newConfig.projects) {
@@ -5294,9 +5320,10 @@ async function loadProjectAgents(projectRoot, provider = providerInUse(projectRo
   });
 }
 async function loadSkillsFromDir(skillsDir2, options = {}) {
-  const { pathPrefix = "", requireMetadata = false } = options;
+  const { pathPrefix = "", requireMetadata = false, folderLabel = `${pathPrefix}/` } = options;
   const skills = {};
   const unusableMetadata = [];
+  let unregisteredCount = 0;
   if (!await directoryExists2(skillsDir2)) {
     return { skills, unusableMetadata };
   }
@@ -5306,11 +5333,13 @@ async function loadSkillsFromDir(skillsDir2, options = {}) {
     if (requireMetadata) {
       const verdict = await judgeSkillMetadata(skill);
       if (verdict.kind === "unusable") unusableMetadata.push(verdict.refusal);
+      if (verdict.kind === "unregistered") unregisteredCount++;
       if (verdict.kind !== "admitted") continue;
     }
     const definition = await readSkillDefinition(skill);
     if (definition) skills[definition.id] = definition;
   }
+  if (unregisteredCount > 0) warn(unregisteredSkillsSkipped(unregisteredCount, folderLabel));
   return { skills, unusableMetadata };
 }
 function locateSkill(skillsDir2, skillFile, pathPrefix) {
@@ -5328,10 +5357,8 @@ function locateSkill(skillsDir2, skillFile, pathPrefix) {
 async function judgeSkillMetadata(skill) {
   const metadataPath = path14.join(skill.skillDir, STANDARD_FILES.METADATA_YAML);
   if (!await fileExists(metadataPath)) {
-    warn(
-      `Skill '${skill.skillDirName}' in '${skill.displayPath}' is missing ${STANDARD_FILES.METADATA_YAML} \u2014 skipped. Add ${STANDARD_FILES.METADATA_YAML} to register it with the CLI.`
-    );
-    return { kind: "skipped" };
+    verbose(`  No ${STANDARD_FILES.METADATA_YAML} in '${skill.skillDirName}'`);
+    return { kind: "unregistered" };
   }
   const read = await readSkillMetadata(metadataPath);
   if (!read.usable) {
@@ -5475,11 +5502,11 @@ function reservedNameError(marketplaceName, wayOut) {
   return `Marketplace name '${marketplaceName}' is reserved. '${DEFAULT_PUBLIC_SOURCE_NAME}' is the public catalogue's own namespace, '${EXTERNAL_SKILL_NAMESPACE}' and '${LOCAL_SKILL_NAMESPACE}' hold the skills that belong to no marketplace, and '${EJECT_SOURCE}' is what an installation records for a skill copied into it rather than installed as a plugin \u2014 a marketplace under any of them is read back as something it is not. Choose a name of your own: ${wayOut}.`;
 }
 function namespaceViolationError(foreignIds, marketplaceName) {
-  const listed2 = foreignIds.slice(0, MAX_REPORTED_NAMESPACE_VIOLATIONS).map((id) => `  ${id} -> ${marketplaceName}-${id}`);
-  const unlisted = foreignIds.length - listed2.length;
+  const listed = foreignIds.slice(0, MAX_REPORTED_NAMESPACE_VIOLATIONS).map((id) => `  ${id} -> ${marketplaceName}-${id}`);
+  const unlisted = foreignIds.length - listed.length;
   return [
     `Marketplace '${marketplaceName}' ships ${foreignIds.length} skill id(s) outside its own namespace. Every skill id must begin with the marketplace's name:`,
-    ...listed2,
+    ...listed,
     ...unlisted > 0 ? [`  ... and ${unlisted} more`] : [],
     `Rename each skill directory and the 'name' in its SKILL.md, re-run 'build plugins', then build the marketplace again.`
   ].join("\n");
@@ -5521,6 +5548,9 @@ var TarballWithheldError = class extends Error {
     this.status = status;
   }
 };
+function isUnanswered(answer) {
+  return answer === "unreachable" || answer instanceof TarballWithheldError;
+}
 var marketplaceMustAnswer = new AsyncLocalStorage3();
 function askingEachMarketplaceItself(body) {
   const differingCopiesReplaced = /* @__PURE__ */ new Set();
@@ -5620,38 +5650,95 @@ async function fetchFromRemoteSource(source, subdir) {
   verbose(`Cache directory: ${cacheDir}`);
   if (await directoryExists2(cacheDir)) {
     const verdict = await revalidateCachedCopy(cacheDir, source);
-    if (keepsTheCopy(verdict)) {
-      verbose(`Using cached marketplace: ${cacheDir}`);
-      return {
-        path: cacheDir,
-        fromCache: true,
-        unreachable: verdict === "unreachable",
-        source: fullSource
-      };
-    }
+    if (keepsTheCopy(verdict)) return readSavedCopy(cacheDir, fullSource, verdict);
     announceRefetch(verdict);
-    if (!mustAnswer()) await discardCachedCopy(cacheDir, source);
+    if (!mustAnswer()) return refreshSavedCopy(cacheDir, source, fullSource, verdict);
   }
   const differingCopiesReplaced = marketplaceMustAnswer.getStore();
   return differingCopiesReplaced ? downloadAnsweredFor(cacheDir, source, fullSource, differingCopiesReplaced) : downloadFreshCopy(cacheDir, source, fullSource);
 }
-async function discardCachedCopy(cacheDir, source) {
-  await clearGigetCache(source);
-  await remove(cacheDir);
+function readSavedCopy(cacheDir, fullSource, verdict) {
+  verbose(`Using cached marketplace: ${cacheDir}`);
+  return {
+    path: cacheDir,
+    fromCache: true,
+    unreachable: verdict === "unreachable",
+    source: fullSource
+  };
+}
+async function refreshSavedCopy(cacheDir, source, fullSource, verdict) {
+  if (verdict === "superseded") await clearGigetCache(source);
+  const staged = `${cacheDir}${STAGED_DOWNLOAD_SUFFIX}`;
+  try {
+    const download = await downloadUnlessItFails(source, fullSource, staged);
+    if (isUnanswered(download)) {
+      const failed = verdictOnFailedDownload(verdict, download, source);
+      return keepSavedCopyUnlessStopped(cacheDir, fullSource, failed);
+    }
+    const downloaded = await verdictOnDownload(download, source);
+    if (downloaded !== "current") {
+      return keepSavedCopyUnlessStopped(cacheDir, fullSource, downloaded);
+    }
+    await moveIntoPlace(cacheDir, staged);
+    await recordFetchedCopy(cacheDir, download.result, download.savedTarball);
+    settleForThisRun(cacheDir, "current");
+    return { path: cacheDir, fromCache: false, unreachable: false, source: fullSource };
+  } catch (error) {
+    throw createDetailedFetchError(error, source);
+  } finally {
+    await remove(staged);
+  }
+}
+function keepSavedCopyUnlessStopped(cacheDir, fullSource, verdict) {
+  if (verdict instanceof TarballWithheldError) throw verdict;
+  settleForThisRun(cacheDir, verdict);
+  return readSavedCopy(cacheDir, fullSource, verdict);
+}
+async function downloadUnlessItFails(source, fullSource, staged) {
+  try {
+    return await downloadStaged(source, fullSource, staged);
+  } catch (error) {
+    verbose(`Could not download ${fullSource}: ${getErrorMessage(error)}`);
+    return refusalIn(error) ?? "unreachable";
+  }
+}
+var GIGET_DOWNLOAD_REFUSED = /^Failed to download \S+: (?<status>\d{3}) (?<statusText>.*)$/;
+function refusalIn(error) {
+  const answered = GIGET_DOWNLOAD_REFUSED.exec(getErrorMessage(error))?.groups;
+  if (answered?.status === void 0 || answered.statusText === void 0) return void 0;
+  const status = Number(answered.status);
+  if (postureOn(status) === void 0) return void 0;
+  return new TarballWithheldError({ status, statusText: answered.statusText });
+}
+function verdictOnFailedDownload(verdict, failure, source) {
+  if (verdict === "unrecorded") return verdictOnUnanswered(failure, source);
+  warn(updateNotFetchedUsingCache(source));
+  return "outdated";
+}
+function updateNotFetchedUsingCache(source) {
+  return `Could not fetch the update from ${source} \u2014 using the cached copy, which is out of date.`;
+}
+async function verdictOnDownload({ result, savedTarball }, source) {
+  return savedTarball ? verdictOnSavedTarball(result, savedTarball, source) : "current";
 }
 async function downloadFreshCopy(cacheDir, source, fullSource) {
   await ensureDir(path16.dirname(cacheDir));
   try {
-    const { result, savedTarball } = await gigetDownload(source, fullSource, {
+    const download = await gigetDownload(source, fullSource, {
       dir: cacheDir,
       force: true,
       // Always force when downloading to avoid "already exists" error
       offline: false
     });
+    const { result, savedTarball } = download;
     verbose(`Downloaded to: ${result.dir}`);
-    if (savedTarball) await askBeforeKeepingTheSavedTarball(cacheDir, result, source);
+    const downloaded = await verdictOnDownload(download, source);
+    if (downloaded instanceof TarballWithheldError) {
+      await remove(cacheDir);
+      throw downloaded;
+    }
     await recordFetchedCopy(cacheDir, result, savedTarball);
-    markCopyCurrentForThisRun(cacheDir);
+    settleForThisRun(cacheDir, "current");
     return {
       path: result.dir,
       fromCache: false,
@@ -5662,25 +5749,27 @@ async function downloadFreshCopy(cacheDir, source, fullSource) {
     throw createDetailedFetchError(error, source);
   }
 }
-async function askBeforeKeepingTheSavedTarball(cacheDir, result, source) {
+async function verdictOnSavedTarball(result, savedTarball, source) {
   const tar = tarballOf(result);
-  if (tar === void 0) return;
+  if (tar === void 0) return "current";
   const answer = await answerAbout(tar);
-  if (answer === "answered") return;
-  if (answer === "unreachable") {
+  if (isUnanswered(answer)) return verdictOnUnanswered(answer, source);
+  if (answer.etag === savedTarball.etag) return "current";
+  warn(updateNotFetchedUsingCache(source));
+  return "outdated";
+}
+function verdictOnUnanswered(unanswered, source) {
+  if (unanswered === "unreachable") {
     warn(sourceUnreachableUsingCache(source));
-    return;
-  }
-  if (stopsTheLoad(answer)) {
-    await remove(cacheDir);
-    throw answer;
+    return "unreachable";
   }
-  announceTheCopyKept(answer, source);
+  if (stopsTheLoad(unanswered)) return unanswered;
+  announceTheCopyKept(unanswered, source);
+  return "refused";
 }
 async function answerAbout(tar) {
   try {
-    await fetchEtag(tar);
-    return "answered";
+    return { etag: await fetchEtag(tar) };
   } catch (error) {
     if (error instanceof TarballWithheldError) return error;
     verbose(`Could not ask ${tar} about the tarball giget saved: ${getErrorMessage(error)}`);
@@ -5692,21 +5781,16 @@ var ONLY_A_SAVED_COPY_CAME_BACK = "the download failed and only a saved copy cam
 var SET_ASIDE_SUFFIX = ".set-aside";
 async function downloadAnsweredFor(cacheDir, source, fullSource, differingCopiesReplaced) {
   const staged = `${cacheDir}${STAGED_DOWNLOAD_SUFFIX}`;
-  const downloadStaged = () => gigetDownload(source, fullSource, {
-    dir: staged,
-    force: true,
-    forceClean: true,
-    offline: false
-  });
+  const download = () => downloadStaged(source, fullSource, staged);
   await ensureDir(path16.dirname(cacheDir));
   try {
-    const { result, savedTarball } = await downloadStaged();
+    const { result, savedTarball } = await download();
     const record = await askAfterTheDownload(result, source);
-    if (savedTarball) await downloadPast(savedTarball, record, downloadStaged, source);
+    if (savedTarball) await downloadPast(savedTarball, record, download, source);
     const differed = await savedCopyDiffers(cacheDir, staged);
     await replaceCopy(cacheDir, staged, record);
     if (differed) differingCopiesReplaced.add(source);
-    markCopyCurrentForThisRun(cacheDir);
+    settleForThisRun(cacheDir, "current");
     return { path: cacheDir, fromCache: false, unreachable: false, source: fullSource };
   } catch (error) {
     if (error instanceof MarketplaceUnreachableError) throw error;
@@ -5715,6 +5799,14 @@ async function downloadAnsweredFor(cacheDir, source, fullSource, differingCopies
     await remove(staged);
   }
 }
+function downloadStaged(source, fullSource, staged) {
+  return gigetDownload(source, fullSource, {
+    dir: staged,
+    force: true,
+    forceClean: true,
+    offline: false
+  });
+}
 async function downloadPast(savedTarball, record, download, source) {
   if (!savedUnder(savedTarball, record)) {
     throw new MarketplaceUnreachableError(source, ONLY_A_SAVED_COPY_CAME_BACK);
@@ -5761,9 +5853,12 @@ function sameBytesAt(file, left, right) {
   return readFileSync(path16.join(left, file)).equals(readFileSync(path16.join(right, file)));
 }
 async function replaceCopy(cacheDir, staged, record) {
+  await moveIntoPlace(cacheDir, staged);
+  await writeFile(fetchRecordPath(cacheDir), JSON.stringify(record));
+}
+async function moveIntoPlace(cacheDir, staged) {
   await remove(cacheDir);
   await rename(staged, cacheDir);
-  await writeFile(fetchRecordPath(cacheDir), JSON.stringify(record));
 }
 var GIGET_TARBALLS = "**/*.tar.gz";
 var gigetTarballRecordSchema = z4.object({ etag: z4.string().min(1).optional() });
@@ -5932,7 +6027,7 @@ function savedUnder(savedTarball, record) {
   return savedTarball.etag !== void 0 && savedTarball.etag === record.etag;
 }
 function keepsTheCopy(verdict) {
-  return verdict === "current" || verdict === "unreachable" || verdict === "refused";
+  return verdict === "current" || verdict === "unreachable" || verdict === "refused" || verdict === "outdated";
 }
 var REVALIDATION_TIMEOUT_MS = 5e3;
 var FETCH_RECORD_SUFFIX = ".etag.json";
@@ -5954,16 +6049,12 @@ function revalidateCachedCopy(cacheDir, source) {
   verdicts.set(cacheDir, verdict);
   return verdict;
 }
-function markCopyCurrentForThisRun(cacheDir) {
-  verdictsThisRun().set(cacheDir, Promise.resolve("current"));
+function settleForThisRun(cacheDir, verdict) {
+  verdictsThisRun().set(cacheDir, Promise.resolve(verdict));
 }
 async function classifyCachedCopy(cacheDir, source) {
   const record = await readFetchRecord(cacheDir);
   if (!record) return "unrecorded";
-  if (record.etag === void 0 && !mustAnswer()) {
-    verbose(`No ETag was recorded for ${record.tar} \u2014 keeping the cached copy`);
-    return "current";
-  }
   try {
     return judgeAnswer(record, await fetchEtag(record.tar));
   } catch (error) {
@@ -5982,6 +6073,7 @@ function stopOrKeepTheCopy(refusal2, source) {
 function judgeAnswer(record, live) {
   if (movedOn(record, live)) return "superseded";
   if (mustAnswer()) return "answered";
+  if (record.etag === void 0 && live !== void 0) return "unstamped";
   if (live === void 0) {
     verbose(`${record.tar} answered without an ETag \u2014 keeping the cached copy`);
   }
@@ -6366,9 +6458,9 @@ function agentNotFoundError(agentName, agents) {
 }
 function describeAvailableAgents(availableAgents) {
   if (availableAgents.length === 0) return "No agents found in scanned directories";
-  const listed2 = availableAgents.slice(0, MAX_LISTED_AVAILABLE_AGENTS).join(", ");
+  const listed = availableAgents.slice(0, MAX_LISTED_AVAILABLE_AGENTS).join(", ");
   const unlisted = availableAgents.length - MAX_LISTED_AVAILABLE_AGENTS;
-  return unlisted > 0 ? `Available agents: ${listed2} (and ${unlisted} more)` : `Available agents: ${listed2}`;
+  return unlisted > 0 ? `Available agents: ${listed} (and ${unlisted} more)` : `Available agents: ${listed}`;
 }
 function assembleAgentConfig(agentName, definition, agentConfig, resolvedSkills) {
   const model = agentConfig.model ?? definition.model;
@@ -6458,7 +6550,10 @@ async function loadSelectedStack(stackId, sourceResult) {
   verbose(
     `buildInstallConfig: loadedStack=${loadedStack ? `found (id='${loadedStack.id}')` : "NOT FOUND"}`
   );
-  if (!loadedStack) throw new Error(stackNotOfferedMessage(stackId, source));
+  if (!loadedStack) {
+    const shippedStackIds = sourceResult.matrix.suggestedStacks.map((stack) => stack.id);
+    throw new Error(stackNotOfferedMessage(stackId, source, shippedStackIds));
+  }
   return loadedStack;
 }
 function stackToPreserve(loadedStack, curatedStack) {
@@ -6832,6 +6927,13 @@ async function claudePluginInstall(pluginPath, scope, projectDir, options) {
     throw new Error(`Plugin installation failed: ${whyClaudeFailed(result)}`);
   }
 }
+async function claudePluginUpdate(pluginRef, scope, projectDir, options) {
+  validatePluginName(pluginRef);
+  const cwd = resolvePluginCwd(scope, projectDir);
+  const args = ["plugin", "update", pluginRef, "--scope", scope];
+  const result = await execCommand("claude", args, { cwd, ...configDirEnv(options) });
+  if (result.exitCode !== 0) throw new Error(whyClaudeFailed(result));
+}
 async function isClaudeCLIAvailable(options) {
   try {
     const result = await execCommand("claude", ["--version"], configDirEnv(options));
@@ -6948,6 +7050,7 @@ function claudeHost() {
     addMarketplace: claudePluginMarketplaceAdd,
     refreshMarketplace: claudePluginMarketplaceUpdate,
     installPlugin: (pluginRef, scope, projectDir, options) => claudePluginInstall(pluginRef, toClaudePluginScope(scope), projectDir, options),
+    updatePlugin: (pluginRef, scope, projectDir, options) => claudePluginUpdate(pluginRef, toClaudePluginScope(scope), projectDir, options),
     uninstallPlugin: (pluginRef, scope, projectDir, options) => claudePluginUninstall(pluginRef, toClaudePluginScope(scope), projectDir, options),
     listPlugins: claudeListPlugins
   };
@@ -6957,6 +7060,87 @@ function claudeHost() {
 import os13 from "os";
 import path21 from "path";
 import { z as z7 } from "zod";
+
+// src/cli/lib/hosts/codex-plugin-switch.ts
+import { partition as partition5 } from "remeda";
+function sayWhichAreLeftOn(leftOn) {
+  return leftOn.map(({ pluginKey, reason }) => `Codex left ${pluginKey} switched on: ${reason}`).join("\n");
+}
+var PluginsLeftSwitchedOnError = class extends Error {
+  constructor(leftOn) {
+    super(sayWhichAreLeftOn(leftOn));
+    this.leftOn = leftOn;
+  }
+  leftOn;
+};
+var FailedLeavingPluginsSwitchedOnError = class extends Error {
+  constructor(failure, leftOn) {
+    super(`${getErrorMessage(failure)}
+${sayWhichAreLeftOn(leftOn)}`, { cause: failure });
+    this.failure = failure;
+    this.leftOn = leftOn;
+  }
+  failure;
+  leftOn;
+};
+var SWITCH = /^(\s*enabled\s*=\s*)(true|false)(\s*)$/;
+var SWITCHED_OFF = "false";
+var NOT_FOUND = -1;
+async function switchCodexPluginsOff(configFile, pluginKeys) {
+  if (pluginKeys.length === 0) return;
+  const leftOn = await pluginsStillSwitchedOn(configFile, pluginKeys);
+  if (leftOn.length > 0) throw new PluginsLeftSwitchedOnError(leftOn);
+}
+async function pluginsStillSwitchedOn(configFile, pluginKeys) {
+  const leftOn = (pluginKey, reason) => ({ pluginKey, configFile, reason });
+  try {
+    const config = await readFile(configFile);
+    const switched = withSwitchesOff(config, pluginKeys);
+    if (switched.config !== config) await writeFile(configFile, switched.config);
+    return switched.unfound.map(
+      (pluginKey) => leftOn(pluginKey, notSpelledAsCodexWritesIt(pluginKey))
+    );
+  } catch (error) {
+    return pluginKeys.map((pluginKey) => leftOn(pluginKey, getErrorMessage(error)));
+  }
+}
+function withSwitchesOff(config, pluginKeys) {
+  const lines = config.split("\n");
+  const located = pluginKeys.map((pluginKey) => ({
+    pluginKey,
+    at: switchLineOf(lines, pluginKey)
+  }));
+  const [found, unfound] = partition5(located, ({ at }) => at !== NOT_FOUND);
+  const toSwitch = new Set(found.map(({ at }) => at));
+  return {
+    config: lines.map((line2, at) => toSwitch.has(at) ? switchedOff(line2) : line2).join("\n"),
+    unfound: unfound.map(({ pluginKey }) => pluginKey)
+  };
+}
+function switchLineOf(lines, pluginKey) {
+  const header = lines.findIndex((line2) => line2.trim() === pluginTableHeader(pluginKey));
+  if (header === NOT_FOUND) return NOT_FOUND;
+  const end = endOfTable(lines, header);
+  return lines.findIndex((line2, at) => at > header && at < end && SWITCH.test(line2));
+}
+function endOfTable(lines, header) {
+  const nextTable = lines.findIndex((line2, at) => at > header && opensATable(line2));
+  return nextTable === NOT_FOUND ? lines.length : nextTable;
+}
+function switchedOff(line2) {
+  return line2.replace(SWITCH, `$1${SWITCHED_OFF}$3`);
+}
+function opensATable(line2) {
+  return line2.trim().startsWith("[");
+}
+function pluginTableHeader(pluginKey) {
+  return `[plugins."${pluginKey}"]`;
+}
+function notSpelledAsCodexWritesIt(pluginKey) {
+  return `it has no ${pluginTableHeader(pluginKey)} table with an 'enabled' line`;
+}
+
+// src/cli/lib/hosts/codex-host.ts
 var CODEX = "codex";
 var PLUGIN_CACHE_SUBDIR = "cache";
 var STANDING_WARNING = /could not create PATH aliases/;
@@ -7113,23 +7297,56 @@ async function upgradeGitMarketplace(name, options) {
   );
 }
 async function reinstallEachPluginOf(name, options) {
-  const installed = await codexPluginListing(options, codexPluginCwd());
-  for (const plugin of installed.filter((entry) => entry.marketplaceName === name)) {
-    await installCodexPlugin(plugin.pluginId, options);
+  const ofTheMarketplace = (await codexPluginListing(options, codexPluginCwd())).filter(
+    (plugin) => plugin.marketplaceName === name
+  );
+  for (const [at, plugin] of ofTheMarketplace.entries()) {
+    try {
+      await installCodexPlugin(plugin.pluginId, options);
+    } catch (refusal2) {
+      await switchBackOffThenRethrow(refusal2, ofTheMarketplace.slice(0, at), options);
+    }
+  }
+  await switchBackOff(ofTheMarketplace, options);
+}
+async function switchBackOffThenRethrow(refusal2, added, options) {
+  try {
+    await switchBackOff(added, options);
+  } catch (error) {
+    if (!(error instanceof PluginsLeftSwitchedOnError)) throw error;
+    throw new FailedLeavingPluginsSwitchedOnError(refusal2, error.leftOn);
   }
+  throw refusal2;
+}
+async function switchBackOff(heldBefore, options) {
+  await switchCodexPluginsOff(
+    codexConfigFile(options),
+    heldBefore.filter((plugin) => !plugin.enabled).map((plugin) => plugin.pluginId)
+  );
+}
+function codexConfigFile(options) {
+  return path21.join(codexStateRoot(options, codexPluginCwd()), CODEX_CONFIG_FILE);
 }
 async function codexInstallPlugin(pluginRef, _scope, _projectDir, options) {
   await installCodexPlugin(pluginRef, options);
 }
-async function installCodexPlugin(pluginRef, options) {
+async function installCodexPlugin(pluginRef, options, attempt = "install") {
   validatePluginPath(pluginRef);
   await runCodexOrThrow(
     ["plugin", "add", pluginRef, "--json"],
     options,
-    `install ${pluginRef}`,
+    `${attempt} ${pluginRef}`,
     codexPluginCwd()
   );
 }
+async function codexUpdatePlugin(pluginRef, _scope, _projectDir, options) {
+  const held = await heldPlugin(pluginRef, options);
+  if (held === void 0) {
+    throw new Error(`Failed to update ${pluginRef}: codex has not installed it`);
+  }
+  await installCodexPlugin(pluginRef, options, "update");
+  await switchBackOff([held], options);
+}
 async function codexUninstallPlugin(pluginRef, _scope, _projectDir, options) {
   validatePluginName(pluginRef);
   const wasInstalled = await isListed(pluginRef, options);
@@ -7147,8 +7364,11 @@ async function codexUninstallPlugin(pluginRef, _scope, _projectDir, options) {
   return wasInstalled ? "removed" : "absent";
 }
 async function isListed(pluginRef, options) {
+  return await heldPlugin(pluginRef, options) !== void 0;
+}
+async function heldPlugin(pluginRef, options) {
   const installed = await codexPluginListing(options, codexPluginCwd());
-  return installed.some((plugin) => plugin.pluginId === pluginRef);
+  return installed.find((plugin) => plugin.pluginId === pluginRef);
 }
 async function codexPluginListing(options, askedFrom) {
   const listing = await readJsonFromCodex(
@@ -7196,6 +7416,7 @@ function codexHost() {
     addMarketplace: codexMarketplaceAdd,
     refreshMarketplace: refreshCodexMarketplace,
     installPlugin: codexInstallPlugin,
+    updatePlugin: codexUpdatePlugin,
     uninstallPlugin: codexUninstallPlugin,
     listPlugins: codexListPlugins
   };
@@ -8179,10 +8400,18 @@ async function loadSkillCategories(configPath) {
   verbose(`Loaded skill categories: ${configPath}`);
   return data.categories;
 }
+var NoSkillRulesError = class extends Error {
+  constructor(configPath) {
+    super(`Invalid skill rules at '${configPath}': failed to load or validate`);
+    this.configPath = configPath;
+    this.name = "NoSkillRulesError";
+  }
+  configPath;
+};
 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`);
+    throw new NoSkillRulesError(configPath);
   }
   const config = {
     version: data.version,
@@ -10161,11 +10390,16 @@ async function loadCatalogue(options) {
     devMode = false,
     matrixOnly = false
   } = options;
-  const sourceConfig = await resolveSource({ caller, flag: sourceFlag, projectDir, provider });
+  const resolvedProjectDir = projectDir || process.cwd();
+  const sourceConfig = await resolveSource({
+    caller,
+    flag: sourceFlag,
+    projectDir: resolvedProjectDir,
+    provider
+  });
   const { source } = sourceConfig;
   verbose(`Loading skills from source: ${source}`);
   const catalogue = await resolveBaseResult(sourceConfig, { purpose, devMode, matrixOnly });
-  const resolvedProjectDir = projectDir || process.cwd();
   const result = {
     ...catalogue,
     marketplaceSkillIds: new Set(typedKeys(catalogue.matrix.skills)),
@@ -10457,11 +10691,11 @@ async function refuseCatalogueCollisions(basePath, source, skills) {
   throw new Error(catalogueCollisionError(collidingIds, source));
 }
 function catalogueCollisionError(collidingIds, source) {
-  const listed2 = collidingIds.slice(0, MAX_REPORTED_COLLISIONS).map((id) => `  ${id}`);
-  const unlisted = collidingIds.length - listed2.length;
+  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:`,
-    ...listed2,
+    ...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");
@@ -10501,7 +10735,7 @@ function convertStackToResolvedStack(stack, catalogue) {
   if (undeclared.length > 0) warn(undeclaredAgentsWarning(stack, undeclared));
   const isCarried = carriedBy(catalogue);
   const agentConfigs = agentConfigsFor(stack, declared);
-  const [allSkillIds, withdrawn] = partition5(namedSkillIds(agentConfigs), isCarried);
+  const [allSkillIds, withdrawn] = partition6(namedSkillIds(agentConfigs), isCarried);
   if (withdrawn.length > 0) warn(withdrawnSkillsWarning(stack, withdrawn));
   verbose(
     `Stack '${stack.id}' has ${allSkillIds.length} skills from ${agentConfigs.length} agents`
@@ -10551,7 +10785,10 @@ 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);
+  if (metadata.localPath === void 0) {
+    throw new Error(`Local skill '${metadata.id}' was discovered without its directory`);
+  }
+  const metadataPath = path28.join(metadata.localPath, 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) {
@@ -10628,6 +10865,7 @@ export {
   rootsHoldingTheRetiredSourceFolder,
   chooseProviderForThisRun,
   forgetTheProviderChosenForThisRun,
+  declaresNoContent,
   providerInUse,
   inheritedGlobalProvider,
   providerAtScope,
@@ -10663,9 +10901,10 @@ export {
   skillAssignedToNoAgent,
   scopeBlockedStackAssignment,
   globalScopedAgentsHint,
-  marketplacesRefreshed,
   marketplaceRefreshFailed,
   marketplacesRefreshFailed,
+  codexPluginLeftSwitchedOn,
+  pluginsLeftSwitchedOn,
   marketplaceOwnerHasNoName,
   marketplaceHasNoVersion,
   marketplaceNameNotPublishable,
@@ -10690,7 +10929,10 @@ export {
   skippedSkills,
   skippedUnknownAgents,
   carriedSkillsWritten,
+  copiedSkillsRemovedAfterRefusedSave,
+  carriedSkillsRemovedAfterRefusedSave,
   SHARED_CONFIG_APPLY,
+  idNamesAnotherMarketplace,
   registeredProjectsRecompiled,
   sharedConfigNeedsTerminal,
   nothingInstalledToApplyTo,
@@ -10748,7 +10990,9 @@ export {
   formatZodIssues,
   validateSkillMetadata,
   splitMetadataValidationIssues,
+  ConfigSchemaError,
   ConfigDefaultExportError,
+  ConfigEvaluationError,
   NO_VALID_DEFAULT_EXPORT,
   configLoadFailure,
   loadConfig,
@@ -10767,12 +11011,13 @@ export {
   MarketplaceRefusedError,
   isLocalSource,
   normalizeStackRecord,
+  StacksLoadError,
   loadStackById,
   defaultUsageGuidance,
   resolveAgentConfigToSkills,
   getStackSkillIds,
   ConfigLoadError,
-  declaresNoContent,
+  configDeclaresNothing,
   loadProjectConfigFromDir,
   loadProjectConfigAt,
   loadInstalledConfig,
@@ -10851,6 +11096,8 @@ export {
   execCommand,
   getInstalledPluginsRegistryPath,
   listRegisteredPluginInstalls,
+  PluginsLeftSwitchedOnError,
+  FailedLeavingPluginsSwitchedOnError,
   refuseUnofferedPlacements,
   hostFor,
   hostAt,
@@ -10863,6 +11110,7 @@ export {
   findUnusableSavedSkillMetadata,
   deleteLocalSkill,
   migrateLocalSkillScope,
+  NoSkillRulesError,
   claimSlug,
   matrixHealthIssues,
   generateMarketplace,
@@ -10898,4 +11146,4 @@ export {
   executeMigration,
   keepsGlobalInstall
 };
-//# sourceMappingURL=chunk-YM3VEDAP.js.map
+//# sourceMappingURL=chunk-ENET4IF6.js.map