agents-inc 0.170.1 → 0.171.0

package/dist/commands/edit.js

@@ -1,78 +1,79 @@
 #!/usr/bin/env node
 import {
   awaitUnderSpinner
-} from "../chunk-NEZ4OAOL.js";
+} from "../chunk-ZEGM3MVR.js";
 import {
   publishSeedConfig,
   seedPayloadForInstallation,
   skillsAuthoredHere
-} from "../chunk-SZYQISA2.js";
+} from "../chunk-TNFYBKVD.js";
 import {
   RemovalPlanConfirm
-} from "../chunk-USVBYQSQ.js";
+} from "../chunk-5FM77WKW.js";
 import {
   unofferablePlacementsFound
-} from "../chunk-WTWMGH2C.js";
+} from "../chunk-RDXY4GRO.js";
 import {
-  arrivalLines,
-  arrivalsByScope,
-  joinedStatement,
-  notInstalledGlobally,
-  openUrl,
-  readInstalledGlobal,
-  reconcileSharedConfig,
-  restoreInstalledGlobal,
-  sameAssignments,
-  skillLabel,
-  withUnplaceableAssignees
-} from "../chunk-6HNXYYVF.js";
+  openUrl
+} from "../chunk-JGPE4RRE.js";
 import {
   fetchSeedConfig
-} from "../chunk-OYJQUA3D.js";
+} from "../chunk-WDH6HHA3.js";
 import {
   promptConfirm
-} from "../chunk-4AAOOAIN.js";
+} from "../chunk-P6CYS4JK.js";
 import "../chunk-OZXAJNLA.js";
 import {
   hostCompileNotices
-} from "../chunk-F5EBEATU.js";
+} from "../chunk-WM2N2D6Q.js";
 import {
   compileAgentsAllScopes,
   compileProjectScope,
   detectProject,
   loadSource,
   movedGlobalAgentInputs,
+  projectsAFanOutReaches,
   sayCapturedWarnings,
   writeProjectConfig
-} from "../chunk-7RDMTR64.js";
+} from "../chunk-S2SKVJT2.js";
 import {
   copyLocalSkills,
   discoverInstalledSkills,
   removeCompiledAgents,
   uninstallPluginSkills
-} from "../chunk-F2BHT5C4.js";
+} from "../chunk-EOKNEGRD.js";
 import {
   loadAgentDefs
-} from "../chunk-HED2DAXZ.js";
-import "../chunk-3G7X2WKI.js";
-import "../chunk-BMRUNMPV.js";
+} from "../chunk-7IVLVEHX.js";
+import "../chunk-WII6GOPM.js";
+import "../chunk-AWWCRL5A.js";
 import {
   formatScopeTag
-} from "../chunk-NIHUOWE4.js";
-import "../chunk-JFLVEFFP.js";
+} from "../chunk-4RQKCV6I.js";
+import "../chunk-KIK5EZYD.js";
 import {
   providerFlag,
   providerNamedBy,
   refuseAnAmbiguousInstallation
-} from "../chunk-RIPSGNLU.js";
+} from "../chunk-W4KAY26P.js";
 import {
   BaseCommand,
   EXIT_CODES,
+  arrivalLines,
+  arrivalsByScope,
   carriedSkillsThatDiffer,
+  installsAtHome,
+  joinedStatement,
+  notInstalledGlobally,
+  readInstalledGlobal,
+  reconcileSharedConfig,
   registerExternalSkills,
+  restoreInstalledGlobal,
+  sameAssignments,
+  skillLabel,
+  withUnplaceableAssignees,
   writeExternalSkills
-} from "../chunk-V3KTSP3Q.js";
-import "../chunk-CLPUWOSA.js";
+} from "../chunk-QIR56IDM.js";
 import {
   ERROR_MESSAGES,
   INCOMPLETE_WORK_RECOVERY,
@@ -85,6 +86,7 @@ import {
   authoredHereKept,
   buildMarketplacePluginRef,
   carriedSkillsWritten,
+  copyingBesideGlobalPlugins,
   deleteLocalSkill,
   detectMigrations,
   editorSkillMetadataUnusableError,
@@ -93,28 +95,31 @@ import {
   getErrorMessage,
   holdsItsOwnInstallation,
   hostAt,
+  installingBesideGlobalCopies,
   isHomeDirectory,
+  keepsGlobalInstall,
   keptAsInstalledGlobally,
   keptUnassigned,
   loadProjectConfig,
   localSkillsCopied,
   migrateLocalSkillScope,
   nothingInstalledToApplyTo,
+  projectCopyMovedToGlobal,
   projectCopyRemoved,
   providerInUse,
   recompileSummary,
+  registeredProjectsRewritten,
   resolveInstallPaths,
   seedToInstallSelection,
   sharedConfigDestinations,
   sharedConfigNeedsTerminal,
-  skippedUnknownAgents,
-  skippedUnknownSkills,
   unplaceableKept
-} from "../chunk-MQ6CGZNJ.js";
+} from "../chunk-3YYHL76L.js";
 import {
   getSkillById,
-  getSkillDisplayName
-} from "../chunk-52HDHJ7I.js";
+  getSkillDisplayName,
+  stripTerminalControls
+} from "../chunk-24OD7IP4.js";
 import {
   CLI_COLORS,
   CLI_INVOKE_COMMAND,
@@ -124,61 +129,110 @@ import {
   formatSourceDisplayName,
   isActiveAt,
   isGlobalTombstone
-} from "../chunk-PJWGTNOX.js";
-import "../chunk-NQW25DCF.js";
+} from "../chunk-A6OWEJGC.js";
+import "../chunk-GHHJYNAN.js";
 
 // src/cli/commands/edit.tsx
 import path from "path";
 import chalk from "chalk";
 import { Flags } from "@oclif/core";
-import { difference, indexBy, partition } from "remeda";
+import { difference, indexBy, partition, unique } from "remeda";
 import { jsx } from "react/jsx-runtime";
 var RECOMPILE_SUBJECT = "agent";
