agents-inc 0.164.0 → 0.166.0

package/dist/commands/edit.js

@@ -3,83 +3,105 @@ import {
   publishSeedConfig,
   seedPayloadForInstallation,
   skillsAuthoredHere
-} from "../chunk-NTF4UXGK.js";
+} from "../chunk-Y47EV74W.js";
 import {
   RemovalPlanConfirm
-} from "../chunk-ZVXGW2IC.js";
-import "../chunk-OZXAJNLA.js";
+} from "../chunk-TODCQFRB.js";
+import {
+  unofferablePlacementsFound
+} from "../chunk-PXWG7KFO.js";
 import {
-  openUrl
-} from "../chunk-7ANJQLPJ.js";
+  arrivalLines,
+  arrivalsByScope,
+  notInstalledGlobally,
+  openUrl,
+  readInstalledGlobal,
+  reconcileSharedConfig,
+  restoreInstalledGlobal,
+  sameAssignments,
+  skillLabel,
+  withUnplaceableAssignees
+} from "../chunk-V3I7VQ7N.js";
 import {
   runWizardSession
-} from "../chunk-RGYDFBCT.js";
-import "../chunk-ECURHW3T.js";
-import "../chunk-AOTCIUGX.js";
-import "../chunk-XHPWTL4I.js";
-import "../chunk-URXIQE7I.js";
-import "../chunk-ARYNOWKF.js";
-import "../chunk-LT5GXEB2.js";
-import "../chunk-QZX7SYKU.js";
-import "../chunk-S63LXWMC.js";
-import "../chunk-DSL66I4N.js";
-import "../chunk-QGUP3QJF.js";
-import "../chunk-6MV4JOCL.js";
-import "../chunk-XATLUKXK.js";
-import "../chunk-V5GLL2JB.js";
-import "../chunk-4VL3CEOS.js";
-import "../chunk-Q4IRRVXK.js";
+} from "../chunk-HHIYT3PI.js";
+import "../chunk-WWIFNPJG.js";
+import "../chunk-RAHSOJQ2.js";
+import "../chunk-DAIEQJIF.js";
+import "../chunk-SCOQ34YM.js";
+import "../chunk-4NDBUJHK.js";
+import "../chunk-2VUYFTUB.js";
+import "../chunk-T6UWJAB3.js";
+import "../chunk-6L75SQZU.js";
+import "../chunk-LFWLEDUG.js";
+import "../chunk-TZ2YJJKK.js";
+import "../chunk-SAYZWCH6.js";
+import "../chunk-PNB3524H.js";
+import "../chunk-XZEVWPX6.js";
+import "../chunk-QHDPLLK6.js";
+import "../chunk-MPTNC32T.js";
 import "../chunk-TSIU7DME.js";
-import "../chunk-XVAQG2CV.js";
+import "../chunk-JOEA52NR.js";
 import {
-  Spinner
-} from "../chunk-ZBPEFQ4G.js";
-import "../chunk-NQXO4LR3.js";
-import "../chunk-J27W6TXS.js";
-import "../chunk-3WVH2CTK.js";
-import "../chunk-YRS3QZP2.js";
+  awaitUnderSpinner
+} from "../chunk-VRXX4D6K.js";
+import "../chunk-SXVHSOTH.js";
+import "../chunk-XQHZPINL.js";
+import "../chunk-JQRJQ4SS.js";
+import "../chunk-TTY6DPJN.js";
 import "../chunk-WTJ3AY33.js";
-import "../chunk-ABAZMMG4.js";
+import "../chunk-WVUDLKIO.js";
 import {
-  fetchSeedConfig,
-  registerExternalSkills,
-  writeExternalSkills
-} from "../chunk-X4SSJZLY.js";
+  fetchSeedConfig
+} from "../chunk-25MPBIK3.js";
 import {
   promptConfirm
-} from "../chunk-JCPANDNR.js";
+} from "../chunk-4AAOOAIN.js";
+import "../chunk-OZXAJNLA.js";
+import {
+  hostCompileNotices
+} from "../chunk-ZXKBERQU.js";
 import {
   applyMigratedGlobalSources,
   compileAgentsAllScopes,
+  compileProjectScope,
   detectProject,
   loadSource,
+  movedGlobalAgentInputs,
   mutateGlobal,
-  normalizeProjectPath,
+  sayCapturedWarnings,
   writeProjectConfig
-} from "../chunk-X37UYIE3.js";
+} from "../chunk-G6UREQ4V.js";
 import {
   copyLocalSkills,
   discoverInstalledSkills,
   removeCompiledAgents,
   uninstallPluginSkills
-} from "../chunk-2CQNPLVF.js";
+} from "../chunk-HWEKHVLE.js";
 import {
   loadAgentDefs
-} from "../chunk-B6FSLXYN.js";
-import "../chunk-JU4ZGJ7A.js";
-import "../chunk-B3Y3QMWI.js";
-import {
-  render
-} from "../chunk-JFLVEFFP.js";
+} from "../chunk-PMJWD27C.js";
+import "../chunk-ZR4YPKXQ.js";
+import "../chunk-GE3WKJ6Q.js";
+import "../chunk-MAWNVT2C.js";
+import "../chunk-JFLVEFFP.js";
 import {
   formatScopeTag
-} from "../chunk-K5ITEA3I.js";
+} from "../chunk-7JNJ52CD.js";
+import {
+  providerFlag,
+  providerNamedBy,
+  refuseAnAmbiguousInstallation
+} from "../chunk-NBXXFIIW.js";
 import {
   BaseCommand,
-  EXIT_CODES
-} from "../chunk-JIERYE6B.js";
-import "../chunk-NKGYKOB7.js";
-import "../chunk-PHCPUQVR.js";
+  EXIT_CODES,
+  carriedSkillsThatDiffer,
+  registerExternalSkills,
+  writeExternalSkills
+} from "../chunk-Y3VIRVVE.js";
+import "../chunk-VAPTVR3J.js";
+import "../chunk-RZDXDMT6.js";
 import {
   ERROR_MESSAGES,
   INCOMPLETE_WORK_RECOVERY,
@@ -88,23 +110,28 @@ import {
   SHARED_CONFIG_APPLY,
   STATUS_MESSAGES,
   agentsNotCompiled,
+  applySharedConfigHere,
   authoredHereKept,
   buildMarketplacePluginRef,
   carriedSkillsWritten,
-  claudePluginInstall,
-  claudePluginUninstall,
   deleteLocalSkill,
   detectMigrations,
   discoverAllPluginSkills,
   ejectCopyFailureError,
   executeMigration,
+  foldLocalSkillIntoGlobal,
   getErrorMessage,
-  globallyInstalledRemoved,
-  installBaseDir,
+  holdsItsOwnInstallation,
+  hostAt,
   isHomeDirectory,
-  loadProjectConfigFromDir,
+  keptAsInstalledGlobally,
+  keptUnassigned,
   localSkillsCopied,
   migrateLocalSkillScope,
+  nothingInstalledToApplyTo,
+  plural,
+  projectCopyRemoved,
+  providerInUse,
   recompileSummary,
   resolveInstallPaths,
   seedToWizardResult,
@@ -112,119 +139,38 @@ import {
   sharedConfigNeedsTerminal,
   skippedUnknownAgents,
   skippedUnknownSkills,
-  toClaudePluginScope,
   unplaceableKept,
-  unresolvedSkillRemovalReasons
-} from "../chunk-XPDVAJDH.js";
+  unresolvedSkillRemovalReasons,
+  wizardNeedsTerminal
+} from "../chunk-A4KDXNOT.js";
 import {
-  getCategoryDomain,
   getSkillById,
   getSkillDisplayName,
   matrix,
-  typedEntries,
   typedKeys
-} from "../chunk-AVK2HEKB.js";
+} from "../chunk-V5WXIM2F.js";
 import {
   CLI_COLORS,
   CLI_INVOKE_COMMAND,
   EDIT_PROJECT_SETUP_FLAG,
+  EDIT_PROJECT_SETUP_MARKETPLACE_FLAG,
   EJECT_SOURCE,
   activeAgentNames,
   activeAgentScopeMap,
   editorConfigUrl,
   formatSourceDisplayName,
   isActiveAt,
-  orderDomains
-} from "../chunk-UITEKY2R.js";
+  isGlobalTombstone
+} from "../chunk-ENGYJCTF.js";
 import "../chunk-OI2H6M5I.js";
 
 // src/cli/commands/edit.tsx
