agents-inc 0.174.0 → 0.175.0

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

@@ -13,7 +13,7 @@ import {
   typedFromEntries,
   typedKeys,
   typedValues
-} from "./chunk-AIBVAYHS.js";
+} from "./chunk-TG3SPPZY.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 partition5, 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,37 @@ function chooseProviderForThisRun(provider) {
 function forgetTheProviderChosenForThisRun() {
   providerChosenForThisRun = void 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)) {
+  const home = os2.homedir();
+  const inheritsItsOwn = holdsAnInstallation(projectDir, own) && holdsAnInstallation(home, own);
+  return inheritsItsOwn ? own : providerInUse(home);
+}
+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 +519,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 +676,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 +699,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 +902,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 +984,8 @@ 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. */
+  GLOBAL_INSTALLATION_STANDS_IN: "This project's config declares nothing, so this works on your global installation.",
   /** 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 +1000,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(", ")}`;
@@ -1167,14 +1196,27 @@ 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)}`;
 }
@@ -1212,10 +1254,13 @@ 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 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,7 +1268,7 @@ function keptAsInstalledGlobally(skillIds, agentNames, idAppliedAtHome, provider
   ].join("\n");
 }
 function skillsMoved(verb, skillIds, namedBy) {
-  const names = skillIds.map((id) => getSkillEntryDisplayName(namedBy[id] ?? { id }));
+  const names = skillIds.map((id) => skillName(id, namedBy));
   return names.length === 0 ? [] : [`${verb} ${listed(names)}`];
 }
 function settingMoved({ setting, from, to }) {
@@ -1250,29 +1295,28 @@ function subAgentChanged({
   const where = scope === "global" ? " (global)" : "";
   return `~ ${name}${where}: ${details.length > 0 ? details.join(", ") : SKILLS_REASSIGNED}`;
 }
-function addedToGlobalSubAgents(joined) {
+function addedToGlobalSubAgents(joined, namedBy) {
+  const gains = (skillIds) => skillIds.map((id) => skillName(id, namedBy)).join(", ");
   return [
     "Added to sub-agents in the global install \u2014 each keeps everything it already has, since a project run only adds to the global install:",
-    ...joined.map(
-      ({ agentName, skillIds }) => `  sub-agent ${agentName}: + ${skillIds.join(", ")}`
-    )
+    ...joined.map(({ agentName, skillIds }) => `  sub-agent ${agentName}: + ${gains(skillIds)}`)
   ].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 +2011,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 +2162,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 +2498,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 +2525,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 };
@@ -2598,7 +2642,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),
@@ -2688,13 +2732,16 @@ 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);
+  return own ?? await readStoredRung(os4.homedir(), "global", provider ?? inheritedBy(projectDir));
+}
+function inheritedBy(projectDir) {
+  return inheritedGlobalProvider(projectDir ?? os4.homedir());
 }
 async function readStoredRung(dir, origin, provider) {
   const config = await loadSourceConfig(dir, origin, provider);
@@ -2793,7 +2840,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 +3186,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";
@@ -3656,12 +3703,12 @@ function mergeInlinedScalarFields(cleaned, cleanedGlobal) {
   ).filter(([key]) => isCopiedScalarField(key));
 }
 function generateProjectConfigWithInlinedGlobal(cleaned, cleanedGlobal) {
-  const partition5 = partitionInlinedConfigEntries(cleaned, cleanedGlobal);
+  const partition6 = 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: partition6.globalSkills.length > 0 || partition6.projectSkills.length > 0,
+    hasAgents: partition6.globalAgents.length > 0 || partition6.projectAgents.length > 0,
+    hasStack: hasStackEntries(partition6.filteredStack),
+    hasSelectedDomains: partition6.selectedDomains.length > 0
   };
   const scalarFields = mergeInlinedScalarFields(cleaned, cleanedGlobal);
   return assembleConfigSource({
@@ -3672,15 +3719,15 @@ function generateProjectConfigWithInlinedGlobal(cleaned, cleanedGlobal) {
       ...emitted.hasSkills ? entryDeclaration(
         "skills",
         "SkillConfig[]",
-        scopeSectionEntries(partition5.globalSkills, partition5.projectSkills)
+        scopeSectionEntries(partition6.globalSkills, partition6.projectSkills)
       ) : [],
       ...emitted.hasAgents ? entryDeclaration(
         "agents",
         "AgentScopeConfig[]",
-        scopeSectionEntries(partition5.globalAgents, partition5.projectAgents)
+        scopeSectionEntries(partition6.globalAgents, partition6.projectAgents)
       ) : [],
-      ...emitted.hasStack ? declaration("stack", STACK_TYPE, partition5.filteredStack) : [],
-      ...emitted.hasSelectedDomains ? declaration("selectedDomains", "Domain[]", partition5.selectedDomains) : []
+      ...emitted.hasStack ? declaration("stack", STACK_TYPE, partition6.filteredStack) : [],
+      ...emitted.hasSelectedDomains ? declaration("selectedDomains", "Domain[]", partition6.selectedDomains) : []
     ],
     exportFields: [
       renderScalarField("name", resolveProjectName(cleaned)),
@@ -3835,7 +3882,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 +3932,7 @@ function skillIdsByCategory(skills) {
   );
 }
 function buildSkillScopeMap(skillConfigs) {
-  const [excludedConfigs, activeConfigs] = partition2(
+  const [excludedConfigs, activeConfigs] = partition3(
     skillConfigs,
     (s) => Boolean(s.excluded)
   );
@@ -4030,11 +4077,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 +4141,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 +4177,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 +4201,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,11 +4209,11 @@ 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 }];
@@ -4219,10 +4277,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 +4335,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 +4366,7 @@ function placeAssignments(agentConfig) {
   );
 }
 function rekeyToLiveCategories(agentConfig) {
-  const [settled, moved] = partition3(
+  const [settled, moved] = partition4(
     placeAssignments(agentConfig),
     (placed) => placed.liveCategory === placed.storedCategory
   );
@@ -4437,6 +4491,14 @@ var ConfigLoadError = class extends Error {
   /** Named in the remedy's `init --from` half, which a bare run would answer with another one. */
   initProviderToName;
 };