-function formatDualScopeTransition(displayName, to) {
-  const isAdd = to === "project";
-  const prefix = isAdd ? "+" : "-";
-  const color = isAdd ? CLI_COLORS.SUCCESS : CLI_COLORS.ERROR;
-  return chalk.hex(color)(`  ${prefix} ${displayName} [P]`);
+var CHANGE_MARKER_COLORS = {
+  "+": CLI_COLORS.SUCCESS,
+  "-": CLI_COLORS.ERROR,
+  "~": CLI_COLORS.WARNING
+};
+var AGENT_DETAIL = " (agent)";
+function changeLine(marker, subject, detail) {
+  const head = chalk.hex(CHANGE_MARKER_COLORS[marker])(`  ${marker} ${subject}`);
+  return detail === void 0 ? head : head + chalk.hex(CLI_COLORS.NEUTRAL)(detail);
+}
+function dualScopeTransitionLine(subject, to, detail) {
+  return changeLine(to === "project" ? "+" : "-", `${subject} [P]`, detail);
 }
 function formatSkillScopeChangeLine(skillId, change, dualScopeSkillTransitions) {
   const displayName = getSkillDisplayName(skillId);
   if (dualScopeSkillTransitions.has(skillId)) {
-    return formatDualScopeTransition(displayName, change.to);
+    return dualScopeTransitionLine(displayName, change.to);
   }
   const isGlobalToProject = change.from === "global" && change.to === "project";
-  const prefix = isGlobalToProject ? "+" : "~";
-  const color = isGlobalToProject ? CLI_COLORS.SUCCESS : CLI_COLORS.WARNING;
-  return chalk.hex(color)(`  ${prefix} ${displayName}`) + chalk.hex(CLI_COLORS.NEUTRAL)(scopeArrow(change));
+  return changeLine(isGlobalToProject ? "+" : "~", displayName, scopeArrow(change));
 }
 function formatAgentScopeChangeLine(agentName, change, dualScopeAgentTransitions) {
-  const agentSuffix = chalk.hex(CLI_COLORS.NEUTRAL)(" (agent)");
   if (dualScopeAgentTransitions.has(agentName)) {
-    return formatDualScopeTransition(agentName, change.to) + agentSuffix;
+    return dualScopeTransitionLine(agentName, change.to, AGENT_DETAIL);
   }
-  return chalk.hex(CLI_COLORS.WARNING)(`  ~ ${agentName}`) + chalk.hex(CLI_COLORS.NEUTRAL)(scopeArrow(change));
+  return changeLine("~", agentName, scopeArrow(change));
 }
 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})`);
+  return changeLine("~", subject, ` (${kind}: ${change.from} \u2192 ${change.to})`);
+}
+function sourceChangeLine(skillId, change) {
+  const from = formatSourceDisplayName(change.from);
+  const to = formatSourceDisplayName(change.to);
+  return changeLine("~", getSkillDisplayName(skillId), ` (${from} \u2192 ${to})`);
+}
+function scopeLabelOf(skillId, skills) {
+  const skill = skills.find((s) => s.id === skillId);
+  return skill === void 0 ? "" : ` ${formatScopeTag(skill.scope)}`;
+}
+function changeSummaryLines(changes, newSkills, oldSkills) {
+  const addedSkill = (id) => changeLine(
+    "+",
+    `${stripTerminalControls(getSkillById(id).displayName)}${scopeLabelOf(id, newSkills)}`
+  );
+  const removedSkill = (id) => changeLine("-", `${getSkillDisplayName(id)}${scopeLabelOf(id, oldSkills)}`);
+  const joinedGlobalDetail = ` ${formatScopeTag("global")} (agent: skills added)`;
+  return [
+    ...changes.addedSkills.map(addedSkill),
+    ...changes.removedSkills.map(removedSkill),
+    ...changes.addedAgents.map((name) => changeLine("+", name, AGENT_DETAIL)),
+    ...changes.removedAgents.map((name) => changeLine("-", name, AGENT_DETAIL)),
+    ...[...changes.sourceChanges].map(([id, change]) => sourceChangeLine(id, change)),
+    ...[...changes.scopeChanges].map(
+      ([id, change]) => formatSkillScopeChangeLine(id, change, changes.dualScopeSkillTransitions)
+    ),
+    ...[...changes.agentScopeChanges].map(
+      ([name, change]) => formatAgentScopeChangeLine(name, change, changes.dualScopeAgentTransitions)
+    ),
+    ...[...changes.tuningChanges].map(
+      ([name, change]) => formatValueChangeLine(name, change, "agent")
+    ),
+    ...changes.reassignedAgents.map((name) => changeLine("~", name, " (agent: skills reassigned)")),
+    ...changes.joinedGlobalAgents.map((name) => changeLine("~", name, joinedGlobalDetail)),
+    ...changes.rewrittenSkills.map(
+      (id) => changeLine("~", getSkillDisplayName(id), " (skill: files rewritten)")
+    )
+  ];
 }
 function resolveEditRoot(installation) {
   const dir = installation.projectDir;
   return { dir, isGlobal: isHomeDirectory(dir) };
 }
-function sharedConfigPlan(changes, kept) {
+function sharedConfigPlan(changes, overwrittenSkillIds2, statements) {
   const dropped = droppedProjectHalves(changes);
+  const moved = movedToGlobal(changes);
   const skillLines = [
     ...changes.removedSkills.map(skillLabel),
-    ...dropped.skillIds.map(droppedSkillLine)
+    ...dropped.skillIds.map((id) => projectCopyRemoved(skillLabel(id))),
+    ...moved.skillIds.map((id) => projectCopyMovedToGlobal(skillLabel(id)))
+  ];
+  const agentLines = [
+    ...changes.removedAgents,
+    ...dropped.agentNames.map(projectCopyRemoved),
+    ...moved.agentNames.map(projectCopyMovedToGlobal)
   ];
-  const agentLines = [...changes.removedAgents, ...dropped.agentNames.map(projectCopyRemoved)];
   const sections = removalSections(skillLines, agentLines);
-  return { heading: planHeading(sections), sections, statements: kept };
-}
-function droppedSkillLine(skillId) {
-  return projectCopyRemoved(skillLabel(skillId));
+  const overwritten = {
+    label: SHARED_CONFIG_APPLY.OVERWRITTEN_HEADING,
+    items: overwrittenSkillIds2.map(skillLabel)
+  };
+  return { ...planHeading(sections, overwritten), sections, overwritten, statements };
 }
 function removalSections(skills, agents) {
   return [
@@ -195,17 +249,54 @@ function droppedProjectHalves(changes) {
     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 movedToGlobal(changes) {
+  const skillMoves = [...scopeMovesOf(changes)].filter(([, change]) => change.to === "global");
+  const agentMoves = [...changes.agentScopeChanges].filter(
+    ([name, change]) => change.to === "global" && !changes.dualScopeAgentTransitions.has(name)
+  );
+  return {
+    skillIds: skillMoves.map(([id]) => id),
+    agentNames: agentMoves.map(([name]) => name)
+  };
+}
+function planHeading(sections, overwritten) {
+  if (sections.length > 0) return { heading: SHARED_CONFIG_APPLY.PREVIEW_HEADING };
+  if (overwritten.items.length > 0) return {};
+  return { heading: SHARED_CONFIG_APPLY.NOTHING_REMOVED };
+}
+function overwrittenSkillIds(changes, active) {
+  const leaving = new Set(movedToGlobal(changes).skillIds);
+  const switched = ejectedCopiesSwitchedToPlugins(migrationPlanOf(changes, active));
+  return unique([...changes.rewrittenSkills, ...switched]).filter((id) => !leaving.has(id));
+}
+function ejectedCopiesSwitchedToPlugins(plan) {
+  return plan.toPlugin.filter((migration) => !keepsGlobalInstall(migration)).map(({ id }) => id);
+}
+function migrationPlanOf(changes, active) {
+  return detectMigrations(
+    withMaskedGlobalsRestored(active.oldSkills, changes.collapsedPairs),
+    active.selection.skills
+  );
+}
+async function carriedThatChange(carried) {
+  const changing = new Set(await carriedSkillsThatDiffer(carried));
+  return carried.filter((skill) => changing.has(skill.id));
+}
+function withRewrittenCarried(planned, carriedToWrite) {
+  const writtenIds = carriedToWrite.map((skill) => skill.id);
+  return { ...planned, rewrittenSkills: difference(writtenIds, skillsNewHere(planned)) };
 }
 function compilesGlobalScope(editRoot, written) {
   return editRoot.isGlobal || movedGlobalAgentInputs(written);
 }
 function withReassignments(changes, result, installedStack, editRoot) {
   const { assignedStack } = result;
+  const arrivingCopies = arrivingProjectHalves(
+    changes.agentScopeChanges,
+    changes.dualScopeAgentTransitions
+  );
   const ownedHere = (agent) => editRoot.isGlobal || isActiveAt(agent, "project");
-  const countedAsAdded = (agent) => changes.addedAgents.includes(agent.name);
+  const countedAsAdded = (agent) => changes.addedAgents.includes(agent.name) || arrivingCopies.has(agent.name);
   const rowsMoved = (agent) => !sameAssignments(assignedStack[agent.name], installedStack?.[agent.name]);
   const reassigned = result.agentConfigs.filter(
     (agent) => ownedHere(agent) && !countedAsAdded(agent) && rowsMoved(agent)
@@ -249,15 +340,50 @@ function unassignedStatement(unassigned) {
     unassigned.map(({ skillId, agentName, category }) => keptUnassigned(skillId, agentName, category)).join("\n")
   ];
 }
-function keptAsInstalledStatement(held, revisedCarried) {
+function keptOnApply(reconciled, held, revisedCarried, idAppliedAtHome) {
+  return [
+    ...keptStatements(reconciled.kept),
+    ...unassignedStatement(reconciled.unassigned),
+    ...joinedStatement(held),
+    ...keptAsInstalledStatement(held, revisedCarried, idAppliedAtHome)
+  ];
+}
+function keptAsInstalledStatement(held, revisedCarried, idAppliedAtHome) {
   const skillIds = [...held.keptAsInstalled.skillIds, ...revisedCarried];
   const { agentNames } = held.keptAsInstalled;
   if (skillIds.length === 0 && agentNames.length === 0) return [];
-  return [keptAsInstalledGlobally(skillIds, agentNames)];
+  return [keptAsInstalledGlobally(skillIds, agentNames, idAppliedAtHome)];
 }
 function applyAuthority(editRoot) {
   return editRoot.isGlobal ? "all" : "owned";
 }
+function activeEntriesOf(result, projectConfig) {
+  const oldSkills = (projectConfig?.skills ?? []).filter((s) => !s.excluded);
+  const oldAgents = (projectConfig?.agents ?? []).filter((a) => !a.excluded);
+  return {
+    selection: {
+      ...result,
+      skills: result.skills.filter((s) => !s.excluded),
+      agentConfigs: result.agentConfigs.filter((a) => !a.excluded)
+    },
+    oldConfig: projectConfig ? { ...projectConfig, skills: oldSkills, agents: oldAgents } : null,
+    oldSkills,
+    oldAgents
+  };
+}
+function planChanges(selection, active, projectConfig, editRoot) {
+  const keptInstalled = globalHalvesKeptInstalled(selection.installedGlobal);
+  const changes = detectConfigChanges(active.oldConfig, active.selection, {
+    newSkills: [...selection.result.skills, ...keptInstalled.skills],
+    oldSkills: projectConfig?.skills ?? [],
+    newAgents: [...selection.result.agentConfigs, ...keptInstalled.agents],
+    oldAgents: projectConfig?.agents ?? []
+  });
+  return {
+    ...withReassignments(changes, active.selection, projectConfig?.stack, editRoot),
+    joinedGlobalAgents: selection.joinedGlobalAgents
+  };
+}
 var Edit = class _Edit extends BaseCommand {
   static summary = "Open this installation in the editor, or apply a configuration with --from";
   static description = "Open this installation in agentsinc.sh/editor, or apply a configuration built there with --from";
@@ -294,17 +420,23 @@ 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, cwd);
+    const namedProvider = providerNamedBy(flags.provider);
+    if (flags.ui && flags.from !== void 0) {
+      return this.openSharedInEditor(flags.from, cwd, namedProvider);
+    }
     await refuseAnAmbiguousInstallation(
       cwd,
       "edit",
-      providerNamedBy(flags.provider),
+      namedProvider,
       (message) => this.error(message, { exit: EXIT_CODES.INVALID_ARGS })
     );
     await this.ensureConfigReadable(cwd);
     await this.refuseUnofferablePlacements(cwd);
     if (flags.from === void 0) return this.openInEditor(cwd);
-    const payload = await this.fetchSharedConfigOrFail(flags.from);
+    return this.applySharedConfig(flags.from, namedProvider);
+  }
+  async applySharedConfig(id, namedProvider) {
+    const payload = await this.fetchSharedConfigOrFail(id, namedProvider);
     const context = await this.loadContextUnderSpinner();
     const editRoot = resolveEditRoot(context.installation);
     await this.ensureSavedSkillsReadable(
@@ -312,87 +444,46 @@ var Edit = class _Edit extends BaseCommand {
       context.sourceResult.matrix,
       editRoot.dir
     );
-    const selection = await this.selectionFromSharedConfig(payload, context, editRoot);
-    const { result } = selection;
-    this.reportValidationErrors(result.validation);
-    const activeNewSkills = result.skills.filter((s) => !s.excluded);
-    const activeNewAgents = result.agentConfigs.filter((a) => !a.excluded);
-    const activeOldSkills = (context.projectConfig?.skills ?? []).filter((s) => !s.excluded);
-    const activeOldAgents = (context.projectConfig?.agents ?? []).filter((a) => !a.excluded);
-    const filteredResult = {
-      ...result,
-      skills: activeNewSkills,
-      agentConfigs: activeNewAgents
-    };
-    const filteredOldConfig = context.projectConfig ? { ...context.projectConfig, skills: activeOldSkills, agents: activeOldAgents } : null;
-    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
-      ),
-      joinedGlobalAgents: selection.joinedGlobalAgents
-    };
-    const rewritten = 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."));
-      return;
-    }
-    this.logChangeSummary(changes, filteredResult.skills, filteredOldConfig?.skills ?? []);
-    const migratedSkillIds = await this.applyMigrations(
-      changes,
-      filteredResult,
-      activeOldSkills,
-      context,
-      editRoot
-    );
-    await this.applyScopeChanges(changes, filteredResult, context, editRoot);
+    const selection = await this.selectionFromSharedConfig(id, payload, context, editRoot);
+    this.reportValidationErrors(selection.result.validation);
+    const active = activeEntriesOf(selection.result, context.projectConfig);
+    const planned = planChanges(selection, active, context.projectConfig, editRoot);
+    const carriedToWrite = await carriedThatChange(selection.carried);
+    const changes = withRewrittenCarried(planned, carriedToWrite);
+    if (!hasAnyChanges(changes)) return this.sayNothingChanged(selection.kept);
+    const plan = await this.planToConfirm(changes, active, selection.kept, context, editRoot);
+    await this.confirmSharedConfigOrCancel(plan, applyArrivals(changes, active.selection));
+    await this.writeCarriedSkills(carriedToWrite);
+    await this.applyApprovedChanges(changes, active, selection.result, context, editRoot);
+  }
+  async applyApprovedChanges(changes, active, result, context, editRoot) {
+    const { selection: activeSelection, oldSkills, oldAgents } = active;
+    this.logChangeSummary(changes, activeSelection.skills, oldSkills);
+    await this.applyMigrations(changes, active, context, editRoot);
+    await this.applyScopeChanges(changes, activeSelection, context, editRoot);
     await this.applyCollapsedPairs(changes, 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.cleanupStaleAgentFiles(changes, activeOldAgents, editRoot);
+    await this.applyPluginChanges(changes, activeSelection, oldSkills, context, editRoot);
+    await this.copyNewLocalSkills(changes, activeSelection, context, editRoot);
+    await this.removeDeletedLocalSkills(changes, oldSkills, editRoot);
+    await this.writeConfigAndCompile(result, context, editRoot);
+    await this.cleanupStaleAgentFiles(changes, oldAgents, editRoot);
     await this.reportWhatThisHostCannotCarry(editRoot);
-    this.logCompletionSummary(changes);
+    this.logCompletionSummary();
   }
   /**
    * A shared configuration applies destructively, except for a skill written here (`forkedFrom`)
    * and an id this catalogue cannot place — both disclosed in the confirm. From a project the
-   * global install is only added to (owner ruling 2026-10-02): entries the configuration omits or
-   * states otherwise are held as installed, and only what it lacks arrives.
+   * global install is only added to.
    */
-  async selectionFromSharedConfig(payload, context, editRoot) {
+  async selectionFromSharedConfig(id, payload, context, editRoot) {
     const { matrix: sourceMatrix } = context.sourceResult;
     const carried = this.registerExternalSkillsOrFail(payload, sourceMatrix, editRoot.dir);
-    const { result, skippedSkillIds, skippedAgentNames } = this.decodeSeedOrFail(
-      payload,
-      sourceMatrix
-    );
+    const mapping = this.decodeSeedOrFail(payload, sourceMatrix);
+    const { result } = mapping;
     this.refuseProjectScopedContentAtHome(result, editRoot.dir);
-    const unplaceable = new Set(skippedSkillIds);
-    const reconciled = reconcileSharedConfig({
-      decoded: withUnplaceableAssignees(result, context.projectConfig, payload, unplaceable),
-      installed: context.projectConfig,
-      authoredHere: await this.readAuthoredHere(context.projectConfig, editRoot.dir),
-      unplaceable
-    });
-    const held = restoreInstalledGlobal(
-      reconciled.result,
-      editRoot.isGlobal ? null : await readInstalledGlobal(editRoot.dir)
-    );
+    const reconciled = await this.reconcileWithInstallation(mapping, payload, context, editRoot);
+    const installedGlobal = editRoot.isGlobal ? null : await readInstalledGlobal(editRoot.dir);
+    const held = restoreInstalledGlobal(reconciled.result, installedGlobal);
     const arrivingCarried = notInstalledGlobally(carried, held);
     await this.refuseSharedConfigBeforeAsking(
       held.result,
@@ -400,23 +491,30 @@ var Edit = class _Edit extends BaseCommand {
       editRoot.dir,
       context.sourceResult
     );
-    const heldGlobally = difference(carried, arrivingCarried);
-    const revisedGlobally = await carriedSkillsThatDiffer(heldGlobally);
+    const revisedGlobally = await carriedSkillsThatDiffer(difference(carried, arrivingCarried));
     sayCapturedWarnings(context.startupMessages);
-    if (skippedSkillIds.length > 0) this.warn(skippedUnknownSkills(skippedSkillIds));
-    if (skippedAgentNames.length > 0) this.warn(skippedUnknownAgents(skippedAgentNames));
+    this.warnOfSkippedEntries(mapping, held.result.selectedAgents);
     return {
       result: held.result,
-      kept: [
-        ...keptStatements(reconciled.kept),
-        ...unassignedStatement(reconciled.unassigned),
-        ...joinedStatement(held),
-        ...keptAsInstalledStatement(held, revisedGlobally)
-      ],
+      kept: keptOnApply(reconciled, held, revisedGlobally, installsAtHome(result) ? id : void 0),
       carried: arrivingCarried,
-      joinedGlobalAgents: held.joined.map(({ agentName }) => agentName)
+      joinedGlobalAgents: held.joined.map(({ agentName }) => agentName),
+      installedGlobal
     };
   }
+  /**
+   * Ids the decode could not place stay, as does a sub-agent only they carried in: a catalogue
+   * limit is not an instruction to delete.
+   */
+  async reconcileWithInstallation({ result, skippedSkillIds }, payload, { projectConfig }, editRoot) {
+    const unplaceable = new Set(skippedSkillIds);
+    return reconcileSharedConfig({
+      decoded: withUnplaceableAssignees(result, projectConfig, payload, unplaceable),
+      installed: projectConfig,
+      authoredHere: await this.readAuthoredHere(projectConfig, editRoot.dir),
+      unplaceable
+    });
+  }
   /** Best-effort: an unreadable directory protects nothing and must not fail an apply. */
   async readAuthoredHere(projectConfig, editRoot) {
     if (!projectConfig) return /* @__PURE__ */ new Set();
@@ -427,13 +525,16 @@ var Edit = class _Edit extends BaseCommand {
       return /* @__PURE__ */ new Set();
     }
   }
-  /** Refuses an empty directory or a missing terminal before spending a round trip. */
-  async fetchSharedConfigOrFail(id) {
+  /**
+   * Refuses an empty directory, or a missing terminal, before spending a round trip: a destructive
+   * apply nobody can confirm must never become a yes.
+   */
+  async fetchSharedConfigOrFail(id, namedProvider) {
     if (!await detectProject()) {
-      this.error(nothingInstalledToApplyTo(id), { exit: EXIT_CODES.ERROR });
+      this.error(nothingInstalledToApplyTo(id, namedProvider), { exit: EXIT_CODES.ERROR });
     }
     if (!process.stdin.isTTY) {
-      this.error(sharedConfigNeedsTerminal(id), { exit: EXIT_CODES.ERROR });
+      this.error(sharedConfigNeedsTerminal(id, namedProvider), { exit: EXIT_CODES.ERROR });
     }
     this.log(`Fetching configuration ${id}...`);
     const fetched = await fetchSeedConfig(id);
@@ -456,31 +557,50 @@ var Edit = class _Edit extends BaseCommand {
       this.handleError(error);
     }
   }
-  async confirmAndWriteCarried(selection, planned, result) {
-    await this.confirmSharedConfigOrCancel(planned, selection.kept, applyArrivals(planned, result));
-    return this.writeCarriedSkills(selection.carried);
-  }
   async writeCarriedSkills(carried) {
-    if (carried.length === 0) return [];
-    const rewritten = await writeExternalSkills(carried);
+    if (carried.length === 0) return;
+    await writeExternalSkills(carried);
     this.log(carriedSkillsWritten(carried.map((skill) => skill.id)));
-    return rewritten;
+  }
+  /** What the run removes and overwrites, then what it keeps and what else it rewrites. */
+  async planToConfirm(changes, active, kept, context, editRoot) {
+    const reachedProjects = await this.registeredProjectsStatement(changes, context, editRoot);
+    return sharedConfigPlan(changes, overwrittenSkillIds(changes, active), [
+      ...kept,
+      ...reachedProjects
+    ]);
+  }
+  /** Nothing to confirm; what the run keeps still says why nothing changed. */
+  sayNothingChanged(kept) {
+    for (const statement of kept) {
+      this.log(statement);
+    }
+    this.log(chalk.hex(CLI_COLORS.NEUTRAL)(INFO_MESSAGES.NO_CHANGES_MADE));
   }
   /**
-   * The plan and the apply read the same `ConfigChanges`, so what is approved is what is removed.
-   * The arrivals print above it, so the question covers the whole of what a yes does.
+   * At home every registered project inlines the global config, so a change to it rewrites each
+   * one the fan-out reaches. Rewritten carried files alone leave the config as it was.
    */
-  async confirmSharedConfigOrCancel(changes, kept, arrivals) {
-    const plan = sharedConfigPlan(changes, kept);
+  async registeredProjectsStatement(changes, context, editRoot) {
+    if (!editRoot.isGlobal || !changesTheConfig(changes)) return [];
+    const reached = await projectsAFanOutReaches(
+      context.projectConfig?.projects ?? [],
+      providerInUse(editRoot.dir)
+    );
+    return reached.length === 0 ? [] : [registeredProjectsRewritten(reached)];
+  }
+  /**
+   * The plan and the apply read the same changes, so what is approved is what is removed. The
+   * arrivals print above it, so the question covers the whole of what a yes does.
+   */
+  async confirmSharedConfigOrCancel(plan, arrivals) {
     for (const line of arrivalLines(arrivals)) {
       this.log(line);
     }
     const outcome = await promptConfirm(({ onConfirm, onCancel }) => /* @__PURE__ */ jsx(
       RemovalPlanConfirm,
       {
-        heading: plan.heading,
-        sections: plan.sections,
-        statements: plan.statements,
+        ...plan,
         message: SHARED_CONFIG_APPLY.CONFIRM,
         onConfirm,
         onCancel
@@ -527,10 +647,10 @@ var Edit = class _Edit extends BaseCommand {
     );
   }
   /** Opens an id rather than applying it; `--from` without `--ui` is the destructive apply. */
-  async openSharedInEditor(id, cwd) {
+  async openSharedInEditor(id, cwd, namedProvider) {
     const url = editorConfigUrl(id);
     this.log(`Open it at ${url}`);
-    this.log(applySharedConfigHere(id, await holdsItsOwnInstallation(cwd)));
+    this.log(applySharedConfigHere(id, await holdsItsOwnInstallation(cwd), namedProvider));
     if (!process.stdin.isTTY) return;
     const opened = await openUrl(url);
     if (!opened.ok) this.warn(opened.error);
@@ -567,94 +687,18 @@ var Edit = class _Edit extends BaseCommand {
     }
   }
   logChangeSummary(changes, newSkills, oldSkills) {
-    const {
-      addedSkills,
-      removedSkills,
-      addedAgents,
-      removedAgents,
-      sourceChanges,
-      scopeChanges,
-      agentScopeChanges,
-      dualScopeSkillTransitions,
-      dualScopeAgentTransitions,
-      tuningChanges,
-      reassignedAgents,
-      joinedGlobalAgents,
-      rewrittenSkills
-    } = changes;
     this.log(`
 ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