-import os from "os";
 import path from "path";
 import chalk from "chalk";
 import { Flags } from "@oclif/core";
 import { difference, indexBy, partition } from "remeda";
-
-// src/cli/lib/seed/seed-apply.ts
-var NOTHING_KEPT = {
-  authoredSkillIds: [],
-  unplaceableSkillIds: []
-};
-function reconcileSharedConfig(options) {
-  const { decoded, installed } = options;
-  if (!installed) return { result: decoded, kept: NOTHING_KEPT };
-  const keptSkills = skillsToKeep(options, installed);
-  if (keptSkills.length === 0) return { result: decoded, kept: NOTHING_KEPT };
-  return {
-    result: withKeptEntries(decoded, installed, keptSkills),
-    kept: describeKept(options, keptSkills)
-  };
-}
-function skillsToKeep(options, installed) {
-  const named = new Set(options.decoded.skills.map((skill) => skill.id));
-  return installed.skills.filter(
-    (skill) => !skill.excluded && !named.has(skill.id) && mayNotRemove(skill, options)
-  );
-}
-function mayNotRemove(skill, options) {
-  return options.authoredHere.has(skill.id) || options.unplaceable.has(skill.id);
-}
-function describeKept(options, keptSkills) {
-  const idsKeptFor = (reason) => keptSkills.filter((skill) => reasonKept(skill, options) === reason).map((skill) => skill.id);
-  return {
-    authoredSkillIds: idsKeptFor("authored"),
-    unplaceableSkillIds: idsKeptFor("unplaceable")
-  };
-}
-function reasonKept(skill, options) {
-  return options.authoredHere.has(skill.id) ? "authored" : "unplaceable";
-}
-function withKeptEntries(decoded, installed, keptSkills) {
-  return {
-    ...decoded,
-    skills: [...decoded.skills, ...keptSkills],
-    selectedDomains: withKeptDomains(decoded.selectedDomains, keptSkills),
-    ...decoded.assignedStack !== void 0 && {
-      assignedStack: withKeptStackRows(decoded.assignedStack, installed.stack, {
-        keptSkillIds: new Set(keptSkills.map((skill) => skill.id)),
-        survivingAgents: new Set(decoded.selectedAgents)
-      })
-    }
-  };
-}
-function withKeptDomains(selected, keptSkills) {
-  const keptDomains = keptSkills.flatMap((skill) => domainOfSkill(skill.id) ?? []);
-  const missing = keptDomains.filter((domain) => !selected.includes(domain));
-  if (missing.length === 0) return selected;
-  return orderDomains([...selected, ...new Set(missing)]);
-}
-function domainOfSkill(skillId) {
-  const category = matrix.skills[skillId]?.category;
-  return category === void 0 ? void 0 : getCategoryDomain(category);
-}
-function withKeptStackRows(assigned, installedStack, filter) {
-  if (!installedStack) return assigned;
-  const carried = { ...assigned };
-  for (const [agent, agentStack] of typedEntries(installedStack)) {
-    if (!filter.survivingAgents.has(agent)) continue;
-    const rows = keptRowsFor(agentStack, filter.keptSkillIds);
-    if (typedKeys(rows).length === 0) continue;
-    carried[agent] = { ...carried[agent], ...rows };
-  }
-  return carried;
-}
-function keptRowsFor(agentStack, keptSkillIds) {
-  const rows = {};
-  for (const [category, assignments] of typedEntries(agentStack)) {
-    const carried = assignments.filter((assignment) => keptSkillIds.has(assignment.id));
-    if (carried.length > 0) rows[category] = carried;
-  }
-  return rows;
-}
-
-// src/cli/commands/edit.tsx
 import { jsx } from "react/jsx-runtime";
