agents-inc 0.171.0 → 0.173.0

package/dist/{chunk-3YYHL76L.js → chunk-WVFBBZEP.js}

@@ -2,12 +2,18 @@
 import {
   BUILT_IN_MATRIX,
   getSkillById,
+  getSkillDisplayName,
+  inertLine,
   initializeMatrix,
   matrix,
   plural,
   stripTerminalControls,
-  toTitleCase
-} from "./chunk-24OD7IP4.js";
+  toTitleCase,
+  typedEntries,
+  typedFromEntries,
+  typedKeys,
+  typedValues
+} from "./chunk-7OG635DK.js";
 import {
   AGENT_NAMES,
   AUTHOR_HANDLE_PATTERN,
@@ -76,7 +82,7 @@ import {
   seedAgentScope,
   sourceDirName,
   validateSelection
-} from "./chunk-A6OWEJGC.js";
+} from "./chunk-MHAQWMNJ.js";
 import {
   defaultCategories,
   defaultRules,
@@ -86,7 +92,7 @@ import {
 // src/cli/lib/loading/source-loader.ts
 import os14 from "os";
 import { partition as partition4, unique as unique6 } from "remeda";
-import path28 from "path";
+import path29 from "path";
 
 // src/cli/lib/installation/is-home-directory.ts
 import fs from "fs";
@@ -485,13 +491,15 @@ function sourceRootOf(root) {
 }
 var RETIRED_SOURCE_FOLDER = ".claude-src";
 function retiredSourceFolderIn(roots) {
-  if (!roots.some(holdsTheRetiredSourceFolder)) return null;
-  return sourceDirName("claude");
+  return [...new Set(roots)].filter(holdsTheRetiredSourceFolder);
 }
 function holdsTheRetiredSourceFolder(root) {
   return directoryExists(path.join(root, RETIRED_SOURCE_FOLDER));
 }
 var PROVIDER_OF_A_NEW_INSTALLATION = "claude";
+function isTheProviderOfANewInstallation(provider) {
+  return provider === PROVIDER_OF_A_NEW_INSTALLATION;
+}
 var providerChosenForThisRun;
 function chooseProviderForThisRun(provider) {
   providerChosenForThisRun = provider;
@@ -736,8 +744,8 @@ async function fileExists(filePath) {
 }
 async function directoryExists2(dirPath) {
   try {
-    const stat = await fs3.stat(dirPath);
-    return stat.isDirectory();
+    const stat2 = await fs3.stat(dirPath);
+    return stat2.isDirectory();
   } catch {
     return false;
   }
@@ -862,6 +870,9 @@ function warnOnce(msg) {
   sayingEachWarningOnce(() => warn(msg));
 }
 
+// src/cli/utils/messages.ts
+import path3 from "path";
+
 // src/cli/lib/validate-kebab-name.ts
 import { unique } from "remeda";
 var KEBAB_CASE_CHARACTER = /[a-z0-9-]/;
@@ -942,6 +953,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.",
+  /** 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. */
   AGENT_PARTIALS_CUSTOMIZABLE: `Each sub-agent directory there holds ${AGENT_PARTIAL_FILES.join(", ")} \u2014 edit those to customize that sub-agent.`
 };
@@ -974,9 +987,9 @@ function completedWithFailures(failures) {
 function failureLines({ what, recovery }) {
   return [`  ${what}`, `    ${recovery}`];
 }
-function propagatedRecompileSummary(rewritten, unchanged, failed) {
+function propagatedRecompileSummary(recompiled, failed) {
   const failureSuffix = failed > 0 ? ` (${failed} failed)` : "";
-  return `Registered projects: ${rewritten} rewritten, ${unchanged} unchanged${failureSuffix}`;
+  return `Registered projects: ${recompiled} recompiled${failureSuffix}`;
 }
 function skillAssignedToNoAgent(skillId) {
   return `Skill '${skillId}' is assigned to no sub-agent \u2014 nothing will load it.`;
@@ -1133,22 +1146,25 @@ function sharedSkillsLeftBehind(skillIds) {
 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) {
+function sharedConfigProjectScopeAtHome(skillIds, agentNames, installedHere, provider) {
   return [
     "This configuration cannot be installed here: the home directory is the global scope, and a global installation holds only global-scoped content \u2014 so these project-scoped entries have nowhere to be written:",
     ...skillIds.map((id) => `  skill ${id} (scope: project)`),
     ...agentNames.map((name) => `  sub-agent ${name} (scope: project)`),
-    "Run this from inside a project directory, or re-share it with each entry above at global scope."
+    installedHere ? changeTheGlobalInstallFromHome(providerArgument(provider)) : "Run this from inside a project directory, or re-share it with each entry above at global scope."
   ].join("\n");
 }
+function changeTheGlobalInstallFromHome(named) {
+  return `Run this from inside a project directory, or change the global install from here: run '${CLI_INVOKE_COMMAND} edit${named}', make the change in the editor, then apply the id it gives you with '${CLI_INVOKE_COMMAND} edit --from <id>${named}'.`;
+}
 function unknownKeys(keys) {
-  return keys.map(stripTerminalControls).join(", ");
+  return keys.map(inertLine).join(", ");
 }
-function skippedUnknownSkills(skillIds, skippedWith) {
+function skippedUnknownSkills(skillIds, installedWithout) {
   return [
     `Skipped ${skillIds.length} skill(s) this catalog does not know: ${unknownKeys(skillIds)}`,
-    ...skippedWith.map(
-      ({ skillId, agentNames }) => `  sub-agent(s) skipped with ${unknownKeys([skillId])}, carrying nothing else this catalog knows: ${agentNames.join(", ")}`
+    ...installedWithout.map(
+      ({ skillId, agentNames }) => `  sub-agent(s) installed without ${unknownKeys([skillId])}, carrying nothing else this catalog knows: ${agentNames.join(", ")}`
     )
   ].join("\n");
 }
@@ -1159,30 +1175,18 @@ function carriedSkillsWritten(skillIds) {
   return `Wrote ${skillIds.length} skill(s) this configuration carries: ${skillIds.join(", ")}`;
 }
 var SHARED_CONFIG_APPLY = {
-  PREVIEW_HEADING: "Applying this configuration will remove:",
-  SKILLS_HEADING: "Skills:",
-  AGENTS_HEADING: "Sub-agents:",
-  NOTHING_REMOVED: "Nothing is removed \u2014 this configuration only adds and re-tunes.",
-  OVERWRITTEN_HEADING: "Will be overwritten:",
   CONFIRM: "Apply this configuration?"
 };
-function projectCopyRemoved(subject) {
-  return `${subject}: this project's copy is removed; the global one takes over`;
-}
-function projectCopyMovedToGlobal(subject) {
-  return `${subject}: moves to the global install, so this project's copy is removed`;
-}
-function registeredProjectsRewritten(projectPaths) {
+function registeredProjectsRecompiled(projectPaths) {
   return [
-    "Each project registered with this global install is rewritten to match:",
+    "Each project registered with this global install is recompiled to match:",
     ...projectPaths.map((projectPath) => `  ${projectPath}`)
   ].join("\n");
 }
-function sharedConfigNeedsTerminal(id, provider) {
-  const named = providerArgument(provider);
+function sharedConfigNeedsTerminal(id, editProvider, initProvider) {
   return [
     `Applying configuration '${id}' removes whatever it leaves out, so it has to be confirmed \u2014 and there is no terminal here to confirm it at.`,
-    `Run '${CLI_INVOKE_COMMAND} edit --from ${id}${named}' from a terminal, or '${CLI_INVOKE_COMMAND} init --from ${id}${named}' in a clean directory, which installs without removing anything.`
+    `Run '${CLI_INVOKE_COMMAND} edit --from ${id}${providerArgument(editProvider)}' from a terminal, or '${CLI_INVOKE_COMMAND} init --from ${id}${providerArgument(initProvider)}' in a clean directory, which installs without removing anything.`
   ].join("\n");
 }
 function nothingInstalledToApplyTo(id, provider) {
@@ -1199,21 +1203,38 @@ function addMarketplaceInTheEditor(ref, isFolder) {
   return isFolder ? `${ref} is a folder on this machine, which the editor cannot read \u2014 push it to GitHub, then add it from the editor's Marketplace button.` : `Add ${ref} from the editor's Marketplace button.`;
 }
 var SHARED_CONFIG_ARRIVALS = {
-  PROJECT_HEADING: "Into this project:",
-  GLOBAL_HEADING: "Into the global install:",
-  SKIPPED_HEADING: "Skipped, already in the global install:",
   INSTALL_CONFIRM: "Install this configuration?"
 };
-function keptAsInstalledGlobally(skillIds, agentNames, idAppliedAtHome) {
+function keptAsInstalledGlobally(skillIds, agentNames, idAppliedAtHome, provider) {
   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}`),
     ...agentNames.map((name) => `  sub-agent ${name}`),
     ...idAppliedAtHome === void 0 ? [] : [
-      `Change them with '${CLI_INVOKE_COMMAND} edit --from ${idAppliedAtHome}' from your home directory.`
+      `Change them with '${CLI_INVOKE_COMMAND} edit --from ${idAppliedAtHome}${providerArgument(provider)}' from your home directory.`
     ]
   ].join("\n");
 }
+function skillsMoved(verb, skillIds) {
+  return skillIds.length === 0 ? [] : [`${verb} ${listed(skillIds.map(getSkillDisplayName))}`];
+}
+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, scope, gains, loses, settings }) {
+  const details = [
+    ...skillsMoved("gains", gains),
+    ...skillsMoved("loses", loses),
+    ...settings.map(settingMoved)
+  ];
+  const where = scope === "global" ? " (global)" : "";
+  return `~ ${name}${where}: ${details.length > 0 ? details.join(", ") : SKILLS_REASSIGNED}`;
+}
 function addedToGlobalSubAgents(joined) {
   return [
     "Added to sub-agents in the global install \u2014 each keeps everything it already has, since a project run only adds to the global install:",
@@ -1260,17 +1281,18 @@ function uninstallSkillMetadataUnreadable(metadataPath) {
 }
 function recreateConfigFrom({
   scopeRoot,
-  providerToName
+  providerToName,
+  initProviderToName
 }) {
-  const named = providerArgument(providerToName);
-  return `'${CLI_INVOKE_COMMAND} uninstall${named}' from '${scopeRoot}', which still works on a config it cannot read, then '${CLI_INVOKE_COMMAND} init --from <id>${named}' with an id from ${EDITOR_URL}`;
+  return `'${CLI_INVOKE_COMMAND} uninstall${providerArgument(providerToName)}' from '${scopeRoot}', which still works on a config it cannot read, then '${CLI_INVOKE_COMMAND} init --from <id>${providerArgument(initProviderToName)}' with an id from ${EDITOR_URL}`;
 }
 function providerArgument(provider) {
-  return provider === void 0 ? "" : ` --provider ${provider}`;
+  if (provider === void 0) return "";
+  return ` --provider ${typeof provider === "string" ? provider : `<${provider.join("|")}>`}`;
 }
-function configUnreadableError(configLoadFailure2) {
+function configUnreadableError(configLoadFailure3) {
   return [
-    configLoadFailure2,
+    configLoadFailure3,
     "This is the marketplace's own config rather than an installation's, so it is fixed in the marketplace repository it comes from."
   ].join("\n");
 }
@@ -1281,17 +1303,8 @@ function unmarkedAgentsKept(agentsDir2, count) {
   const object = count === 1 ? "it" : "them";
   return `Kept ${plural(count, "agent")} in ${agentsDir2}/ \u2014 no ${DEFAULT_PLUGIN_NAME} marker, so this CLI did not compile ${object}.`;
 }
-var UNINSTALL_PLAN = {
-  PREVIEW_HEADING: "The following will be removed:",
-  PLUGINS_HEADING: "Plugins:",
-  CLI_MANAGED_FILES_HEADING: "CLI-managed files:",
-  CONFIG_HEADING: "Config:"
-};
-function localSkillsRemoval(skillsDir2) {
-  return `${skillsDir2}/ (matching the marketplace)`;
-}
-function compiledAgentsRemoval(agentsDir2) {
-  return `${agentsDir2}/ (CLI-compiled)`;
+function configFileRemoved(filePath) {
+  return `- ${filePath}`;
 }
 function scopeNoun(kind) {
   return kind === "project" ? "this project" : "the global installation";
@@ -1305,8 +1318,8 @@ function sentenceCase(text) {
 function layoutIsCurrent(label, to) {
   return `${label} is on ${to}/`;
 }
-function retiredSourceFolderUnsupported(replacement) {
-  return `${RETIRED_SOURCE_FOLDER}/ is no longer supported (agents-inc now serves Claude and Codex). Move it to ${replacement}/.`;
+function retiredSourceFolderUnsupported(root) {
+  return `${path3.join(root, RETIRED_SOURCE_FOLDER)}/ is no longer supported (agents-inc now serves Claude and Codex). Move it to ${path3.join(root, sourceDirName("claude"))}/.`;
 }
 
 // src/cli/types/generated/source-types.ts
@@ -1930,24 +1943,10 @@ function isSkillAssignment(value) {
   return typeof value.id === "string";
 }
 
-// src/cli/utils/typed-object.ts
-function typedEntries(obj) {
-  return Object.entries(obj);
-}
-function typedKeys(obj) {
-  return Object.keys(obj);
-}
-function typedFromEntries(entries) {
-  return Object.fromEntries(entries);
-}
-function typedValues(obj) {
-  return Object.values(obj).filter((value) => value !== void 0);
-}
-
 // src/cli/lib/configuration/config.ts
 import { BlockList, isIPv4 } from "net";
 import os4 from "os";
-import path5 from "path";
+import path6 from "path";
 import { z as z3 } from "zod";
 
 // src/cli/lib/schemas.ts
@@ -1957,11 +1956,11 @@ import { partition } from "remeda";
 // src/cli/lib/schema-validator.ts
 import "zod";
 function formatZodIssue(issue) {
-  const path29 = stripTerminalControls(issue.path.join("."));
+  const path30 = stripTerminalControls(issue.path.join("."));
   if (issue.code === "unrecognized_keys") {
     return `Unrecognized key: "${stripTerminalControls(issue.keys.join('", "'))}"`;
   }
-  return path29 ? `${path29}: ${stripTerminalControls(issue.message)}` : stripTerminalControls(issue.message);
+  return path30 ? `${path30}: ${stripTerminalControls(issue.message)}` : stripTerminalControls(issue.message);
 }
 function formatZodErrors(error) {
   return error.issues.map(formatZodIssue);
@@ -2103,12 +2102,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, path29, ctx) {
+function reportRenamedKeys(record, renames, path30, ctx) {
   for (const [oldKey, newKey] of Object.entries(renames)) {
     if (!(oldKey in record)) continue;
     ctx.addIssue({
       code: "custom",
-      path: [...path29, oldKey],
+      path: [...path30, oldKey],
       message: renamedFieldMessage(oldKey, newKey)
     });
   }
@@ -2426,9 +2425,16 @@ var stackConfigValidationSchema = z2.object({
 function formatZodIssues(issues) {
   return issues.map(formatZodIssue).join("; ");
 }
+var carriedMetadataValidationSchema = customMetadataValidationSchema.extend({
+  displayName: z2.string().min(1),
+  slug: z2.string().regex(KEBAB_CASE_PATTERN).min(1)
+});
 function validateSkillMetadata(rawMetadata) {
-  const schema = isCustomMetadata(rawMetadata) ? customMetadataValidationSchema : metadataValidationSchema;
-  return schema.safeParse(rawMetadata);
+  return metadataSchemaFor(rawMetadata).safeParse(rawMetadata);
+}
+function metadataSchemaFor(raw) {
+  if (!isCustomMetadata(raw)) return metadataValidationSchema;
+  return isCarriedMetadata(raw) ? carriedMetadataValidationSchema : customMetadataValidationSchema;
 }
 function describeMetadataSchemaFailure(issues, rawMetadata) {
   const [absent, malformed] = partition(issues, (issue) => isAbsentField(issue, rawMetadata));
@@ -2479,6 +2485,9 @@ function validateNestingDepth(value, maxDepth) {
 function isCustomMetadata(raw) {
   return isRecord(raw) && raw.custom === true;
 }
+function isCarriedMetadata(raw) {
+  return isRecord(raw) && isRecord(raw.forkedFrom) && typeof raw.forkedFrom.path === "string";
+}
 function warnUnknownFields(parsed, expectedKeys, context) {
   const expectedSet = new Set(expectedKeys);
   const unknownKeys2 = Object.keys(parsed).filter((k) => !expectedSet.has(k));
@@ -2488,11 +2497,11 @@ function warnUnknownFields(parsed, expectedKeys, context) {
 }
 
 // src/cli/lib/configuration/config-loader.ts
-import path3 from "path";
+import path4 from "path";
 import { fileURLToPath } from "url";
 import { createJiti } from "jiti";
-var CONFIG_EXPORTS_PATH = path3.resolve(
-  path3.dirname(fileURLToPath(import.meta.url)),
+var CONFIG_EXPORTS_PATH = path4.resolve(
+  path4.dirname(fileURLToPath(import.meta.url)),
   "../../config-exports.ts"
 );
 var ConfigSchemaError = class extends Error {
@@ -2515,13 +2524,16 @@ var ConfigDefaultExportError = class extends Error {
 };
 var ES_MODULE_MARKER = "__esModule";
 function unwrapDefaultExport(namespace) {
-  if (isRecord(namespace) && namespace.default !== void 0) return namespace.default;
+  if (isRecord(namespace) && "default" in namespace) return namespace.default;
   return namespace;
 }
 function declaresNoDefaultExport(namespace) {
   return isRecord(namespace) && ES_MODULE_MARKER in namespace && !("default" in namespace);
 }
 var NO_VALID_DEFAULT_EXPORT = "the file has no valid default export";
+function configLoadFailure(configPath, reason) {
+  return `Failed to load config from '${configPath}': ${reason}`;
+}
 function exportsNothing(value) {
   return value == null || typeof value === "object" && Object.keys(value).length === 0;
 }
@@ -2539,14 +2551,12 @@ async function loadConfig(configPath, schema) {
   if (declaresNoDefaultExport(namespace)) {
     throw new ConfigDefaultExportError(configPath);
   }
-  if (schema) {
-    const result = schema.safeParse(raw);
-    if (!result.success) {
-      throw new ConfigSchemaError(configPath, formatZodIssues(result.error.issues));
-    }
-    return result.data;
+  if (!schema) return raw;
+  const result = schema.safeParse(raw);
+  if (!result.success) {
+    throw new ConfigSchemaError(configPath, formatZodIssues(result.error.issues));
   }
-  return raw;
+  return result.data;
 }
 async function importConfigModule(configPath) {
   try {
@@ -2557,16 +2567,14 @@ async function importConfigModule(configPath) {
     });
     return await jiti.import(configPath);
   } catch (error) {
-    throw new Error(`Failed to load config from '${configPath}': ${getErrorMessage(error)}`, {
-      cause: error
-    });
+    throw new Error(configLoadFailure(configPath, getErrorMessage(error)), { cause: error });
   }
 }
 
 // src/cli/lib/installation/install-base-dir.ts
-import path4 from "path";
+import path5 from "path";
 function getProjectConfigPath(dir, provider) {
-  return path4.join(sourceFolderInUse(dir, provider).dir, STANDARD_FILES.CONFIG_TS);
+  return path5.join(sourceFolderInUse(dir, provider).dir, STANDARD_FILES.CONFIG_TS);
 }
 function getInstalledConfigPath(dir) {
   return getProjectConfigPath(dir, providerInUse(dir));
@@ -2589,6 +2597,9 @@ function providerToNameAt(root, provider) {
   );
   return besideAnother ? provider : void 0;
 }
+function initProviderToNameAt(root, provider) {
+  return providerToNameAt(root, provider) ?? (isTheProviderOfANewInstallation(provider) ? void 0 : provider);
+}
 
 // src/cli/lib/configuration/config.ts
 var SOURCE_ENV_VAR = "CC_MARKETPLACE";
@@ -2613,8 +2624,11 @@ async function loadSourceConfig(dir, scope, provider) {
 }
 function refuseInstallationConfig(configPath, scope, scopeRoot, provider) {
   const providerToName = providerToNameAt(scopeRoot, provider);
+  const initProviderToName = initProviderToNameAt(scopeRoot, provider);
   return (reason, cause) => new Error(
-    installationConfigsUnreadable([{ configPath, reason, scope, scopeRoot, providerToName }]),
+    installationConfigsUnreadable([
+      { configPath, reason, scope, scopeRoot, providerToName, initProviderToName }
+    ]),
     { cause }
   );
 }
@@ -2638,7 +2652,7 @@ function describesItsOwnFault(error) {
 }
 var unreadableSourceRepoConfig = (reason, cause) => new Error(configUnreadableError(reason), { cause });
 async function readSourceRepoConfig(basePath) {
-  const configPath = path5.join(basePath, SOURCE_ROOT_DIR, STANDARD_FILES.CONFIG_TS);
+  const configPath = path6.join(basePath, SOURCE_ROOT_DIR, STANDARD_FILES.CONFIG_TS);
   if (!await fileExists(configPath)) {
     verbose(`Source config not found at ${configPath}`);
     return { kind: "absent" };
@@ -2902,6 +2916,7 @@ function validateSourceFormat(source, carrier) {
 function validateRemoteSource(source, protocol, carrier) {
   const isHttp = protocol === "https://" || protocol === "http://";
   if (isHttp) refuseCredentials(source, protocol, carrier);
+  refuseLineBreaksAndControls(source, carrier, REMOTE_EXAMPLES);
   const pathAfterProtocol = source.slice(protocol.length).trim();
   if (pathAfterProtocol.length < MIN_REMOTE_PATH_LENGTH) {
     throw refusal(
@@ -3041,16 +3056,18 @@ function validateGitShorthand(source, repoPath, carrier) {
     );
   }
 }
+function refuseLineBreaksAndControls(source, carrier, examples) {
+  const inert = inertLine(source);
+  if (inert === source) return;
+  throw refusal(
+    carrier,
+    `contains invalid characters: "${inert}"`,
+    ["Marketplace values must not contain line breaks or control characters."],
+    examples
+  );
+}
 function validateLocalPath(source, carrier) {
-  const CONTROL_CHAR_PATTERN2 = /[\x00-\x08\x0E-\x1F\x7F]/u;
-  if (CONTROL_CHAR_PATTERN2.test(source)) {
-    throw refusal(
-      carrier,
-      `contains invalid characters: "${source}"`,
-      ["Marketplace paths must not contain control characters."],
-      LOCAL_EXAMPLES
-    );
-  }
+  refuseLineBreaksAndControls(source, carrier, LOCAL_EXAMPLES);
   if (UNC_PATH_PATTERN.test(source)) {
     throw refusal(
       carrier,
@@ -3068,7 +3085,7 @@ function isDefaultSource(source) {
 }
 var packageIdentitySchema = z3.object({ name: z3.string() });
 async function isPublicCatalogueCheckout(basePath) {
-  const raw = await readFileOptional(path5.join(basePath, STANDARD_FILES.PACKAGE_JSON));
+  const raw = await readFileOptional(path6.join(basePath, STANDARD_FILES.PACKAGE_JSON));
   return declaredPackageName(raw) === PUBLIC_CATALOGUE_PACKAGE;
 }
 function declaredPackageName(raw) {
@@ -3099,7 +3116,10 @@ function isLocalSource(source) {
 }
 
 // src/cli/lib/compile-seat.ts
-seatDiagnostics({ warn, verbose });
+seatDiagnostics({
+  warn: (message) => warn(inertLine(message)),
+  verbose: (message) => verbose(inertLine(message))
+});
 
 // ../compile/src/seed-to-config.ts
 import { groupBy, indexBy, isDefined, mapValues, omit as omit2, partition as partition2 } from "remeda";
@@ -3157,7 +3177,16 @@ function brokenUnionLayout(members, bodyIndent) {
 }
 function renderUnionBody(members, layout, bodyIndent) {
   const padding = spaces(bodyIndent);
-  return layout === "indented" ? `${padding}${flatUnion(members)}` : members.map((member) => `${padding}| ${member}`).join("\n");
+  switch (layout) {
+    case "indented":
+      return `${padding}${flatUnion(members)}`;
+    case "stacked":
+      return members.map((member) => `${padding}| ${member}`).join("\n");
+    default: {
+      const _exhaustive = layout;
+      return _exhaustive;
+    }
+  }
 }
 function flatUnion(members) {
   return members.join(" | ");
@@ -3205,9 +3234,18 @@ function renderArray(entries, position) {
   return ["[", ...lines, `${spaces(position.indent)}]`].join("\n");
 }
 function renderEntryLine(entry, indent) {
-  if (entry.kind === "comment") return `${spaces(indent)}// ${entry.text}`;
-  if (entry.kind === "source") return `${spaces(indent)}${entry.source},`;
-  return renderValueLine(entry.value, { indent, prefix: "", suffix: "," });
+  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: {
+      const _exhaustive = entry;
+      return _exhaustive;
+    }
+  }
 }
 function renderRecord(record, position) {
   const properties = Object.entries(record);
@@ -3227,11 +3265,27 @@ function propertyPosition(key, indent) {
 function flatArray(entries) {
   const items = [];
   for (const entry of entries) {
-    if (entry.kind === "comment") return void 0;
-    items.push(entry.kind === "source" ? entry.source : flatValue(entry.value));
+    const item = flatEntry(entry);
+    if (item === void 0) return void 0;
+    items.push(item);
   }
   return flatList(items);
 }
+function flatEntry(entry) {
+  switch (entry.kind) {
+    // A `//` line cannot fold onto one line.
+    case "comment":
+      return void 0;
+    case "source":
+      return entry.source;
+    case "value":
+      return flatValue(entry.value);
+    default: {
+      const _exhaustive = entry;
+      return _exhaustive;
+    }
+  }
+}
 function flatValue(value) {
   if (Array.isArray(value)) return flatList(value.map(flatValue));
   if (isKeyedRecord(value)) return flatRecord(value);
@@ -3273,12 +3327,20 @@ var HAND_WRITTEN_FIELDS = [
   "categoriesFile",
   "rulesFile"
 ];
-var EXTRACTED_FIELDS = /* @__PURE__ */ new Set([
+var GLOBAL_IDENTITY_FIELDS = [
+  ...HAND_WRITTEN_FIELDS,
+  "description"
+];
+var EXTRACTED_FIELDS = [
   "skills",
   "agents",
   "stack",
   "selectedDomains"
-]);
+];
+var extractedFields = new Set(EXTRACTED_FIELDS);
+function isExtractedField(key) {
+  return extractedFields.has(key);
+}
 var CANONICAL_FIELD_ORDER = [
   "name",
   "description",
@@ -3479,11 +3541,21 @@ function generateStandaloneConfig(cleaned) {
   });
 }
 function standaloneExportField(key, value, emitted) {
-  if (!EXTRACTED_FIELDS.has(key)) return [renderScalarField(key, value)];
-  if (key === "skills") return [`  skills${emitted.hasSkills ? "" : ": []"},`];
-  if (key === "agents") return [`  agents${emitted.hasAgents ? "" : ": []"},`];
-  if (key === "stack") return emitted.hasStack ? [`  stack,`] : [];
-  return [`  selectedDomains${emitted.hasSelectedDomains ? "" : ": []"},`];
+  if (!isExtractedField(key)) return [renderScalarField(key, value)];
+  switch (key) {
+    case "skills":
+      return [`  skills${emitted.hasSkills ? "" : ": []"},`];
+    case "agents":
+      return [`  agents${emitted.hasAgents ? "" : ": []"},`];
+    case "stack":
+      return emitted.hasStack ? [`  stack,`] : [];
+    case "selectedDomains":
+      return [`  selectedDomains${emitted.hasSelectedDomains ? "" : ": []"},`];
+    default: {
+      const _exhaustive = key;
+      return _exhaustive;
+    }
+  }
 }
 function assembleConfigSource({
   imports,
@@ -3514,7 +3586,7 @@ function buildTypeImports(flags) {
   ].filter((t) => Boolean(t));
 }
 function isCopiedScalarField(key) {
-  return !EXTRACTED_FIELDS.has(key) && key !== "name";
+  return !isExtractedField(key) && key !== "name";
 }
 function resolveProjectName(cleaned) {
   return cleaned.name && cleaned.name !== GLOBAL_CONFIG_NAME ? cleaned.name : DEFAULT_PLUGIN_NAME;
@@ -3560,7 +3632,7 @@ function stackOfAgents(stack, agents) {
 function mergeInlinedScalarFields(cleaned, cleanedGlobal) {
   return Object.entries(
     canonicalizeFieldOrder({
-      ...omit(cleanedGlobal, HAND_WRITTEN_FIELDS),
+      ...omit(cleanedGlobal, GLOBAL_IDENTITY_FIELDS),
       ...cleaned
     })
   ).filter(([key]) => isCopiedScalarField(key));
@@ -4008,9 +4080,9 @@ function seedToInstallSelection(payload, catalog) {
   const rows = installable.flatMap((skill) => assignmentRows(skill, agentMap));
   refuseUnwritableAssignments(rows);
   const placed = rows.filter((row) => row.kind === "placed");
-  const selectedAgents = selectedAgentsOf(placed, agentMap);
+  const carried = new Set(agentsCarriedIn(placed, agentMap));
+  const selectedAgents = withAgentsSkippedSkillsName(carried, skipped, agentMap);
   const skills = installable.map(toSeedSkillConfig);
-  const selected = new Set(selectedAgents);
   return {
     result: {
       skills,
@@ -4036,7 +4108,7 @@ function seedToInstallSelection(payload, catalog) {
     skippedSkillIds: skipped.map(({ skillId }) => skillId),
     skippedAgentNames: skippedAgentNamesOf(agentMap, rows),
     agentsOnlySkippedSkillsCarried: skipped.flatMap(
-      (skill) => agentsOnlyItCarried(skill, agentMap, selected)
+      (skill) => agentsOnlyItCarried(skill, agentMap, carried)
     )
   };
 }
@@ -4046,11 +4118,14 @@ function refuseUnwritableAssignments(rows) {
     throw new Error(unwritableAssignmentsError(unwritable));
   }
 }
-function selectedAgentsOf(placed, agentMap) {
+function agentsCarriedIn(placed, agentMap) {
+  return [...placed.map((row) => row.agent), ...agentsSwitchedOn(agentMap)];
+}
+function withAgentsSkippedSkillsName(carried, skipped, agentMap) {
   return [
     .../* @__PURE__ */ new Set([
-      ...placed.map((row) => row.agent),
-      ...agentsSwitchedOn(agentMap)
+      ...carried,
+      ...skipped.flatMap((skill) => agentsNamedBy(skill, agentMap))
     ])
   ];
 }
@@ -4058,9 +4133,14 @@ function skippedAgentNamesOf(agentMap, rows) {
   const unknownAssignees = rows.filter((row) => row.kind === "unknownAgent").map((row) => row.agentName);
   return [.../* @__PURE__ */ new Set([...agentMap.unknown, ...unknownAssignees])];
 }
-function agentsOnlyItCarried({ skillId, seedSkill }, agentMap, selected) {
-  const agentNames = Object.keys(seedSkill.assignments).filter(isAgentName2).filter((name) => !agentMap.switchedOff.has(name) && !selected.has(name));
-  return agentNames.length === 0 ? [] : [{ skillId, agentNames }];
+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(
+    (name) => !carried.has(name)
+  );
+  return agentNames.length === 0 ? [] : [{ skillId: skill.skillId, agentNames }];
 }
 function readAgentMap(agents) {
   const known = /* @__PURE__ */ new Map();
@@ -4178,10 +4258,10 @@ import { indexBy as indexBy2, omit as omit3, pick, uniqueBy as uniqueBy2 } from
 
 // src/cli/lib/configuration/project-config.ts
 import os5 from "os";
-import path7 from "path";
+import path8 from "path";
 
 // src/cli/lib/stacks/stacks-loader.ts
-import path6 from "path";
+import path7 from "path";
 import { flatMap, groupBy as groupBy2, mapValues as mapValues2, partition as partition3, pipe, unique as unique2, uniqueBy } from "remeda";
 var stacksCache = /* @__PURE__ */ new Map();
 function normalizeAgentConfig(agentConfig) {
@@ -4241,7 +4321,7 @@ async function loadStacks(configDir, stacksFile) {
   const cacheKey = `${configDir}:${resolvedStacksFile}`;
   const cached = stacksCache.get(cacheKey);
   if (cached) return cached;
-  const stacksPath = path6.join(configDir, resolvedStacksFile);
+  const stacksPath = path7.join(configDir, resolvedStacksFile);
   try {
     const raw = await loadConfig(stacksPath, stacksConfigSchema);
     if (raw == null) {
@@ -4278,16 +4358,16 @@ async function loadStackById(stackId, configDir, source) {
     );
     return null;
   }
-  const defaultStack = defaultStacks.find((s) => s.id === stackId) ?? null;
-  if (defaultStack) {
-    verbose(`Found default stack: ${defaultStack.name} (${stackId})`);
-  } else {
+  const defaultStack = defaultStacks.find((s) => s.id === stackId);
+  if (!defaultStack) {
     verbose(`Stack '${stackId}' not found in the default marketplace or the built-ins`);
+    return null;
   }
+  verbose(`Found default stack: ${defaultStack.name} (${stackId})`);
   return defaultStack;
 }
 function stackNotOfferedMessage(stackId, source) {
-  return `Stack '${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.`;
+  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 defaultUsageGuidance(category) {
   return `Use when working with ${category}.`;
@@ -4327,6 +4407,7 @@ var ConfigLoadError = class extends Error {
     this.name = "ConfigLoadError";
     this.scope = isHomeDirectory(scopeRoot) ? "global" : "project";
     this.providerToName = providerToNameAt(scopeRoot, provider);
+    this.initProviderToName = initProviderToNameAt(scopeRoot, provider);
   }
   configPath;
   reason;
@@ -4334,6 +4415,8 @@ var ConfigLoadError = class extends Error {
   scope;
   /** Named with `--provider` in a remedy handed out for this installation; beside another only. */
   providerToName;
+  /** Named in the remedy's `init --from` half, which a bare run would answer with another one. */
+  initProviderToName;
 };
 async function loadProjectConfigFromDir(projectDir, provider) {
   return loadProjectConfigAt(getProjectConfigPath(projectDir, provider), projectDir, provider);
@@ -4372,7 +4455,7 @@ function asProjectConfig(parsed, projectDir) {
   const normalizedStack = parsed.stack ? normalizeStackRecord(parsed.stack) : void 0;
   return {
     ...parsed,
-    name: parsed.name ?? path7.basename(projectDir),
+    name: parsed.name ?? path8.basename(projectDir),
     skills: parsed.skills ?? [],
     agents: parsed.agents ?? [],
     ...normalizedStack && { stack: normalizedStack }
@@ -4395,10 +4478,10 @@ function configDirsInPlay(projectDir) {
   return isHomeDirectory(projectDir) ? [projectDir] : [projectDir, os5.homedir()];
 }
 async function findConfigLoadFailures(projectDir) {
-  const outcomes = await Promise.all(configDirsInPlay(projectDir).map(configLoadFailure));
+  const outcomes = await Promise.all(configDirsInPlay(projectDir).map(configLoadFailure2));
   return outcomes.filter((failure) => failure !== void 0);
 }
-async function configLoadFailure(dir) {
+async function configLoadFailure2(dir) {
   try {
     await loadInstalledConfig(dir);
     return void 0;
@@ -4411,10 +4494,8 @@ async function loadProjectConfig(projectDir) {
   const provider = providerInUse(projectDir);
   const projectResult = await loadProjectConfigFromDir(projectDir, provider);
   if (projectResult) return projectResult;
-  if (!isHomeDirectory(projectDir)) {
-    return loadProjectConfigFromDir(os5.homedir(), provider);
-  }
-  return null;
+  if (isHomeDirectory(projectDir)) return null;
+  return loadProjectConfigFromDir(os5.homedir(), provider);
 }
 function validateProjectConfig(config) {
   const result = projectConfigLoaderSchema.safeParse(config);
@@ -4499,7 +4580,6 @@ function mergeConfigs(newConfig, existingConfig, options) {
   }
   return merged;
 }
-var GLOBAL_IDENTITY_FIELDS = [...HAND_WRITTEN_FIELDS, "description"];
 function existingConfigForMerge(loaded, projectDir, ownName) {
   const isProjectsOwnFile = loaded.configPath === getProjectConfigPath(projectDir, loaded.provider);
   if (isProjectsOwnFile) return loaded.config;
@@ -4521,13 +4601,13 @@ async function mergeWithExistingConfig(newConfig, context) {
 }
 
 // src/cli/lib/skills/skill-metadata.ts
-import path9 from "path";
+import path10 from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 
 // src/cli/lib/versioning.ts
 import { createHash } from "crypto";
 import { readFile as readFileBytes } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 var ISO_DATE_LENGTH = 10;
 function getCurrentDate() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, ISO_DATE_LENGTH);
@@ -4544,18 +4624,18 @@ async function computeFileHash(filePath) {
 async function computeSkillFolderHash(skillPath) {
   const contents = [];
   for (const fileName of SKILL_CONTENT_FILES) {
-    const filePath = path8.join(skillPath, fileName);
+    const filePath = path9.join(skillPath, fileName);
     if (await fileExists(filePath)) {
       const content = await readFile(filePath);
       contents.push(`${fileName}:${content}`);
     }
   }
   for (const dirName of SKILL_CONTENT_DIRS) {
-    const dirPath = path8.join(skillPath, dirName);
+    const dirPath = path9.join(skillPath, dirName);
     if (await fileExists(dirPath)) {
       const files = await glob("**/*", dirPath);
       for (const file of files.sort()) {
-        const filePath = path8.join(dirPath, file);
+        const filePath = path9.join(dirPath, file);
         const content = await readFile(filePath);
         contents.push(`${dirName}/${file}:${content}`);
       }
@@ -4576,21 +4656,6 @@ function bumpMajorVersion(version) {
   const major = parseMajorVersion(version);
   return `${major + 1}.0.0`;
 }
-async function readExistingPluginManifest(pluginDir, getManifestPath) {
-  const manifestPath = getManifestPath(pluginDir);
-  if (!await fileExists(manifestPath)) {
-    return null;
-  }
-  try {
-    const version = await readManifestVersion(manifestPath);
-    const hashFilePath = contentHashFileBeside(manifestPath);
-    const contentHash = await fileExists(hashFilePath) ? (await readFile(hashFilePath)).trim() : void 0;
-    return { version, contentHash };
-  } catch (error) {
-    warn(`Failed to read plugin manifest at '${manifestPath}': ${getErrorMessage(error)}`);
-    return null;
-  }
-}
 async function readManifestVersion(manifestPath) {
   const content = await readFileSafe(manifestPath, MAX_PLUGIN_FILE_SIZE);
   return pluginManifestSchema.parse(JSON.parse(content)).version ?? DEFAULT_VERSION;
@@ -4599,7 +4664,7 @@ async function computeBytesHash(filePath) {
   return createHash("sha256").update(await readFileBytes(filePath)).digest("hex");
 }
 async function describeShippedFile(pluginDir, file) {
-  return `${file}\0${await computeBytesHash(path8.join(pluginDir, file))}\0`;
+  return `${file}\0${await computeBytesHash(path9.join(pluginDir, file))}\0`;
 }
 async function computeShippedHash(pluginDir) {
   const files = await glob("**/*", pluginDir, { dot: true });
@@ -4620,25 +4685,6 @@ function versionAfterRebuild(earlier, shippedHash) {
   if (!earlier) return DEFAULT_VERSION;
   return earlier.shippedHash === shippedHash ? earlier.version : bumpMajorVersion(earlier.version);
 }
-async function determinePluginVersion(newHash, pluginDir, getManifestPath) {
-  const existing = await readExistingPluginManifest(pluginDir, getManifestPath);
-  if (!existing) {
-    return {
-      version: DEFAULT_VERSION,
-      contentHash: newHash
-    };
-  }
-  if (existing.contentHash !== newHash) {
-    return {
-      version: bumpMajorVersion(existing.version),
-      contentHash: newHash
-    };
-  }
-  return {
-    version: existing.version,
-    contentHash: newHash
-  };
-}
 async function writeContentHash(pluginDir, contentHash, getManifestPath) {
   await writeFile(contentHashFileBeside(getManifestPath(pluginDir)), contentHash);
 }
@@ -4662,7 +4708,7 @@ async function readForkedFromMetadata(skillDir) {
   return metadata?.forkedFrom ?? null;
 }
 async function readLocalSkillMetadata(skillDir) {
-  const metadataPath = path9.join(skillDir, STANDARD_FILES.METADATA_YAML);
+  const metadataPath = path10.join(skillDir, STANDARD_FILES.METADATA_YAML);
   if (!await fileExists(metadataPath)) {
     return null;
   }
@@ -4680,7 +4726,7 @@ async function readLocalSkillMetadata(skillDir) {
   return result.data;
 }
 async function injectForkedFromMetadata(destPath, skillId, contentHash, origin = {}) {
-  const metadataPath = path9.join(destPath, STANDARD_FILES.METADATA_YAML);
+  const metadataPath = path10.join(destPath, STANDARD_FILES.METADATA_YAML);
   const rawContent = await readFile(metadataPath);
   const { yamlContent } = stripYamlSchemaComment(rawContent);
   const metadata = {
@@ -4718,7 +4764,7 @@ function existingMetadataFields(yamlContent, metadataPath) {
 }
 
 // src/cli/lib/skills/skill-copier.ts
-import path10 from "path";
+import path11 from "path";
 var NULL_BYTE_PATTERN2 = /\0/;
 function validateSkillPath(resolvedPath, expectedParent, skillPath) {
   if (NULL_BYTE_PATTERN2.test(skillPath)) {
@@ -4726,26 +4772,26 @@ function validateSkillPath(resolvedPath, expectedParent, skillPath) {
   }
   if (!isPathWithin(resolvedPath, expectedParent)) {
     throw new Error(
-      `Invalid skill path: '${skillPath}' escapes expected directory '${path10.resolve(expectedParent)}'`
+      `Invalid skill path: '${skillPath}' escapes expected directory '${path11.resolve(expectedParent)}'`
     );
   }
 }
 function resolveSkillPath(basePath, skillPath) {
-  const resolved = path10.join(basePath, skillPath);
+  const resolved = path11.join(basePath, skillPath);
   validateSkillPath(resolved, basePath, skillPath);
   return resolved;
 }
 function getSkillSourcePath(skill, rootDir) {
-  const srcDir = path10.join(rootDir, SOURCE_SRC_DIR);
+  const srcDir = path11.join(rootDir, SOURCE_SRC_DIR);
   return resolveSkillPath(srcDir, skill.path);
 }
 async function generateSkillHash(skillSourcePath) {
-  const skillMdPath = path10.join(skillSourcePath, STANDARD_FILES.SKILL_MD);
+  const skillMdPath = path11.join(skillSourcePath, STANDARD_FILES.SKILL_MD);
   return computeFileHash(skillMdPath);
 }
 async function copySkillTo(skill, sourcePath, destPath, source) {
   const contentHash = await generateSkillHash(sourcePath);
-  await ensureDir(path10.dirname(destPath));
+  await ensureDir(path11.dirname(destPath));
   await copy(sourcePath, destPath);
   await injectForkedFromMetadata(destPath, skill.id, contentHash, {
     ...source !== void 0 && { source }
@@ -4812,7 +4858,7 @@ async function copySelectedSkill(skillId, localSkillsDir, sourceResult, selected
     return copySkillToLocalFlattened(skill, localSkillsDir, sourceResult);
   }
   const destPath = getFlattenedSkillDestPath(skill, localSkillsDir);
-  if (path10.resolve(localPath) === path10.resolve(destPath)) {
+  if (path11.resolve(localPath) === path11.resolve(destPath)) {
     return resolveLocalCopiedSkill(skill, localPath);
   }
   return copyLocalSkillTo(skill, localPath, destPath);
@@ -4825,33 +4871,33 @@ function localPathOf(skill) {
 }
 async function copyLocalSkillTo(skill, localPath, destPath) {
   const contentHash = await generateSkillHash(localPath);
-  await ensureDir(path10.dirname(destPath));
+  await ensureDir(path11.dirname(destPath));
   await copy(localPath, destPath);
   return { skillId: skill.id, sourcePath: localPath, destPath, contentHash };
 }
 
 // src/cli/lib/skills/skill-plugin-compiler.ts
-import path23 from "path";
+import path24 from "path";
 import { parse as parseYaml4 } from "yaml";
 
 // src/cli/lib/plugins/plugin-manifest.ts
-import path12 from "path";
+import path13 from "path";
 
 // src/cli/lib/plugins/plugin-finder.ts
 import os6 from "os";
-import path11 from "path";
+import path12 from "path";
 function getUserPluginsDir() {
-  return path11.join(os6.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR);
+  return path12.join(os6.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR);
 }
 function getProjectPluginsDir(projectDir) {
   const dir = projectDir ?? process.cwd();
-  return path11.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR);
+  return path12.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR);
 }
 function getPluginAgentsDir(pluginDir) {
-  return path11.join(pluginDir, STANDARD_DIRS.AGENTS);
+  return path12.join(pluginDir, STANDARD_DIRS.AGENTS);
 }
 function getPluginManifestPath(pluginDir) {
-  return path11.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+  return path12.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
 }
 async function readPluginManifest(pluginDir) {
   const manifestPath = getPluginManifestPath(pluginDir);
@@ -4906,7 +4952,7 @@ function generateAgentPluginManifest(options) {
 }
 async function writePluginManifest(outputDir, manifest) {
   const manifestPath = getPluginManifestPath(outputDir);
-  await ensureDir(path12.dirname(manifestPath));
+  await ensureDir(path13.dirname(manifestPath));
   const content = JSON.stringify(manifest, null, 2);
   await writeFile(manifestPath, content);
   return manifestPath;
@@ -4921,12 +4967,24 @@ function parseMarketplacePluginRef(ref) {
   return separator === -1 ? ref : ref.slice(0, separator);
 }
 
+// src/cli/lib/plugins/earlier-build.ts
+async function isEarlierBuild(pluginDir) {
+  return fileExists(getPluginManifestPath(pluginDir));
+}
+async function holdsContentNoBuildMade(pluginDir) {
+  if (await isEarlierBuild(pluginDir)) return false;
+  return !await isDirectoryEmpty(pluginDir);
+}
+async function clearEarlierBuild(pluginDir) {
+  if (await isEarlierBuild(pluginDir)) await remove(pluginDir);
+}
+
 // src/cli/lib/plugins/plugin-info.ts
 import { readdir } from "fs/promises";
 
 // src/cli/lib/installation/installation.ts
 import os7 from "os";
-import path13 from "path";
+import path14 from "path";
 var INSTALL_MODE_LABELS = {
   plugin: "Plugin",
   mixed: "Mixed",
@@ -4965,7 +5023,7 @@ async function detectInstallationInDir(dir, scope) {
     configPath,
     agentsDir: agentsDir(provider, scope, dir),
     // Mixed mode uses the local skills dir, as eject does.
-    skillsDir: path13.join(
+    skillsDir: path14.join(
       dir,
       CLAUDE_DIR,
       mode === "plugin" ? PLUGINS_SUBDIR : STANDARD_DIRS.SKILLS
@@ -4995,12 +5053,12 @@ async function detectInstallation(projectDir = process.cwd()) {
 
 // src/cli/lib/installation/local-installer.ts
 import os10 from "os";
-import path17 from "path";
+import path18 from "path";
 import { unique as unique4 } from "remeda";
 
 // src/cli/lib/loading/loader.ts
 import { parse as parseYaml3 } from "yaml";
-import path14 from "path";
+import path15 from "path";
 
 // src/cli/utils/frontmatter.ts
 import { parse as parseYaml2 } from "yaml";
@@ -5073,7 +5131,7 @@ async function loadAgentsFromDir(agentsDir2, sourceRoot, options) {
   return agents;
 }
 async function readAgentDefinition(agentsDir2, file, sourceRoot, options) {
-  const fullPath = path14.join(agentsDir2, file);
+  const fullPath = path15.join(agentsDir2, file);
   try {
     const content = await readFile(fullPath);
     const parsed = agentYamlConfigSchema.safeParse(parseYaml3(content));
@@ -5106,7 +5164,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: path14.dirname(file),
+    path: path15.dirname(file),
     sourceRoot,
     ...options.agentBaseDir ? { agentBaseDir: options.agentBaseDir } : {},
     ...config.domain ? { domain: config.domain } : {},
@@ -5114,7 +5172,7 @@ function toAgentDefinition(config, file, sourceRoot, options) {
   };
 }
 async function loadAllAgents(projectRoot) {
-  return loadAgentsFromDir(path14.join(projectRoot, DIRS.agents), projectRoot, {
+  return loadAgentsFromDir(path15.join(projectRoot, DIRS.agents), projectRoot, {
     includeCustomFlag: true,
     verboseLabel: "agent"
   });
@@ -5128,7 +5186,7 @@ async function loadMergedAgents(sourcePath) {
 }
 async function loadProjectAgents(projectRoot) {
   const sourceFolder = sourceFolderInUse(projectRoot, providerInUse(projectRoot));
-  const projectAgentsDir = path14.join(sourceFolder.dir, STANDARD_DIRS.AGENTS);
+  const projectAgentsDir = path15.join(sourceFolder.dir, STANDARD_DIRS.AGENTS);
   if (!await directoryExists2(projectAgentsDir)) {
     verbose(`No project agents directory at ${projectAgentsDir}`);
     return {};
@@ -5160,19 +5218,19 @@ async function loadSkillsFromDir(skillsDir2, options = {}) {
   return { skills, unusableMetadata };
 }
 function locateSkill(skillsDir2, skillFile, pathPrefix) {
-  const skillMdPath = path14.join(skillsDir2, skillFile);
-  const skillDir = path14.dirname(skillMdPath);
-  const relativePath = path14.relative(skillsDir2, skillDir);
+  const skillMdPath = path15.join(skillsDir2, skillFile);
+  const skillDir = path15.dirname(skillMdPath);
+  const relativePath = path15.relative(skillsDir2, skillDir);
   return {
     skillFile,
     skillMdPath,
     skillDir,
-    skillDirName: path14.basename(skillDir),
+    skillDirName: path15.basename(skillDir),
     displayPath: pathPrefix ? `${pathPrefix}/${relativePath}/` : `${relativePath}/`
   };
 }
 async function judgeSkillMetadata(skill) {
-  const metadataPath = path14.join(skill.skillDir, STANDARD_FILES.METADATA_YAML);
+  const metadataPath = path15.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.`
@@ -5214,7 +5272,7 @@ async function readSkillDefinition(skill) {
   }
 }
 async function loadPluginSkills(pluginDir) {
-  const { skills } = await loadSkillsFromDir(path14.join(pluginDir, "skills"), {
+  const { skills } = await loadSkillsFromDir(path15.join(pluginDir, "skills"), {
     pathPrefix: "skills",
     requireMetadata: false
   });
@@ -5222,13 +5280,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 { readFileSync } from "fs";
+import { rename, stat } from "fs/promises";
 import { downloadTemplate } from "giget";
 import os8 from "os";
-import path16 from "path";
+import path17 from "path";
+import { isDeepEqual } from "remeda";
+import { z as z4 } from "zod";
 
 // src/cli/lib/marketplace-generator.ts
-import path15 from "path";
+import path16 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";
@@ -5260,7 +5323,7 @@ async function generateMarketplace(pluginsDir2, options) {
   const rootWithoutDotSlash = options.pluginRoot.replace(/^\.\//, "");
   for (const manifestFile of manifestFiles) {
     const pluginDirName = pluginDirNameOf(manifestFile);
-    const pluginDir = path15.join(pluginsDir2, pluginDirName);
+    const pluginDir = path16.join(pluginsDir2, pluginDirName);
     const manifest = await readPluginManifest(pluginDir);
     if (!manifest) {
       warn(`Could not read plugin manifest: '${manifestFile}'`);
@@ -5315,17 +5378,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 listed = foreignIds.slice(0, MAX_REPORTED_NAMESPACE_VIOLATIONS).map((id) => `  ${id} -> ${marketplaceName}-${id}`);
-  const unlisted = foreignIds.length - listed.length;
+  const listed2 = foreignIds.slice(0, MAX_REPORTED_NAMESPACE_VIOLATIONS).map((id) => `  ${id} -> ${marketplaceName}-${id}`);
+  const unlisted = foreignIds.length - listed2.length;
   return [
     `Marketplace '${marketplaceName}' ships ${foreignIds.length} skill id(s) outside its own namespace. Every skill id must begin with the marketplace's name:`,
-    ...listed,
+    ...listed2,
     ...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(path15.dirname(outputPath));
+  await ensureDir(path16.dirname(outputPath));
   const content = `${JSON.stringify(marketplace, null, 2)}
 `;
   await writeFile(outputPath, content);
@@ -5343,6 +5406,30 @@ var MAX_NAME_LENGTH = 200;
 var QUOTED_NAME_LENGTH = 50;
 var SOURCE_PROTO_RE = /^([\w-.]+):/;
 var GIT_URI_RE = /^(?<repo>[\w.-]+\/[\w.-]+)(?<subdir>[^#]+)?(?<ref>#[\w./@-]+)?/;
+var MarketplaceUnreachableError = class extends Error {
+  constructor(source, reason) {
+    super(`Could not reach ${source}: ${reason}`);
+    this.source = source;
+    this.reason = reason;
+    this.name = "MarketplaceUnreachableError";
+  }
+  source;
+  reason;
+};
+var TarballWithheldError = class extends Error {
+  constructor({ status, statusText }) {
+    super(`the marketplace answered ${status} ${statusText}`.trimEnd());
+    this.name = "TarballWithheldError";
+  }
+};
+var marketplaceMustAnswer = new AsyncLocalStorage3();
+function askingEachMarketplaceItself(body) {
+  const differingCopiesReplaced = /* @__PURE__ */ new Set();
+  return marketplaceMustAnswer.run(differingCopiesReplaced, () => body(differingCopiesReplaced));
+}
+function mustAnswer() {
+  return marketplaceMustAnswer.getStore() !== void 0;
+}
 function sanitizeSourceForCache(source) {
   const hash = createHash2("sha256").update(source).digest("hex").slice(0, CACHE_HASH_LENGTH);
   const readable = source.replace(/[^a-zA-Z0-9]/g, "-").replace(/--+/g, "-").replace(/^-|-$/g, "").slice(0, CACHE_READABLE_PREFIX_LENGTH);
@@ -5350,7 +5437,7 @@ function sanitizeSourceForCache(source) {
 }
 function getCacheDir(source) {
   const sanitized = sanitizeSourceForCache(source) || "unknown";
-  return path16.join(cacheRoot(), "sources", sanitized);
+  return path17.join(cacheRoot(), "sources", sanitized);
 }
 async function fetchFromSource(source, options = {}) {
   const { subdir } = options;
@@ -5361,8 +5448,8 @@ async function fetchFromSource(source, options = {}) {
   return fetchFromRemoteSource(source, subdir);
 }
 async function fetchFromLocalSource(source, subdir) {
-  const fullPath = subdir ? path16.join(source, subdir) : source;
-  const absolutePath = path16.isAbsolute(fullPath) ? fullPath : path16.resolve(process.cwd(), fullPath);
+  const fullPath = subdir ? path17.join(source, subdir) : source;
+  const absolutePath = path17.isAbsolute(fullPath) ? fullPath : path17.resolve(process.cwd(), fullPath);
   if (!await directoryExists2(absolutePath)) {
     throw new Error(
       `Local marketplace not found: '${absolutePath}'
@@ -5393,8 +5480,10 @@ function getGigetCacheDir(source) {
     return void 0;
   }
   const templateName = uriMatch.groups.repo.replace("/", "-").replace(/[^\da-z-]/gi, "-");
-  const gigetCacheRoot = process.env.XDG_CACHE_HOME ? path16.resolve(process.env.XDG_CACHE_HOME, "giget") : path16.resolve(os8.homedir(), ".cache", "giget");
-  return path16.join(gigetCacheRoot, providerName, templateName);
+  return path17.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");
 }
 async function clearGigetCache(source) {
   const gigetDir = getGigetCacheDir(source);
@@ -5421,25 +5510,26 @@ async function fetchFromRemoteSource(source, subdir) {
       };
     }
     announceRefetch(verdict);
-    await discardCachedCopy(cacheDir, source);
+    if (!mustAnswer()) await discardCachedCopy(cacheDir, source);
   }
-  return downloadFreshCopy(cacheDir, source, fullSource);
+  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);
 }
 async function downloadFreshCopy(cacheDir, source, fullSource) {
-  await ensureDir(path16.dirname(cacheDir));
+  await ensureDir(path17.dirname(cacheDir));
   try {
-    const result = await downloadTemplate(fullSource, {
+    const { result, savedTarball } = await gigetDownload(source, fullSource, {
       dir: cacheDir,
       force: true,
       // Always force when downloading to avoid "already exists" error
       offline: false
     });
     verbose(`Downloaded to: ${result.dir}`);
-    await recordFetchedCopy(cacheDir, result);
+    await recordFetchedCopy(cacheDir, result, savedTarball);
     markCopyCurrentForThisRun(cacheDir);
     return {
       path: result.dir,
@@ -5451,51 +5541,184 @@ async function downloadFreshCopy(cacheDir, source, fullSource) {
     throw createDetailedFetchError(error, source);
   }
 }
+var STAGED_DOWNLOAD_SUFFIX = ".download";
+var ONLY_A_SAVED_COPY_CAME_BACK = "the download failed and only a saved copy came back";
+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));
+  try {
+    const { result, savedTarball } = await downloadStaged();
+    const record = await askAfterTheDownload(result, source);
+    if (savedTarball) await downloadPast(savedTarball, record, downloadStaged, source);
+    const differed = await savedCopyDiffers(cacheDir, staged);
+    await replaceCopy(cacheDir, staged, record);
+    if (differed) differingCopiesReplaced.add(source);
+    markCopyCurrentForThisRun(cacheDir);
+    return { path: cacheDir, fromCache: false, unreachable: false, source: fullSource };
+  } catch (error) {
+    if (error instanceof MarketplaceUnreachableError) throw error;
+    throw createDetailedFetchError(error, source);
+  } finally {
+    await remove(staged);
+  }
+}
+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);
+}
+async function withTarballSetAside(tarball, download) {
+  const record = gigetRecordOf(tarball);
+  await rename(record, setAsideOf(record));
+  await rename(tarball, setAsideOf(tarball));
+  try {
+    await download();
+  } catch (error) {
+    await rename(setAsideOf(tarball), tarball);
+    await rename(setAsideOf(record), record);
+    throw error;
+  }
+  await Promise.all([remove(setAsideOf(tarball)), remove(setAsideOf(record))]);
+}
+function setAsideOf(file) {
+  return `${file}${SET_ASIDE_SUFFIX}`;
+}
+async function savedCopyDiffers(cacheDir, downloaded) {
+  if (!await directoryExists2(cacheDir)) return false;
+  try {
+    return !await holdSameFiles(cacheDir, downloaded);
+  } catch (error) {
+    verbose(`Could not read the saved copy at ${cacheDir}: ${getErrorMessage(error)}`);
+    return true;
+  }
+}
+async function holdSameFiles(left, right) {
+  const [leftFiles, rightFiles] = await Promise.all([everyFileIn(left), everyFileIn(right)]);
+  return isDeepEqual(leftFiles, rightFiles) && leftFiles.every((file) => sameBytesAt(file, left, right));
+}
+var EVERY_FILE = "**/*";
+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)));
+}
+async function replaceCopy(cacheDir, staged, record) {
+  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) } };
+}
+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);
+}
+async function tarballTimes(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)])));
+}
+async function modifiedAt(file) {
+  return await fileExists(file) ? (await stat(file)).mtimeMs : void 0;
+}
+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`);
+}
+function gigetRecordOf(tarball) {
+  return `${tarball}.json`;
+}
+async function etagSavedWith(tarballPath) {
+  const raw = await readFileOptional(gigetRecordOf(tarballPath));
+  const parsed = gigetTarballRecordSchema.safeParse(parseJsonOrUndefined(raw));
+  return parsed.success ? parsed.data.etag : void 0;
+}
+function savedUnder(savedTarball, record) {
+  return savedTarball.etag !== void 0 && savedTarball.etag === record.etag;
+}
 var REVALIDATION_TIMEOUT_MS = 5e3;
 var FETCH_RECORD_SUFFIX = ".etag.json";
 var askedThisRun = /* @__PURE__ */ new Map();
+var askedItselfThisRun = /* @__PURE__ */ new Map();
+function verdictsThisRun() {
+  return mustAnswer() ? askedItselfThisRun : askedThisRun;
+}
 function announceRefetch(verdict) {
   if (verdict === "superseded") {
     log(STATUS_MESSAGES.MARKETPLACE_HAS_NEWER_CONTENT);
   }
 }
 function revalidateCachedCopy(cacheDir, source) {
-  const asked = askedThisRun.get(cacheDir);
+  const verdicts = verdictsThisRun();
+  const asked = verdicts.get(cacheDir);
   if (asked) return asked;
   const verdict = classifyCachedCopy(cacheDir, source);
-  askedThisRun.set(cacheDir, verdict);
+  verdicts.set(cacheDir, verdict);
   return verdict;
 }
 function markCopyCurrentForThisRun(cacheDir) {
-  askedThisRun.set(cacheDir, Promise.resolve("current"));
+  verdictsThisRun().set(cacheDir, Promise.resolve("current"));
 }
 async function classifyCachedCopy(cacheDir, source) {
   const record = await readFetchRecord(cacheDir);
   if (!record) return "unrecorded";
-  if (record.etag === void 0) {
+  if (record.etag === void 0 && !mustAnswer()) {
     verbose(`No ETag was recorded for ${record.tar} \u2014 keeping the cached copy`);
     return "current";
   }
   try {
-    const live = await fetchEtag(record.tar);
-    if (live === void 0) {
-      verbose(`${record.tar} answered without an ETag \u2014 keeping the cached copy`);
-      return "current";
-    }
-    return live === record.etag ? "current" : "superseded";
+    return judgeAnswer(record, await fetchEtag(record.tar));
   } catch (error) {
+    if (error instanceof TarballWithheldError) throw createDetailedFetchError(error, source);
     verbose(`Could not revalidate ${record.tar}: ${getErrorMessage(error)}`);
+    if (mustAnswer()) throw new MarketplaceUnreachableError(source, getErrorMessage(error));
     warn(sourceUnreachableUsingCache(source));
     return "unreachable";
   }
 }
+function judgeAnswer(record, live) {
+  if (movedOn(record, live)) return "superseded";
+  if (mustAnswer()) return "answered";
+  if (live === void 0) {
+    verbose(`${record.tar} answered without an ETag \u2014 keeping the cached copy`);
+  }
+  return "current";
+}
+function movedOn(record, live) {
+  return live !== void 0 && record.etag !== void 0 && live !== record.etag;
+}
 async function fetchEtag(tar) {
   const auth = process.env.GIGET_AUTH;
   const response = await fetch(tar, {
-    method: "HEAD",
+    method: mustAnswer() ? "GET" : "HEAD",
     ...auth && { headers: { Authorization: `Bearer ${auth}` } },
     signal: AbortSignal.timeout(REVALIDATION_TIMEOUT_MS)
   });
+  await response.body?.cancel();
+  if (mustAnswer() && !response.ok) throw new TarballWithheldError(response);
   return response.headers.get("etag") ?? void 0;
 }
 function fetchRecordPath(cacheDir) {
@@ -5511,15 +5734,41 @@ async function readFetchRecord(cacheDir) {
   }
   return parsed.data;
 }
-async function recordFetchedCopy(cacheDir, result) {
-  const tar = result.tar;
-  if (typeof tar !== "string") {
+async function recordFetchedCopy(cacheDir, result, savedTarball) {
+  const tar = tarballOf(result);
+  if (tar === void 0) {
     verbose("No tarball URL came back from the download \u2014 the copy cannot be revalidated");
     return;
   }
-  const etag = await fetchEtag(tar).catch(() => void 0);
-  const record = { tar, ...etag !== void 0 && { etag } };
-  await writeFile(fetchRecordPath(cacheDir), JSON.stringify(record));
+  const etag = savedTarball ? savedTarball.etag : await etagIfAnswered(tar);
+  await writeFile(fetchRecordPath(cacheDir), JSON.stringify(fetchRecord(tar, etag)));
+}
+async function etagIfAnswered(tar) {
+  try {
+    return await fetchEtag(tar);
+  } catch (error) {
+    verbose(`Could not ask ${tar} after the download: ${getErrorMessage(error)}`);
+    return void 0;
+  }
+}
+async function askAfterTheDownload(result, source) {
+  const tar = tarballOf(result);
+  if (tar === void 0) {
+    throw new Error("the download named no tarball to ask the marketplace about");
+  }
+  try {
+    return fetchRecord(tar, await fetchEtag(tar));
+  } catch (error) {
+    if (error instanceof TarballWithheldError) throw error;
+    throw new MarketplaceUnreachableError(source, getErrorMessage(error));
+  }
+}
+function tarballOf(result) {
+  const tar = result.tar;
+  return typeof tar === "string" ? tar : void 0;
+}
+function fetchRecord(tar, etag) {
+  return { tar, ...etag !== void 0 && { etag } };
 }
 function parseJsonOrUndefined(raw) {
   try {
@@ -5824,9 +6073,9 @@ function agentNotFoundError(agentName, agents) {
 }
 function describeAvailableAgents(availableAgents) {
   if (availableAgents.length === 0) return "No agents found in scanned directories";
-  const listed = availableAgents.slice(0, MAX_LISTED_AVAILABLE_AGENTS).join(", ");
+  const listed2 = availableAgents.slice(0, MAX_LISTED_AVAILABLE_AGENTS).join(", ");
   const unlisted = availableAgents.length - MAX_LISTED_AVAILABLE_AGENTS;
-  return unlisted > 0 ? `Available agents: ${listed} (and ${unlisted} more)` : `Available agents: ${listed}`;
+  return unlisted > 0 ? `Available agents: ${listed2} (and ${unlisted} more)` : `Available agents: ${listed2}`;
 }
 function assembleAgentConfig(agentName, definition, agentConfig, resolvedSkills) {
   const model = agentConfig.model ?? definition.model;
@@ -5863,10 +6112,10 @@ function resolveStackProperty(generated, assigned) {
   return generated === void 0 ? void 0 : assigned;
 }
 function resolveDescription(loadedStack, shared) {
-  return loadedStack === null ? shared : loadedStack.description;
+  return shared ?? loadedStack?.description;
 }
 function configNameFor(projectDir) {
-  return isHomeDirectory(projectDir) ? DEFAULT_PLUGIN_NAME : path17.basename(projectDir);
+  return isHomeDirectory(projectDir) ? DEFAULT_PLUGIN_NAME : path18.basename(projectDir);
 }
 async function loadCuratedStack(projectDir, projectStack) {
   const globalStack = isHomeDirectory(projectDir) ? void 0 : await loadGlobalStack();
@@ -6039,12 +6288,12 @@ async function installationIfPresent(candidate) {
 
 // src/cli/lib/hosts/claude-host.ts
 import os12 from "os";
-import path20 from "path";
-import { z as z5 } from "zod";
+import path21 from "path";
+import { z as z6 } from "zod";
 
 // src/cli/utils/exec.ts
 import { spawn } from "child_process";
-import path18 from "path";
+import path19 from "path";
 var MAX_PLUGIN_PATH_LENGTH = 1024;
 var MAX_PLUGIN_NAME_LENGTH = 256;
 var MAX_MARKETPLACE_SOURCE_LENGTH = 1024;
@@ -6052,7 +6301,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 path18.isAbsolute(source) || OPENS_A_RELATIVE_PATH.test(source);
+  return path19.isAbsolute(source) || OPENS_A_RELATIVE_PATH.test(source);
 }
 var CONTROL_CHAR_PATTERN = /[\x00-\x08\x0E-\x1F\x7F]/u;
 function validatePluginPath(pluginPath) {
@@ -6142,28 +6391,28 @@ async function execCommand(command, args, options) {
 }
 
 // src/cli/lib/plugins/plugin-settings.ts
-import path19 from "path";
-import { z as z4 } from "zod";
-var pluginSettingsSchema = z4.object({
+import path20 from "path";
+import { z as z5 } from "zod";
+var pluginSettingsSchema = z5.object({
   // Absent when no plugin is enabled.
-  enabledPlugins: z4.record(z4.string(), z4.unknown()).exactOptional()
+  enabledPlugins: z5.record(z5.string(), z5.unknown()).exactOptional()
 }).passthrough();
 var installationFields = {
-  installPath: z4.string(),
-  version: z4.string(),
-  installedAt: z4.string()
+  installPath: z5.string(),
+  version: z5.string(),
+  installedAt: z5.string()
 };
-var pluginInstallationSchema = z4.discriminatedUnion("scope", [
-  z4.object({ scope: z4.literal("project"), projectPath: z4.string(), ...installationFields }),
-  z4.object({ scope: z4.literal("user"), ...installationFields }),
-  z4.object({ scope: z4.literal("local"), ...installationFields })
+var pluginInstallationSchema = z5.discriminatedUnion("scope", [
+  z5.object({ scope: z5.literal("project"), projectPath: z5.string(), ...installationFields }),
+  z5.object({ scope: z5.literal("user"), ...installationFields }),
+  z5.object({ scope: z5.literal("local"), ...installationFields })
 ]);
-var installedPluginsSchema = z4.object({
-  version: z4.number(),
-  plugins: z4.record(z4.string(), z4.array(pluginInstallationSchema))
+var installedPluginsSchema = z5.object({
+  version: z5.number(),
+  plugins: z5.record(z5.string(), z5.array(pluginInstallationSchema))
 }).passthrough();
 function getInstalledPluginsRegistryPath(pluginsDir2) {
-  return path19.join(pluginsDir2, INSTALLED_PLUGINS_FILE);
+  return path20.join(pluginsDir2, INSTALLED_PLUGINS_FILE);
 }
 async function readRegisteredInstallations(pluginsDir2) {
   const registryPath = getInstalledPluginsRegistryPath(pluginsDir2);
@@ -6196,7 +6445,7 @@ async function listPluginInstallsForProject(pluginsDir2, projectDir) {
   });
 }
 async function getEnabledPluginKeys(projectDir) {
-  const settingsPath = path19.join(projectDir, CLAUDE_DIR, STANDARD_FILES.SETTINGS_JSON);
+  const settingsPath = path20.join(projectDir, CLAUDE_DIR, STANDARD_FILES.SETTINGS_JSON);
   if (!await fileExists(settingsPath)) {
     verbose(`No settings.json found at '${settingsPath}'`);
     return [];
@@ -6264,12 +6513,12 @@ async function isClaudeCLIAvailable(options) {
     return false;
   }
 }
-var marketplaceInfoListSchema = z5.array(
-  z5.object({
-    name: z5.string(),
-    source: z5.string(),
-    repo: z5.string().exactOptional(),
-    path: z5.string().exactOptional()
+var marketplaceInfoListSchema = z6.array(
+  z6.object({
+    name: z6.string(),
+    source: z6.string(),
+    repo: z6.string().exactOptional(),
+    path: z6.string().exactOptional()
   })
 );
 async function claudePluginMarketplaceList(options) {
@@ -6344,7 +6593,7 @@ function namesNothingThere(message) {
   return NOT_INSTALLED_MESSAGES.some((phrase) => message.includes(phrase));
 }
 function claudePluginsRoot(projectDir, options) {
-  if (options?.configDir !== void 0) return path20.join(options.configDir, PLUGINS_SUBDIR);
+  if (options?.configDir !== void 0) return path21.join(options.configDir, PLUGINS_SUBDIR);
   return pluginsDir(CLAUDE, "global", projectDir);
 }
 async function claudeListPlugins(projectDir, options) {
@@ -6379,8 +6628,8 @@ function claudeHost() {
 
 // src/cli/lib/hosts/codex-host.ts
 import os13 from "os";
-import path21 from "path";
-import { z as z6 } from "zod";
+import path22 from "path";
+import { z as z7 } from "zod";
 var CODEX = "codex";
 var PLUGIN_CACHE_SUBDIR = "cache";
 var STANDING_WARNING = /could not create PATH aliases/;
@@ -6443,27 +6692,27 @@ async function readJsonFromCodex(schema, args, options, attempt, askedFrom) {
   }
   return validated.data;
 }
-var marketplaceRegistrySchema = z6.object({
-  marketplaces: z6.array(
-    z6.object({
-      name: z6.string(),
-      marketplaceSource: z6.object({ sourceType: z6.string(), source: z6.string() })
+var marketplaceRegistrySchema = z7.object({
+  marketplaces: z7.array(
+    z7.object({
+      name: z7.string(),
+      marketplaceSource: z7.object({ sourceType: z7.string(), source: z7.string() })
     })
   )
 });
-var pluginListingSchema = z6.object({
-  installed: z6.array(
-    z6.object({
-      pluginId: z6.string(),
-      name: z6.string(),
-      marketplaceName: z6.string(),
-      version: z6.string(),
-      enabled: z6.boolean()
+var pluginListingSchema = z7.object({
+  installed: z7.array(
+    z7.object({
+      pluginId: z7.string(),
+      name: z7.string(),
+      marketplaceName: z7.string(),
+      version: z7.string(),
+      enabled: z7.boolean()
     })
   )
 });
 function codexPluginsRoot(projectDir, options) {
-  if (options?.configDir !== void 0) return path21.join(options.configDir, PLUGINS_SUBDIR);
+  if (options?.configDir !== void 0) return path22.join(options.configDir, PLUGINS_SUBDIR);
   return pluginsDir(CODEX, "global", projectDir);
 }
 async function isCodexCLIAvailable(options) {
@@ -6593,7 +6842,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 = path21.join(pluginsRoot, PLUGIN_CACHE_SUBDIR);
+  const cacheRoot2 = path22.join(pluginsRoot, PLUGIN_CACHE_SUBDIR);
   let installed;
   try {
     installed = await codexPluginListing(options, projectDir);
@@ -6605,7 +6854,7 @@ async function codexPluginsOrUnreadable(projectDir, options) {
     kind: "listed",
     plugins: installed.map((plugin) => ({
       pluginKey: plugin.pluginId,
-      installPath: path21.join(cacheRoot2, plugin.marketplaceName, plugin.name, plugin.version),
+      installPath: path22.join(cacheRoot2, plugin.marketplaceName, plugin.name, plugin.version),
       enabled: plugin.enabled
     }))
   };
@@ -6915,7 +7164,7 @@ function formatInstallationDisplay(info) {
 }
 
 // src/cli/lib/plugins/plugin-validator.ts
-import path22 from "path";
+import path23 from "path";
 
 // src/cli/lib/validation-result.ts
 function validResult() {
@@ -6947,15 +7196,15 @@ async function validatePluginStructure(pluginPath) {
   if (!await directoryExists2(pluginPath)) {
     return invalidResult(`Plugin directory does not exist: ${pluginPath}`);
   }
-  const pluginDir = path22.join(pluginPath, PLUGIN_MANIFEST_DIR);
+  const pluginDir = path23.join(pluginPath, PLUGIN_MANIFEST_DIR);
   if (!await directoryExists2(pluginDir)) {
     errors.push(`Missing ${PLUGIN_MANIFEST_DIR}/ directory`);
   }
-  const manifestPath = path22.join(pluginDir, STANDARD_FILES.PLUGIN_JSON);
+  const manifestPath = path23.join(pluginDir, STANDARD_FILES.PLUGIN_JSON);
   if (!await fileExists(manifestPath)) {
     errors.push(`Missing ${PLUGIN_MANIFEST_DIR}/${STANDARD_FILES.PLUGIN_JSON}`);
   }
-  const readmePath = path22.join(pluginPath, STANDARD_FILES.README_MD);
+  const readmePath = path23.join(pluginPath, STANDARD_FILES.README_MD);
   if (!await fileExists(readmePath)) {
     warnings.push("Missing README.md (recommended for documentation)");
   }
@@ -6998,15 +7247,15 @@ async function validatePluginManifest(manifestPath) {
   if (!manifest.description) {
     warnings.push("Missing description field (recommended for discoverability)");
   }
-  const pluginDir = path22.dirname(path22.dirname(manifestPath));
+  const pluginDir = path23.dirname(path23.dirname(manifestPath));
   if (isNonEmptyString(manifest.skills)) {
-    const skillsPath = path22.join(pluginDir, manifest.skills);
+    const skillsPath = path23.join(pluginDir, manifest.skills);
     if (!await directoryExists2(skillsPath)) {
       errors.push(`Skills path does not exist: ${manifest.skills}`);
     }
   }
   if (isNonEmptyString(manifest.agents)) {
-    const agentsPath = path22.join(pluginDir, manifest.agents);
+    const agentsPath = path23.join(pluginDir, manifest.agents);
     if (!await directoryExists2(agentsPath)) {
       errors.push(`Agents path does not exist: ${manifest.agents}`);
     }
@@ -7075,14 +7324,14 @@ function prefixResult(result, prefix) {
 async function validateEachFile(pluginPath, scannedDir, files, validate) {
   const results = await Promise.all(
     files.map(async (file) => {
-      const filePath = path22.join(scannedDir, file);
-      return prefixResult(await validate(filePath), path22.relative(pluginPath, filePath));
+      const filePath = path23.join(scannedDir, file);
+      return prefixResult(await validate(filePath), path23.relative(pluginPath, filePath));
     })
   );
   return mergeValidationResults(results);
 }
 async function validatePluginSkillFiles(pluginPath, skillsRelPath) {
-  const skillsDir2 = path22.join(pluginPath, skillsRelPath);
+  const skillsDir2 = path23.join(pluginPath, skillsRelPath);
   if (!await directoryExists2(skillsDir2)) return validResult();
   const files = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir2);
   if (files.length === 0) {
@@ -7095,7 +7344,7 @@ async function validatePluginSkillFiles(pluginPath, skillsRelPath) {
   return validateEachFile(pluginPath, skillsDir2, files, validateSkillFrontmatter);
 }
 async function validatePluginAgentFiles(pluginPath, agentsRelPath) {
-  const agentsDir2 = path22.join(pluginPath, agentsRelPath);
+  const agentsDir2 = path23.join(pluginPath, agentsRelPath);
   if (!await directoryExists2(agentsDir2)) return validResult();
   const files = await glob(agentCodec("claude").listGlob, agentsDir2);
   if (files.length === 0) {
@@ -7166,7 +7415,7 @@ async function listPluginDirNames(pluginsDir2) {
   const dirChecks = await Promise.all(
     allDirs.map(async (dirName) => ({
       dirName,
-      isPlugin: await directoryExists2(path22.join(pluginsDir2, dirName, PLUGIN_MANIFEST_DIR))
+      isPlugin: await directoryExists2(path23.join(pluginsDir2, dirName, PLUGIN_MANIFEST_DIR))
     }))
   );
   return dirChecks.filter((c) => c.isPlugin).map((c) => c.dirName);
@@ -7174,7 +7423,7 @@ async function listPluginDirNames(pluginsDir2) {
 async function validateEachPlugin(pluginsDir2, pluginDirs) {
   const results = [];
   for (const pluginName of pluginDirs) {
-    const result = await validatePlugin(path22.join(pluginsDir2, pluginName));
+    const result = await validatePlugin(path23.join(pluginsDir2, pluginName));
     results.push({ name: pluginName, result });
   }
   return results;
@@ -7257,11 +7506,11 @@ function sanitizeSkillName(name) {
   return name.replace(/\+/g, "-");
 }
 function isSingleFolderName(name) {
-  return name !== "" && name !== "." && name !== ".." && path23.basename(name) === name;
+  return name !== "" && name !== "." && name !== ".." && path24.basename(name) === name;
 }
 async function assertClearable(pluginDir, skillPath, skillName) {
-  const skill = `Skill '${path23.basename(skillPath)}'`;
-  const file = `File: ${path23.join(skillPath, STANDARD_FILES.SKILL_MD)}`;
+  const skill = `Skill '${path24.basename(skillPath)}'`;
+  const file = `File: ${path24.join(skillPath, STANDARD_FILES.SKILL_MD)}`;
   if (!isSingleFolderName(skillName)) {
     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}`
@@ -7274,22 +7523,12 @@ async function assertClearable(pluginDir, skillPath, skillName) {
   }
   if (await holdsContentNoBuildMade(pluginDir)) {
     throw new Error(
-      `${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}`
+      `${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}`
     );
   }
 }
-async function isEarlierBuild(pluginDir) {
-  return fileExists(getPluginManifestPath(pluginDir));
-}
-async function holdsContentNoBuildMade(pluginDir) {
-  if (await isEarlierBuild(pluginDir)) return false;
-  return !await isDirectoryEmpty(pluginDir);
-}
-async function clearEarlierBuild(pluginDir) {
-  if (await isEarlierBuild(pluginDir)) await remove(pluginDir);
-}
 async function readPluginSkillMetadata(skillPath) {
-  const metadataPath = path23.join(skillPath, STANDARD_FILES.METADATA_YAML);
+  const metadataPath = path24.join(skillPath, STANDARD_FILES.METADATA_YAML);
   if (!await fileExists(metadataPath)) {
     return null;
   }
@@ -7333,28 +7572,28 @@ This skill is automatically available when installed.
 }
 async function writeSkillFiles(skillPath, pluginSkillDir, skillMdContent) {
   await ensureDir(pluginSkillDir);
-  await writeFile(path23.join(pluginSkillDir, STANDARD_FILES.SKILL_MD), skillMdContent);
+  await writeFile(path24.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 = path23.join(skillPath, fileName);
+    const sourcePath = path24.join(skillPath, fileName);
     if (await fileExists(sourcePath)) {
       const content = await readFile(sourcePath);
-      await writeFile(path23.join(pluginSkillDir, fileName), content);
+      await writeFile(path24.join(pluginSkillDir, fileName), content);
       verbose(`  Copied ${fileName}`);
     }
   }
   for (const dirName of SKILL_CONTENT_DIRS) {
-    const sourceDir2 = path23.join(skillPath, dirName);
+    const sourceDir2 = path24.join(skillPath, dirName);
     if (await fileExists(sourceDir2)) {
-      await copy(sourceDir2, path23.join(pluginSkillDir, dirName));
+      await copy(sourceDir2, path24.join(pluginSkillDir, dirName));
       verbose(`  Copied ${dirName}/`);
     }
   }
 }
 async function readSkillMdToBuild(skillPath) {
-  const dirBasename = path23.basename(skillPath);
-  const skillMdPath = path23.join(skillPath, STANDARD_FILES.SKILL_MD);
+  const dirBasename = path24.basename(skillPath);
+  const skillMdPath = path24.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}`
@@ -7373,7 +7612,7 @@ async function compileSkillPlugin(options) {
   const { skillPath, outputDir, skillName: overrideName } = options;
   const { skillMdContent, frontmatter } = await readSkillMdToBuild(skillPath);
   const skillName = overrideName ?? sanitizeSkillName(frontmatter.name);
-  const pluginDir = path23.join(outputDir, skillName);
+  const pluginDir = path24.join(outputDir, skillName);
   await assertClearable(pluginDir, skillPath, skillName);
   verbose(`Compiling skill plugin: ${skillName} from ${skillPath}`);
   const metadata = await readPluginSkillMetadata(skillPath);
@@ -7390,11 +7629,11 @@ async function compileSkillPlugin(options) {
   await writeContentHash(pluginDir, await computeSkillFolderHash(skillPath), getPluginManifestPath);
   await writeSkillFiles(
     skillPath,
-    path23.join(pluginDir, STANDARD_DIRS.SKILLS, skillName),
+    path24.join(pluginDir, STANDARD_DIRS.SKILLS, skillName),
     skillMdContent
   );
   const readme = generateReadme(skillName, frontmatter);
-  await writeFile(path23.join(pluginDir, STANDARD_FILES.README_MD), readme);
+  await writeFile(path24.join(pluginDir, STANDARD_FILES.README_MD), readme);
   verbose("  Generated README.md");
   const manifest = manifestAt(
     versionAfterRebuild(earlierBuild, await computeShippedHash(pluginDir))
@@ -7412,7 +7651,7 @@ async function compileAllSkillPlugins(skillsDir2, outputDir) {
   const failed = [];
   const skillMdFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir2);
   for (const skillMdFile of skillMdFiles) {
-    const skillPath = path23.join(skillsDir2, path23.dirname(skillMdFile));
+    const skillPath = path24.join(skillsDir2, path24.dirname(skillMdFile));
     try {
       const result = await compileSkillPlugin({
         skillPath,
@@ -7422,7 +7661,7 @@ async function compileAllSkillPlugins(skillsDir2, outputDir) {
       log(`  [OK] ${result.skillName}`);
     } catch (error) {
       const errorMessage = getErrorMessage(error);
-      const dirBasename = path23.basename(skillPath);
+      const dirBasename = path24.basename(skillPath);
       failed.push(dirBasename);
       warn(`Failed to compile skill from '${dirBasename}': ${errorMessage}`);
     }
@@ -7438,16 +7677,23 @@ Compiled ${plural(results.length, "skill plugin")}:`);
 }
 
 // src/cli/lib/skills/local-skill-loader.ts
-import path24 from "path";
-async function discoverLocalSkills(projectDir) {
-  const localSkillsPath = path24.join(projectDir, LOCAL_SKILLS_PATH);
+import path25 from "path";
+function copiedInSkillsAt(root, provider) {
+  const scope = isHomeDirectory(root) ? "global" : "project";
+  return {
+    dir: skillsDir(provider, scope, root),
+    pathPrefix: skillsPathPrefix(provider, scope, root)
+  };
+}
+async function discoverLocalSkills(root, provider = providerInUse(root)) {
+  const { dir: localSkillsPath, pathPrefix } = copiedInSkillsAt(root, provider);
   if (!await directoryExists2(localSkillsPath)) {
     verbose(`Local skills directory not found: ${localSkillsPath}`);
     return null;
   }
   const skillDirs = await listDirectories(localSkillsPath);
   const extracted = await Promise.all(
-    skillDirs.map((skillDirName) => extractLocalSkill(localSkillsPath, skillDirName))
+    skillDirs.map((skillDirName) => extractLocalSkill(localSkillsPath, pathPrefix, skillDirName))
   );
   const skills = extracted.filter((skill) => skill !== null);
   verbose(`Discovered ${plural(skills.length, "local skill")} from ${localSkillsPath}`);
@@ -7456,10 +7702,10 @@ async function discoverLocalSkills(projectDir) {
     localSkillsPath
   };
 }
-async function extractLocalSkill(localSkillsPath, skillDirName) {
-  const skillDir = path24.join(localSkillsPath, skillDirName);
-  const metadataPath = path24.join(skillDir, STANDARD_FILES.METADATA_YAML);
-  const skillMdPath = path24.join(skillDir, STANDARD_FILES.SKILL_MD);
+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);
   if (!await fileExists(metadataPath)) {
     verbose(`Skipping local skill '${skillDirName}': No metadata.yaml found`);
     return null;
@@ -7488,8 +7734,8 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
     verbose(`Skipping local skill '${skillDirName}': invalid SKILL.md frontmatter`);
     return null;
   }
-  const relativePath = `${LOCAL_SKILLS_PATH}/${skillDirName}/`;
-  const absolutePath = path24.join(localSkillsPath, skillDirName) + path24.sep;
+  const relativePath = `${pathPrefix}/${skillDirName}/`;
+  const absolutePath = path25.join(localSkillsPath, skillDirName) + path25.sep;
   const skillId = frontmatter.name;
   const extracted = {
     id: skillId,
@@ -7512,7 +7758,7 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
 }
 
 // src/cli/lib/skills/unresolved-skill-entries.ts
-import path25 from "path";
+import path26 from "path";
 async function findUnusableSavedSkillMetadata(savedSkills, projectDir) {
   const verdicts = await Promise.all(
     savedSkills.map((saved) => unusableMetadataOf(saved, projectDir))
@@ -7531,11 +7777,11 @@ function claimsLocalCopy(saved) {
 }
 function installedMetadataPath(saved, projectDir) {
   const { skillsDir: skillsDir2 } = resolveInstallPaths(projectDir, saved.scope);
-  return path25.join(skillsDir2, saved.id, STANDARD_FILES.METADATA_YAML);
+  return path26.join(skillsDir2, saved.id, STANDARD_FILES.METADATA_YAML);
 }
 
 // src/cli/lib/skills/local-skill-mover.ts
-import path26 from "path";
+import path27 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("\\"));
@@ -7545,8 +7791,8 @@ async function deleteLocalSkill(projectDir, skillId, scope = "project") {
     warn(`Invalid skill ID for deletion: '${skillId}'`);
     return;
   }
-  const skillsDir2 = path26.resolve(resolveInstallPaths(projectDir, scope).skillsDir);
-  const skillPath = path26.resolve(skillsDir2, skillId);
+  const skillsDir2 = path27.resolve(resolveInstallPaths(projectDir, scope).skillsDir);
+  const skillPath = path27.resolve(skillsDir2, skillId);
   if (!isPathWithin(skillPath, skillsDir2)) {
     warn(`Skill ID '${skillId}' resolves outside the skills directory.`);
     return;
@@ -7564,10 +7810,10 @@ async function migrateLocalSkillScope(skillId, fromScope, projectDir) {
     return;
   }
   const toScope = fromScope === "global" ? "project" : "global";
-  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);
+  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);
   if (!isPathWithin(fromPath, fromSkillsDir)) {
     warn(`Skill ID '${skillId}' resolves outside the source skills directory.`);
     return;
@@ -7594,7 +7840,7 @@ async function migrateLocalSkillScope(skillId, fromScope, projectDir) {
 
 // src/cli/lib/matrix/matrix-loader.ts
 import { parse as parseYaml5 } from "yaml";
-import path27 from "path";
+import path28 from "path";
 async function loadSkillCategories(configPath) {
   const data = await loadConfig(configPath, skillCategoriesFileSchema);
   if (!data) {
@@ -7630,20 +7876,21 @@ async function extractAllSkills(skillsDir2) {
   return skills;
 }
 async function extractSkill(skillsDir2, metadataFile) {
-  const skillDir = path27.dirname(metadataFile);
-  const skillMdPath = path27.join(skillsDir2, skillDir, STANDARD_FILES.SKILL_MD);
+  const skillDir = path28.dirname(metadataFile);
+  const skillMdPath = path28.join(skillsDir2, skillDir, STANDARD_FILES.SKILL_MD);
   if (!await fileExists(skillMdPath)) {
     verbose(`Skipping ${metadataFile}: No ${STANDARD_FILES.SKILL_MD} found`);
     return null;
   }
-  const metadata = await readMatrixMetadataOrWarn(metadataFile, path27.join(skillsDir2, metadataFile));
+  const metadata = await readMatrixMetadataOrWarn(metadataFile, path28.join(skillsDir2, metadataFile));
   if (!metadata) return null;
   const frontmatter = parseFrontmatterOrWarn(skillDir, skillMdPath, await readFile(skillMdPath));
   if (!frontmatter) return null;
   if (!metadata.displayName) {
-    throw new Error(
-      `Skill at ${metadataFile} is missing required '${METADATA_KEYS.DISPLAY_NAME}' field in metadata.yaml`
+    warn(
+      `Skipping '${metadataFile}': invalid ${STANDARD_FILES.METADATA_YAML} \u2014 missing required field: ${METADATA_KEYS.DISPLAY_NAME}`
     );
+    return null;
   }
   const skillId = frontmatter.name;
   const extracted = {
@@ -7689,7 +7936,7 @@ function parseFrontmatterOrWarn(skillDir, skillMdPath, skillMdContent) {
   const unreadable = unreadableFrontmatter(skillMdContent);
   if (unreadable !== void 0) {
     warn(
-      `Skipping '${path27.join(skillDir, STANDARD_FILES.SKILL_MD)}': unparseable ${STANDARD_FILES.SKILL_MD} frontmatter at ${skillMdPath} \u2014 ${unreadable}`
+      `Skipping '${path28.join(skillDir, STANDARD_FILES.SKILL_MD)}': unparseable ${STANDARD_FILES.SKILL_MD} frontmatter at ${skillMdPath} \u2014 ${unreadable}`
     );
   }
   return null;
@@ -9580,7 +9827,7 @@ async function loadCatalogue(options) {
     ...catalogue,
     marketplaceSkillIds: new Set(typedKeys(catalogue.matrix.skills))
   };
-  result.matrix = await mergeLocalSkills(result.matrix, resolvedProjectDir);
+  result.matrix = await mergeLocalSkills(result.matrix, resolvedProjectDir, provider);
   await seatGlobalInstallationSkills(result.matrix, source, purpose);
   if (!options.skipExtraSources) {
     await loadSkillsFromAllSources(
@@ -9742,12 +9989,12 @@ function goesOnWithoutManifest(source, purpose) {
 function configuredLabel(sourceConfig) {
   return sourceConfig.marketplace === void 0 ? {} : { marketplace: sourceConfig.marketplace };
 }
-async function mergeLocalSkills(matrix2, projectDir) {
-  const withGlobal = isHomeDirectory(projectDir) ? matrix2 : await mergeDiscoveredLocalSkills(matrix2, os14.homedir(), "global");
-  return mergeDiscoveredLocalSkills(withGlobal, projectDir, "project");
+async function mergeLocalSkills(matrix2, projectDir, provider) {
+  const withGlobal = isHomeDirectory(projectDir) ? matrix2 : await mergeDiscoveredLocalSkills(matrix2, os14.homedir(), "global", provider);
+  return mergeDiscoveredLocalSkills(withGlobal, projectDir, "project", provider);
 }
-async function mergeDiscoveredLocalSkills(matrix2, dir, label) {
-  const discovered = await discoverLocalSkills(dir);
+async function mergeDiscoveredLocalSkills(matrix2, dir, label, provider) {
+  const discovered = await discoverLocalSkills(dir, provider);
   if (!discovered || discovered.skills.length === 0) return matrix2;
   verbose(
     `Found ${discovered.skills.length} ${label} local skill(s) in ${discovered.localSkillsPath}`
@@ -9800,7 +10047,7 @@ async function loadAndMergeFromBasePath(basePath, source) {
   const skillsDirRelPath = sourceProjectConfig?.skillsDir ?? SKILLS_DIR_PATH;
   const stacksRelFile = sourceProjectConfig?.stacksFile;
   const { categories, sourceRules } = await loadSourceTaxonomy(basePath);
-  const skillsDir2 = path28.join(basePath, skillsDirRelPath);
+  const skillsDir2 = path29.join(basePath, skillsDirRelPath);
   verbose(`Skills from source: ${skillsDir2}`);
   const skills = await extractAllSkills(skillsDir2);
   await refuseCatalogueCollisions(basePath, source, skills);
@@ -9823,7 +10070,7 @@ async function loadSourceTaxonomy(basePath) {
   return { categories, sourceRules };
 }
 async function loadSourceCategories(basePath) {
-  const categoriesPath = path28.join(basePath, SKILL_CATEGORIES_PATH);
+  const categoriesPath = path29.join(basePath, SKILL_CATEGORIES_PATH);
   if (!await fileExists(categoriesPath)) return void 0;
   const categories = await loadSkillCategories(categoriesPath);
   verbose(
@@ -9832,7 +10079,7 @@ async function loadSourceCategories(basePath) {
   return categories;
 }
 async function loadSourceRules(basePath) {
-  const rulesPath = path28.join(basePath, SKILL_RULES_PATH);
+  const rulesPath = path29.join(basePath, SKILL_RULES_PATH);
   if (!await fileExists(rulesPath)) return void 0;
   const rules = await loadSkillRules(rulesPath);
   verbose(`Loaded source rules: ${rulesPath}`);
@@ -9847,11 +10094,11 @@ async function refuseCatalogueCollisions(basePath, source, skills) {
   throw new Error(catalogueCollisionError(collidingIds, source));
 }
 function catalogueCollisionError(collidingIds, source) {
-  const listed = collidingIds.slice(0, MAX_REPORTED_COLLISIONS).map((id) => `  ${id}`);
-  const unlisted = collidingIds.length - listed.length;
+  const listed2 = collidingIds.slice(0, MAX_REPORTED_COLLISIONS).map((id) => `  ${id}`);
+  const unlisted = collidingIds.length - listed2.length;
   return [
     `Marketplace '${source}' ships ${collidingIds.length} skill id(s) the public catalogue already owns:`,
-    ...listed,
+    ...listed2,
     ...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");
@@ -9940,7 +10187,7 @@ function declaresCategory(matrix2, category) {
   return category !== LOCAL_PSEUDO_CATEGORY && matrix2.categories[category] !== void 0;
 }
 function undeclaredCategoryRefusal(metadata, category) {
-  const metadataPath = path28.join(metadata.path, STANDARD_FILES.METADATA_YAML);
+  const metadataPath = path29.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) {
@@ -10076,15 +10323,14 @@ export {
   skippedUnknownAgents,
   carriedSkillsWritten,
   SHARED_CONFIG_APPLY,
-  projectCopyRemoved,
-  projectCopyMovedToGlobal,
-  registeredProjectsRewritten,
+  registeredProjectsRecompiled,
   sharedConfigNeedsTerminal,
   nothingInstalledToApplyTo,
   uninstallNeedsTerminal,
   addMarketplaceInTheEditor,
   SHARED_CONFIG_ARRIVALS,
   keptAsInstalledGlobally,
+  subAgentChanged,
   addedToGlobalSubAgents,
   authoredHereKept,
   unplaceableKept,
@@ -10094,11 +10340,10 @@ export {
   uninstallSkillMetadataUnreadable,
   recreateConfigFrom,
   providerArgument,
+  configUnreadableError,
   registeredProjectsUpdateFailed,
   unmarkedAgentsKept,
-  UNINSTALL_PLAN,
-  localSkillsRemoval,
-  compiledAgentsRemoval,
+  configFileRemoved,
   scopeNoun,
   scopeLabel,
   layoutIsCurrent,
@@ -10106,6 +10351,7 @@ export {
   GlobalPairWriteViolation,
   withGateToken,
   assertGateToken,
+  isPathWithin,
   readFile,
   readFileSafe,
   readFileOptional,
@@ -10135,11 +10381,14 @@ export {
   validateSkillMetadata,
   splitMetadataValidationIssues,
   ConfigDefaultExportError,
+  NO_VALID_DEFAULT_EXPORT,
+  configLoadFailure,
   loadConfig,
   getProjectConfigPath,
   getInstalledConfigPath,
   resolveInstallPaths,
   providerToNameAt,
+  initProviderToNameAt,
   isHomeDirectory,
   SOURCE_ENV_VAR,
   readSourceRepoConfig,
@@ -10150,11 +10399,8 @@ export {
   resolvePrimarySourceEntry,
   MarketplaceRefusedError,
   isLocalSource,
-  typedEntries,
-  typedKeys,
-  typedFromEntries,
-  typedValues,
   normalizeStackRecord,
+  loadStackById,
   defaultUsageGuidance,
   resolveAgentConfigToSkills,
   getStackSkillIds,
@@ -10183,11 +10429,12 @@ export {
   flatUnion,
   renderTypeImportLine,
   spaces,
+  EXTRACTED_FIELDS,
   generateConfigSource,
   refuseUnwritableStack,
   generateBlankGlobalConfigSource,
-  typedEntries2,
-  typedKeys2,
+  typedEntries2 as typedEntries,
+  typedKeys2 as typedKeys,
   isScopePairCompatible,
   splitConfigByScope,
   seedToInstallSelection,
@@ -10201,9 +10448,12 @@ export {
   loadSkillsFromDir,
   getCurrentDate,
   computeStringHash,
-  determinePluginVersion,
+  computeShippedHash,
+  readEarlierBuild,
+  versionAfterRebuild,
   writeContentHash,
   readForkedFromMetadata,
+  readLocalSkillMetadata,
   validateSkillPath,
   copySkillsToLocalFlattened,
   getUserPluginsDir,
@@ -10216,6 +10466,8 @@ export {
   writePluginManifest,
   buildMarketplacePluginRef,
   parseMarketplacePluginRef,
+  holdsContentNoBuildMade,
+  clearEarlierBuild,
   getInstallationInfo,
   getInstallationsByProvider,
   formatInstallationDisplay,
@@ -10248,6 +10500,8 @@ export {
   validateSkillIdNamespace,
   writeMarketplace,
   getMarketplaceStats,
+  MarketplaceUnreachableError,
+  askingEachMarketplaceItself,
   MarketplaceNameRefusedError,
   fetchMarketplace,
   isLocalOnlySkill,
@@ -10271,4 +10525,4 @@ export {
   executeMigration,
   keepsGlobalInstall
 };
-//# sourceMappingURL=chunk-3YYHL76L.js.map
+//# sourceMappingURL=chunk-WVFBBZEP.js.map