-    for (const skillId of addedSkills) {
-      const scope = newSkills.find((s) => s.id === skillId)?.scope;
-      const scopeLabel = scope ? ` ${formatScopeTag(scope)}` : "";
-      this.log(
-        chalk.hex(CLI_COLORS.SUCCESS)(`  + ${getSkillById(skillId).displayName}${scopeLabel}`)
-      );
-    }
-    for (const skillId of removedSkills) {
-      const scope = oldSkills.find((s) => s.id === skillId)?.scope;
-      const scopeLabel = scope ? ` ${formatScopeTag(scope)}` : "";
-      this.log(chalk.hex(CLI_COLORS.ERROR)(`  - ${getSkillDisplayName(skillId)}${scopeLabel}`));
-    }
-    for (const agentName of addedAgents) {
-      this.log(
-        chalk.hex(CLI_COLORS.SUCCESS)(`  + ${agentName}`) + chalk.hex(CLI_COLORS.NEUTRAL)(" (agent)")
-      );
-    }
-    for (const agentName of removedAgents) {
-      this.log(
-        chalk.hex(CLI_COLORS.ERROR)(`  - ${agentName}`) + chalk.hex(CLI_COLORS.NEUTRAL)(" (agent)")
-      );
-    }
-    for (const [skillId, change] of sourceChanges) {
-      const displayName = getSkillDisplayName(skillId);
-      const fromLabel = formatSourceDisplayName(change.from);
-      const toLabel = formatSourceDisplayName(change.to);
-      this.log(
-        chalk.hex(CLI_COLORS.WARNING)(`  ~ ${displayName}`) + chalk.hex(CLI_COLORS.NEUTRAL)(` (${fromLabel} \u2192 ${toLabel})`)
-      );
-    }
-    for (const [skillId, change] of scopeChanges) {
-      this.log(formatSkillScopeChangeLine(skillId, change, dualScopeSkillTransitions));
-    }
-    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 agentName of joinedGlobalAgents) {
-      this.log(
-        chalk.hex(CLI_COLORS.WARNING)(`  ~ ${agentName}`) + chalk.hex(CLI_COLORS.NEUTRAL)(` ${formatScopeTag("global")} (agent: skills added)`)
-      );
-    }
-    for (const skillId of rewrittenSkills) {
-      this.log(
-        chalk.hex(CLI_COLORS.WARNING)(`  ~ ${getSkillDisplayName(skillId)}`) + chalk.hex(CLI_COLORS.NEUTRAL)(" (skill: files rewritten)")
-      );
+    for (const line of changeSummaryLines(changes, newSkills, oldSkills)) {
+      this.log(line);
     }
     this.log("");
   }
