agents-inc 0.174.0 → 0.176.0

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

@@ -13,7 +13,7 @@ import {
   typedFromEntries,
   typedKeys,
   typedValues
-} from "./chunk-AIBVAYHS.js";
+} from "./chunk-UE4Z3YMB.js";
 import {
   AGENT_NAMES,
   AUTHOR_HANDLE_PATTERN,
@@ -82,7 +82,7 @@ import {
   seedAgentScope,
   sourceDirName,
   validateSelection
-} from "./chunk-WUSEZFER.js";
+} from "./chunk-U46LYYRA.js";
 import {
   defaultCategories,
   defaultRules,
@@ -91,8 +91,8 @@ import {
 
 // src/cli/lib/loading/source-loader.ts
 import os14 from "os";
-import { partition as partition4, unique as unique6 } from "remeda";
-import path29 from "path";
+import { partition as partition6, unique as unique6 } from "remeda";
+import path28 from "path";
 
 // src/cli/lib/installation/is-home-directory.ts
 import fs from "fs";
@@ -105,33 +105,6 @@ function isHomeDirectory(dir) {
   }
 }
 
-// src/cli/lib/metadata-keys.ts
-var METADATA_KEYS = {
-  DISPLAY_NAME: "displayName",
-  CLI_DESCRIPTION: "cliDescription",
-  CATEGORY: "category",
-  FORKED_FROM: "forkedFrom",
-  CONTENT_HASH: "contentHash",
-  USAGE_GUIDANCE: "usageGuidance",
-  CUSTOM: "custom"
-};
-var LOCAL_DEFAULTS = {
-  AUTHOR: "@dummy-author"
-};
-var SKILL_CONTENT_FILES = [STANDARD_FILES.SKILL_MD, STANDARD_FILES.REFERENCE_MD];
-var SKILL_CONTENT_DIRS = [STANDARD_DIRS.EXAMPLES, STANDARD_DIRS.SCRIPTS];
-
-// src/cli/utils/errors.ts
-function getErrorMessage(error) {
-  return stripTerminalControls(error instanceof Error ? error.message : String(error));
-}
-
-// src/cli/utils/fs.ts
-import fs3 from "fs-extra";
-import fg from "fast-glob";
-import os3 from "os";
-import path2 from "path";
-
 // src/cli/lib/installation/install-layout.ts
 import fs2 from "fs";
 import os2 from "os";
@@ -508,11 +481,38 @@ 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);
+  if (stamp !== null) declaresNothingAsRead.set(configPath, { stamp, declaresNothing });
+}
+function declaresNothingAsLastRead(configPath) {
+  const read = declaresNothingAsRead.get(configPath);
+  if (read === void 0 || read.stamp !== stampOf(configPath)) return void 0;
+  return read.declaresNothing;
+}
+function stampOf(file) {
+  try {
+    const stats = fs2.statSync(file, { throwIfNoEntry: false });
+    return stats === void 0 ? null : `${stats.mtimeMs}:${stats.size}`;
+  } catch {
+    return null;
+  }
+}
 function providerInUse(root) {
   if (providerChosenForThisRun !== void 0) return providerChosenForThisRun;
   if (root === void 0) return PROVIDER_OF_A_NEW_INSTALLATION;
   return providerOnDisk(root);
 }