+function declaresNoContent(config) {
+  return config.skills.length === 0 && config.agents.length === 0;
+}
+async function configDeclaresNothing(projectDir, provider) {
+  const configPath = getProjectConfigPath(projectDir, provider);
+  const parsed = await parseConfigFile(configPath, refusalAt(configPath, projectDir, provider));
+  return declaresNoContent({ skills: parsed.skills ?? [], agents: parsed.agents ?? [] });
+}
 async function loadProjectConfigFromDir(projectDir, provider) {
   return loadProjectConfigAt(getProjectConfigPath(projectDir, provider), projectDir, provider);
 }
@@ -4447,8 +4509,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 +4519,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 +4557,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) {
@@ -4870,6 +4944,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 +4985,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 +5092,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 +5101,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 +5108,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 +5120,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 +5138,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 +5227,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 +5260,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 +5268,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 +5280,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 {};
@@ -5237,19 +5314,19 @@ async function loadSkillsFromDir(skillsDir2, options = {}) {
   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.`
@@ -5291,7 +5368,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 +5377,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 +5420,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}'`);
@@ -5407,7 +5485,7 @@ function namespaceViolationError(foreignIds, marketplaceName) {
   ].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);
@@ -5481,7 +5559,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 +5570,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 +5602,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);
@@ -5564,7 +5640,7 @@ async function discardCachedCopy(cacheDir, source) {
   await remove(cacheDir);
 }
 async function downloadFreshCopy(cacheDir, source, fullSource) {
-  await ensureDir(path17.dirname(cacheDir));
+  await ensureDir(path16.dirname(cacheDir));
   try {
     const { result, savedTarball } = await gigetDownload(source, fullSource, {
       dir: cacheDir,
@@ -5622,7 +5698,7 @@ async function downloadAnsweredFor(cacheDir, source, fullSource, differingCopies
     forceClean: true,
     offline: false
   });
-  await ensureDir(path17.dirname(cacheDir));
+  await ensureDir(path16.dirname(cacheDir));
   try {
     const { result, savedTarball } = await downloadStaged();
     const record = await askAfterTheDownload(result, source);
@@ -5643,7 +5719,10 @@ 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,7 +5758,7 @@ 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 remove(cacheDir);
@@ -5690,33 +5769,156 @@ 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 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);
 }
-async function tarballTimes(providerDir) {
+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 putBackLeftUnmarked(record) {
+  if (await fileExists(unmarkedOf(record))) await rename(unmarkedOf(record), record);
+}
+function unmarkedOf(record) {
+  return `${record}${UNMARKED_SUFFIX}`;
 }
-async function modifiedAt(file) {
-  return await fileExists(file) ? (await stat(file)).mtimeMs : void 0;
+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`;
@@ -6102,7 +6304,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 +6314,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)) {
@@ -6206,14 +6408,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));
@@ -6360,31 +6566,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 +6628,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 +6718,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 +6739,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 +6772,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 [];
@@ -6684,7 +6920,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) {
@@ -6719,7 +6955,7 @@ 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";
 var CODEX = "codex";
 var PLUGIN_CACHE_SUBDIR = "cache";
@@ -6803,7 +7039,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) {
@@ -6933,7 +7169,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 +7181,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
     }))
   };
@@ -7225,10 +7461,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 +7494,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 +7526,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 +7577,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 +7654,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 +7674,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 +7745,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 +7753,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 +7774,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 +7796,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 +7836,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 +7853,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 +7876,8 @@ async function readPluginSkillMetadata(skillPath) {
     return null;
   }
 }
-function generateReadme(skillName, frontmatter) {
-  return `# ${skillName}
+function generateReadme(skillName2, frontmatter) {
+  return `# ${skillName2}
 
 ${frontmatter.description}
 
@@ -7650,7 +7887,7 @@ Add this plugin to your Claude Code configuration:
 
 \`\`\`json
 {
-  "plugins": ["${skillName}"]
+  "plugins": ["${skillName2}"]
 }
 \`\`\`
 
@@ -7665,28 +7902,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 +7941,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 +7959,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 +7981,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 +7991,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 +8007,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 +8033,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 +8065,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 +8088,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 +8107,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 +8121,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 +8140,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 +8170,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) {
@@ -7961,29 +8198,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 +8242,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 +8279,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;
@@ -9918,10 +10168,17 @@ async function loadCatalogue(options) {
   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 +10192,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 +10215,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 +10277,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 +10349,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 +10364,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 +10380,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 +10393,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 +10409,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 +10433,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 +10442,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}`);
@@ -10226,11 +10496,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] = partition5(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 +10510,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 +10528,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 +10551,7 @@ 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);
+  const metadataPath = path28.join(metadata.path, STANDARD_FILES.METADATA_YAML);
   return `Skipping local skill '${metadata.id}': ${METADATA_KEYS.CATEGORY} '${category}' is not one this installation declares, so the skill belongs in no grid tab and can be given to no sub-agent. Set ${METADATA_KEYS.CATEGORY} in ${metadataPath} to a category that already exists \u2014 a skill is placed in the taxonomy, it does not extend it.`;
 }
 function mergeLocalSkillsIntoMatrix(matrix2, localResult) {
@@ -10358,6 +10629,8 @@ export {
   chooseProviderForThisRun,
   forgetTheProviderChosenForThisRun,
   providerInUse,
+  inheritedGlobalProvider,
+  providerAtScope,
   sourceFolderInUse,
   relativeConfigPath,
   sourceFolderName,
@@ -10414,7 +10687,7 @@ export {
   sharedSkillsLeftBehind,
   sharedConfigExistingInstall,
   sharedConfigProjectScopeAtHome,
-  skippedUnknownSkills,
+  skippedSkills,
   skippedUnknownAgents,
   carriedSkillsWritten,
   SHARED_CONFIG_APPLY,
@@ -10499,16 +10772,17 @@ export {
   resolveAgentConfigToSkills,
   getStackSkillIds,
   ConfigLoadError,
+  declaresNoContent,
   loadProjectConfigFromDir,
   loadProjectConfigAt,
   loadInstalledConfig,
-  configDirsInPlay,
+  configsInPlay,
   findConfigLoadFailures,
   loadProjectConfig,
+  loadConfigInPlay,
   validateProjectConfig,
   INSTALL_MODE_LABELS,
   INSTALL_MODE_DESCRIPTIONS,
-  declaresNoContent,
   deriveInstallMode,
   detectProjectInstallation,
   holdsItsOwnInstallation,
@@ -10550,6 +10824,7 @@ export {
   readLocalSkillMetadata,
   validateSkillPath,
   copySkillsToLocalFlattened,
+  copyMarketplaceSkillsToLocalFlattened,
   getUserPluginsDir,
   getProjectPluginsDir,
   getPluginAgentsDir,
@@ -10579,6 +10854,7 @@ export {
   refuseUnofferedPlacements,
   hostFor,
   hostAt,
+  getVerifiedPluginInstallPaths,
   discoverAllPluginSkills,
   listPluginNames,
   compileSkillPlugin,
@@ -10613,6 +10889,8 @@ export {
   sourceScopesInPlay,
   scopeRootsInPlay,
   detectInstallations,
+  configsDeclaringNothing,
+  holdsAConfigDeclaringNothing,
   ejectCopyFailureError,
   copyingBesideGlobalPlugins,
   installingBesideGlobalCopies,
@@ -10620,4 +10898,4 @@ export {
   executeMigration,
   keepsGlobalInstall
 };
-//# sourceMappingURL=chunk-E45IT3HC.js.map
+//# sourceMappingURL=chunk-YM3VEDAP.js.map