-  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)
-    ]);
-    if (migratedSkillIds.size === 0) return migratedSkillIds;
-    if (migrationPlan.toEject.length > 0) {
-      this.logModeSwitch(migrationPlan.toEject.length, INSTALL_MODE_DESCRIPTIONS.eject);
-    }
+  async applyMigrations(changes, active, context, editRoot) {
+    const migrationPlan = migrationPlanOf(changes, active);
+    if (migrationPlan.toEject.length === 0 && migrationPlan.toPlugin.length === 0) return;
+    this.announceMigrations(migrationPlan);
     if (migrationPlan.toPlugin.length > 0) {
-      this.logModeSwitch(migrationPlan.toPlugin.length, INSTALL_MODE_DESCRIPTIONS.plugin);
       await this.requireMarketplaceOrExit(
         context.sourceResult,
         "migrate skills to plugin mode",
@@ -676,7 +720,6 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
     if (migrationPlan.toPlugin.length > 0) {
       this.reportPluginInstalls(migrationResult.pluginInstalls);
     }
-    return migratedSkillIds;
   }
   /**
    * Mirrors `BaseCommand.reportPluginInstalls` for the plugin→eject half. The count line names no
@@ -691,26 +734,46 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
     }
     this.log(chalk.hex(CLI_COLORS.NEUTRAL)(localSkillsCopied(result.copied.length)));
   }
+  /**
+   * One line per kind, each counting its own: a mode switch, then a skill added in the project
+   * beside the global install it keeps (`keepsGlobalInstall` decides both the keep and the line).
+   */
+  announceMigrations(plan) {
+    const [copiesBesideGlobalPlugin, switchesToEject] = partition(plan.toEject, keepsGlobalInstall);
+    const [installsBesideGlobalCopy, switchesToPlugin] = partition(
+      plan.toPlugin,
+      keepsGlobalInstall
+    );
+    if (switchesToEject.length > 0) {
+      this.logModeSwitch(switchesToEject.length, INSTALL_MODE_DESCRIPTIONS.eject);
+    }
+    if (copiesBesideGlobalPlugin.length > 0) {
+      this.logCopiesBesideGlobalPlugins(copiesBesideGlobalPlugin.length);
+    }
+    if (switchesToPlugin.length > 0) {
+      this.logModeSwitch(switchesToPlugin.length, INSTALL_MODE_DESCRIPTIONS.plugin);
+    }
+    if (installsBesideGlobalCopy.length > 0) {
+      this.logInstallsBesideGlobalCopies(installsBesideGlobalCopy.length);
+    }
+  }
   logModeSwitch(count, modeDescription) {
     this.log(chalk.hex(CLI_COLORS.NEUTRAL)(`Switching ${count} skill(s) to ${modeDescription}`));
   }
+  logCopiesBesideGlobalPlugins(count) {
+    this.log(chalk.hex(CLI_COLORS.NEUTRAL)(copyingBesideGlobalPlugins(count)));
+  }
+  logInstallsBesideGlobalCopies(count) {
+    this.log(chalk.hex(CLI_COLORS.NEUTRAL)(installingBesideGlobalCopies(count)));
+  }
   /**
    * A collapsed `[P][G]` pair is not a move: its project half is dropped
    * ({@link applyCollapsedPairs}).
    */
   async applyScopeChanges(changes, filteredResult, context, editRoot) {
     const scopeChanges = scopeMovesOf(changes);
-    for (const [skillId, change] of scopeChanges) {
-      const skillConfig = filteredResult.skills.find((s) => s.id === skillId);
-      if (skillConfig?.origin === EJECT_SOURCE) {
-        await migrateLocalSkillScope(skillId, change.from, editRoot.dir);
-      }
-    }
-    const hasPluginScopeChanges = [...scopeChanges.keys()].some((skillId) => {
-      const skillConfig = filteredResult.skills.find((s) => s.id === skillId);
-      return skillConfig && skillConfig.origin !== EJECT_SOURCE;
-    });
-    if (!hasPluginScopeChanges) return;
+    await moveEjectedSkillCopies(scopeChanges, filteredResult.skills, editRoot.dir);
+    if (!movesAPluginSkill(scopeChanges, filteredResult.skills)) return;
     const marketplace = await this.requireMarketplaceOrExit(
       context.sourceResult,
       "migrate plugin skill scopes",
@@ -755,33 +818,27 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
       }
       return;
     }
-    const uninstallResult = await uninstallPluginSkills(
+    await this.uninstallPluginSkillsReported(
       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)`)
-      );
+  }
+  async uninstallPluginSkillsReported(skillIds, oldSkills, marketplace, projectDir) {
+    const { uninstalled, failed } = await uninstallPluginSkills(
+      skillIds,
+      oldSkills,
+      marketplace,
+      projectDir
+    );
+    if (uninstalled.length > 0) {
+      this.log(chalk.hex(CLI_COLORS.NEUTRAL)(`Removed ${uninstalled.length} plugin(s)`));
     }
-    for (const item of uninstallResult.failed) {
+    for (const item of 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) {
-      if (migratedSkillIds.has(skillId)) {
-        continue;
-      }
-      if (change.from === EJECT_SOURCE) {
-        const oldSkill = activeOldSkills.find((s) => s.id === skillId);
-        await deleteLocalSkill(editRoot.dir, skillId, oldSkill?.scope);
-      }
-    }
-  }
   async applyPluginChanges(changes, filteredResult, activeOldSkills, context, editRoot) {
     const { addedSkills, removedSkills } = changes;
     const addedPluginSkills = filteredResult.skills.filter(
@@ -805,20 +862,12 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
       );
     }
     if (removedPluginSkills.length > 0) {
-      const uninstallResult = await uninstallPluginSkills(
+      await this.uninstallPluginSkillsReported(
         removedPluginSkills,
         activeOldSkills,
         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 copyNewLocalSkills(changes, filteredResult, context, editRoot) {
@@ -843,57 +892,48 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
       await deleteLocalSkill(editRoot.dir, skillId, oldSkill.scope);
     }
   }
-  async writeConfigAndCompile(result, context, editRoot, authority) {
-    let agentDefsResult;
+  async writeConfigAndCompile(result, context, editRoot) {
+    const agentDefs = await this.loadAgentDefsOrFail();
+    const configResult = await this.writeConfigOrFail(result, context, editRoot, agentDefs);
+    this.reportUnassignedSkills(configResult.config, result.skills);
+    await this.recompileAgents(result, editRoot, configResult.propagation, agentDefs.sourcePath);
+    this.reportFanOut(configResult.propagation);
+  }
+  async loadAgentDefsOrFail() {
     try {
-      agentDefsResult = await loadAgentDefs();
+      return await loadAgentDefs();
     } catch (error) {
       this.handleError(error);
     }
-    let configResult;
+  }
+  /** Fatal: every mutation has landed and config.ts is their only record. */
+  async writeConfigOrFail(result, context, editRoot, agentDefs) {
     try {
-      configResult = await writeProjectConfig({
+      return await writeProjectConfig({
         selection: result,
         sourceResult: context.sourceResult,
         projectDir: editRoot.dir,
-        agentDefs: agentDefsResult,
-        authoritativeScope: authority
+        agentDefs,
+        authoritativeScope: applyAuthority(editRoot)
       });
     } catch (error) {
       this.error(`Could not update config: ${getErrorMessage(error)}`, {
         exit: EXIT_CODES.ERROR
       });
     }
-    this.reportUnassignedSkills(configResult.config, result.skills);
+  }
+  async recompileAgents(result, editRoot, propagation, sourcePath) {
     try {
       const agentScopeMap = activeAgentScopeMap(result.agentConfigs);
       const { allSkills } = await discoverInstalledSkills(editRoot.dir);
-      const compile = compilesGlobalScope(editRoot, configResult.propagation) ? compileAgentsAllScopes : compileProjectScope;
-      const compilationResult = await compile({
+      const compile = compilesGlobalScope(editRoot, propagation) ? compileAgentsAllScopes : compileProjectScope;
+      const compilation = await compile({
         projectDir: editRoot.dir,
-        sourcePath: agentDefsResult.sourcePath,
+        sourcePath,
         skills: allSkills,
         agentScopeMap
       });
-      const { compiled, rewritten, failed, warnings } = compilationResult;
-      const summary = recompileSummary(
-        rewritten.length,
-        compiled.length - rewritten.length,
-        RECOMPILE_SUBJECT
-      );
-      if (failed.length > 0) {
-        this.log(
-          chalk.hex(CLI_COLORS.NEUTRAL)(summary) + chalk.hex(CLI_COLORS.WARNING)(` (${failed.length} failed)`)
-        );
-        for (const warning of warnings) {
-          this.warn(warning);
-        }
-        this.recordIncompleteWork(agentsNotCompiled(failed), INCOMPLETE_WORK_RECOVERY.RECOMPILE);
-      } else if (compiled.length > 0) {
-        this.log(chalk.hex(CLI_COLORS.NEUTRAL)(summary));
-      } else {
-        this.log(chalk.hex(CLI_COLORS.NEUTRAL)(INFO_MESSAGES.NO_AGENTS_TO_RECOMPILE));
-      }
+      this.reportRecompile(compilation);
     } catch (error) {
       this.reportIncompleteWork(
         `Agent recompilation failed: ${getErrorMessage(error)}`,
@@ -901,7 +941,26 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
       );
       this.log(`You can manually recompile with '${CLI_INVOKE_COMMAND} compile'.`);
     }
-    this.reportFanOut(configResult.propagation);
+  }
+  reportRecompile({ compiled, rewritten, failed, warnings }) {
+    const summary = recompileSummary(
+      rewritten.length,
+      compiled.length - rewritten.length,
+      RECOMPILE_SUBJECT
+    );
+    if (failed.length > 0) {
+      this.log(
+        chalk.hex(CLI_COLORS.NEUTRAL)(summary) + chalk.hex(CLI_COLORS.WARNING)(` (${failed.length} failed)`)
+      );
+      for (const warning of warnings) {
+        this.warn(warning);
+      }
+      this.recordIncompleteWork(agentsNotCompiled(failed), INCOMPLETE_WORK_RECOVERY.RECOMPILE);
+    } else if (compiled.length > 0) {
+      this.log(chalk.hex(CLI_COLORS.NEUTRAL)(summary));
+    } else {
+      this.log(chalk.hex(CLI_COLORS.NEUTRAL)(INFO_MESSAGES.NO_AGENTS_TO_RECOMPILE));
+    }
   }
   async cleanupStaleAgentFiles(changes, oldAgents, editRoot) {
     for (const removal of planStaleAgentRemovals(changes, oldAgents, editRoot.dir)) {
@@ -926,7 +985,7 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
       this.log(notice);
     }
   }
-  logCompletionSummary(_changes) {
+  logCompletionSummary() {
     if (this.hasIncompleteWork) return;
     this.log(`
 ${chalk.hex(CLI_COLORS.SUCCESS)("\u2713 Done")}
@@ -954,44 +1013,63 @@ function detectConfigChanges(oldConfig, selection, fullEntries) {
   );
   const dualScopeSkillTransitions = detectDualScopeTransitions(
     scopeChanges,
-    fullEntries?.newSkills ?? [],
-    fullEntries?.oldSkills ?? [],
+    fullEntries.newSkills,
+    fullEntries.oldSkills,
     (s) => s.id
   );
   const collapsedPairs = collapsedPairsOf(
     scopeChanges,
     dualScopeSkillTransitions,
-    fullEntries?.oldSkills ?? []
+    fullEntries.oldSkills
+  );
+  const dualScopeAgentTransitions = detectDualScopeTransitions(
+    agentScopeChanges,
+    fullEntries.newAgents,
+    fullEntries.oldAgents,
+    (a) => a.name
   );
+  const arrivingSkills = arrivingProjectHalves(scopeChanges, dualScopeSkillTransitions);
   return {
     addedSkills: difference(newSkillIds, oldSkillIds),
     removedSkills: difference(oldSkillIds, newSkillIds),
     addedAgents: difference(newAgentNames, oldAgentNames),
     removedAgents: difference(oldAgentNames, newAgentNames),
-    sourceChanges: detectPropertyChanges(
-      selection.skills,
-      indexBy(withMaskedGlobalsRestored(oldConfig?.skills ?? [], collapsedPairs), (s) => s.id),
-      (s) => s.id,
-      (s) => s.origin
+    sourceChanges: withoutKeys(
+      detectPropertyChanges(
+        selection.skills,
+        indexBy(withMaskedGlobalsRestored(oldConfig?.skills ?? [], collapsedPairs), (s) => s.id),
+        (s) => s.id,
+        (s) => s.origin
+      ),
+      arrivingSkills
     ),
     scopeChanges,
     agentScopeChanges,
     dualScopeSkillTransitions,
     collapsedPairs,
-    dualScopeAgentTransitions: detectDualScopeTransitions(
-      agentScopeChanges,
-      fullEntries?.newAgents ?? [],
-      fullEntries?.oldAgents ?? [],
-      (a) => a.name
-    ),
-    tuningChanges: detectPropertyChanges(
-      selection.agentConfigs,
-      oldAgentsByName,
-      (a) => a.name,
-      describeTuning
+    dualScopeAgentTransitions,
+    // Either half of a pair is measured against the other install, which this edit never retunes.
+    tuningChanges: withoutKeys(
+      detectPropertyChanges(selection.agentConfigs, oldAgentsByName, (a) => a.name, describeTuning),
+      dualScopeAgentTransitions
     )
   };
 }
+function skillsNewHere(changes) {
+  return [
+    ...changes.addedSkills,
+    ...arrivingProjectHalves(changes.scopeChanges, changes.dualScopeSkillTransitions)
+  ];
+}
+function arrivingProjectHalves(scopeChanges, dualScopeTransitions) {
+  const arriving = [...scopeChanges].filter(
+    ([key, change]) => change.to === "project" && dualScopeTransitions.has(key)
+  );
+  return new Set(arriving.map(([key]) => key));
+}
+function withoutKeys(changes, keys) {
+  return new Map([...changes].filter(([key]) => !keys.has(key)));
+}
 var RESTING_TUNING = "defaults";
 function describeTuning(agent) {
   const settings = [
@@ -1012,17 +1090,20 @@ function detectPropertyChanges(newItems, oldByKey, getKey, getValue) {
   }
   return changes;
 }
+function globalHalvesKeptInstalled(installedGlobal) {
+  if (installedGlobal === null) return { skills: [], agents: [] };
+  return {
+    skills: installedGlobal.skills.map(asTombstone),
+    agents: installedGlobal.agents.map(asTombstone)
+  };
+}
+function asTombstone(entry) {
+  return { ...entry, excluded: true };
+}
 function detectDualScopeTransitions(scopeChanges, fullNew, fullOld, getKey) {
-  const hasGlobalTombstone = (items, key) => items.some((item) => getKey(item) === key && item.scope === "global" && item.excluded === true);
-  const result = /* @__PURE__ */ new Set();
-  for (const [key, change] of scopeChanges) {
-    if (change.from === "global" && change.to === "project" && hasGlobalTombstone(fullNew, key)) {
-      result.add(key);
-    } else if (change.from === "project" && change.to === "global" && hasGlobalTombstone(fullOld, key)) {
-      result.add(key);
-    }
-  }
-  return result;
+  const hasGlobalTombstone = (items, key) => items.some((item) => getKey(item) === key && isGlobalTombstone(item));
+  const isDualScope = ([key, { from, to }]) => from === "global" && to === "project" && hasGlobalTombstone(fullNew, key) || from === "project" && to === "global" && hasGlobalTombstone(fullOld, key);
+  return new Set([...scopeChanges].filter(isDualScope).map(([key]) => key));
 }
 function collapsedPairsOf(scopeChanges, dualScopeSkillTransitions, fullOldSkills) {
   return [...scopeChanges].filter(([id, change]) => change.to === "global" && dualScopeSkillTransitions.has(id)).map(([id]) => ({
@@ -1056,6 +1137,20 @@ function scopeMovesOf(changes) {
   const collapsed = new Set(changes.collapsedPairs.map(({ projectHalf }) => projectHalf.id));
   return new Map([...changes.scopeChanges].filter(([id]) => !collapsed.has(id)));
 }
+async function moveEjectedSkillCopies(scopeMoves, skills, projectDir) {
+  for (const [skillId, change] of scopeMoves) {
+    const skillConfig = skills.find((s) => s.id === skillId);
+    if (skillConfig?.origin === EJECT_SOURCE) {
+      await migrateLocalSkillScope(skillId, change.from, projectDir);
+    }
+  }
+}
+function movesAPluginSkill(scopeMoves, skills) {
+  return [...scopeMoves.keys()].some((skillId) => {
+    const skill = skills.find((s) => s.id === skillId);
+    return skill !== void 0 && skill.origin !== EJECT_SOURCE;
+  });
+}
 var STALE_AGENT_SCOPES = ["project", "global"];
 var UNRECORDED_AGENT_SCOPE = "project";
 function installedScope(name, oldAgents) {
@@ -1075,11 +1170,13 @@ function planStaleAgentRemovals(changes, oldAgents, editRoot) {
   return STALE_AGENT_SCOPES.map(removalAtScope).filter((removal) => removal.agents.length > 0);
 }
 function hasAnyChanges(changes) {
-  return changes.reassignedAgents.length > 0 || changes.joinedGlobalAgents.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;
+  return changes.rewrittenSkills.length > 0 || changesTheConfig(changes);
+}
+function changesTheConfig(changes) {
+  return changes.reassignedAgents.length > 0 || changes.joinedGlobalAgents.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) {
     const skillConfig = skills.find((s) => s.id === skillId);
@@ -1092,16 +1189,13 @@ async function migratePluginSkillScopes(scopeChanges, skills, marketplace, proje
         await host.uninstallPlugin(pluginRef, "project", projectDir);
       }
       await host.installPlugin(pluginRef, change.to, projectDir);
-      migrated.push(skillId);
     } catch (error) {
       failed.push({ id: skillId, error: getErrorMessage(error) });
     }
   }
-  return { migrated, failed };
+  return { failed };
 }
 export {
-  Edit as default,
-  detectConfigChanges,
-  migratePluginSkillScopes
+  Edit as default
 };
 //# sourceMappingURL=edit.js.map