+function inheritedGlobalProvider(projectDir, own = providerInUse(projectDir)) {
+  return holdsAnInstallation(projectDir, own) ? own : providerInUse(os2.homedir());
+}
+function providerAtScope(projectDir, scope) {
+  return scope === "global" ? inheritedGlobalProvider(projectDir) : providerInUse(projectDir);
+}
 function providerOnDisk(root) {
   const live = PROVIDERS.find((provider) => holdsAnInstallation(root, provider));
   if (live !== void 0) return live;
@@ -520,7 +520,8 @@ function providerOnDisk(root) {
   return started ?? PROVIDER_OF_A_NEW_INSTALLATION;
 }
 function holdsAnInstallation(root, provider) {
-  return holdsAConfig(sourceDir(root, provider));
+  const dir = sourceDir(root, provider);
+  return holdsAConfig(dir) && declaresNothingAsLastRead(configIn(dir)) !== true;
 }
 function holdsASourceFolder(root, provider) {
   return holdsAnything(sourceDir(root, provider));
@@ -676,7 +677,10 @@ function advisesOnPermissions(provider) {
   }
 }
 function holdsAConfig(dir) {
-  return fs2.existsSync(path.join(dir, STANDARD_FILES.CONFIG_TS));
+  return fs2.existsSync(configIn(dir));
+}
+function configIn(dir) {
+  return path.join(dir, STANDARD_FILES.CONFIG_TS);
 }
 function holdsAnything(dir) {
   return directoryExists(dir) && isNotEmpty(dir);
@@ -696,6 +700,29 @@ function directoryExists(dir) {
   }
 }
 
+// src/cli/lib/metadata-keys.ts
+var METADATA_KEYS = {
+  DISPLAY_NAME: "displayName",
+  CATEGORY: "category",
+  CUSTOM: "custom"
+};
+var LOCAL_DEFAULTS = {
+  AUTHOR: "@dummy-author"
+};
+var SKILL_CONTENT_FILES = [STANDARD_FILES.SKILL_MD, STANDARD_FILES.REFERENCE_MD];
+var SKILL_CONTENT_DIRS = [STANDARD_DIRS.EXAMPLES, STANDARD_DIRS.SCRIPTS];
+
+// src/cli/utils/errors.ts
+function getErrorMessage(error) {
+  return stripTerminalControls(error instanceof Error ? error.message : String(error));
+}
+
+// src/cli/utils/fs.ts
+import fs3 from "fs-extra";
+import fg from "fast-glob";
+import os3 from "os";
+import path2 from "path";
+
 // src/cli/lib/config-gate/gate-token.ts
 import { AsyncLocalStorage } from "async_hooks";
 var gateToken = new AsyncLocalStorage();
@@ -876,6 +903,7 @@ function warnOnce(msg) {
 
 // src/cli/utils/messages.ts
 import path3 from "path";
+import { partition } from "remeda";
 
 // src/cli/lib/validate-kebab-name.ts
 import { unique } from "remeda";
@@ -957,6 +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 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. */
@@ -971,8 +1009,8 @@ function pluginsInstalled(count) {
 function localSkillsCopied(count) {
   return `Copied ${count} local skill(s)`;
 }
-function recompileSummary(rewritten, unchanged, subject) {
-  return `${plural(rewritten, subject)} rewritten, ${unchanged} unchanged`;
+function recompileSummary(rewritten2, unchanged, subject) {
+  return `${plural(rewritten2, subject)} rewritten, ${unchanged} unchanged`;
 }
 function agentsNotCompiled(agentNames) {
   return `${agentNames.length} sub-agent(s) did not compile: ${agentNames.join(", ")}`;
@@ -995,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}`;
 }
@@ -1022,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}.`,
@@ -1089,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,
@@ -1137,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");
@@ -1167,23 +1213,45 @@ function changeTheGlobalInstallFromHome(named) {
 function unknownKeys(keys) {
   return keys.map(inertLine).join(", ");
 }
-function skippedUnknownSkills(skillIds, installedWithout) {
+var SKIP_CAUSE = {
+  UNLOADED: "could not load",
+  UNKNOWN: "does not know"
+};
+function skippedSkills(skillIds, installedWithout, unloadedSkillIds) {
+  const [unloaded, unknown] = partition(skillIds, (id) => unloadedSkillIds.has(id));
   return [
-    `Skipped ${skillIds.length} skill(s) this catalog does not know: ${unknownKeys(skillIds)}`,
-    ...installedWithout.map(
-      ({ skillId, agentNames }) => `  sub-agent(s) installed without ${unknownKeys([skillId])}, carrying nothing else this catalog knows: ${agentNames.join(", ")}`
-    )
+    ...skippedFor(SKIP_CAUSE.UNLOADED, unloaded, installedWithout),
+    ...skippedFor(SKIP_CAUSE.UNKNOWN, unknown, installedWithout)
   ].join("\n");
 }
+function skippedFor(cause, skillIds, installedWithout) {
+  if (skillIds.length === 0) return [];
+  return [
+    `Skipped ${skillIds.length} skill(s) this catalog ${cause}: ${unknownKeys(skillIds)}`,
+    ...installedWithout.filter(({ skillId }) => skillIds.includes(skillId)).map(subAgentsInstalledWithout)
+  ];
+}
+function subAgentsInstalledWithout({ skillId, agentNames }) {
+  return `  sub-agent(s) installed without ${unknownKeys([skillId])}, carrying nothing else this catalog knows: ${agentNames.join(", ")}`;
+}
 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:",
@@ -1212,10 +1280,16 @@ function addMarketplaceInTheEditor(ref, isFolder) {
 var SHARED_CONFIG_ARRIVALS = {
   INSTALL_CONFIRM: "Install this configuration?"
 };
-function keptAsInstalledGlobally(skillIds, agentNames, idAppliedAtHome, provider) {
+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:",
-    ...skillIds.map((id) => `  skill ${id}`),
+    ...skillIds.map((id) => `  skill ${skillName(id, namedBy)}`),
     ...agentNames.map((name) => `  sub-agent ${name}`),
     ...idAppliedAtHome === void 0 ? [] : [
       `Change them with '${CLI_INVOKE_COMMAND} edit --from ${idAppliedAtHome}${providerArgument(provider)}' from your home directory.`
@@ -1223,16 +1297,12 @@ function keptAsInstalledGlobally(skillIds, agentNames, idAppliedAtHome, provider
   ].join("\n");
 }
 function skillsMoved(verb, skillIds, namedBy) {
-  const names = skillIds.map((id) => getSkillEntryDisplayName(namedBy[id] ?? { id }));
-  return names.length === 0 ? [] : [`${verb} ${listed(names)}`];
+  const names = skillIds.map((id) => skillName(id, namedBy));
+  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,
@@ -1250,29 +1320,29 @@ function subAgentChanged({
   const where = scope === "global" ? " (global)" : "";
   return `~ ${name}${where}: ${details.length > 0 ? details.join(", ") : SKILLS_REASSIGNED}`;
 }
-function addedToGlobalSubAgents(joined) {
+function addedToGlobalSubAgents(joined, namedBy) {
   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(", ")}`
+      ({ agentName, skillIds }) => `  sub-agent ${agentName}: + ${skillNames(skillIds, namedBy)}`
     )
   ].join("\n");
 }
-function authoredHereKept(skillIds) {
+function authoredHereKept(skillIds, namedBy) {
   return [
     "Kept \u2014 written here rather than installed, so a shared configuration never carried them:",
-    ...skillIds.map((id) => `  skill ${id}`)
+    ...skillIds.map((id) => `  skill ${skillName(id, namedBy)}`)
   ].join("\n");
 }
-function unplaceableKept(skillIds) {
+function unplaceableKept(skillIds, namedBy) {
   return [
     "Kept \u2014 named by this configuration, and this catalogue cannot place them:",
-    ...skillIds.map((id) => `  skill ${id}`),
+    ...skillIds.map((id) => `  skill ${skillName(id, namedBy)}`),
     `Run '${CLI_INVOKE_COMMAND} update' to refresh this installation's marketplace, then apply the configuration again.`
   ].join("\n");
 }
-function keptUnassigned(skillId, agentName, category) {
-  return `${skillId}: kept, no longer assigned to ${agentName}'s ${category}`;
+function keptUnassigned({ skillId, agentName, category }, namedBy) {
+  return `${skillName(skillId, namedBy)}: kept, no longer assigned to ${agentName}'s ${category}`;
 }
 function doctorReportsTheSame(count) {
   return `'${CLI_INVOKE_COMMAND} doctor' reports the same ${count === 1 ? "file" : "files"}, alongside whatever else is wrong here.`;
@@ -1967,16 +2037,16 @@ import { z as z3 } from "zod";
 
 // src/cli/lib/schemas.ts
 import { z as z2 } from "zod";
-import { partition } from "remeda";
+import { partition as partition2 } from "remeda";
 
 // src/cli/lib/schema-validator.ts
 import "zod";
 function formatZodIssue(issue) {
-  const path30 = stripTerminalControls(issue.path.join("."));
   if (issue.code === "unrecognized_keys") {
-    return `Unrecognized key: "${stripTerminalControls(issue.keys.join('", "'))}"`;
+    return `Unrecognized key: "${inertLine(issue.keys.join('", "'))}"`;
   }
-  return path30 ? `${path30}: ${stripTerminalControls(issue.message)}` : stripTerminalControls(issue.message);
+  const path29 = inertLine(issue.path.join("."));
+  return path29 ? `${path29}: ${inertLine(issue.message)}` : inertLine(issue.message);
 }
 function formatZodErrors(error) {
   return error.issues.map(formatZodIssue);
@@ -2118,12 +2188,12 @@ var RENAMED_SKILL_ENTRY_FIELDS = { source: "origin" };
 function renamedFieldMessage(oldKey, newKey) {
   return `"${oldKey}" was renamed to "${newKey}". Rename the key in this config \u2014 the CLI does not read "${oldKey}" any more and will not fall back to it.`;
 }
-function reportRenamedKeys(record, renames, path30, ctx) {
+function reportRenamedKeys(record, renames, path29, ctx) {
   for (const [oldKey, newKey] of Object.entries(renames)) {
     if (!(oldKey in record)) continue;
     ctx.addIssue({
       code: "custom",
-      path: [...path30, oldKey],
+      path: [...path29, oldKey],
       message: renamedFieldMessage(oldKey, newKey)
     });
   }
@@ -2454,7 +2524,7 @@ function metadataSchemaFor(raw) {
   return isCarriedMetadata(raw) ? carriedMetadataValidationSchema : customMetadataValidationSchema;
 }
 function describeMetadataSchemaFailure(issues, rawMetadata) {
-  const [absent, malformed] = partition(issues, (issue) => isAbsentField(issue, rawMetadata));
+  const [absent, malformed] = partition2(issues, (issue) => isAbsentField(issue, rawMetadata));
   return [
     ...absent.length > 0 ? [nameMissingFields(absent)] : [],
     ...malformed.map(formatZodIssue)
@@ -2481,7 +2551,7 @@ function formatOverLengthWarning(issue, cliDescription) {
   return `cliDescription is ${cliDescription.length} characters \u2014 exceeds the recommended maximum of ${CLI_DESCRIPTION_MAX_LENGTH}`;
 }
 function splitMetadataValidationIssues(error, rawMetadata) {
-  const [overLength, hardFailures] = partition(error.issues, isOverLengthCliDescription);
+  const [overLength, hardFailures] = partition2(error.issues, isOverLengthCliDescription);
   const cliDescription = readCliDescription(rawMetadata);
   const warnings = overLength.map((issue) => formatOverLengthWarning(issue, cliDescription));
   return { errors: hardFailures.map(formatZodIssue), warnings };
@@ -2539,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;
@@ -2584,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 });
   }
 }
 
@@ -2598,7 +2676,7 @@ function getInstalledConfigPath(dir) {
 }
 function resolveInstallPaths(projectDir, scope = "project") {
   const baseDir = installBaseDir(projectDir, scope);
-  const provider = providerInUse(baseDir);
+  const provider = providerAtScope(projectDir, scope);
   return {
     skillsDir: skillsDir(provider, scope, projectDir),
     agentsDir: agentsDir(provider, scope, projectDir),
@@ -2620,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)) {
@@ -2637,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);
@@ -2688,17 +2776,29 @@ async function loadSourceRepoConfig(basePath) {
 async function loadProjectSourceConfig(projectDir) {
   return loadSourceConfig(projectDir, isHomeDirectory(projectDir) ? "global" : "project");
 }
-async function loadGlobalSourceConfig() {
-  return loadSourceConfig(os4.homedir(), "global");
+async function loadGlobalSourceConfig(provider) {
+  return loadSourceConfig(os4.homedir(), "global", 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);
+  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);
@@ -2732,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 {
@@ -2793,7 +2893,7 @@ ${getErrorMessage(error)}`
 async function resolveBranding(projectDir) {
   const [own, global] = await Promise.all([
     loadOwnProjectSourceConfig(projectDir),
-    loadGlobalSourceConfig()
+    loadGlobalSourceConfig(inheritedBy(projectDir))
   ]);
   return {
     name: own?.branding?.name ?? global?.branding?.name ?? DEFAULT_BRANDING.NAME
@@ -3139,7 +3239,7 @@ seatDiagnostics({
 });
 
 // ../compile/src/seed-to-config.ts
-import { groupBy, indexBy, isDefined, mapValues, omit as omit2, partition as partition2 } from "remeda";
+import { groupBy, indexBy, isDefined, mapValues, omit as omit2, partition as partition3 } from "remeda";
 
 // ../compile/src/config-source.ts
 import { omit } from "remeda";
@@ -3171,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),
@@ -3254,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: {
@@ -3293,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: {
@@ -3479,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 = {
@@ -3650,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 partition5 = partitionInlinedConfigEntries(cleaned, cleanedGlobal);
+  const partition7 = partitionInlinedConfigEntries(cleaned, cleanedGlobal);
   const emitted = {
-    hasSkills: partition5.globalSkills.length > 0 || partition5.projectSkills.length > 0,
-    hasAgents: partition5.globalAgents.length > 0 || partition5.projectAgents.length > 0,
-    hasStack: hasStackEntries(partition5.filteredStack),
-    hasSelectedDomains: partition5.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({
@@ -3672,15 +3726,15 @@ function generateProjectConfigWithInlinedGlobal(cleaned, cleanedGlobal) {
       ...emitted.hasSkills ? entryDeclaration(
         "skills",
         "SkillConfig[]",
-        scopeSectionEntries(partition5.globalSkills, partition5.projectSkills)
+        scopeSectionEntries(partition7.globalSkills, partition7.projectSkills)
       ) : [],
       ...emitted.hasAgents ? entryDeclaration(
         "agents",
         "AgentScopeConfig[]",
-        scopeSectionEntries(partition5.globalAgents, partition5.projectAgents)
+        scopeSectionEntries(partition7.globalAgents, partition7.projectAgents)
       ) : [],
-      ...emitted.hasStack ? declaration("stack", STACK_TYPE, partition5.filteredStack) : [],
-      ...emitted.hasSelectedDomains ? declaration("selectedDomains", "Domain[]", partition5.selectedDomains) : []
+      ...emitted.hasStack ? declaration("stack", STACK_TYPE, partition7.filteredStack) : [],
+      ...emitted.hasSelectedDomains ? declaration("selectedDomains", "Domain[]", partition7.selectedDomains) : []
     ],
     exportFields: [
       renderScalarField("name", resolveProjectName(cleaned)),
@@ -3835,7 +3889,7 @@ function assertScopeConfigsGiven(skillConfigs, agentConfigs) {
   }
 }
 function resolveValidSkills(selectedSkillIds, skillConfigs, catalog) {
-  const [found, absent] = partition2(
+  const [found, absent] = partition3(
     selectedSkillIds.map((skillId) => ({
       skillId,
       skill: catalog.skills[skillId]
@@ -3885,7 +3939,7 @@ function skillIdsByCategory(skills) {
   );
 }
 function buildSkillScopeMap(skillConfigs) {
-  const [excludedConfigs, activeConfigs] = partition2(
+  const [excludedConfigs, activeConfigs] = partition3(
     skillConfigs,
     (s) => Boolean(s.excluded)
   );
@@ -4030,11 +4084,11 @@ function mapCategoriesDroppingEmpty(agentStack, transform) {
   );
 }
 function splitConfigByScope(config) {
-  const [globalSkills, projectSkills] = partition2(
+  const [globalSkills, projectSkills] = partition3(
     config.skills,
     (s) => isActiveAt(s, "global")
   );
-  const [globalAgents, projectAgents] = partition2(
+  const [globalAgents, projectAgents] = partition3(
     config.agents,
     (a) => isActiveAt(a, "global")
   );
@@ -4094,9 +4148,9 @@ function splitAgentStack(agentStack, globalSkillIds) {
 }
 function seedToInstallSelection(payload, catalog) {
   const agentMap = readAgentMap(payload.agents);
+  refuseUnwritableAssignments(payload.skills, agentMap);
   const { installable, skipped } = resolveSeedSkills(payload.skills, catalog);
   const rows = installable.flatMap((skill) => assignmentRows(skill, agentMap));
-  refuseUnwritableAssignments(rows);
   const placed = rows.filter((row) => row.kind === "placed");
   const carried = new Set(agentsCarriedIn(placed, agentMap));
   const selectedAgents = withAgentsSkippedSkillsName(carried, skipped, agentMap);
@@ -4130,12 +4184,23 @@ function seedToInstallSelection(payload, catalog) {
     )
   };
 }
-function refuseUnwritableAssignments(rows) {
-  const unwritable = rows.filter((row) => row.kind === "unwritable");
+function refuseUnwritableAssignments(seedSkills, agentMap) {
+  const unwritable = unwritableAssignmentsOf(seedSkills, agentMap);
   if (unwritable.length > 0) {
     throw new Error(unwritableAssignmentsError(unwritable));
   }
 }
+function unwritableAssignmentsOf(seedSkills, agentMap) {
+  return Object.entries(seedSkills).flatMap(
+    ([skillId, seedSkill]) => agentsNamedBy(seedSkill, agentMap).filter((agent) => !isWritablePair(seedSkill, agent, agentMap)).map((agent) => ({ skillId, agent }))
+  );
+}
+function isWritablePair(seedSkill, agent, agentMap) {
+  return isScopePairCompatible(
+    seedSkill.scope,
+    seedAgentScope(agentMap.known.get(agent))
+  );
+}
 function agentsCarriedIn(placed, agentMap) {
   return [...placed.map((row) => row.agent), ...agentsSwitchedOn(agentMap)];
 }
@@ -4143,7 +4208,7 @@ function withAgentsSkippedSkillsName(carried, skipped, agentMap) {
   return [
     .../* @__PURE__ */ new Set([
       ...carried,
-      ...skipped.flatMap((skill) => agentsNamedBy(skill, agentMap))
+      ...skipped.flatMap((skill) => agentsNamedBy(skill.seedSkill, agentMap))
     ])
   ];
 }
@@ -4151,25 +4216,25 @@ function skippedAgentNamesOf(agentMap, rows) {
   const unknownAssignees = rows.filter((row) => row.kind === "unknownAgent").map((row) => row.agentName);
   return [.../* @__PURE__ */ new Set([...agentMap.unknown, ...unknownAssignees])];
 }
-function agentsNamedBy({ seedSkill }, agentMap) {
+function agentsNamedBy(seedSkill, agentMap) {
   return Object.keys(seedSkill.assignments).filter(isAgentName2).filter((name) => !agentMap.switchedOff.has(name));
 }
 function agentsOnlyItCarried(skill, agentMap, carried) {
-  const agentNames = agentsNamedBy(skill, agentMap).filter(
+  const agentNames = agentsNamedBy(skill.seedSkill, agentMap).filter(
     (name) => !carried.has(name)
   );
   return agentNames.length === 0 ? [] : [{ skillId: skill.skillId, agentNames }];
 }
 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);
@@ -4219,10 +4284,6 @@ function assignmentRows(skill, agentMap) {
 function assignmentRow(skill, agentName, load, agentMap) {
   if (agentMap.switchedOff.has(agentName)) return void 0;
   if (!isAgentName2(agentName)) return { kind: "unknownAgent", agentName };
-  const agentScope = seedAgentScope(agentMap.known.get(agentName));
-  if (!isScopePairCompatible(skill.seedSkill.scope, agentScope)) {
-    return { kind: "unwritable", skillId: skill.id, agent: agentName };
-  }
   return {
     kind: "placed",
     agent: agentName,
@@ -4281,7 +4342,7 @@ import path8 from "path";
 
 // src/cli/lib/stacks/stacks-loader.ts
 import path7 from "path";
-import { flatMap, groupBy as groupBy2, mapValues as mapValues2, partition as partition3, pipe, unique as unique2, uniqueBy } from "remeda";
+import { flatMap, groupBy as groupBy2, mapValues as mapValues2, partition as partition4, pipe, unique as unique2, uniqueBy } from "remeda";
 var stacksCache = /* @__PURE__ */ new Map();
 function normalizeAgentConfig(agentConfig) {
   return mapValues2(agentConfig, (value) => {
@@ -4312,7 +4373,7 @@ function placeAssignments(agentConfig) {
   );
 }
 function rekeyToLiveCategories(agentConfig) {
-  const [settled, moved] = partition3(
+  const [settled, moved] = partition4(
     placeAssignments(agentConfig),
     (placed) => placed.liveCategory === placed.storedCategory
   );
@@ -4335,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}`;
@@ -4358,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})`);
@@ -4385,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}.`;
@@ -4437,6 +4509,11 @@ var ConfigLoadError = class extends Error {
   /** Named in the remedy's `init --from` half, which a bare run would answer with another one. */
   initProviderToName;
 };
+async function configDeclaresNothing(projectDir, provider) {
+  const configPath = getProjectConfigPath(projectDir, provider);
+  const parsed = await parseConfigFile(configPath, refusalAt(configPath, projectDir, provider));
+  return declaresNoContent({ skills: parsed.skills ?? [], agents: parsed.agents ?? [] });
+}
 async function loadProjectConfigFromDir(projectDir, provider) {
   return loadProjectConfigAt(getProjectConfigPath(projectDir, provider), projectDir, provider);
 }
@@ -4447,8 +4524,7 @@ async function loadProjectConfigAt(configPath, projectDir, provider) {
     verbose(`${scopeLabel2} config not found at ${configPath}`);
     return null;
   }
-  const refuse = (reason) => new ConfigLoadError(configPath, reason, projectDir, provider);
-  const parsed = await parseConfigFile(configPath, refuse);
+  const parsed = await parseConfigFile(configPath, refusalAt(configPath, projectDir, provider));
   const config = asProjectConfig(parsed, projectDir);
   warnOfDefaultedFields(parsed, configPath);
   verbose(`Loaded ${scope} config from ${configPath}`);
@@ -4458,6 +4534,9 @@ async function loadProjectConfigAt(configPath, projectDir, provider) {
     provider
   };
 }
+function refusalAt(configPath, projectDir, provider) {
+  return (reason) => new ConfigLoadError(configPath, reason, projectDir, provider);
+}
 async function parseConfigFile(configPath, refuse) {
   let raw;
   try {
@@ -4493,29 +4572,39 @@ function warnOfDefaultedFields(parsed, configPath) {
 async function loadInstalledConfig(dir) {
   return loadProjectConfigFromDir(dir, providerInUse(dir));
 }
-function configDirsInPlay(projectDir) {
-  return isHomeDirectory(projectDir) ? [projectDir] : [projectDir, os5.homedir()];
+function configsInPlay(projectDir) {
+  const own = { dir: projectDir, provider: providerInUse(projectDir) };
+  if (isHomeDirectory(projectDir)) return [own];
+  return [own, { dir: os5.homedir(), provider: inheritedGlobalProvider(projectDir) }];
 }
 async function findConfigLoadFailures(projectDir) {
-  const outcomes = await Promise.all(configDirsInPlay(projectDir).map(configLoadFailure2));
+  const outcomes = await Promise.all(configsInPlay(projectDir).map(configLoadFailure2));
   return outcomes.filter((failure) => failure !== void 0);
 }
-async function configLoadFailure2(dir) {
+async function configLoadFailure2({
+  dir,
+  provider
+}) {
   try {
-    await loadInstalledConfig(dir);
+    await loadProjectConfigFromDir(dir, provider);
     return void 0;
   } catch (error) {
     if (error instanceof ConfigLoadError) return error;
     throw error;
   }
 }
-async function loadProjectConfig(projectDir) {
-  const provider = providerInUse(projectDir);
+async function loadProjectConfig(projectDir, provider = providerInUse(projectDir)) {
   const projectResult = await loadProjectConfigFromDir(projectDir, provider);
   if (projectResult) return projectResult;
   if (isHomeDirectory(projectDir)) return null;
   return loadProjectConfigFromDir(os5.homedir(), provider);
 }
+async function loadConfigInPlay(projectDir) {
+  const own = await loadInstalledConfig(projectDir);
+  if (isHomeDirectory(projectDir)) return own;
+  if (own !== null && !declaresNoContent(own.config)) return own;
+  return loadInstalledConfig(os5.homedir());
+}
 function validateProjectConfig(config) {
   const result = projectConfigLoaderSchema.safeParse(config);
   if (!result.success) {
@@ -4561,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) {
@@ -4590,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) {
@@ -4870,6 +4970,21 @@ async function copySkillsToLocalFlattened(selectedSkillIds, localSkillsDir, sour
     (skillId) => copySelectedSkill(skillId, localSkillsDir, sourceResult, sourceSelections?.[skillId])
   );
 }
+async function copyMarketplaceSkillsToLocalFlattened(marketplaceSkillIds, localSkillsDir, sourceResult) {
+  return copyEachSkill(
+    marketplaceSkillIds,
+    (skillId) => copySkillToLocalFlattened(
+      marketplaceSkillOf(skillId, sourceResult),
+      localSkillsDir,
+      sourceResult
+    )
+  );
+}
+function marketplaceSkillOf(skillId, sourceResult) {
+  const skill = sourceResult.marketplaceSkills[skillId];
+  if (!skill) throw new Error(`Not one of the marketplace's skills: ${skillId}`);
+  return skill;
+}
 async function copySelectedSkill(skillId, localSkillsDir, sourceResult, selectedSource) {
   const skill = getSkillById(skillId);
   const localPath = picksRemoteSource(selectedSource) ? void 0 : localPathOf(skill);
@@ -4896,7 +5011,7 @@ async function copyLocalSkillTo(skill, localPath, destPath) {
 }
 
 // src/cli/lib/skills/skill-plugin-compiler.ts
-import path24 from "path";
+import path23 from "path";
 import { parse as parseYaml4 } from "yaml";
 
 // src/cli/lib/plugins/plugin-manifest.ts
@@ -5003,7 +5118,6 @@ import { readdir } from "fs/promises";
 
 // src/cli/lib/installation/installation.ts
 import os7 from "os";
-import path14 from "path";
 var INSTALL_MODE_LABELS = {
   plugin: "Plugin",
   mixed: "Mixed",
@@ -5013,9 +5127,6 @@ var INSTALL_MODE_DESCRIPTIONS = {
   plugin: `${INSTALL_MODE_LABELS.plugin} (native install)`,
   eject: `${INSTALL_MODE_LABELS.eject} (local copy)`
 };
-function declaresNoContent(config) {
-  return config.skills.length === 0 && config.agents.length === 0;
-}
 function deriveInstallMode(skills) {
   if (skills.length === 0) return "eject";
   const hasEject = skills.some((s) => s.origin === EJECT_SOURCE);
@@ -5023,8 +5134,7 @@ function deriveInstallMode(skills) {
   if (hasEject && hasPlugin) return "mixed";
   return hasEject ? "eject" : "plugin";
 }
-async function detectInstallationInDir(dir, scope) {
-  const provider = providerInUse(dir);
+async function detectInstallationInDir(dir, scope, provider = providerInUse(dir)) {
   const configPath = getProjectConfigPath(dir, provider);
   if (!await fileExists(configPath)) {
     return null;
@@ -5036,17 +5146,10 @@ async function detectInstallationInDir(dir, scope) {
   if (declaresNoContent(loaded.config)) {
     return null;
   }
-  const mode = deriveInstallMode(loaded.config.skills);
   return {
-    mode,
+    mode: deriveInstallMode(loaded.config.skills),
     configPath,
     agentsDir: agentsDir(provider, scope, dir),
-    // Mixed mode uses the local skills dir, as eject does.
-    skillsDir: path14.join(
-      dir,
-      CLAUDE_DIR,
-      mode === "plugin" ? PLUGINS_SUBDIR : STANDARD_DIRS.SKILLS
-    ),
     projectDir: dir
   };
 }
@@ -5061,23 +5164,23 @@ async function holdsItsOwnInstallation(dir) {
     throw error;
   }
 }
-async function detectGlobalInstallation() {
-  return detectInstallationInDir(os7.homedir(), "global");
+async function detectGlobalInstallation(projectDir) {
+  return detectInstallationInDir(os7.homedir(), "global", inheritedGlobalProvider(projectDir));
 }
 async function detectInstallation(projectDir = process.cwd()) {
   const projectInstallation = await detectProjectInstallation(projectDir);
   if (projectInstallation) return projectInstallation;
-  return detectGlobalInstallation();
+  return detectGlobalInstallation(projectDir);
 }
 
 // src/cli/lib/installation/local-installer.ts
 import os10 from "os";
-import path18 from "path";
+import path17 from "path";
 import { unique as unique4 } from "remeda";
 
 // src/cli/lib/loading/loader.ts
 import { parse as parseYaml3 } from "yaml";
-import path15 from "path";
+import path14 from "path";
 
 // src/cli/utils/frontmatter.ts
 import { parse as parseYaml2 } from "yaml";
@@ -5150,7 +5253,7 @@ async function loadAgentsFromDir(agentsDir2, sourceRoot, options) {
   return agents;
 }
 async function readAgentDefinition(agentsDir2, file, sourceRoot, options) {
-  const fullPath = path15.join(agentsDir2, file);
+  const fullPath = path14.join(agentsDir2, file);
   try {
     const content = await readFile(fullPath);
     const parsed = agentYamlConfigSchema.safeParse(parseYaml3(content));
@@ -5183,7 +5286,7 @@ function toAgentDefinition(config, file, sourceRoot, options) {
     ...config.hooks !== void 0 && { hooks: config.hooks },
     ...config.experimental !== void 0 && { experimental: config.experimental },
     ...config.outputFormat !== void 0 && { outputFormat: config.outputFormat },
-    path: path15.dirname(file),
+    path: path14.dirname(file),
     sourceRoot,
     ...options.agentBaseDir ? { agentBaseDir: options.agentBaseDir } : {},
     ...config.domain ? { domain: config.domain } : {},
@@ -5191,7 +5294,7 @@ function toAgentDefinition(config, file, sourceRoot, options) {
   };
 }
 async function loadAllAgents(projectRoot) {
-  return loadAgentsFromDir(path15.join(projectRoot, DIRS.agents), projectRoot, {
+  return loadAgentsFromDir(path14.join(projectRoot, DIRS.agents), projectRoot, {
     includeCustomFlag: true,
     verboseLabel: "agent"
   });
@@ -5203,9 +5306,9 @@ async function loadMergedAgents(sourcePath) {
   ]);
   return { ...cliAgents, ...sourceAgents };
 }
-async function loadProjectAgents(projectRoot) {
-  const sourceFolder = sourceFolderInUse(projectRoot, providerInUse(projectRoot));
-  const projectAgentsDir = path15.join(sourceFolder.dir, STANDARD_DIRS.AGENTS);
+async function loadProjectAgents(projectRoot, provider = providerInUse(projectRoot)) {
+  const sourceFolder = sourceFolderInUse(projectRoot, provider);
+  const projectAgentsDir = path14.join(sourceFolder.dir, STANDARD_DIRS.AGENTS);
   if (!await directoryExists2(projectAgentsDir)) {
     verbose(`No project agents directory at ${projectAgentsDir}`);
     return {};
@@ -5217,9 +5320,10 @@ async function loadProjectAgents(projectRoot) {
   });
 }
 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 };
   }
@@ -5229,32 +5333,32 @@ 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) {
-  const skillMdPath = path15.join(skillsDir2, skillFile);
-  const skillDir = path15.dirname(skillMdPath);
-  const relativePath = path15.relative(skillsDir2, skillDir);
+  const skillMdPath = path14.join(skillsDir2, skillFile);
+  const skillDir = path14.dirname(skillMdPath);
+  const relativePath = path14.relative(skillsDir2, skillDir);
   return {
     skillFile,
     skillMdPath,
     skillDir,
-    skillDirName: path15.basename(skillDir),
+    skillDirName: path14.basename(skillDir),
     displayPath: pathPrefix ? `${pathPrefix}/${relativePath}/` : `${relativePath}/`
   };
 }
 async function judgeSkillMetadata(skill) {
-  const metadataPath = path15.join(skill.skillDir, STANDARD_FILES.METADATA_YAML);
+  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) {
@@ -5291,7 +5395,7 @@ async function readSkillDefinition(skill) {
   }
 }
 async function loadPluginSkills(pluginDir) {
-  const { skills } = await loadSkillsFromDir(path15.join(pluginDir, "skills"), {
+  const { skills } = await loadSkillsFromDir(path14.join(pluginDir, "skills"), {
     pathPrefix: "skills",
     requireMetadata: false
   });
@@ -5300,17 +5404,18 @@ async function loadPluginSkills(pluginDir) {
 
 // src/cli/lib/loading/source-fetcher.ts
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash2, randomUUID } from "crypto";
 import { readFileSync } from "fs";
-import { rename, stat } from "fs/promises";
+import { open, rename, stat } from "fs/promises";
+import { setTimeout as sleep } from "timers/promises";
 import { downloadTemplate } from "giget";
 import os8 from "os";
-import path17 from "path";
+import path16 from "path";
 import { isDeepEqual } from "remeda";
 import { z as z4 } from "zod";
 
 // src/cli/lib/marketplace-generator.ts
-import path16 from "path";
+import path15 from "path";
 import { countBy, sortBy } from "remeda";
 var PLUGIN_MANIFEST_PATH = `${PLUGIN_MANIFEST_DIR}/${PLUGIN_MANIFEST_FILE}`;
 var MARKETPLACE_SCHEMA_URL = "https://anthropic.com/claude-code/marketplace.schema.json";
@@ -5342,7 +5447,7 @@ async function generateMarketplace(pluginsDir2, options) {
   const rootWithoutDotSlash = options.pluginRoot.replace(/^\.\//, "");
   for (const manifestFile of manifestFiles) {
     const pluginDirName = pluginDirNameOf(manifestFile);
-    const pluginDir = path16.join(pluginsDir2, pluginDirName);
+    const pluginDir = path15.join(pluginsDir2, pluginDirName);
     const manifest = await readPluginManifest(pluginDir);
     if (!manifest) {
       warn(`Could not read plugin manifest: '${manifestFile}'`);
@@ -5397,17 +5502,17 @@ 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");
 }
 async function writeMarketplace(outputPath, marketplace) {
-  await ensureDir(path16.dirname(outputPath));
+  await ensureDir(path15.dirname(outputPath));
   const content = `${JSON.stringify(marketplace, null, 2)}
 `;
   await writeFile(outputPath, content);
@@ -5443,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();
@@ -5481,7 +5589,7 @@ function sanitizeSourceForCache(source) {
 }
 function getCacheDir(source) {
   const sanitized = sanitizeSourceForCache(source) || "unknown";
-  return path17.join(cacheRoot(), "sources", sanitized);
+  return path16.join(cacheRoot(), "sources", sanitized);
 }
 async function fetchFromSource(source, options = {}) {
   const { subdir } = options;
@@ -5492,8 +5600,8 @@ async function fetchFromSource(source, options = {}) {
   return fetchFromRemoteSource(source, subdir);
 }
 async function fetchFromLocalSource(source, subdir) {
-  const fullPath = subdir ? path17.join(source, subdir) : source;
-  const absolutePath = path17.isAbsolute(fullPath) ? fullPath : path17.resolve(process.cwd(), fullPath);
+  const fullPath = subdir ? path16.join(source, subdir) : source;
+  const absolutePath = path16.isAbsolute(fullPath) ? fullPath : path16.resolve(process.cwd(), fullPath);
   if (!await directoryExists2(absolutePath)) {
     throw new Error(
       `Local marketplace not found: '${absolutePath}'
@@ -5524,18 +5632,16 @@ function getGigetCacheDir(source) {
     return void 0;
   }
   const templateName = uriMatch.groups.repo.replace("/", "-").replace(/[^\da-z-]/gi, "-");
-  return path17.join(gigetCacheRoot(), providerName, templateName);
+  return path16.join(gigetCacheRoot(), providerName, templateName);
 }
 function gigetCacheRoot() {
-  return process.env.XDG_CACHE_HOME ? path17.resolve(process.env.XDG_CACHE_HOME, "giget") : path17.resolve(os8.homedir(), ".cache", "giget");
+  return process.env.XDG_CACHE_HOME ? path16.resolve(process.env.XDG_CACHE_HOME, "giget") : path16.resolve(os8.homedir(), ".cache", "giget");
 }
 async function clearGigetCache(source) {
   const gigetDir = getGigetCacheDir(source);
-  if (!gigetDir) return;
-  if (await directoryExists2(gigetDir)) {
-    verbose(`Clearing giget cache: ${gigetDir}`);
-    await remove(gigetDir);
-  }
+  if (!gigetDir || !await directoryExists2(gigetDir)) return;
+  verbose(`Clearing giget cache: ${gigetDir}`);
+  await holdingGigetFolder(path16.dirname(gigetDir), () => remove(gigetDir));
 }
 async function fetchFromRemoteSource(source, subdir) {
   const cacheDir = getCacheDir(source);
@@ -5544,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(path17.dirname(cacheDir));
+  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,
@@ -5586,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)}`);
@@ -5616,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
-  });
-  await ensureDir(path17.dirname(cacheDir));
+  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;
@@ -5639,11 +5799,22 @@ 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);
   }
-  await withTarballSetAside(savedTarball.path, download);
+  await holdingGigetFolder(
+    gigetProviderDir(source),
+    () => withTarballSetAside(savedTarball.path, download)
+  );
 }
 async function withTarballSetAside(tarball, download) {
   const record = gigetRecordOf(tarball);
@@ -5679,44 +5850,170 @@ function everyFileIn(dir) {
   return glob(EVERY_FILE, dir, { dot: true });
 }
 function sameBytesAt(file, left, right) {
-  return readFileSync(path17.join(left, file)).equals(readFileSync(path17.join(right, file)));
+  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() });
 async function gigetDownload(source, fullSource, options) {
   const providerDir = gigetProviderDir(source);
-  const timesBefore = await tarballTimes(providerDir);
-  const result = await downloadTemplate(fullSource, options);
-  const tarball = path17.join(providerDir, gigetTarballOf(result));
-  const writtenByThisDownload = timesBefore.get(tarball) !== await modifiedAt(tarball);
-  if (writtenByThisDownload) return { result };
-  verbose(`giget extracted the tarball it saved earlier, not a download: ${tarball}`);
-  return { result, savedTarball: { path: tarball, etag: await etagSavedWith(tarball) } };
+  return holdingGigetFolder(
+    providerDir,
+    () => downloadOverMarkedRecords(providerDir, fullSource, options)
+  );
+}
+async function downloadOverMarkedRecords(providerDir, fullSource, options) {
+  const marks = await markSavedRecords(providerDir);
+  try {
+    const result = await downloadTemplate(fullSource, options);
+    const tarball = path16.join(providerDir, gigetTarballOf(result));
+    if (await writtenByThisDownload(marks.get(tarball))) return { result };
+    verbose(`giget extracted the tarball it saved earlier, not a download: ${tarball}`);
+    return { result, savedTarball: { path: tarball, etag: await etagSavedWith(tarball) } };
+  } finally {
+    await Promise.all([...marks.values()].map(unmark));
+  }
 }
 function gigetProviderDir(source) {
   const provider = SOURCE_PROTO_RE.exec(source)?.[1];
   if (provider === void 0) throw new Error(`No provider named in '${source}'`);
-  return path17.join(gigetCacheRoot(), provider);
+  return path16.join(gigetCacheRoot(), provider);
+}
+var GIGET_FOLDER_LOCK = "agents-inc.lock";
+var EXCLUSIVE_CREATE = "wx";
+var LOCK_RETRY_MS = 100;
+var LOCK_ABANDONED_MS = 10 * 60 * 1e3;
+var gigetFolderHeld = new AsyncLocalStorage3();
+var holdersInThisProcess = /* @__PURE__ */ new Set();
+async function holdingGigetFolder(folder, body) {
+  if (gigetFolderHeld.getStore() === folder) return body();
+  const lock = lockFor(folder);
+  try {
+    await lockGigetFolder(folder, lock);
+    return await gigetFolderHeld.run(folder, body);
+  } finally {
+    await letGo(lock);
+  }
+}
+function lockFor(folder) {
+  const holder = `${process.pid} ${randomUUID()}`;
+  holdersInThisProcess.add(holder);
+  return { path: path16.join(folder, GIGET_FOLDER_LOCK), holder };
 }
-async function tarballTimes(providerDir) {
+async function letGo({ path: lockPath, holder }) {
+  try {
+    await removeLockHeldBy(lockPath, holder);
+  } finally {
+    holdersInThisProcess.delete(holder);
+  }
+}
+async function lockGigetFolder(folder, lock) {
+  await ensureDir(folder);
+  while (!await created(lock)) {
+    const holder = await readFileOptional(lock.path);
+    if (await abandoned(lock.path, holder)) {
+      verbose(`Taking over the lock on ${folder}: its run ended, or held it past any download`);
+      await removeLockHeldBy(lock.path, holder);
+    } else {
+      await sleep(LOCK_RETRY_MS);
+    }
+  }
+}
+async function created({ path: lockPath, holder }) {
+  try {
+    await (await open(lockPath, EXCLUSIVE_CREATE)).close();
+  } catch (error) {
+    if (failedWith(error, "EEXIST")) return false;
+    throw error;
+  }
+  await writeFile(lockPath, holder);
+  return true;
+}
+async function abandoned(lockPath, holder) {
+  return holderEnded(holder) || await outlastedAnyDownload(lockPath);
+}
+function holderEnded(holder) {
+  const pid = Number.parseInt(holder, 10);
+  if (pid === process.pid) return !holdersInThisProcess.has(holder);
+  return pid > 0 && !processRunning(pid);
+}
+async function outlastedAnyDownload(lockPath) {
+  const age = await ageOf(lockPath);
+  return age !== void 0 && age > LOCK_ABANDONED_MS;
+}
+function processRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !failedWith(error, "ESRCH");
+  }
+}
+async function ageOf(file) {
+  try {
+    return Date.now() - (await stat(file)).mtimeMs;
+  } catch (error) {
+    if (failedWith(error, "ENOENT")) return void 0;
+    throw error;
+  }
+}
+async function removeLockHeldBy(lockPath, holder) {
+  if (await readFileOptional(lockPath) === holder) await remove(lockPath);
+}
+function failedWith(error, code) {
+  return isRecord(error) && error.code === code;
+}
+var RECORD_MARK = "\n";
+var NO_RECORD = "{}";
+var UNMARKED_SUFFIX = ".unmarked";
+async function markSavedRecords(providerDir) {
   const tarballs = await glob(GIGET_TARBALLS, providerDir);
-  const paths = tarballs.map((tarball) => path17.join(providerDir, tarball));
-  return new Map(await Promise.all(paths.map(async (at) => [at, await modifiedAt(at)])));
+  const paths = tarballs.map((tarball) => path16.join(providerDir, tarball));
+  return new Map(await Promise.all(paths.map(async (at) => [at, await markRecordOf(at)])));
+}
+async function markRecordOf(tarball) {
+  const record = gigetRecordOf(tarball);
+  await putBackLeftUnmarked(record);
+  const held = await fileExists(record);
+  const marked = `${RECORD_MARK}${await readFileOptional(record, NO_RECORD)}`;
+  if (held) await rename(record, unmarkedOf(record));
+  await writeFile(record, marked);
+  return { record, marked, held };
 }
-async function modifiedAt(file) {
-  return await fileExists(file) ? (await stat(file)).mtimeMs : void 0;
+async function putBackLeftUnmarked(record) {
+  if (await fileExists(unmarkedOf(record))) await rename(unmarkedOf(record), record);
+}
+function unmarkedOf(record) {
+  return `${record}${UNMARKED_SUFFIX}`;
+}
+async function writtenByThisDownload(mark) {
+  return mark === void 0 || await rewritten(mark);
+}
+async function rewritten({ record, marked }) {
+  return await readFileOptional(record, marked) !== marked;
+}
+async function unmark(mark) {
+  const { record, held } = mark;
+  if (await rewritten(mark)) {
+    if (held) await remove(unmarkedOf(record));
+    return;
+  }
+  if (held) await rename(unmarkedOf(record), record);
+  else await remove(record);
 }
 function gigetTarballOf(result) {
   const name = result.name;
   const version = result.version;
   if (typeof name !== "string") throw new Error("the download named no template");
   const stem = typeof version === "string" && version !== "" ? version : name;
-  return path17.join(name, `${stem}.tar.gz`);
+  return path16.join(name, `${stem}.tar.gz`);
 }
 function gigetRecordOf(tarball) {
   return `${tarball}.json`;
@@ -5730,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";
@@ -5752,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) {
@@ -5780,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`);
   }
@@ -6102,7 +6396,7 @@ function markInstalledAsPlugin(skill, primarySourceName, primarySourceType) {
 }
 async function collectPluginSkillIds(projectDir) {
   const projectSkillIds = await pluginSkillIdsIn(projectDir);
-  const globalSkillIds = isHomeDirectory(projectDir) ? [] : await pluginSkillIdsIn(os9.homedir());
+  const globalSkillIds = isHomeDirectory(projectDir) ? [] : await pluginSkillIdsIn(os9.homedir(), inheritedGlobalProvider(projectDir));
   if (globalSkillIds.length > 0) {
     verbose(`Found ${globalSkillIds.length} global plugin skill(s)`);
     return unique3([...projectSkillIds, ...globalSkillIds]);
@@ -6112,8 +6406,8 @@ async function collectPluginSkillIds(projectDir) {
   }
   return projectSkillIds;
 }
-async function pluginSkillIdsIn(dir) {
-  return typedKeys(await discoverAllPluginSkills(dir));
+async function pluginSkillIdsIn(dir, provider) {
+  return typedKeys(await discoverAllPluginSkills(dir, provider));
 }
 function setActiveSources(matrix2) {
   for (const [, skill] of typedEntries(matrix2.skills)) {
@@ -6164,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;
@@ -6206,14 +6500,18 @@ function resolveDescription(loadedStack, shared) {
   return shared ?? loadedStack?.description;
 }
 function configNameFor(projectDir) {
-  return isHomeDirectory(projectDir) ? DEFAULT_PLUGIN_NAME : path18.basename(projectDir);
+  return isHomeDirectory(projectDir) ? DEFAULT_PLUGIN_NAME : path17.basename(projectDir);
 }
 async function loadCuratedStack(projectDir, projectStack) {
-  const globalStack = isHomeDirectory(projectDir) ? void 0 : await loadGlobalStack();
+  const globalStack = isHomeDirectory(projectDir) ? void 0 : await loadGlobalStack(projectDir);
   return { ...globalStack, ...projectStack };
 }
-async function loadGlobalStack() {
-  return (await loadInstalledConfig(os10.homedir()))?.config.stack;
+async function loadGlobalStack(projectDir) {
+  const inherited = await loadProjectConfigFromDir(
+    os10.homedir(),
+    inheritedGlobalProvider(projectDir)
+  );
+  return inherited?.config.stack;
 }
 async function buildInstallConfig(selection, sourceResult, projectDir) {
   const skillIds = unique4(selection.skills.map((s) => s.id));
@@ -6252,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) {
@@ -6360,31 +6661,61 @@ async function describeScope(kind, root, provider) {
 
 // src/cli/lib/installation/detect-installations.ts
 async function detectInstallations(cwd) {
+  const configs = await configsRead(cwd);
+  return configs.filter((config) => !config.declaresNothingInAProject).map(asInstallation);
+}
+async function configsDeclaringNothing(cwd) {
+  const configs = await configsRead(cwd);
+  return configs.filter((config) => config.declaresNothingInAProject).map(asInstallation);
+}
+async function holdsAConfigDeclaringNothing(cwd) {
+  return (await configsDeclaringNothing(cwd)).length > 0;
+}
+async function configsRead(cwd) {
   const everywhereOneCouldBe = scopeRootsInPlay(cwd).flatMap(everyProviderUnder);
-  const found = await Promise.all(everywhereOneCouldBe.map(installationIfPresent));
-  return found.filter(
-    (installation) => installation !== null
-  );
+  const found = await Promise.all(everywhereOneCouldBe.map(configIfPresent));
+  const onDisk = found.filter((config) => config !== null);
+  return Promise.all(onDisk.map(withWhetherItDeclaresNothing));
 }
 function everyProviderUnder({ kind, root }) {
   return PROVIDERS.map((provider) => ({
     provider,
     scope: kind,
+    root,
     configPath: getProjectConfigPath(root, provider)
   }));
 }
-async function installationIfPresent(candidate) {
+async function configIfPresent(candidate) {
   return await fileExists(candidate.configPath) ? candidate : null;
 }
+async function withWhetherItDeclaresNothing(config) {
+  return { ...config, declaresNothingInAProject: await declaresNothingInAProject(config) };
+}
+async function declaresNothingInAProject(config) {
+  if (config.scope === "global") return false;
+  const asRead = declaresNothingAsLastRead(config.configPath);
+  if (asRead !== void 0) return asRead;
+  try {
+    const declaresNothing = await configDeclaresNothing(config.root, config.provider);
+    recordWhetherItDeclaresNothing(config.configPath, declaresNothing);
+    return declaresNothing;
+  } catch (error) {
+    if (error instanceof ConfigLoadError) return false;
+    throw error;
+  }
+}
+function asInstallation({ provider, scope, configPath }) {
+  return { provider, scope, configPath };
+}
 
 // src/cli/lib/hosts/claude-host.ts
 import os12 from "os";
-import path21 from "path";
+import path20 from "path";
 import { z as z6 } from "zod";
 
 // src/cli/utils/exec.ts
 import { spawn } from "child_process";
-import path19 from "path";
+import path18 from "path";
 var MAX_PLUGIN_PATH_LENGTH = 1024;
 var MAX_PLUGIN_NAME_LENGTH = 256;
 var MAX_MARKETPLACE_SOURCE_LENGTH = 1024;
@@ -6392,7 +6723,7 @@ var SAFE_NAME_PATTERN2 = /^[a-zA-Z0-9._@/-]+$/;
 var SAFE_PLUGIN_PATH_PATTERN = /^[a-zA-Z0-9._@/:~-]+$/;
 var OPENS_A_RELATIVE_PATH = /^\.\.?[/\\]/;
 function namesADirectoryOnThisMachine(source) {
-  return path19.isAbsolute(source) || OPENS_A_RELATIVE_PATH.test(source);
+  return path18.isAbsolute(source) || OPENS_A_RELATIVE_PATH.test(source);
 }
 var CONTROL_CHAR_PATTERN = /[\x00-\x08\x0E-\x1F\x7F]/u;
 function validatePluginPath(pluginPath) {
@@ -6482,7 +6813,7 @@ async function execCommand(command, args, options) {
 }
 
 // src/cli/lib/plugins/plugin-settings.ts
-import path20 from "path";
+import path19 from "path";
 import { z as z5 } from "zod";
 var pluginSettingsSchema = z5.object({
   // Absent when no plugin is enabled.
@@ -6503,7 +6834,7 @@ var installedPluginsSchema = z5.object({
   plugins: z5.record(z5.string(), z5.array(pluginInstallationSchema))
 }).passthrough();
 function getInstalledPluginsRegistryPath(pluginsDir2) {
-  return path20.join(pluginsDir2, INSTALLED_PLUGINS_FILE);
+  return path19.join(pluginsDir2, INSTALLED_PLUGINS_FILE);
 }
 async function readRegisteredInstallations(pluginsDir2) {
   const registryPath = getInstalledPluginsRegistryPath(pluginsDir2);
@@ -6536,7 +6867,7 @@ async function listPluginInstallsForProject(pluginsDir2, projectDir) {
   });
 }
 async function getEnabledPluginKeys(projectDir) {
-  const settingsPath = path20.join(projectDir, CLAUDE_DIR, STANDARD_FILES.SETTINGS_JSON);
+  const settingsPath = path19.join(projectDir, CLAUDE_DIR, STANDARD_FILES.SETTINGS_JSON);
   if (!await fileExists(settingsPath)) {
     verbose(`No settings.json found at '${settingsPath}'`);
     return [];
@@ -6596,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));
@@ -6684,7 +7022,7 @@ function namesNothingThere(message) {
   return NOT_INSTALLED_MESSAGES.some((phrase) => message.includes(phrase));
 }
 function claudePluginsRoot(projectDir, options) {
-  if (options?.configDir !== void 0) return path21.join(options.configDir, PLUGINS_SUBDIR);
+  if (options?.configDir !== void 0) return path20.join(options.configDir, PLUGINS_SUBDIR);
   return pluginsDir(CLAUDE, "global", projectDir);
 }
 async function claudeListPlugins(projectDir, options) {
@@ -6712,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
   };
@@ -6719,8 +7058,89 @@ function claudeHost() {
 
 // src/cli/lib/hosts/codex-host.ts
 import os13 from "os";
-import path22 from "path";
+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/;
@@ -6803,7 +7223,7 @@ var pluginListingSchema = z7.object({
   )
 });
 function codexPluginsRoot(projectDir, options) {
-  if (options?.configDir !== void 0) return path22.join(options.configDir, PLUGINS_SUBDIR);
+  if (options?.configDir !== void 0) return path21.join(options.configDir, PLUGINS_SUBDIR);
   return pluginsDir(CODEX, "global", projectDir);
 }
 async function isCodexCLIAvailable(options) {
@@ -6877,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);
@@ -6911,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(
@@ -6933,7 +7389,7 @@ async function codexListPlugins(projectDir, options) {
 async function codexPluginsOrUnreadable(projectDir, options) {
   const pluginsRoot = codexPluginsRoot(projectDir, options);
   if (pluginsRoot === null) return { kind: "listed", plugins: [] };
-  const cacheRoot2 = path22.join(pluginsRoot, PLUGIN_CACHE_SUBDIR);
+  const cacheRoot2 = path21.join(pluginsRoot, PLUGIN_CACHE_SUBDIR);
   let installed;
   try {
     installed = await codexPluginListing(options, projectDir);
@@ -6945,7 +7401,7 @@ async function codexPluginsOrUnreadable(projectDir, options) {
     kind: "listed",
     plugins: installed.map((plugin) => ({
       pluginKey: plugin.pluginId,
-      installPath: path22.join(cacheRoot2, plugin.marketplaceName, plugin.name, plugin.version),
+      installPath: path21.join(cacheRoot2, plugin.marketplaceName, plugin.name, plugin.version),
       enabled: plugin.enabled
     }))
   };
@@ -6960,6 +7416,7 @@ function codexHost() {
     addMarketplace: codexMarketplaceAdd,
     refreshMarketplace: refreshCodexMarketplace,
     installPlugin: codexInstallPlugin,
+    updatePlugin: codexUpdatePlugin,
     uninstallPlugin: codexUninstallPlugin,
     listPlugins: codexListPlugins
   };
@@ -7225,10 +7682,11 @@ function sumCounts(scopeCounts) {
 async function countCompiledAgentsPerScope(installation, scopes) {
   return Promise.all(
     scopes.map(async (scope) => {
-      const dir = resolveInstallPaths(installation.projectDir, scope).agentsDir;
+      const provider = providerAtScope(installation.projectDir, scope);
+      const dir = agentsDir(provider, scope, installation.projectDir);
       return {
         dir,
-        count: await countDirEntries(dir, isCompiledAgentFileIn(agentCodec("claude").extension))
+        count: await countDirEntries(dir, isCompiledAgentFileIn(agentCodec(provider).extension))
       };
     })
   );
@@ -7257,7 +7715,7 @@ function formatInstallationDisplay(info, skillLines = []) {
 }
 
 // src/cli/lib/plugins/plugin-validator.ts
-import path23 from "path";
+import path22 from "path";
 
 // src/cli/lib/validation-result.ts
 function validResult() {
@@ -7289,15 +7747,15 @@ async function validatePluginStructure(pluginPath) {
   if (!await directoryExists2(pluginPath)) {
     return invalidResult(`Plugin directory does not exist: ${pluginPath}`);
   }
-  const pluginDir = path23.join(pluginPath, PLUGIN_MANIFEST_DIR);
+  const pluginDir = path22.join(pluginPath, PLUGIN_MANIFEST_DIR);
   if (!await directoryExists2(pluginDir)) {
     errors.push(`Missing ${PLUGIN_MANIFEST_DIR}/ directory`);
   }
-  const manifestPath = path23.join(pluginDir, STANDARD_FILES.PLUGIN_JSON);
+  const manifestPath = path22.join(pluginDir, STANDARD_FILES.PLUGIN_JSON);
   if (!await fileExists(manifestPath)) {
     errors.push(`Missing ${PLUGIN_MANIFEST_DIR}/${STANDARD_FILES.PLUGIN_JSON}`);
   }
-  const readmePath = path23.join(pluginPath, STANDARD_FILES.README_MD);
+  const readmePath = path22.join(pluginPath, STANDARD_FILES.README_MD);
   if (!await fileExists(readmePath)) {
     warnings.push("Missing README.md (recommended for documentation)");
   }
@@ -7340,15 +7798,15 @@ async function validatePluginManifest(manifestPath) {
   if (!manifest.description) {
     warnings.push("Missing description field (recommended for discoverability)");
   }
-  const pluginDir = path23.dirname(path23.dirname(manifestPath));
+  const pluginDir = path22.dirname(path22.dirname(manifestPath));
   if (isNonEmptyString(manifest.skills)) {
-    const skillsPath = path23.join(pluginDir, manifest.skills);
+    const skillsPath = path22.join(pluginDir, manifest.skills);
     if (!await directoryExists2(skillsPath)) {
       errors.push(`Skills path does not exist: ${manifest.skills}`);
     }
   }
   if (isNonEmptyString(manifest.agents)) {
-    const agentsPath = path23.join(pluginDir, manifest.agents);
+    const agentsPath = path22.join(pluginDir, manifest.agents);
     if (!await directoryExists2(agentsPath)) {
       errors.push(`Agents path does not exist: ${manifest.agents}`);
     }
@@ -7417,14 +7875,14 @@ function prefixResult(result, prefix) {
 async function validateEachFile(pluginPath, scannedDir, files, validate) {
   const results = await Promise.all(
     files.map(async (file) => {
-      const filePath = path23.join(scannedDir, file);
-      return prefixResult(await validate(filePath), path23.relative(pluginPath, filePath));
+      const filePath = path22.join(scannedDir, file);
+      return prefixResult(await validate(filePath), path22.relative(pluginPath, filePath));
     })
   );
   return mergeValidationResults(results);
 }
 async function validatePluginSkillFiles(pluginPath, skillsRelPath) {
-  const skillsDir2 = path23.join(pluginPath, skillsRelPath);
+  const skillsDir2 = path22.join(pluginPath, skillsRelPath);
   if (!await directoryExists2(skillsDir2)) return validResult();
   const files = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir2);
   if (files.length === 0) {
@@ -7437,7 +7895,7 @@ async function validatePluginSkillFiles(pluginPath, skillsRelPath) {
   return validateEachFile(pluginPath, skillsDir2, files, validateSkillFrontmatter);
 }
 async function validatePluginAgentFiles(pluginPath, agentsRelPath) {
-  const agentsDir2 = path23.join(pluginPath, agentsRelPath);
+  const agentsDir2 = path22.join(pluginPath, agentsRelPath);
   if (!await directoryExists2(agentsDir2)) return validResult();
   const files = await glob(agentCodec("claude").listGlob, agentsDir2);
   if (files.length === 0) {
@@ -7508,7 +7966,7 @@ async function listPluginDirNames(pluginsDir2) {
   const dirChecks = await Promise.all(
     allDirs.map(async (dirName) => ({
       dirName,
-      isPlugin: await directoryExists2(path23.join(pluginsDir2, dirName, PLUGIN_MANIFEST_DIR))
+      isPlugin: await directoryExists2(path22.join(pluginsDir2, dirName, PLUGIN_MANIFEST_DIR))
     }))
   );
   return dirChecks.filter((c) => c.isPlugin).map((c) => c.dirName);
@@ -7516,7 +7974,7 @@ async function listPluginDirNames(pluginsDir2) {
 async function validateEachPlugin(pluginsDir2, pluginDirs) {
   const results = [];
   for (const pluginName of pluginDirs) {
-    const result = await validatePlugin(path23.join(pluginsDir2, pluginName));
+    const result = await validatePlugin(path22.join(pluginsDir2, pluginName));
     results.push({ name: pluginName, result });
   }
   return results;
@@ -7537,10 +7995,10 @@ function summarizePluginValidations(results) {
 }
 
 // src/cli/lib/plugins/plugin-discovery.ts
-async function getVerifiedPluginInstallPaths(projectDir) {
+async function getVerifiedPluginInstallPaths(projectDir, provider = providerInUse(projectDir)) {
   let enabled;
   try {
-    const installed = await hostAt(projectDir).listPlugins(projectDir);
+    const installed = await hostFor(provider).listPlugins(projectDir);
     enabled = installed.filter((plugin) => plugin.enabled).map(({ pluginKey, installPath }) => ({ pluginKey, installPath }));
   } catch (error) {
     verbose(`Failed to list installed plugins: ${getErrorMessage(error)}`);
@@ -7559,8 +8017,8 @@ async function hasManifestOnDisk({ pluginKey, installPath }) {
   }
   return manifestExists;
 }
-async function discoverAllPluginSkills(projectDir) {
-  const pluginPaths = await getVerifiedPluginInstallPaths(projectDir);
+async function discoverAllPluginSkills(projectDir, provider = providerInUse(projectDir)) {
+  const pluginPaths = await getVerifiedPluginInstallPaths(projectDir, provider);
   if (pluginPaths.length === 0) {
     verbose(`No enabled plugins found for '${projectDir}'`);
     return {};
@@ -7599,14 +8057,14 @@ function sanitizeSkillName(name) {
   return name.replace(/\+/g, "-");
 }
 function isSingleFolderName(name) {
-  return name !== "" && name !== "." && name !== ".." && path24.basename(name) === name;
+  return name !== "" && name !== "." && name !== ".." && path23.basename(name) === name;
 }
-async function assertClearable(pluginDir, skillPath, skillName) {
-  const skill = `Skill '${path24.basename(skillPath)}'`;
-  const file = `File: ${path24.join(skillPath, STANDARD_FILES.SKILL_MD)}`;
-  if (!isSingleFolderName(skillName)) {
+async function assertClearable(pluginDir, skillPath, skillName2) {
+  const skill = `Skill '${path23.basename(skillPath)}'`;
+  const file = `File: ${path23.join(skillPath, STANDARD_FILES.SKILL_MD)}`;
+  if (!isSingleFolderName(skillName2)) {
     throw new Error(
-      `${skill} is named '${skillName}', which is not a single folder name, so its plugin cannot be built inside the output directory. ${file}`
+      `${skill} is named '${skillName2}', which is not a single folder name, so its plugin cannot be built inside the output directory. ${file}`
     );
   }
   if (isPathWithin(skillPath, pluginDir)) {
@@ -7616,12 +8074,12 @@ async function assertClearable(pluginDir, skillPath, skillName) {
   }
   if (await holdsContentNoBuildMade(pluginDir)) {
     throw new Error(
-      `${skill} would be built into ${pluginDir}, which holds no ${path24.join(PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE)} and is not empty, so no earlier build made it and a rebuild would delete what it holds. Move its contents out, or build into another output directory. ${file}`
+      `${skill} would be built into ${pluginDir}, which holds no ${path23.join(PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE)} and is not empty, so no earlier build made it and a rebuild would delete what it holds. Move its contents out, or build into another output directory. ${file}`
     );
   }
 }
 async function readPluginSkillMetadata(skillPath) {
-  const metadataPath = path24.join(skillPath, STANDARD_FILES.METADATA_YAML);
+  const metadataPath = path23.join(skillPath, STANDARD_FILES.METADATA_YAML);
   if (!await fileExists(metadataPath)) {
     return null;
   }
@@ -7639,8 +8097,8 @@ async function readPluginSkillMetadata(skillPath) {
     return null;
   }
 }
-function generateReadme(skillName, frontmatter) {
-  return `# ${skillName}
+function generateReadme(skillName2, frontmatter) {
+  return `# ${skillName2}
 
 ${frontmatter.description}
 
@@ -7650,7 +8108,7 @@ Add this plugin to your Claude Code configuration:
 
 \`\`\`json
 {
-  "plugins": ["${skillName}"]
+  "plugins": ["${skillName2}"]
 }
 \`\`\`
 
@@ -7665,28 +8123,28 @@ This skill is automatically available when installed.
 }
 async function writeSkillFiles(skillPath, pluginSkillDir, skillMdContent) {
   await ensureDir(pluginSkillDir);
-  await writeFile(path24.join(pluginSkillDir, STANDARD_FILES.SKILL_MD), skillMdContent);
+  await writeFile(path23.join(pluginSkillDir, STANDARD_FILES.SKILL_MD), skillMdContent);
   verbose(`  Copied ${STANDARD_FILES.SKILL_MD}`);
   for (const fileName of SKILL_CONTENT_FILES) {
     if (fileName === STANDARD_FILES.SKILL_MD) continue;
-    const sourcePath = path24.join(skillPath, fileName);
+    const sourcePath = path23.join(skillPath, fileName);
     if (await fileExists(sourcePath)) {
       const content = await readFile(sourcePath);
-      await writeFile(path24.join(pluginSkillDir, fileName), content);
+      await writeFile(path23.join(pluginSkillDir, fileName), content);
       verbose(`  Copied ${fileName}`);
     }
   }
   for (const dirName of SKILL_CONTENT_DIRS) {
-    const sourceDir2 = path24.join(skillPath, dirName);
+    const sourceDir2 = path23.join(skillPath, dirName);
     if (await fileExists(sourceDir2)) {
-      await copy(sourceDir2, path24.join(pluginSkillDir, dirName));
+      await copy(sourceDir2, path23.join(pluginSkillDir, dirName));
       verbose(`  Copied ${dirName}/`);
     }
   }
 }
 async function readSkillMdToBuild(skillPath) {
-  const dirBasename = path24.basename(skillPath);
-  const skillMdPath = path24.join(skillPath, STANDARD_FILES.SKILL_MD);
+  const dirBasename = path23.basename(skillPath);
+  const skillMdPath = path23.join(skillPath, STANDARD_FILES.SKILL_MD);
   if (!await fileExists(skillMdPath)) {
     throw new Error(
       `Skill '${dirBasename}' is missing required ${STANDARD_FILES.SKILL_MD} file. Expected at: ${skillMdPath}`
@@ -7704,13 +8162,13 @@ async function readSkillMdToBuild(skillPath) {
 async function compileSkillPlugin(options) {
   const { skillPath, outputDir, skillName: overrideName } = options;
   const { skillMdContent, frontmatter } = await readSkillMdToBuild(skillPath);
-  const skillName = overrideName ?? sanitizeSkillName(frontmatter.name);
-  const pluginDir = path24.join(outputDir, skillName);
-  await assertClearable(pluginDir, skillPath, skillName);
-  verbose(`Compiling skill plugin: ${skillName} from ${skillPath}`);
+  const skillName2 = overrideName ?? sanitizeSkillName(frontmatter.name);
+  const pluginDir = path23.join(outputDir, skillName2);
+  await assertClearable(pluginDir, skillPath, skillName2);
+  verbose(`Compiling skill plugin: ${skillName2} from ${skillPath}`);
   const metadata = await readPluginSkillMetadata(skillPath);
   const manifestAt = (version) => generateSkillPluginManifest({
-    skillName,
+    skillName: skillName2,
     description: frontmatter.description,
     ...metadata?.author !== void 0 && { author: metadata.author },
     ...metadata?.category !== void 0 && { category: metadata.category },
@@ -7722,21 +8180,21 @@ async function compileSkillPlugin(options) {
   await writeContentHash(pluginDir, await computeSkillFolderHash(skillPath), getPluginManifestPath);
   await writeSkillFiles(
     skillPath,
-    path24.join(pluginDir, STANDARD_DIRS.SKILLS, skillName),
+    path23.join(pluginDir, STANDARD_DIRS.SKILLS, skillName2),
     skillMdContent
   );
-  const readme = generateReadme(skillName, frontmatter);
-  await writeFile(path24.join(pluginDir, STANDARD_FILES.README_MD), readme);
+  const readme = generateReadme(skillName2, frontmatter);
+  await writeFile(path23.join(pluginDir, STANDARD_FILES.README_MD), readme);
   verbose("  Generated README.md");
   const manifest = manifestAt(
     versionAfterRebuild(earlierBuild, await computeShippedHash(pluginDir))
   );
   await writePluginManifest(pluginDir, manifest);
-  verbose(`  Wrote plugin.json for ${skillName} (v${manifest.version})`);
+  verbose(`  Wrote plugin.json for ${skillName2} (v${manifest.version})`);
   return {
     pluginPath: pluginDir,
     manifest,
-    skillName
+    skillName: skillName2
   };
 }
 async function compileAllSkillPlugins(skillsDir2, outputDir) {
@@ -7744,7 +8202,7 @@ async function compileAllSkillPlugins(skillsDir2, outputDir) {
   const failed = [];
   const skillMdFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir2);
   for (const skillMdFile of skillMdFiles) {
-    const skillPath = path24.join(skillsDir2, path24.dirname(skillMdFile));
+    const skillPath = path23.join(skillsDir2, path23.dirname(skillMdFile));
     try {
       const result = await compileSkillPlugin({
         skillPath,
@@ -7754,7 +8212,7 @@ async function compileAllSkillPlugins(skillsDir2, outputDir) {
       log(`  [OK] ${result.skillName}`);
     } catch (error) {
       const errorMessage = getErrorMessage(error);
-      const dirBasename = path24.basename(skillPath);
+      const dirBasename = path23.basename(skillPath);
       failed.push(dirBasename);
       warn(`Failed to compile skill from '${dirBasename}': ${errorMessage}`);
     }
@@ -7770,7 +8228,7 @@ Compiled ${plural(results.length, "skill plugin")}:`);
 }
 
 // src/cli/lib/skills/local-skill-loader.ts
-import path25 from "path";
+import path24 from "path";
 function copiedInSkillsAt(root, provider) {
   const scope = isHomeDirectory(root) ? "global" : "project";
   return {
@@ -7796,9 +8254,9 @@ async function discoverLocalSkills(root, provider = providerInUse(root)) {
   };
 }
 async function extractLocalSkill(localSkillsPath, pathPrefix, skillDirName) {
-  const skillDir = path25.join(localSkillsPath, skillDirName);
-  const metadataPath = path25.join(skillDir, STANDARD_FILES.METADATA_YAML);
-  const skillMdPath = path25.join(skillDir, STANDARD_FILES.SKILL_MD);
+  const skillDir = path24.join(localSkillsPath, skillDirName);
+  const metadataPath = path24.join(skillDir, STANDARD_FILES.METADATA_YAML);
+  const skillMdPath = path24.join(skillDir, STANDARD_FILES.SKILL_MD);
   if (!await fileExists(metadataPath)) {
     verbose(`Skipping local skill '${skillDirName}': No metadata.yaml found`);
     return null;
@@ -7828,7 +8286,7 @@ async function extractLocalSkill(localSkillsPath, pathPrefix, skillDirName) {
     return null;
   }
   const relativePath = `${pathPrefix}/${skillDirName}/`;
-  const absolutePath = path25.join(localSkillsPath, skillDirName) + path25.sep;
+  const absolutePath = path24.join(localSkillsPath, skillDirName) + path24.sep;
   const skillId = frontmatter.name;
   const extracted = {
     id: skillId,
@@ -7851,7 +8309,7 @@ async function extractLocalSkill(localSkillsPath, pathPrefix, skillDirName) {
 }
 
 // src/cli/lib/skills/unresolved-skill-entries.ts
-import path26 from "path";
+import path25 from "path";
 async function findUnusableSavedSkillMetadata(savedSkills, projectDir) {
   const verdicts = await Promise.all(
     savedSkills.map((saved) => unusableMetadataOf(saved, projectDir))
@@ -7870,11 +8328,11 @@ function claimsLocalCopy(saved) {
 }
 function installedMetadataPath(saved, projectDir) {
   const { skillsDir: skillsDir2 } = resolveInstallPaths(projectDir, saved.scope);
-  return path26.join(skillsDir2, saved.id, STANDARD_FILES.METADATA_YAML);
+  return path25.join(skillsDir2, saved.id, STANDARD_FILES.METADATA_YAML);
 }
 
 // src/cli/lib/skills/local-skill-mover.ts
-import path27 from "path";
+import path26 from "path";
 var THE_DIRECTORY_ITSELF = ".";
 function validateSkillId(skillId) {
   return !(skillId.length === 0 || skillId === THE_DIRECTORY_ITSELF || skillId.includes("\0") || skillId.includes("..") || skillId.includes("/") || skillId.includes("\\"));
@@ -7884,8 +8342,8 @@ async function deleteLocalSkill(projectDir, skillId, scope = "project") {
     warn(`Invalid skill ID for deletion: '${skillId}'`);
     return;
   }
-  const skillsDir2 = path27.resolve(resolveInstallPaths(projectDir, scope).skillsDir);
-  const skillPath = path27.resolve(skillsDir2, skillId);
+  const skillsDir2 = path26.resolve(resolveInstallPaths(projectDir, scope).skillsDir);
+  const skillPath = path26.resolve(skillsDir2, skillId);
   if (!isPathWithin(skillPath, skillsDir2)) {
     warn(`Skill ID '${skillId}' resolves outside the skills directory.`);
     return;
@@ -7903,10 +8361,10 @@ async function migrateLocalSkillScope(skillId, fromScope, projectDir) {
     return;
   }
   const toScope = fromScope === "global" ? "project" : "global";
-  const fromSkillsDir = path27.resolve(resolveInstallPaths(projectDir, fromScope).skillsDir);
-  const toSkillsDir = path27.resolve(resolveInstallPaths(projectDir, toScope).skillsDir);
-  const fromPath = path27.resolve(fromSkillsDir, skillId);
-  const toPath = path27.resolve(toSkillsDir, skillId);
+  const fromSkillsDir = path26.resolve(resolveInstallPaths(projectDir, fromScope).skillsDir);
+  const toSkillsDir = path26.resolve(resolveInstallPaths(projectDir, toScope).skillsDir);
+  const fromPath = path26.resolve(fromSkillsDir, skillId);
+  const toPath = path26.resolve(toSkillsDir, skillId);
   if (!isPathWithin(fromPath, fromSkillsDir)) {
     warn(`Skill ID '${skillId}' resolves outside the source skills directory.`);
     return;
@@ -7933,7 +8391,7 @@ async function migrateLocalSkillScope(skillId, fromScope, projectDir) {
 
 // src/cli/lib/matrix/matrix-loader.ts
 import { parse as parseYaml5 } from "yaml";
-import path28 from "path";
+import path27 from "path";
 async function loadSkillCategories(configPath) {
   const data = await loadConfig(configPath, skillCategoriesFileSchema);
   if (!data) {
@@ -7942,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,
@@ -7961,29 +8427,33 @@ async function loadSkillRules(configPath) {
 }
 async function extractAllSkills(skillsDir2) {
   const metadataFiles = await glob(`**/${STANDARD_FILES.METADATA_YAML}`, skillsDir2);
-  const skills = [];
+  const folders = [];
   for (const metadataFile of metadataFiles) {
-    const skill = await extractSkill(skillsDir2, metadataFile);
-    if (skill) skills.push(skill);
+    folders.push(await readSkillFolder(skillsDir2, metadataFile));
   }
-  return skills;
+  return {
+    skills: folders.flatMap((folder) => folder.kind === "loaded" ? [folder.skill] : []),
+    unloadedSkillIds: folders.flatMap(
+      (folder) => folder.kind === "unloaded" ? [folder.skillId] : []
+    )
+  };
 }
-async function extractSkill(skillsDir2, metadataFile) {
-  const skillDir = path28.dirname(metadataFile);
-  const skillMdPath = path28.join(skillsDir2, skillDir, STANDARD_FILES.SKILL_MD);
+async function readSkillFolder(skillsDir2, metadataFile) {
+  const skillDir = path27.dirname(metadataFile);
+  const skillMdPath = path27.join(skillsDir2, skillDir, STANDARD_FILES.SKILL_MD);
   if (!await fileExists(skillMdPath)) {
-    verbose(`Skipping ${metadataFile}: No ${STANDARD_FILES.SKILL_MD} found`);
-    return null;
+    warn(`Skipping '${metadataFile}': No ${STANDARD_FILES.SKILL_MD} found`);
+    return { kind: "unnamed" };
   }
-  const metadata = await readMatrixMetadataOrWarn(metadataFile, path28.join(skillsDir2, metadataFile));
-  if (!metadata) return null;
+  const metadata = await readMatrixMetadataOrWarn(metadataFile, path27.join(skillsDir2, metadataFile));
+  if (!metadata) return unloadedSkillNamedBy(skillMdPath);
   const frontmatter = parseFrontmatterOrWarn(skillDir, skillMdPath, await readFile(skillMdPath));
-  if (!frontmatter) return null;
+  if (!frontmatter) return { kind: "unnamed" };
   if (!metadata.displayName) {
     warn(
       `Skipping '${metadataFile}': invalid ${STANDARD_FILES.METADATA_YAML} \u2014 missing required field: ${METADATA_KEYS.DISPLAY_NAME}`
     );
-    return null;
+    return { kind: "unloaded", skillId: frontmatter.name };
   }
   const skillId = frontmatter.name;
   const extracted = {
@@ -8001,7 +8471,16 @@ async function extractSkill(skillsDir2, metadataFile) {
     ...metadata.custom === true ? { custom: true } : {}
   };
   verbose(`Extracted skill: ${skillId}`);
-  return extracted;
+  return { kind: "loaded", skill: extracted };
+}
+async function unloadedSkillNamedBy(skillMdPath) {
+  try {
+    const frontmatter = parseFrontmatter(await readFile(skillMdPath), skillMdPath);
+    return frontmatter ? { kind: "unloaded", skillId: frontmatter.name } : { kind: "unnamed" };
+  } catch (error) {
+    verbose(`No skill named by '${skillMdPath}' \u2014 ${getErrorMessage(error)}`);
+    return { kind: "unnamed" };
+  }
 }
 async function readMatrixMetadataOrWarn(metadataFile, metadataPath) {
   const metadataContent = await readFile(metadataPath);
@@ -8029,7 +8508,7 @@ function parseFrontmatterOrWarn(skillDir, skillMdPath, skillMdContent) {
   const unreadable = unreadableFrontmatter(skillMdContent);
   if (unreadable !== void 0) {
     warn(
-      `Skipping '${path28.join(skillDir, STANDARD_FILES.SKILL_MD)}': unparseable ${STANDARD_FILES.SKILL_MD} frontmatter at ${skillMdPath} \u2014 ${unreadable}`
+      `Skipping '${path27.join(skillDir, STANDARD_FILES.SKILL_MD)}': unparseable ${STANDARD_FILES.SKILL_MD} frontmatter at ${skillMdPath} \u2014 ${unreadable}`
     );
   }
   return null;
@@ -9911,17 +10390,29 @@ 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))
+    marketplaceSkillIds: new Set(typedKeys(catalogue.matrix.skills)),
+    marketplaceSkills: { ...catalogue.matrix.skills }
   };
-  result.matrix = await mergeLocalSkills(result.matrix, resolvedProjectDir, provider);
-  await seatGlobalInstallationSkills(result.matrix, source, purpose);
+  const globalProvider = provider ?? inheritedGlobalProvider(resolvedProjectDir);
+  result.matrix = await mergeLocalSkills(
+    result.matrix,
+    resolvedProjectDir,
+    provider,
+    globalProvider
+  );
+  await seatGlobalInstallationSkills(result.matrix, source, purpose, globalProvider);
   if (!options.skipExtraSources) {
     await loadSkillsFromAllSources(
       result.matrix,
@@ -9935,16 +10426,20 @@ async function loadCatalogue(options) {
   initializeMatrix(result.matrix);
   return result;
 }
-async function seatGlobalInstallationSkills(matrix2, loadedSource, purpose) {
-  const uncarried = await globalPluginSkillsUncarried(matrix2);
+async function seatGlobalInstallationSkills(matrix2, loadedSource, purpose, globalProvider) {
+  const uncarried = await globalPluginSkillsUncarried(matrix2, globalProvider);
   if (uncarried.length === 0) return;
-  const globalCatalogue = await loadGlobalInstallationCatalogue(loadedSource, purpose);
+  const globalCatalogue = await loadGlobalInstallationCatalogue(
+    loadedSource,
+    purpose,
+    globalProvider
+  );
   if (globalCatalogue === null) return;
   for (const id of uncarried) seatFromCatalogue(matrix2, globalCatalogue, id);
 }
-async function globalPluginSkillsUncarried(matrix2) {
+async function globalPluginSkillsUncarried(matrix2, globalProvider) {
   try {
-    const globalConfig = await loadGlobalSourceConfig();
+    const globalConfig = await loadGlobalSourceConfig(globalProvider);
     return (globalConfig?.skills ?? []).filter(isActivePlugin).filter((skill) => matrix2.skills[skill.id] === void 0).map((skill) => skill.id);
   } catch (error) {
     verbose(`Global installation's skills not seated \u2014 ${getErrorMessage(error)}`);
@@ -9954,9 +10449,13 @@ async function globalPluginSkillsUncarried(matrix2) {
 function isActivePlugin(skill) {
   return !skill.excluded && skill.origin !== EJECT_SOURCE;
 }
-async function loadGlobalInstallationCatalogue(loadedSource, purpose) {
+async function loadGlobalInstallationCatalogue(loadedSource, purpose, globalProvider) {
   try {
-    const globalSourceConfig = await resolveSource({ caller: "stored", projectDir: os14.homedir() });
+    const globalSourceConfig = await resolveSource({
+      caller: "stored",
+      projectDir: os14.homedir(),
+      provider: globalProvider
+    });
     if (globalSourceConfig.source === loadedSource) return null;
     return await resolveBaseResult(globalSourceConfig, {
       purpose,
@@ -10012,6 +10511,8 @@ async function resolveBaseResult(sourceConfig, { purpose, devMode, matrixOnly })
     const fetched = matrixOnly ? NOTHING_FETCHED : await fetchFromSource(source);
     return {
       matrix: copyOfBuiltInMatrix(),
+      // Checked when it was generated, so nothing in it failed to load.
+      unloadedSkillIds: /* @__PURE__ */ new Set(),
       sourceConfig,
       sourcePath: fetched.path,
       isLocal: false,
@@ -10082,8 +10583,8 @@ function goesOnWithoutManifest(source, purpose) {
 function configuredLabel(sourceConfig) {
   return sourceConfig.marketplace === void 0 ? {} : { marketplace: sourceConfig.marketplace };
 }
-async function mergeLocalSkills(matrix2, projectDir, provider) {
-  const withGlobal = isHomeDirectory(projectDir) ? matrix2 : await mergeDiscoveredLocalSkills(matrix2, os14.homedir(), "global", provider);
+async function mergeLocalSkills(matrix2, projectDir, provider, globalProvider) {
+  const withGlobal = isHomeDirectory(projectDir) ? matrix2 : await mergeDiscoveredLocalSkills(matrix2, os14.homedir(), "global", globalProvider);
   return mergeDiscoveredLocalSkills(withGlobal, projectDir, "project", provider);
 }
 async function mergeDiscoveredLocalSkills(matrix2, dir, label, provider) {
@@ -10097,10 +10598,11 @@ async function mergeDiscoveredLocalSkills(matrix2, dir, label, provider) {
 async function loadFromLocal(source, sourceConfig, purpose) {
   const skillsPath = isLocalSource(source) ? (await fetchFromSource(source)).path : PROJECT_ROOT;
   verbose(`Loading skills from local path: ${skillsPath}`);
-  const mergedMatrix = await loadAndMergeFromBasePath(skillsPath, source);
+  const { matrix: matrix2, unloadedSkillIds } = await loadAndMergeFromBasePath(skillsPath, source);
   const labels = await resolveMarketplaceLabels(skillsPath, sourceConfig, purpose);
   return {
-    matrix: mergedMatrix,
+    matrix: matrix2,
+    unloadedSkillIds,
     sourceConfig,
     sourcePath: skillsPath,
     isLocal: true,
@@ -10112,10 +10614,11 @@ async function loadFromRemote(source, sourceConfig, purpose) {
   verbose(`Fetching skills from remote source: ${source}`);
   const fetchResult = await fetchFromSource(source);
   verbose(`Fetched to: ${fetchResult.path}`);
-  const mergedMatrix = await loadAndMergeFromBasePath(fetchResult.path, source);
+  const { matrix: matrix2, unloadedSkillIds } = await loadAndMergeFromBasePath(fetchResult.path, source);
   const labels = await resolveMarketplaceLabels(source, sourceConfig, purpose);
   return {
-    matrix: mergedMatrix,
+    matrix: matrix2,
+    unloadedSkillIds,
     sourceConfig,
     sourcePath: fetchResult.path,
     isLocal: false,
@@ -10124,7 +10627,7 @@ async function loadFromRemote(source, sourceConfig, purpose) {
   };
 }
 async function loadMarketplaceMatrix(marketplaceDir) {
-  const matrix2 = await loadAndMergeFromBasePath(marketplaceDir, marketplaceDir);
+  const { matrix: matrix2 } = await loadAndMergeFromBasePath(marketplaceDir, marketplaceDir);
   return { ...matrix2, categories: categoriesTheseSkillsAreIn(matrix2) };
 }
 function categoriesTheseSkillsAreIn(matrix2) {
@@ -10140,16 +10643,17 @@ async function loadAndMergeFromBasePath(basePath, source) {
   const skillsDirRelPath = sourceProjectConfig?.skillsDir ?? SKILLS_DIR_PATH;
   const stacksRelFile = sourceProjectConfig?.stacksFile;
   const { categories, sourceRules } = await loadSourceTaxonomy(basePath);
-  const skillsDir2 = path29.join(basePath, skillsDirRelPath);
+  const skillsDir2 = path28.join(basePath, skillsDirRelPath);
   verbose(`Skills from source: ${skillsDir2}`);
-  const skills = await extractAllSkills(skillsDir2);
+  const { skills, unloadedSkillIds } = await extractAllSkills(skillsDir2);
   await refuseCatalogueCollisions(basePath, source, skills);
   const relationships = relationshipsForSource(skills, sourceRules);
   const mergedMatrix = mergeMatrixWithSkills(categories, relationships, skills);
-  initializeMatrix(mergedMatrix);
   const stacks = await resolveOfferedStacks(basePath, stacksRelFile, source);
-  mergedMatrix.suggestedStacks = stacks.map((stack) => convertStackToResolvedStack(stack));
-  return mergedMatrix;
+  mergedMatrix.suggestedStacks = stacks.map(
+    (stack) => convertStackToResolvedStack(stack, mergedMatrix)
+  );
+  return { matrix: mergedMatrix, unloadedSkillIds: new Set(unloadedSkillIds) };
 }
 async function loadSourceTaxonomy(basePath) {
   const sourceCategories = await loadSourceCategories(basePath);
@@ -10163,7 +10667,7 @@ async function loadSourceTaxonomy(basePath) {
   return { categories, sourceRules };
 }
 async function loadSourceCategories(basePath) {
-  const categoriesPath = path29.join(basePath, SKILL_CATEGORIES_PATH);
+  const categoriesPath = path28.join(basePath, SKILL_CATEGORIES_PATH);
   if (!await fileExists(categoriesPath)) return void 0;
   const categories = await loadSkillCategories(categoriesPath);
   verbose(
@@ -10172,7 +10676,7 @@ async function loadSourceCategories(basePath) {
   return categories;
 }
 async function loadSourceRules(basePath) {
-  const rulesPath = path29.join(basePath, SKILL_RULES_PATH);
+  const rulesPath = path28.join(basePath, SKILL_RULES_PATH);
   if (!await fileExists(rulesPath)) return void 0;
   const rules = await loadSkillRules(rulesPath);
   verbose(`Loaded source rules: ${rulesPath}`);
@@ -10187,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");
@@ -10226,11 +10730,12 @@ function withdrawnSkillsWarning(stack, withdrawn) {
   const named = withdrawn.map((id) => `'${id}'`).join(", ");
   return `Stack '${stack.id}' names ${withdrawn.length} skill(s) this marketplace's catalogue does not carry: ${named}. Left out of the stack \u2014 selecting it would install nothing.`;
 }
-function convertStackToResolvedStack(stack) {
+function convertStackToResolvedStack(stack, catalogue) {
   const { declared, undeclared } = declaredAgentsIn(stack);
   if (undeclared.length > 0) warn(undeclaredAgentsWarning(stack, undeclared));
+  const isCarried = carriedBy(catalogue);
   const agentConfigs = agentConfigsFor(stack, declared);
-  const [allSkillIds, withdrawn] = partition4(namedSkillIds(agentConfigs), isInCurrentCatalogue);
+  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`
@@ -10239,7 +10744,7 @@ function convertStackToResolvedStack(stack) {
     id: stack.id,
     name: stack.name,
     description: stack.description,
-    skills: skillsByAgent(agentConfigs),
+    skills: skillsByAgent(agentConfigs, isCarried),
     allSkillIds,
     philosophy: stack.philosophy || ""
   };
@@ -10257,21 +10762,21 @@ function namedSkillIds(agentConfigs) {
     )
   );
 }
-function isInCurrentCatalogue(id) {
-  return id in matrix.skills;
+function carriedBy(catalogue) {
+  return (id) => id in catalogue.skills;
 }
-function skillsByAgent(agentConfigs) {
+function skillsByAgent(agentConfigs, isCarried) {
   return typedFromEntries(
     agentConfigs.map(
-      ({ agentId, agentConfig }) => [agentId, resolveStackAgentSkills(agentConfig)]
+      ({ agentId, agentConfig }) => [agentId, resolveStackAgentSkills(agentConfig, isCarried)]
     )
   );
 }
-function resolveStackAgentSkills(agentConfig) {
+function resolveStackAgentSkills(agentConfig, isCarried) {
   const carriedByCategory = typedEntries(agentConfig).map(
     ([category, assignments]) => (
       // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Object.entries drops the `| undefined` a Partial<Record> admits
-      [category, (assignments ?? []).map((a) => a.id).filter(isInCurrentCatalogue)]
+      [category, (assignments ?? []).map((a) => a.id).filter(isCarried)]
     )
   );
   return typedFromEntries(carriedByCategory.filter(([, ids]) => ids.length > 0));
@@ -10280,7 +10785,10 @@ function declaresCategory(matrix2, category) {
   return category !== LOCAL_PSEUDO_CATEGORY && matrix2.categories[category] !== void 0;
 }
 function undeclaredCategoryRefusal(metadata, category) {
-  const metadataPath = path29.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) {
@@ -10357,7 +10865,10 @@ export {
   rootsHoldingTheRetiredSourceFolder,
   chooseProviderForThisRun,
   forgetTheProviderChosenForThisRun,
+  declaresNoContent,
   providerInUse,
+  inheritedGlobalProvider,
+  providerAtScope,
   sourceFolderInUse,
   relativeConfigPath,
   sourceFolderName,
@@ -10390,9 +10901,10 @@ export {
   skillAssignedToNoAgent,
   scopeBlockedStackAssignment,
   globalScopedAgentsHint,
-  marketplacesRefreshed,
   marketplaceRefreshFailed,
   marketplacesRefreshFailed,
+  codexPluginLeftSwitchedOn,
+  pluginsLeftSwitchedOn,
   marketplaceOwnerHasNoName,
   marketplaceHasNoVersion,
   marketplaceNameNotPublishable,
@@ -10414,10 +10926,13 @@ export {
   sharedSkillsLeftBehind,
   sharedConfigExistingInstall,
   sharedConfigProjectScopeAtHome,
-  skippedUnknownSkills,
+  skippedSkills,
   skippedUnknownAgents,
   carriedSkillsWritten,
+  copiedSkillsRemovedAfterRefusedSave,
+  carriedSkillsRemovedAfterRefusedSave,
   SHARED_CONFIG_APPLY,
+  idNamesAnotherMarketplace,
   registeredProjectsRecompiled,
   sharedConfigNeedsTerminal,
   nothingInstalledToApplyTo,
@@ -10475,7 +10990,9 @@ export {
   formatZodIssues,
   validateSkillMetadata,
   splitMetadataValidationIssues,
+  ConfigSchemaError,
   ConfigDefaultExportError,
+  ConfigEvaluationError,
   NO_VALID_DEFAULT_EXPORT,
   configLoadFailure,
   loadConfig,
@@ -10494,21 +11011,23 @@ export {
   MarketplaceRefusedError,
   isLocalSource,
   normalizeStackRecord,
+  StacksLoadError,
   loadStackById,
   defaultUsageGuidance,
   resolveAgentConfigToSkills,
   getStackSkillIds,
   ConfigLoadError,
+  configDeclaresNothing,
   loadProjectConfigFromDir,
   loadProjectConfigAt,
   loadInstalledConfig,
-  configDirsInPlay,
+  configsInPlay,
   findConfigLoadFailures,
   loadProjectConfig,
+  loadConfigInPlay,
   validateProjectConfig,
   INSTALL_MODE_LABELS,
   INSTALL_MODE_DESCRIPTIONS,
-  declaresNoContent,
   deriveInstallMode,
   detectProjectInstallation,
   holdsItsOwnInstallation,
@@ -10550,6 +11069,7 @@ export {
   readLocalSkillMetadata,
   validateSkillPath,
   copySkillsToLocalFlattened,
+  copyMarketplaceSkillsToLocalFlattened,
   getUserPluginsDir,
   getProjectPluginsDir,
   getPluginAgentsDir,
@@ -10576,9 +11096,12 @@ export {
   execCommand,
   getInstalledPluginsRegistryPath,
   listRegisteredPluginInstalls,
+  PluginsLeftSwitchedOnError,
+  FailedLeavingPluginsSwitchedOnError,
   refuseUnofferedPlacements,
   hostFor,
   hostAt,
+  getVerifiedPluginInstallPaths,
   discoverAllPluginSkills,
   listPluginNames,
   compileSkillPlugin,
@@ -10587,6 +11110,7 @@ export {
   findUnusableSavedSkillMetadata,
   deleteLocalSkill,
   migrateLocalSkillScope,
+  NoSkillRulesError,
   claimSlug,
   matrixHealthIssues,
   generateMarketplace,
@@ -10613,6 +11137,8 @@ export {
   sourceScopesInPlay,
   scopeRootsInPlay,
   detectInstallations,
+  configsDeclaringNothing,
+  holdsAConfigDeclaringNothing,
   ejectCopyFailureError,
   copyingBesideGlobalPlugins,
   installingBesideGlobalCopies,
@@ -10620,4 +11146,4 @@ export {
   executeMigration,
   keepsGlobalInstall
 };
-//# sourceMappingURL=chunk-E45IT3HC.js.map
+//# sourceMappingURL=chunk-ENET4IF6.js.map