-var RECOMPILE_SUBJECT = "agents";
+var RECOMPILE_SUBJECT = "agent";
 function formatDualScopeTransition(displayName, to) {
   const isAdd = to === "project";
   const prefix = isAdd ? "+" : "-";
@@ -251,6 +197,9 @@ function formatAgentScopeChangeLine(agentName, change, dualScopeAgentTransitions
 function scopeArrow(change) {
   return ` (${formatScopeTag(change.from)} \u2192 ${formatScopeTag(change.to)})`;
 }
+function formatValueChangeLine(subject, change, kind) {
+  return chalk.hex(CLI_COLORS.WARNING)(`  ~ ${subject}`) + chalk.hex(CLI_COLORS.NEUTRAL)(` (${kind}: ${change.from} \u2192 ${change.to})`);
+}
 function loadedSourceLabel(sourceResult) {
   return sourceResult.marketplace ?? sourceResult.sourceConfig.source;
 }
@@ -259,55 +208,73 @@ function resolveEditRoot(installation, cwd, setupRequested) {
   const isGlobal = isHomeDirectory(dir);
   return { dir, isGlobal, isProjectSetup: setupRequested && !isGlobal };
 }
-function globalScopePlan(changes, kept) {
-  const sections = removalSections(changes.removedSkills, changes.removedAgents);
+function sharedConfigPlan(changes, kept) {
+  const dropped = droppedProjectHalves(changes);
+  const skillLines = [
+    ...changes.removedSkills.map(skillLabel),
+    ...dropped.skillIds.map(droppedSkillLine)
+  ];
+  const agentLines = [...changes.removedAgents, ...dropped.agentNames.map(projectCopyRemoved)];
+  const sections = removalSections(skillLines, agentLines);
   return { heading: planHeading(sections), sections, statements: kept };
 }
-function projectScopePlan(changes, kept, installed, otherProjects) {
-  const { here, global } = splitRemovalsByScope(changes, installed);
-  const sections = [
-    ...removalSections(here.skills, here.agents),
-    ...globalRemovalSections(global.skills, global.agents)
-  ];
-  return {
-    heading: planHeading(sections),
-    sections,
-    statements: [...globalReachStatement(global, otherProjects), ...kept]
-  };
-}
-function splitRemovalsByScope(changes, installed) {
-  const isGlobalSkill = (id) => installed.skills.some((skill) => skill.id === id && isActiveAt(skill, "global"));
-  const isGlobalAgent = (name) => installed.agents.some((agent) => agent.name === name && isActiveAt(agent, "global"));
-  const [globalSkills, projectSkills] = partition(changes.removedSkills, isGlobalSkill);
-  const [globalAgents, projectAgents] = partition(changes.removedAgents, isGlobalAgent);
-  return {
-    here: { skills: projectSkills, agents: projectAgents },
-    global: { skills: globalSkills, agents: globalAgents }
-  };
+function droppedSkillLine(skillId) {
+  return projectCopyRemoved(skillLabel(skillId));
 }
 function removalSections(skills, agents) {
   return [
-    { label: SHARED_CONFIG_APPLY.SKILLS_HEADING, items: skills.map(skillLabel) },
-    { label: SHARED_CONFIG_APPLY.AGENTS_HEADING, items: [...agents] }
-  ].filter((section) => section.items.length > 0);
-}
-function globalRemovalSections(skills, agents) {
-  return [
-    { label: SHARED_CONFIG_APPLY.GLOBAL_SKILLS_HEADING, items: skills.map(skillLabel) },
-    { label: SHARED_CONFIG_APPLY.GLOBAL_AGENTS_HEADING, items: [...agents] }
+    { label: SHARED_CONFIG_APPLY.SKILLS_HEADING, items: skills },
+    { label: SHARED_CONFIG_APPLY.AGENTS_HEADING, items: agents }
   ].filter((section) => section.items.length > 0);
 }
-function globalReachStatement(global, otherProjects) {
-  if (global.skills.length === 0 && global.agents.length === 0) return [];
-  return [globallyInstalledRemoved(otherProjects)];
+function droppedProjectHalves(changes) {
+  const droppedSkills = changes.collapsedPairs.filter((pair) => !pair.folded);
+  const droppedAgents = [...changes.agentScopeChanges].filter(
+    ([name, change]) => change.to === "global" && changes.dualScopeAgentTransitions.has(name)
+  );
+  return {
+    skillIds: droppedSkills.map(({ projectHalf }) => projectHalf.id),
+    agentNames: droppedAgents.map(([name]) => name)
+  };
 }
 function planHeading(sections) {
   if (sections.length === 0) return SHARED_CONFIG_APPLY.NOTHING_REMOVED;
   return SHARED_CONFIG_APPLY.PREVIEW_HEADING;
 }
-function skillLabel(skillId) {
-  const displayName = getSkillDisplayName(skillId);
-  return displayName === skillId ? skillId : `${displayName} (${skillId})`;
+function compilesGlobalScope(producer, editRoot, written) {
+  if (editRoot.isGlobal || producer === "wizard") return true;
+  return movedGlobalAgentInputs(written);
+}
+function withReassignments(changes, result, installedStack, editRoot) {
+  const { assignedStack } = result;
+  if (assignedStack === void 0) return { ...changes, reassignedAgents: [] };
+  const ownedHere = (agent) => editRoot.isGlobal || isActiveAt(agent, "project");
+  const countedAsAdded = (agent) => changes.addedAgents.includes(agent.name);
+  const rowsMoved = (agent) => !sameAssignments(assignedStack[agent.name], installedStack?.[agent.name]);
+  const reassigned = result.agentConfigs.filter(
+    (agent) => ownedHere(agent) && !countedAsAdded(agent) && rowsMoved(agent)
+  );
+  return { ...changes, reassignedAgents: reassigned.map((agent) => agent.name) };
+}
+function applyArrivals(changes, result) {
+  const changedSkills = /* @__PURE__ */ new Set([
+    ...changes.addedSkills,
+    ...changes.sourceChanges.keys(),
+    ...changes.scopeChanges.keys()
+  ]);
+  const changedAgents = /* @__PURE__ */ new Set([
+    ...changes.addedAgents,
+    ...changes.agentScopeChanges.keys(),
+    ...changes.tuningChanges.keys(),
+    ...changes.reassignedAgents
+  ]);
+  const dropped = droppedProjectHalves(changes);
+  const skillArrives = (skill) => changedSkills.has(skill.id) && !dropped.skillIds.includes(skill.id);
+  const agentArrives = (agent) => changedAgents.has(agent.name) && !dropped.agentNames.includes(agent.name);
+  return arrivalsByScope(
+    result.skills.filter(skillArrives),
+    result.agentConfigs.filter(agentArrives)
+  );
 }
 function keptStatements(kept) {
   return [...authorshipStatement(kept), ...catalogueStatement(kept)];
@@ -320,9 +287,20 @@ function catalogueStatement(kept) {
   if (kept.unplaceableSkillIds.length === 0) return [];
   return [unplaceableKept(kept.unplaceableSkillIds)];
 }
-function applyAuthority(producer, editRoot) {
-  if (editRoot.isGlobal) return "all";
-  return producer === "shared" ? "all" : "owned";
+function unassignedStatement(unassigned) {
+  if (unassigned.length === 0) return [];
+  return [
+    unassigned.map(({ skillId, agentName, category }) => keptUnassigned(skillId, agentName, category)).join("\n")
+  ];
+}
+function keptAsInstalledStatement(held, revisedCarried) {
+  const skillIds = [...held.keptAsInstalled.skillIds, ...revisedCarried];
+  const { agentNames } = held.keptAsInstalled;
+  if (skillIds.length === 0 && agentNames.length === 0) return [];
+  return [keptAsInstalledGlobally(skillIds, agentNames)];
+}
+function applyAuthority(editRoot) {
+  return editRoot.isGlobal ? "all" : "owned";
 }
 var Edit = class _Edit extends BaseCommand {
   static summary = "Edit skills in the plugin";
@@ -347,14 +325,20 @@ var Edit = class _Edit extends BaseCommand {
       default: false
     }),
     from: Flags.string({
-      description: "Apply a configuration shared from agentsinc.sh by its id, removing whatever it leaves out",
+      description: "Apply a configuration shared from agentsinc.sh by its id, removing whatever it leaves out \u2014 from a project, only the project's own entries",
       helpValue: "<id>"
     }),
     [EDIT_PROJECT_SETUP_FLAG]: Flags.boolean({
       description: "Internal: this run continues an `init` project setup",
       default: false,
       hidden: true
-    })
+    }),
+    [EDIT_PROJECT_SETUP_MARKETPLACE_FLAG]: Flags.string({
+      description: "Internal: the marketplace `init --marketplace` named for that project setup",
+      hidden: true,
+      dependsOn: [EDIT_PROJECT_SETUP_FLAG]
+    }),
+    provider: providerFlag()
   };
   /**
    * The command in two statements: do the work, then answer for it.
@@ -371,11 +355,18 @@ var Edit = class _Edit extends BaseCommand {
   async applyEdit() {
     const { flags } = await this.parse(_Edit);
     const cwd = process.cwd();
-    if (flags.ui && flags.from !== void 0) return this.openSharedInEditor(flags.from);
+    if (flags.ui && flags.from !== void 0) return this.openSharedInEditor(flags.from, cwd);
+    await refuseAnAmbiguousInstallation(
+      cwd,
+      "edit",
+      providerNamedBy(flags.provider),
+      (message) => this.error(message, { exit: EXIT_CODES.INVALID_ARGS })
+    );
     await this.ensureConfigReadable(cwd);
+    await this.refuseUnofferablePlacements(cwd);
     if (flags.ui) return this.openInEditor(cwd);
     const payload = flags.from === void 0 ? null : await this.fetchSharedConfigOrFail(flags.from);
-    const context = await this.loadContextUnderSpinner();
+    const context = await this.loadContextUnderSpinner(flags[EDIT_PROJECT_SETUP_MARKETPLACE_FLAG]);
     const editRoot = resolveEditRoot(context.installation, cwd, flags[EDIT_PROJECT_SETUP_FLAG]);
     await this.ensureSavedSkillsReadable(
       context.projectConfig?.skills ?? [],
@@ -396,26 +387,28 @@ var Edit = class _Edit extends BaseCommand {
       agentConfigs: activeNewAgents
     };
     const filteredOldConfig = context.projectConfig ? { ...context.projectConfig, skills: activeOldSkills, agents: activeOldAgents } : null;
-    const changes = detectConfigChanges(filteredOldConfig, filteredResult, {
-      newSkills: result.skills,
-      oldSkills: context.projectConfig?.skills ?? [],
-      newAgents: result.agentConfigs,
-      oldAgents: context.projectConfig?.agents ?? []
-    });
-    if (selection.producer === "shared") {
-      await this.confirmSharedConfigOrCancel(
-        changes,
-        selection.kept,
-        { skills: activeOldSkills, agents: activeOldAgents },
-        editRoot
-      );
-      await this.writeCarriedSkills(selection.carried);
-    }
-    const authority = applyAuthority(selection.producer, editRoot);
+    const planned = withReassignments(
+      detectConfigChanges(filteredOldConfig, filteredResult, {
+        newSkills: result.skills,
+        oldSkills: context.projectConfig?.skills ?? [],
+        newAgents: result.agentConfigs,
+        oldAgents: context.projectConfig?.agents ?? []
+      }),
+      filteredResult,
+      context.projectConfig?.stack,
+      editRoot
+    );
+    const rewritten = selection.producer === "shared" ? await this.confirmAndWriteCarried(selection, planned, filteredResult) : [];
+    const changes = {
+      ...planned,
+      rewrittenSkills: difference(rewritten, planned.addedSkills)
+    };
+    const authority = applyAuthority(editRoot);
     if (!hasAnyChanges(changes)) {
       this.log(chalk.hex(CLI_COLORS.NEUTRAL)("No changes made."));
       if (!editRoot.isProjectSetup) return;
-      await this.writeConfigAndCompile(result, context, editRoot, authority);
+      await this.writeConfigAndCompile(result, context, editRoot, authority, selection.producer);
+      await this.reportWhatThisHostCannotCarry(editRoot);
       this.logCompletionSummary(changes);
       return;
     }
@@ -445,16 +438,21 @@ var Edit = class _Edit extends BaseCommand {
       context
     );
     await this.applyScopeChanges(changes, filteredResult, context, editRoot);
+    await this.applyCollapsedPairs(changes, filteredResult, context, editRoot);
     await this.applySourceChanges(changes, activeOldSkills, editRoot, migratedSkillIds);
     await this.applyPluginChanges(changes, filteredResult, activeOldSkills, context, editRoot);
     await this.copyNewLocalSkills(changes, filteredResult, context, editRoot);
     await this.removeDeletedLocalSkills(changes, activeOldSkills, editRoot);
-    await this.writeConfigAndCompile(result, context, editRoot, authority);
+    await this.writeConfigAndCompile(result, context, editRoot, authority, selection.producer);
     await this.cleanupStaleAgentFiles(changes, activeOldAgents, editRoot);
+    await this.reportWhatThisHostCannotCarry(editRoot);
     this.logCompletionSummary(changes);
   }
   /** The interactive producer: open the wizard on what is installed, return what was chosen. */
   async selectionFromWizard(context, editRoot) {
+    if (!process.stdin.isTTY) {
+      this.error(wizardNeedsTerminal("edit"), { exit: EXIT_CODES.ERROR });
+    }
     const result = await this.runEditWizard(context, editRoot);
     if (!result) return null;
     return { producer: "wizard", result };
@@ -470,9 +468,12 @@ var Edit = class _Edit extends BaseCommand {
    * catalogue cannot place, because a destructive apply removes on intent and never on its own
    * inability. Both are disclosed in the confirm rather than silently excused.
    *
-   * A globally installed entry is NOT one of them. It is removable from here, and what its scope
-   * changes is who the removal reaches — which the confirm names, rather than this putting the
-   * entry back and calling the reach impossible.
+   * From a project the global install comes back too, whole: it is one installation every project
+   * on the machine reads, so a project run only ADDS to it (owner ruling 2026-10-02). Every global
+   * entry the configuration leaves out is put back as installed, every one it states otherwise is
+   * held as installed and named in the confirm, and only the global entries the global install
+   * lacks arrive — a skill with its rows, on a global sub-agent already there too. At the home
+   * directory the run IS the global install, so nothing is held there.
    */
   async selectionFromSharedConfig(payload, context, editRoot) {
     const { matrix: sourceMatrix } = context.sourceResult;
@@ -482,22 +483,38 @@ var Edit = class _Edit extends BaseCommand {
       sourceMatrix
     );
     this.refuseProjectScopedContentAtHome(result, editRoot.dir);
-    if (skippedSkillIds.length > 0) this.warn(skippedUnknownSkills(skippedSkillIds));
-    if (skippedAgentNames.length > 0) this.warn(skippedUnknownAgents(skippedAgentNames));
+    const unplaceable = new Set(skippedSkillIds);
     const reconciled = reconcileSharedConfig({
-      decoded: result,
+      decoded: withUnplaceableAssignees(result, context.projectConfig, payload, unplaceable),
       installed: context.projectConfig,
       authoredHere: await this.readAuthoredHere(context.projectConfig, editRoot.dir),
-      // The ids the decode above could not place. They are the skips just reported, read as
-      // what STAYS rather than as what did not arrive: the payload named them, so their absence
-      // from the decode is this catalogue's limit and not an instruction to delete anything.
-      unplaceable: new Set(skippedSkillIds)
+      unplaceable
     });
+    const held = restoreInstalledGlobal(
+      reconciled.result,
+      editRoot.isGlobal ? null : await readInstalledGlobal(editRoot.dir)
+    );
+    const arrivingCarried = notInstalledGlobally(carried, held);
+    await this.refuseSharedConfigBeforeAsking(
+      held.result,
+      arrivingCarried,
+      editRoot.dir,
+      context.sourceResult
+    );
+    const heldGlobally = difference(carried, arrivingCarried);
+    const revisedGlobally = await carriedSkillsThatDiffer(heldGlobally);
+    sayCapturedWarnings(context.startupMessages);
+    if (skippedSkillIds.length > 0) this.warn(skippedUnknownSkills(skippedSkillIds));
+    if (skippedAgentNames.length > 0) this.warn(skippedUnknownAgents(skippedAgentNames));
     return {
       producer: "shared",
-      result: reconciled.result,
-      kept: keptStatements(reconciled.kept),
-      carried
+      result: held.result,
+      kept: [
+        ...keptStatements(reconciled.kept),
+        ...unassignedStatement(reconciled.unassigned),
+        ...keptAsInstalledStatement(held, revisedGlobally)
+      ],
+      carried: arrivingCarried
     };
   }
   /**
@@ -521,11 +538,17 @@ var Edit = class _Edit extends BaseCommand {
   /**
    * The id, fetched — or the run refused before it is.
    *
-   * The terminal question is answered first because nothing in the payload can change its
-   * answer: an apply that cannot be confirmed is over before the store is asked, and a refusal
-   * that had already spent a round trip would be describing work it never intended to do.
+   * Two questions are answered first, because nothing in the payload can change either answer:
+   * an apply with nothing to apply to, or that cannot be confirmed, is over before the store is
+   * asked, and a refusal that had already spent a round trip would be describing work it never
+   * intended to do. Whether anything is installed comes before the terminal: the terminal
+   * refusal's way on is this same command from a terminal, which in a folder with nothing
+   * installed would only refuse again.
    */
   async fetchSharedConfigOrFail(id) {
+    if (!await detectProject()) {
+      this.error(nothingInstalledToApplyTo(id), { exit: EXIT_CODES.ERROR });
+    }
     if (!process.stdin.isTTY) {
       this.error(sharedConfigNeedsTerminal(id), { exit: EXIT_CODES.ERROR });
     }
@@ -562,11 +585,20 @@ var Edit = class _Edit extends BaseCommand {
       this.handleError(error);
     }
   }
+  /**
+   * Confirms a shared configuration, then writes the skills it brought with it — answering with
+   * those whose files now read differently.
+   */
+  async confirmAndWriteCarried(selection, planned, result) {
+    await this.confirmSharedConfigOrCancel(planned, selection.kept, applyArrivals(planned, result));
+    return this.writeCarriedSkills(selection.carried);
+  }
   /** Writes the skills the configuration brought with it, and says which they were. */
   async writeCarriedSkills(carried) {
-    if (carried.length === 0) return;
-    await writeExternalSkills(carried);
+    if (carried.length === 0) return [];
+    const rewritten = await writeExternalSkills(carried);
     this.log(carriedSkillsWritten(carried.map((skill) => skill.id)));
+    return rewritten;
   }
   /**
    * Shows what applying this configuration takes away, and stops the run unless a person says
@@ -577,18 +609,15 @@ var Edit = class _Edit extends BaseCommand {
    * honesty: nothing is refused over an entry this run cannot remove, and nothing is silent
    * about one either.
    *
-   * WHICH plan is built is decided here and only here, on the directory the run was started in.
-   * Inside the global installation the scope was chosen and is obvious, so the ordinary confirm
-   * is the whole of the gate; inside a project a global removal reaches projects nobody here is
-   * looking at, so it is shown apart and the reach is named.
+   * Above it go the two lists every `--from` install prints — what the apply adds or changes in
+   * this project, and in the global install — so the question is asked about the whole of what a
+   * yes does, not only about what it takes away.
    */
-  async confirmSharedConfigOrCancel(changes, kept, installed, editRoot) {
-    const plan = editRoot.isGlobal ? globalScopePlan(changes, kept) : projectScopePlan(
-      changes,
-      kept,
-      installed,
-      await this.otherRegisteredProjects(editRoot.dir)
-    );
+  async confirmSharedConfigOrCancel(changes, kept, arrivals) {
+    const plan = sharedConfigPlan(changes, kept);
+    for (const line of arrivalLines(arrivals)) {
+      this.log(line);
+    }
     const outcome = await promptConfirm(({ onConfirm, onCancel }) => /* @__PURE__ */ jsx(
       RemovalPlanConfirm,
       {
@@ -605,25 +634,16 @@ var Edit = class _Edit extends BaseCommand {
     this.error("Cancelled", { exit: EXIT_CODES.CANCELLED });
   }
   /**
-   * Every registered project but this one — the blast radius a global removal actually has.
+   * Refuses a configuration whose own host cannot place what it asks for, before the wizard runs.
    *
-   * Read from the GLOBAL config rather than from `context.projectConfig`: `projects[]` is the
-   * registry the fan-out itself walks, and a project's own config never carries it, so taking
-   * the list from anywhere else would let the confirm name a set the propagation does not.
-   *
-   * Best-effort by nature. The list exists to be DISCLOSED, so a home directory that cannot be
-   * read leaves the disclosure counting nobody rather than failing an apply — and the statement
-   * it produces then is the one that says no other project is registered.
+   * `compile` asks the same question of the same roster and `update` asks it too. `edit` is the
+   * command that REWRITES the file, so letting it through would mean a user curating a
+   * configuration no command will act on — and then saving it back, with the unofferable row
+   * carried forward because nothing on the edit path had any reason to drop it.
    */
-  async otherRegisteredProjects(editRoot) {
-    try {
-      const global = await loadProjectConfigFromDir(os.homedir());
-      const here = normalizeProjectPath(editRoot);
-      return (global?.config.projects ?? []).filter((projectDir) => projectDir !== here);
-    } catch (error) {
-      this.warn(`Could not tell which projects share this install: ${getErrorMessage(error)}`);
-      return [];
-    }
+  async refuseUnofferablePlacements(cwd) {
+    const [finding] = await unofferablePlacementsFound(cwd);
+    if (finding !== void 0) this.error(finding, { exit: EXIT_CODES.ERROR });
   }
   /**
    * The outbound half of the editor round trip: this installation, minted as a configuration
@@ -637,37 +657,37 @@ var Edit = class _Edit extends BaseCommand {
    * Nothing on disk is touched. A configuration is read, not rewritten, so a run that changed
    * anything here would be editing the project on the way to offering to edit it.
    */
+  async openInEditor(projectDir) {
+    const prepared = await seedPayloadForInstallation(projectDir);
+    if (!prepared.ok) {
+      this.error(prepared.error, { exit: EXIT_CODES.ERROR });
+    }
+    this.log(`Opening ${prepared.skills} skill(s) across ${prepared.agents} sub-agent(s)...`);
+    const published = await publishSeedConfig(prepared.payload);
+    if (!published.ok) {
+      this.error(published.error, { exit: EXIT_CODES.ERROR });
+    }
+    await this.handToBrowser(published.id);
+  }
   /**
    * An id somebody shared, opened rather than applied.
    *
    * The counterpart of `openInEditor` above and deliberately not a variant of it: that one MINTS,
    * because an installation is not yet a configuration the store holds. An id already is one, so
-   * there is nothing to publish, nothing to read off disk, and no way for this to fail except the
-   * browser refusing to launch — which is a warning beside a link that still works.
+   * there is nothing to publish, and no way for this to fail except the browser refusing to launch
+   * — which is a warning beside a link that still works.
    *
    * `--from` without `--ui` remains the destructive apply. Looking and applying are the two
    * things a recipient can do with an id, and this is the one that changes nothing.
    */
-  async openSharedInEditor(id) {
+  async openSharedInEditor(id, cwd) {
     const url = editorConfigUrl(id);
     this.log(`Open it at ${url}`);
-    this.log(`To apply it here instead, run '${CLI_INVOKE_COMMAND} edit --from ${id}'.`);
+    this.log(applySharedConfigHere(id, await holdsItsOwnInstallation(cwd)));
     if (!process.stdin.isTTY) return;
     const opened = await openUrl(url);
     if (!opened.ok) this.warn(opened.error);
   }
-  async openInEditor(projectDir) {
-    const prepared = await seedPayloadForInstallation(projectDir);
-    if (!prepared.ok) {
-      this.error(prepared.error, { exit: EXIT_CODES.ERROR });
-    }
-    this.log(`Opening ${prepared.skills} skill(s) across ${prepared.agents} sub-agent(s)...`);
-    const published = await publishSeedConfig(prepared.payload);
-    if (!published.ok) {
-      this.error(published.error, { exit: EXIT_CODES.ERROR });
-    }
-    await this.handToBrowser(published.id);
-  }
   /**
    * The link, printed first and opened second.
    *
@@ -690,25 +710,20 @@ var Edit = class _Edit extends BaseCommand {
     if (!opened.ok) this.warn(opened.error);
   }
   /**
-   * The load below, behind a spinner that comes down whichever way the await ends.
-   *
-   * The cleanup is a `finally` because all three of `loadContext`'s refusals are raised
-   * while this spinner is mounted, and oclif would otherwise paint its error under an Ink
-   * tree still repainting over it. Never a `catch`: the throw reaches oclif untouched, or
-   * both the error rendering and the pinned exit codes change with it.
+   * The load below, behind a spinner that comes down whichever way the await ends — all
+   * three of `loadContext`'s refusals are raised while it is mounted.
    */
-  async loadContextUnderSpinner() {
-    const { unmount, clear: clearSpinner } = render(
-      /* @__PURE__ */ jsx(Spinner, { label: STATUS_MESSAGES.LOADING_SKILLS })
+  async loadContextUnderSpinner(setupMarketplace) {
+    return awaitUnderSpinner(
+      STATUS_MESSAGES.LOADING_SKILLS,
+      () => this.loadContext(setupMarketplace)
     );
-    try {
-      return await this.loadContext();
-    } finally {
-      clearSpinner();
-      unmount();
-    }
   }
-  async loadContext() {
+  /**
+   * @param setupMarketplace - What `init --marketplace` named for the project setup this run
+   *   continues. Absent, the catalogue is the one the installation stored.
+   */
+  async loadContext(setupMarketplace) {
     const detected = await detectProject();
     if (!detected) {
       this.error(ERROR_MESSAGES.NO_INSTALLATION, {
@@ -720,13 +735,17 @@ var Edit = class _Edit extends BaseCommand {
     let sourceResult;
     let startupMessages = [];
     try {
-      const loaded = await loadSource({ projectDir, captureStartupMessages: true });
+      const loaded = await loadSource({
+        projectDir,
+        ...setupMarketplace !== void 0 && { sourceFlag: setupMarketplace },
+        captureStartupMessages: true
+      });
       sourceResult = loaded.sourceResult;
       startupMessages = loaded.startupMessages;
       const sourceInfo = sourceResult.isLocal ? "local" : sourceResult.sourceConfig.sourceOrigin;
       startupMessages.push({
         level: "info",
-        text: `Loaded ${Object.keys(matrix.skills).length} skills (${sourceInfo})`
+        text: `Loaded ${plural(Object.keys(matrix.skills).length, "skill")} (${sourceInfo})`
       });
     } catch (error) {
       this.handleError(error);
@@ -744,7 +763,7 @@ var Edit = class _Edit extends BaseCommand {
       currentSkillIds = [...mergedIds];
       startupMessages.push({
         level: "info",
-        text: `Found ${currentSkillIds.length} installed skills`
+        text: `Found ${plural(currentSkillIds.length, "installed skill")}`
       });
     } catch (error) {
       this.handleError(error);
@@ -755,7 +774,8 @@ var Edit = class _Edit extends BaseCommand {
       projectDir,
       sourceResult,
       startupMessages,
-      currentSkillIds
+      currentSkillIds,
+      ...setupMarketplace !== void 0 && sourceResult.marketplace !== void 0 && { setupMarketplace: sourceResult.marketplace }
     };
   }
   async runEditWizard(context, editRoot) {
@@ -771,7 +791,10 @@ var Edit = class _Edit extends BaseCommand {
         installedSkillIds: currentSkillIds,
         ...projectConfig?.skills !== void 0 && { installedSkillConfigs: projectConfig.skills },
         ...projectConfig?.agents !== void 0 && { installedAgentConfigs: projectConfig.agents },
-        isEditingFromGlobalScope: editRoot.isGlobal
+        isEditingFromGlobalScope: editRoot.isGlobal,
+        ...context.setupMarketplace !== void 0 && {
+          setupMarketplace: context.setupMarketplace
+        }
       },
       props: {
         version: this.config.version,
@@ -840,7 +863,7 @@ var Edit = class _Edit extends BaseCommand {
           loadAgents: async () => (await loadAgentDefs()).agents
         }
       );
-      this.reportPropagatedRecompile(report);
+      this.reportFanOut(report);
     } catch (error) {
       this.reportIncompleteWork(
         `Could not record global origin change: ${getErrorMessage(error)}`,
@@ -858,7 +881,10 @@ var Edit = class _Edit extends BaseCommand {
       scopeChanges,
       agentScopeChanges,
       dualScopeSkillTransitions,
-      dualScopeAgentTransitions
+      dualScopeAgentTransitions,
+      tuningChanges,
+      reassignedAgents,
+      rewrittenSkills
     } = changes;
     this.log(`
 ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
@@ -901,10 +927,26 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
     for (const [agentName, change] of agentScopeChanges) {
       this.log(formatAgentScopeChangeLine(agentName, change, dualScopeAgentTransitions));
     }
+    for (const [agentName, change] of tuningChanges) {
+      this.log(formatValueChangeLine(agentName, change, "agent"));
+    }
+    for (const agentName of reassignedAgents) {
+      this.log(
+        chalk.hex(CLI_COLORS.WARNING)(`  ~ ${agentName}`) + chalk.hex(CLI_COLORS.NEUTRAL)(" (agent: skills reassigned)")
+      );
+    }
+    for (const skillId of rewrittenSkills) {
+      this.log(
+        chalk.hex(CLI_COLORS.WARNING)(`  ~ ${getSkillDisplayName(skillId)}`) + chalk.hex(CLI_COLORS.NEUTRAL)(" (skill: files rewritten)")
+      );
+    }
     this.log("");
   }
-  async applyMigrations(_changes, filteredResult, activeOldSkills, context, editRoot) {
-    const migrationPlan = detectMigrations(activeOldSkills, filteredResult.skills);
+  async applyMigrations(changes, filteredResult, activeOldSkills, context, editRoot) {
+    const migrationPlan = detectMigrations(
+      withMaskedGlobalsRestored(activeOldSkills, changes.collapsedPairs),
+      filteredResult.skills
+    );
     const migratedSkillIds = /* @__PURE__ */ new Set([
       ...migrationPlan.toEject.map((m) => m.id),
       ...migrationPlan.toPlugin.map((m) => m.id)
@@ -915,7 +957,11 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
     }
     if (migrationPlan.toPlugin.length > 0) {
       this.logModeSwitch(migrationPlan.toPlugin.length, INSTALL_MODE_DESCRIPTIONS.plugin);
-      await this.requireMarketplaceOrExit(context.sourceResult, "migrate skills to plugin mode");
+      await this.requireMarketplaceOrExit(
+        context.sourceResult,
+        "migrate skills to plugin mode",
+        hostAt(editRoot.dir)
+      );
       this.announcePluginInstall();
     }
     const migrationResult = await executeMigration(
@@ -961,8 +1007,13 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
   logModeSwitch(count, modeDescription) {
     this.log(chalk.hex(CLI_COLORS.NEUTRAL)(`Switching ${count} skill(s) to ${modeDescription}`));
   }
+  /**
+   * The scope moves this edit made, on disk. A collapsed `[P][G]` pair is not one of them: its
+   * project half is dropped or folded ({@link applyCollapsedPairs}), and moving every collapse is
+   * what wrote a dropped copy over the global install.
+   */
   async applyScopeChanges(changes, filteredResult, context, editRoot) {
-    const { scopeChanges } = changes;
+    const scopeChanges = scopeMovesOf(changes);
     for (const [skillId, change] of scopeChanges) {
       const skillConfig = filteredResult.skills.find((s) => s.id === skillId);
       if (skillConfig?.origin === EJECT_SOURCE) {
@@ -976,7 +1027,8 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
     if (!hasPluginScopeChanges) return;
     const marketplace = await this.requireMarketplaceOrExit(
       context.sourceResult,
-      "migrate plugin skill scopes"
+      "migrate plugin skill scopes",
+      hostAt(editRoot.dir)
     );
     const pluginScopeResult = await migratePluginSkillScopes(
       scopeChanges,
@@ -991,6 +1043,63 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
       );
     }
   }
+  /**
+   * The project's own half of each `[P][G]` pair this edit collapsed. A Local copy `s` folded into
+   * a Local global install moves there, edits included, replacing the global copy every project
+   * reads. Every other half is removed at project scope and nowhere else: its ejected copy deleted,
+   * or its project-scope plugin registration uninstalled.
+   *
+   * The global install's MODE is {@link applyMigrations}' to change, and it changes only when the
+   * collapse carried a new install mode with it — a fold into a plugin installs the plugin there.
+   *
+   * The uninstall is diagnostic, as every plugin uninstall here is: the config no longer names the
+   * registration, so one left behind is untidy rather than wrong.
+   */
+  async applyCollapsedPairs(changes, filteredResult, context, editRoot) {
+    const [foldedCopies, removedPairs] = partition(
+      changes.collapsedPairs,
+      (pair) => foldsItsCopyIntoGlobal(pair, filteredResult.skills)
+    );
+    const [ejectedHalves, pluginHalves] = partition(
+      removedPairs.map(({ projectHalf }) => projectHalf),
+      (half) => half.origin === EJECT_SOURCE
+    );
+    for (const { projectHalf } of foldedCopies) {
+      await foldLocalSkillIntoGlobal(editRoot.dir, projectHalf.id);
+    }
+    for (const half of ejectedHalves) {
+      await deleteLocalSkill(editRoot.dir, half.id, half.scope);
+    }
+    await this.uninstallProjectPluginHalves(
+      pluginHalves,
+      context.sourceResult.marketplace,
+      editRoot
+    );
+  }
+  /** The project-scope registrations of collapsed pairs' plugin halves, uninstalled and reported. */
+  async uninstallProjectPluginHalves(pluginHalves, marketplace, editRoot) {
+    if (pluginHalves.length === 0) return;
+    if (marketplace === void 0) {
+      for (const half of pluginHalves) {
+        this.warn(`Could not uninstall this project's plugin for ${half.id}: no marketplace`);
+      }
+      return;
+    }
+    const uninstallResult = await uninstallPluginSkills(
+      pluginHalves.map((half) => half.id),
+      pluginHalves,
+      marketplace,
+      editRoot.dir
+    );
+    if (uninstallResult.uninstalled.length > 0) {
+      this.log(
+        chalk.hex(CLI_COLORS.NEUTRAL)(`Removed ${uninstallResult.uninstalled.length} plugin(s)`)
+      );
+    }
+    for (const item of uninstallResult.failed) {
+      this.warn(`Failed to uninstall plugin ${item.id}: ${item.error}`);
+    }
+  }
   async applySourceChanges(changes, activeOldSkills, editRoot, migratedSkillIds) {
     const { sourceChanges } = changes;
     for (const [skillId, change] of sourceChanges) {
@@ -999,8 +1108,7 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
       }
       if (change.from === EJECT_SOURCE) {
         const oldSkill = activeOldSkills.find((s) => s.id === skillId);
-        const deleteDir = installBaseDir(editRoot.dir, oldSkill?.scope);
-        await deleteLocalSkill(deleteDir, skillId);
+        await deleteLocalSkill(editRoot.dir, skillId, oldSkill?.scope);
       }
     }
   }
@@ -1015,7 +1123,8 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
     if (addedPluginSkills.length === 0 && removedPluginSkills.length === 0) return;
     const marketplace = await this.requireMarketplaceOrExit(
       context.sourceResult,
-      "install or uninstall plugin skills"
+      "install or uninstall plugin skills",
+      hostAt(editRoot.dir)
     );
     if (addedPluginSkills.length > 0) {
       await this.installPluginSkillsReported(
@@ -1061,11 +1170,10 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
     for (const skillId of removedSkills) {
       const oldSkill = activeOldSkills.find((s) => s.id === skillId);
       if (oldSkill?.origin !== EJECT_SOURCE) continue;
-      const deleteDir = installBaseDir(editRoot.dir, oldSkill.scope);
-      await deleteLocalSkill(deleteDir, skillId);
+      await deleteLocalSkill(editRoot.dir, skillId, oldSkill.scope);
     }
   }
-  async writeConfigAndCompile(result, context, editRoot, authority) {
+  async writeConfigAndCompile(result, context, editRoot, authority, producer) {
     let agentDefsResult;
     try {
       agentDefsResult = await loadAgentDefs();
@@ -1090,11 +1198,12 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
         exit: EXIT_CODES.ERROR
       });
     }
-    this.reportUnassignedSkills(configResult.config);
+    this.reportUnassignedSkills(configResult.config, result.skills);
     try {
       const agentScopeMap = activeAgentScopeMap(result.agentConfigs);
       const { allSkills } = await discoverInstalledSkills(editRoot.dir);
-      const compilationResult = await compileAgentsAllScopes({
+      const compile = compilesGlobalScope(producer, editRoot, configResult.propagation) ? compileAgentsAllScopes : compileProjectScope;
+      const compilationResult = await compile({
         projectDir: editRoot.dir,
         sourcePath: agentDefsResult.sourcePath,
         skills: allSkills,
@@ -1126,7 +1235,7 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
       );
       this.log(`You can manually recompile with '${CLI_INVOKE_COMMAND} compile'.`);
     }
-    this.reportPropagatedRecompile(configResult.propagation);
+    this.reportFanOut(configResult.propagation);
   }
   async cleanupStaleAgentFiles(changes, oldAgents, editRoot) {
     for (const removal of planStaleAgentRemovals(changes, oldAgents, editRoot.dir)) {
@@ -1140,6 +1249,24 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
       }
     }
   }
+  /**
+   * What this host could not carry, once per run and after the last write: the lines `init` and
+   * `compile` print, from {@link hostCompileNotices}, so `edit` cannot say something different
+   * about the tree it just compiled.
+   *
+   * After {@link cleanupStaleAgentFiles}, because the question is about the tree as it now stands:
+   * an edit that removed the project's last gated sub-agent must not count the file it deleted.
+   *
+   * Not on a run that owes work, which ends on that account instead: such a run may have left
+   * nothing here to read, and a notice that threw over it would turn the run's
+   * `COMPLETED_WITH_FAILURES` exit into an `ERROR`.
+   */
+  async reportWhatThisHostCannotCarry(editRoot) {
+    if (this.hasIncompleteWork) return;
+    for (const notice of await hostCompileNotices(providerInUse(editRoot.dir), editRoot.dir)) {
+      this.log(notice);
+    }
+  }
   logCompletionSummary(_changes) {
     if (this.hasIncompleteWork) return;
     this.log(`
@@ -1166,6 +1293,18 @@ function detectConfigChanges(oldConfig, wizardResult, fullEntries) {
     (a) => a.name,
     (a) => a.scope
   );
+  const dualScopeSkillTransitions = detectDualScopeTransitions(
+    scopeChanges,
+    fullEntries?.newSkills ?? [],
+    fullEntries?.oldSkills ?? [],
+    (s) => s.id
+  );
+  const collapsedPairs = collapsedPairsOf(
+    scopeChanges,
+    dualScopeSkillTransitions,
+    fullEntries?.oldSkills ?? [],
+    wizardResult.foldedSkillIds ?? []
+  );
   return {
     addedSkills: difference(newSkillIds, oldSkillIds),
     removedSkills: difference(oldSkillIds, newSkillIds),
@@ -1173,26 +1312,36 @@ function detectConfigChanges(oldConfig, wizardResult, fullEntries) {
     removedAgents: difference(oldAgentNames, newAgentNames),
     sourceChanges: detectPropertyChanges(
       wizardResult.skills,
-      oldSkillsById,
+      indexBy(withMaskedGlobalsRestored(oldConfig?.skills ?? [], collapsedPairs), (s) => s.id),
       (s) => s.id,
       (s) => s.origin
     ),
     scopeChanges,
     agentScopeChanges,
-    dualScopeSkillTransitions: detectDualScopeTransitions(
-      scopeChanges,
-      fullEntries?.newSkills ?? [],
-      fullEntries?.oldSkills ?? [],
-      (s) => s.id
-    ),
+    dualScopeSkillTransitions,
+    collapsedPairs,
     dualScopeAgentTransitions: detectDualScopeTransitions(
       agentScopeChanges,
       fullEntries?.newAgents ?? [],
       fullEntries?.oldAgents ?? [],
       (a) => a.name
+    ),
+    tuningChanges: detectPropertyChanges(
+      wizardResult.agentConfigs,
+      oldAgentsByName,
+      (a) => a.name,
+      describeTuning
     )
   };
 }
+var RESTING_TUNING = "defaults";
+function describeTuning(agent) {
+  const settings = [
+    agent.model === void 0 ? void 0 : `model ${agent.model}`,
+    agent.effort === void 0 ? void 0 : `effort ${agent.effort}`
+  ].filter((setting) => setting !== void 0);
+  return settings.length === 0 ? RESTING_TUNING : settings.join(", ");
+}
 function detectPropertyChanges(newItems, oldByKey, getKey, getValue) {
   const changes = /* @__PURE__ */ new Map();
   for (const item of newItems) {
@@ -1216,6 +1365,46 @@ function detectDualScopeTransitions(scopeChanges, fullNew, fullOld, getKey) {
   }
   return result;
 }
+function collapsedPairsOf(scopeChanges, dualScopeSkillTransitions, fullOldSkills, foldedSkillIds) {
+  return [...scopeChanges].filter(([id, change]) => change.to === "global" && dualScopeSkillTransitions.has(id)).map(([id]) => ({
+    projectHalf: oldHalfOf(fullOldSkills, id, (skill) => isActiveAt(skill, "project")),
+    maskedGlobal: oldHalfOf(fullOldSkills, id, isGlobalTombstone),
+    folded: foldedSkillIds.includes(id)
+  }));
+}
+function foldsItsCopyIntoGlobal(pair, newSkills) {
+  const { projectHalf, folded } = pair;
+  const globalEntry = newSkills.find(
+    (skill) => skill.id === projectHalf.id && isActiveAt(skill, "global")
+  );
+  return folded && projectHalf.origin === EJECT_SOURCE && globalEntry?.origin === EJECT_SOURCE;
+}
+function oldHalfOf(fullOldSkills, id, isHalf) {
+  const half = fullOldSkills.find((skill) => skill.id === id && isHalf(skill));
+  if (half === void 0) {
+    throw new Error(`The config before this edit holds no such half of the pair for '${id}'`);
+  }
+  return half;
+}
+function withMaskedGlobalsRestored(oldSkills, collapsedPairs) {
+  const maskedById = indexBy(
+    collapsedPairs.map(({ maskedGlobal }) => maskedGlobal),
+    (skill) => skill.id
+  );
+  return oldSkills.map((skill) => {
+    const masked = maskedById[skill.id];
+    if (masked === void 0 || skill.scope !== "project") return skill;
+    return installRecordedBy(masked);
+  });
+}
+function installRecordedBy(tombstone) {
+  const { excluded: _masked, ...install } = tombstone;
+  return install;
+}
+function scopeMovesOf(changes) {
+  const collapsed = new Set(changes.collapsedPairs.map(({ projectHalf }) => projectHalf.id));
+  return new Map([...changes.scopeChanges].filter(([id]) => !collapsed.has(id)));
+}
 var STALE_AGENT_SCOPES = ["project", "global"];
 var UNRECORDED_AGENT_SCOPE = "project";
 function installedScope(name, oldAgents) {
@@ -1235,9 +1424,10 @@ function planStaleAgentRemovals(changes, oldAgents, editRoot) {
   return STALE_AGENT_SCOPES.map(removalAtScope).filter((removal) => removal.agents.length > 0);
 }
 function hasAnyChanges(changes) {
-  return changes.addedSkills.length > 0 || changes.removedSkills.length > 0 || changes.addedAgents.length > 0 || changes.removedAgents.length > 0 || changes.sourceChanges.size > 0 || changes.scopeChanges.size > 0 || changes.agentScopeChanges.size > 0;
+  return changes.reassignedAgents.length > 0 || changes.rewrittenSkills.length > 0 || changes.addedSkills.length > 0 || changes.removedSkills.length > 0 || changes.addedAgents.length > 0 || changes.removedAgents.length > 0 || changes.sourceChanges.size > 0 || changes.scopeChanges.size > 0 || changes.agentScopeChanges.size > 0 || changes.tuningChanges.size > 0;
 }
 async function migratePluginSkillScopes(scopeChanges, skills, marketplace, projectDir) {
+  const host = hostAt(projectDir);
   const migrated = [];
   const failed = [];
   for (const [skillId, change] of scopeChanges) {
@@ -1245,13 +1435,12 @@ async function migratePluginSkillScopes(scopeChanges, skills, marketplace, proje
     if (!skillConfig || skillConfig.origin === EJECT_SOURCE) {
       continue;
     }
-    const newPluginScope = toClaudePluginScope(change.to);
     const pluginRef = buildMarketplacePluginRef(skillId, marketplace);
     try {
       if (change.from === "project") {
-        await claudePluginUninstall(pluginRef, "project", projectDir);
+        await host.uninstallPlugin(pluginRef, "project", projectDir);
       }
-      await claudePluginInstall(pluginRef, newPluginScope, projectDir);
+      await host.installPlugin(pluginRef, change.to, projectDir);
       migrated.push(skillId);
     } catch (error) {
       failed.push({ id: skillId, error: getErrorMessage(error) });