agents-inc 0.153.0 → 0.155.0

package/dist/commands/edit.js

@@ -1,98 +1,136 @@
 #!/usr/bin/env node
 import {
-  Spinner
-} from "../chunk-ZBPEFQ4G.js";
+  publishSeedConfig,
+  seedPayloadForInstallation,
+  skillsAuthoredHere
+} from "../chunk-2H7UWE2G.js";
+import {
+  RemovalPlanConfirm
+} from "../chunk-D2CAV7MG.js";
+import "../chunk-OZXAJNLA.js";
+import {
+  seedToWizardResult
+} from "../chunk-MO5FGLVS.js";
 import {
   runWizardSession
-} from "../chunk-KET3EVGX.js";
-import "../chunk-BMGBA6HJ.js";
-import "../chunk-M5HSTNYU.js";
-import "../chunk-NSJ2S7R5.js";
-import "../chunk-JC7DBPRD.js";
-import "../chunk-K7PJDWER.js";
-import "../chunk-WDAO3RUY.js";
-import "../chunk-R4SEU3DF.js";
-import "../chunk-VECFAKM5.js";
-import "../chunk-VGEBYCQZ.js";
-import "../chunk-U2DNAHFE.js";
-import "../chunk-WG6V6VJV.js";
-import "../chunk-EFU6P3B7.js";
+} from "../chunk-IXRZAHZF.js";
+import "../chunk-TNGMF4UX.js";
+import "../chunk-LJCNUP6M.js";
+import "../chunk-HTYH7CKN.js";
+import "../chunk-PCC4LBKB.js";
+import "../chunk-HG4JPXJT.js";
+import "../chunk-6RLV45HN.js";
+import "../chunk-ILUVL7WM.js";
+import "../chunk-HXKOIWLU.js";
+import "../chunk-QWVXOCXO.js";
+import "../chunk-GS2NZ3GD.js";
+import "../chunk-VPASBA7P.js";
+import "../chunk-PNMM5HNX.js";
+import "../chunk-CLFHC2DK.js";
+import "../chunk-5OKLCVM4.js";
+import "../chunk-5F2YR5XV.js";
 import "../chunk-TSIU7DME.js";
 import "../chunk-XVAQG2CV.js";
-import "../chunk-ZNDLUWWD.js";
+import {
+  Spinner
+} from "../chunk-ZBPEFQ4G.js";
+import "../chunk-4A4L3YIW.js";
 import "../chunk-J27W6TXS.js";
-import "../chunk-4VYALFQZ.js";
-import "../chunk-JFAUQDZM.js";
-import "../chunk-IO4VEW5U.js";
-import "../chunk-V3ENMW7G.js";
-import "../chunk-2HC2SNRP.js";
-import "../chunk-Q5FLW4JG.js";
-import "../chunk-6CNRMCFM.js";
+import "../chunk-SY4X2LND.js";
+import "../chunk-WFRTHH3A.js";
+import "../chunk-WTJ3AY33.js";
+import "../chunk-OKH64JZE.js";
+import {
+  fetchSeedConfig,
+  registerExternalSkills,
+  writeExternalSkills
+} from "../chunk-PMUABBPG.js";
+import {
+  promptConfirm
+} from "../chunk-JCPANDNR.js";
 import {
   compileAgentsAllScopes,
   detectProject,
   loadSource,
   writeProjectConfig
-} from "../chunk-F7Z5I6GU.js";
+} from "../chunk-WUQ3MTPF.js";
 import {
   discoverInstalledSkills,
+  removeCompiledAgents,
   uninstallPluginSkills
-} from "../chunk-REKOWTIB.js";
-import {
-  copyLocalSkills
-} from "../chunk-NXGMM5YN.js";
+} from "../chunk-5QZAK6J7.js";
 import {
   loadAgentDefs
-} from "../chunk-FRWKCE6R.js";
-import "../chunk-FIHTAFST.js";
-import "../chunk-ACKC577F.js";
+} from "../chunk-MHRC3KRX.js";
+import {
+  copyLocalSkills
+} from "../chunk-F2AMBBIA.js";
+import "../chunk-ZUAZHDKP.js";
+import "../chunk-Y5Y7XHVU.js";
 import {
   render
 } from "../chunk-JFLVEFFP.js";
 import {
-  formatScopeTag
-} from "../chunk-HEBPKK5L.js";
+  formatScopeTag,
+  orderDomains
+} from "../chunk-F5T6TV4Z.js";
 import {
   BaseCommand,
   EXIT_CODES
-} from "../chunk-X5XJ6WKO.js";
-import "../chunk-TY6CAOL7.js";
-import "../chunk-K3O3YQYG.js";
+} from "../chunk-YO2LTXB4.js";
+import "../chunk-UMH2YZKG.js";
+import "../chunk-G47TDUK3.js";
 import {
   ERROR_MESSAGES,
   INFO_MESSAGES,
   INSTALL_MODE_DESCRIPTIONS,
+  SHARED_CONFIG_APPLY,
+  SHARED_CONFIG_ONE_DIRECTION,
   STATUS_MESSAGES,
   activeAgentNames,
   activeAgentScopeMap,
   applyMigratedGlobalSources,
+  authoredHereKept,
   buildMarketplacePluginRef,
+  carriedSkillsWritten,
   claudePluginInstall,
   claudePluginUninstall,
   deleteLocalSkill,
   detectMigrations,
   discoverAllPluginSkills,
+  ejectCopyFailureError,
+  execCommand,
   executeMigration,
+  globallyInstalledRemoved,
   installBaseDir,
   isActiveAt,
   isHomeDirectory,
+  loadProjectConfigFromDir,
+  localSkillsCopied,
   migrateLocalSkillScope,
   mutateGlobal,
+  normalizeProjectPath,
   recompileSummary,
   resolveInstallPaths,
+  sharedConfigDestinations,
+  sharedConfigNeedsTerminal,
+  skippedUnknownAgents,
+  skippedUnknownSkills,
   toClaudePluginScope,
+  unplaceableKept,
   unresolvedSkillRemovalReasons
-} from "../chunk-NXQAY5U7.js";
+} from "../chunk-WCAUUBHO.js";
 import {
-  getErrorMessage,
-  remove
-} from "../chunk-U2YSGBHA.js";
+  getErrorMessage
+} from "../chunk-XAXJWXI4.js";
 import {
+  getCategoryDomain,
   getSkillById,
   getSkillDisplayName,
   matrix
-} from "../chunk-35VOK7XE.js";
+} from "../chunk-RWOYPOMR.js";
 import {
+  typedEntries,
   typedKeys
 } from "../chunk-VASLW636.js";
 import {
@@ -100,15 +138,121 @@ import {
   CLI_INVOKE_COMMAND,
   EDIT_PROJECT_SETUP_FLAG,
   EJECT_SOURCE,
+  editorConfigUrl,
   formatSourceDisplayName
-} from "../chunk-R54KIGN2.js";
+} from "../chunk-IO5YBKHV.js";
 import "../chunk-VZRO7RYT.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 } from "remeda";
+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/utils/open-url.ts
+function browserOpenerCommand(platform, url) {
+  if (platform === "darwin") return { command: "open", args: [url] };
+  if (platform === "win32") return { command: "cmd", args: ["/c", "start", "", url] };
+  return { command: "xdg-open", args: [url] };
+}
+function openerRefusedMessage(command, exitCode) {
+  return `Could not open your browser \u2014 '${command}' exited ${exitCode}.`;
+}
+function openerUnavailableMessage(command, reason) {
+  return `Could not open your browser \u2014 '${command}' could not be run: ${reason}`;
+}
+async function openUrl(url) {
+  const { command, args } = browserOpenerCommand(process.platform, url);
+  try {
+    const result = await execCommand(command, args);
+    if (result.exitCode !== 0) {
+      return { ok: false, error: openerRefusedMessage(command, result.exitCode) };
+    }
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: openerUnavailableMessage(command, getErrorMessage(error)) };
+  }
+}
+
+// src/cli/commands/edit.tsx
 import { jsx } from "react/jsx-runtime";
 var RECOMPILE_SUBJECT = "agents";
 function formatDualScopeTransition(displayName, to) {
@@ -140,6 +284,71 @@ function scopeArrow(change) {
 function loadedSourceLabel(sourceResult) {
   return sourceResult.marketplace ?? sourceResult.sourceConfig.source;
 }
+function globalScopePlan(changes, kept) {
+  const sections = removalSections(changes.removedSkills, changes.removedAgents);
+  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 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] }
+  ].filter((section) => section.items.length > 0);
+}
+function globalReachStatement(global, otherProjects) {
+  if (global.skills.length === 0 && global.agents.length === 0) return [];
+  return [globallyInstalledRemoved(otherProjects)];
+}
+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 keptStatements(kept) {
+  return [...authorshipStatement(kept), ...catalogueStatement(kept)];
+}
+function authorshipStatement(kept) {
+  if (kept.authoredSkillIds.length === 0) return [];
+  return [authoredHereKept(kept.authoredSkillIds)];
+}
+function catalogueStatement(kept) {
+  if (kept.unplaceableSkillIds.length === 0) return [];
+  return [unplaceableKept(kept.unplaceableSkillIds)];
+}
+function applyAuthority(producer, cwd) {
+  if (isHomeDirectory(cwd)) return "all";
+  return producer === "shared" ? "all" : "owned";
+}
 var Edit = class _Edit extends BaseCommand {
   static summary = "Edit skills in the plugin";
   static description = "Modify the currently installed skills via interactive wizard";
@@ -147,9 +356,25 @@ var Edit = class _Edit extends BaseCommand {
     {
       description: "Open the edit wizard",
       command: "<%= config.bin %> <%= command.id %>"
+    },
+    {
+      description: "Open this installation in the editor instead of the wizard",
+      command: "<%= config.bin %> <%= command.id %> --ui"
+    },
+    {
+      description: "Apply a configuration built in the editor, by its id",
+      command: "<%= config.bin %> <%= command.id %> --from <id>"
     }
   ];
   static flags = {
+    ui: Flags.boolean({
+      description: "Edit this installation in the browser at agentsinc.sh instead of the wizard",
+      default: false
+    }),
+    from: Flags.string({
+      description: "Apply a configuration shared from agentsinc.sh by its id, removing whatever it leaves out",
+      helpValue: "<id>"
+    }),
     [EDIT_PROJECT_SETUP_FLAG]: Flags.boolean({
       description: "Internal: this run continues an `init` project setup",
       default: false,
@@ -160,19 +385,20 @@ var Edit = class _Edit extends BaseCommand {
     const { flags } = await this.parse(_Edit);
     const cwd = process.cwd();
     await this.ensureConfigReadable(cwd);
-    const { unmount, clear: clearSpinner } = render(
-      /* @__PURE__ */ jsx(Spinner, { label: STATUS_MESSAGES.LOADING_SKILLS })
-    );
-    const context = await this.loadContext();
-    clearSpinner();
-    unmount();
+    if (flags.ui && flags.from !== void 0) {
+      this.error(SHARED_CONFIG_ONE_DIRECTION, { exit: EXIT_CODES.ERROR });
+    }
+    if (flags.ui) return this.openInEditor(cwd);
+    const payload = flags.from === void 0 ? null : await this.fetchSharedConfigOrFail(flags.from);
+    const context = await this.loadContextUnderSpinner();
     await this.ensureSavedSkillsReadable(
       context.projectConfig?.skills ?? [],
       context.sourceResult.matrix,
       context.projectDir
     );
-    const result = await this.runEditWizard(context, cwd);
-    if (!result) this.error("Cancelled", { exit: EXIT_CODES.CANCELLED });
+    const selection = payload ? await this.selectionFromSharedConfig(payload, context, cwd) : await this.selectionFromWizard(context, cwd);
+    if (!selection) this.error("Cancelled", { exit: EXIT_CODES.CANCELLED });
+    const { result } = selection;
     this.reportValidationErrors(result.validation);
     const activeNewSkills = result.skills.filter((s) => !s.excluded);
     const activeNewAgents = result.agentConfigs.filter((a) => !a.excluded);
@@ -191,10 +417,20 @@ var Edit = class _Edit extends BaseCommand {
       oldAgents: context.projectConfig?.agents ?? []
     });
     const isProjectSetup = flags[EDIT_PROJECT_SETUP_FLAG] && !isHomeDirectory(cwd);
+    if (selection.producer === "shared") {
+      await this.confirmSharedConfigOrCancel(
+        changes,
+        selection.kept,
+        { skills: activeOldSkills, agents: activeOldAgents },
+        cwd
+      );
+      await this.writeCarriedSkills(selection.carried);
+    }
+    const authority = applyAuthority(selection.producer, cwd);
     if (!hasAnyChanges(changes)) {
       this.log(chalk.hex(CLI_COLORS.NEUTRAL)("No changes made."));
       if (!isProjectSetup) return;
-      await this.writeConfigAndCompile(result, context, cwd);
+      await this.writeConfigAndCompile(result, context, cwd, authority);
       this.logCompletionSummary(changes);
       return;
     }
@@ -223,10 +459,239 @@ var Edit = class _Edit extends BaseCommand {
     await this.applyPluginChanges(changes, filteredResult, activeOldSkills, context, cwd);
     await this.copyNewLocalSkills(changes, filteredResult, context, cwd);
     await this.removeDeletedLocalSkills(changes, activeOldSkills, cwd);
-    await this.writeConfigAndCompile(result, context, cwd);
+    await this.writeConfigAndCompile(result, context, cwd, authority);
     await this.cleanupStaleAgentFiles(changes, activeOldAgents, cwd);
     this.logCompletionSummary(changes);
   }
+  /** The interactive producer: open the wizard on what is installed, return what was chosen. */
+  async selectionFromWizard(context, cwd) {
+    const result = await this.runEditWizard(context, cwd);
+    if (!result) return null;
+    return { producer: "wizard", result };
+  }
+  /**
+   * The `--from <id>` producer: fetch, seat what the configuration carries, decode, and put back
+   * what this run has no authority to remove.
+   *
+   * Everything a shared configuration says is a statement about the whole roster, so the apply
+   * that follows is destructive — the project is made to MATCH it. Two exceptions come back into
+   * the result: a skill written here, which the producer drops on the way out because
+   * `forkedFrom` says the CLI never wrote it, and an id the configuration NAMES that this
+   * 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.
+   */
+  async selectionFromSharedConfig(payload, context, cwd) {
+    const { matrix: sourceMatrix } = context.sourceResult;
+    const carried = this.registerExternalSkillsOrFail(payload, sourceMatrix, cwd);
+    const { result, skippedSkillIds, skippedAgentNames } = this.decodeSeedOrFail(
+      payload,
+      sourceMatrix
+    );
+    this.refuseProjectScopedContentAtHome(result, cwd);
+    if (skippedSkillIds.length > 0) this.warn(skippedUnknownSkills(skippedSkillIds));
+    if (skippedAgentNames.length > 0) this.warn(skippedUnknownAgents(skippedAgentNames));
+    const reconciled = reconcileSharedConfig({
+      decoded: result,
+      installed: context.projectConfig,
+      authoredHere: await this.readAuthoredHere(context.projectConfig, cwd),
+      // 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)
+    });
+    return {
+      producer: "shared",
+      result: reconciled.result,
+      kept: keptStatements(reconciled.kept),
+      carried
+    };
+  }
+  /**
+   * Which installed skills the round trip does not own, asked of the disk exactly as the
+   * producing half asks it.
+   *
+   * Best-effort by nature and never fatal: the question is only ever asked to PROTECT a skill,
+   * so a directory that cannot be read protects nothing and must not fail an apply. The
+   * consequence of an unanswered question is that the entry is treated as the CLI's own, which
+   * is what every other command already assumes about it.
+   */
+  async readAuthoredHere(projectConfig, cwd) {
+    if (!projectConfig) return /* @__PURE__ */ new Set();
+    try {
+      return await skillsAuthoredHere(projectConfig, cwd);
+    } catch (error) {
+      this.warn(`Could not tell which skills were written here: ${getErrorMessage(error)}`);
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  /**
+   * 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.
+   */
+  async fetchSharedConfigOrFail(id) {
+    if (!process.stdin.isTTY) {
+      this.error(sharedConfigNeedsTerminal(id), { exit: EXIT_CODES.ERROR });
+    }
+    this.log(`Fetching configuration ${id}...`);
+    const fetched = await fetchSeedConfig(id);
+    if (!fetched.ok) {
+      this.error(fetched.error, { exit: EXIT_CODES.ERROR });
+    }
+    return fetched.payload;
+  }
+  /**
+   * The decode refuses a payload the config model has nowhere to write (see `seedToWizardResult`).
+   * That is a failure of this command, reported with this command's exit code rather than left to
+   * surface as an unhandled throw.
+   */
+  decodeSeedOrFail(payload, sourceMatrix) {
+    try {
+      return seedToWizardResult(payload, sourceMatrix);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Seats the catalogue entries the payload carries with it, or refuses the run. The refusal is
+   * `registerExternalSkills`' own — a carried skill asked for as a plugin, which no marketplace
+   * serves — reported with this command's exit code for the same reason the decode's is.
+   */
+  registerExternalSkillsOrFail(payload, sourceMatrix, projectDir) {
+    try {
+      return registerExternalSkills(payload, sourceMatrix, projectDir);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /** Writes the skills the configuration brought with it, and says which they were. */
+  async writeCarriedSkills(carried) {
+    if (carried.length === 0) return;
+    await writeExternalSkills(carried);
+    this.log(carriedSkillsWritten(carried.map((skill) => skill.id)));
+  }
+  /**
+   * Shows what applying this configuration takes away, and stops the run unless a person says
+   * yes.
+   *
+   * The plan is built from the SAME `ConfigChanges` the apply below acts on, so what is approved
+   * and what is removed are one value read twice. Its kept half is the other side of the same
+   * 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.
+   */
+  async confirmSharedConfigOrCancel(changes, kept, installed, cwd) {
+    const plan = isHomeDirectory(cwd) ? globalScopePlan(changes, kept) : projectScopePlan(changes, kept, installed, await this.otherRegisteredProjects(cwd));
+    const outcome = await promptConfirm(({ onConfirm, onCancel }) => /* @__PURE__ */ jsx(
+      RemovalPlanConfirm,
+      {
+        heading: plan.heading,
+        sections: plan.sections,
+        statements: plan.statements,
+        message: SHARED_CONFIG_APPLY.CONFIRM,
+        onConfirm,
+        onCancel
+      }
+    ));
+    if (outcome === "confirmed") return;
+    this.log("\nEdit cancelled");
+    this.error("Cancelled", { exit: EXIT_CODES.CANCELLED });
+  }
+  /**
+   * Every registered project but this one — the blast radius a global removal actually has.
+   *
+   * 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.
+   */
+  async otherRegisteredProjects(cwd) {
+    try {
+      const global = await loadProjectConfigFromDir(os.homedir());
+      const here = normalizeProjectPath(cwd);
+      return (global?.config.projects ?? []).filter((projectDir) => projectDir !== here);
+    } catch (error) {
+      this.warn(`Could not tell which projects share this install: ${getErrorMessage(error)}`);
+      return [];
+    }
+  }
+  /**
+   * The outbound half of the editor round trip: this installation, minted as a configuration
+   * the editor opens, and handed to a browser.
+   *
+   * It is the same mint `share` performs — same reader, same mapping, same refusals, through
+   * `seedPayloadForInstallation` — because an id is the whole of what either command produces
+   * and two spellings of "the installation in this directory" would mint two different ids for
+   * one project. What differs is only the ending: `share` reports the id, this opens it.
+   *
+   * 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);
+  }
+  /**
+   * The link, printed first and opened second.
+   *
+   * Printed first because it is the only part of this that works everywhere: over a pipe, in CI
+   * and on a machine with no desktop session there is no browser to be anybody's, and a link
+   * nobody can copy is the whole loss. Opening one is the convenience on top, so a failure to
+   * open is a warning beside a link that still works rather than a failed command.
+   *
+   * `process.stdin.isTTY` is the same question `init`'s dashboard asks before it offers a
+   * prompt — is there a person here — because that is exactly what "whose browser is this"
+   * means.
+   */
+  async handToBrowser(id) {
+    this.logSuccess(`Shared as ${id}`);
+    for (const destination of sharedConfigDestinations(id)) {
+      this.log(destination);
+    }
+    if (!process.stdin.isTTY) return;
+    const opened = await openUrl(editorConfigUrl(id));
+    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.
+   */
+  async loadContextUnderSpinner() {
+    const { unmount, clear: clearSpinner } = render(
+      /* @__PURE__ */ jsx(Spinner, { label: STATUS_MESSAGES.LOADING_SKILLS })
+    );
+    try {
+      return await this.loadContext();
+    } finally {
+      clearSpinner();
+      unmount();
+    }
+  }
   async loadContext() {
     const detected = await detectProject();
     if (!detected) {
@@ -317,11 +782,19 @@ var Edit = class _Edit extends BaseCommand {
    * source contradict the filesystem and the plugin registry.
    *
    * So authority follows the work actually performed, and no further: only ids
-   * `executeMigration` acted on this run are rewritten, and only their `source` field. Global
+   * `executeMigration` acted on this run are rewritten, and only their `origin` field. Global
    * entries this session merely displayed, re-scoped or deselected are untouched, as are
    * `marketplace`, `stack`, `agents` and every other registered project's view of them.
-   * Refusing the switch instead is not an option — driving a global-scope migration from a
-   * project directory is a supported flow (`scope-aware-local-copy` lifecycle tests).
+   *
+   * Driving a global-scope migration from a project directory is NOT a supported flow, and this
+   * method is no longer the thing that permits it. The wizard now refuses it at source: the two
+   * bulk install-mode keys are withdrawn, and `setInstallMode` ignores a project-context call
+   * against a global slot the hydration snapshot owns — the same authority the Sources grid
+   * already enforced by rendering that row inert. What still reaches here is the residue that
+   * authority leaves legitimate: a mode change committed on the project half of a `[P][G]` pair
+   * and then carried to global scope by a P->G collapse (`s`) in the same session. The entry is
+   * the project's own to configure at the moment it is configured, and global at the moment it
+   * is written — so the migration is real, and the global config must record it.
    *
    * Runs BEFORE `writeConfigAndCompile`, so the global config written here is the one
    * the wizard write reloads, keeps (existing wins in `mergeGlobalConfigs`) and inlines
@@ -329,14 +802,14 @@ var Edit = class _Edit extends BaseCommand {
    * classifies as a no-op against what this one left on disk, so the fan-out below
    * happens once.
    *
-   * The migrated `source` decides the reference form a compiled agent emits, so every
+   * The migrated `origin` decides the reference form a compiled agent emits, so every
    * OTHER registered project's config and agents are stale until this write fans out —
    * which is why it goes through the gate rather than straight to the file.
    */
   async recordGlobalSourceMigrations(migratedSkillIds, newSkills, cwd, context) {
     if (isHomeDirectory(cwd)) return;
     const migratedSources = new Map(
-      newSkills.filter((s) => migratedSkillIds.has(s.id) && isActiveAt(s, "global")).map((s) => [s.id, s.source])
+      newSkills.filter((s) => migratedSkillIds.has(s.id) && isActiveAt(s, "global")).map((s) => [s.id, s.origin])
     );
     if (migratedSources.size === 0) return;
     try {
@@ -348,12 +821,12 @@ var Edit = class _Edit extends BaseCommand {
           // matrix in hand already.
           // eslint-disable-next-line @typescript-eslint/require-await -- deps contract
           loadMatrix: async () => context.sourceResult.matrix,
-          loadAgents: async () => (await loadAgentDefs({ projectDir: cwd })).agents
+          loadAgents: async () => (await loadAgentDefs()).agents
         }
       );
       this.reportPropagatedRecompile(report);
     } catch (error) {
-      this.warn(`Could not record global source change: ${getErrorMessage(error)}`);
+      this.warn(`Could not record global origin change: ${getErrorMessage(error)}`);
     }
   }
   logChangeSummary(changes, newSkills, oldSkills, removalReasons) {
@@ -430,11 +903,37 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
     for (const warning of migrationResult.warnings) {
       this.warn(warning);
     }
+    if (migrationPlan.toEject.length > 0) {
+      this.reportEjectCopies(migrationResult.ejectCopies);
+    }
     if (migrationPlan.toPlugin.length > 0) {
       this.reportPluginInstalls(migrationResult.pluginInstalls);
     }
     return migratedSkillIds;
   }
+  /**
+   * What the plugin→eject half copied, what it could not, and the refusal to continue past
+   * a failure.
+   *
+   * The shape of `BaseCommand.reportPluginInstalls`, deliberately: the two directions of one
+   * mode switch owe the user the same account, and the eject half having no structured
+   * failure at all is what let a config record `origin: "eject"` for a skill whose copy was
+   * refused. It stays private because `edit` is the only command that migrates a mode —
+   * `init` installs, and has no old state to move.
+   *
+   * The count line is the same one `copyNewLocalSkills` prints, and names no destination:
+   * the migration splits its copies between the project and $HOME by each skill's own scope,
+   * so one directory would misname the other half.
+   */
+  reportEjectCopies(result) {
+    for (const item of result.failed) {
+      this.warn(`Failed to copy ${item.id} for eject: ${item.error}`);
+    }
+    if (result.failed.length > 0) {
+      this.error(ejectCopyFailureError(result.failed.length), { exit: EXIT_CODES.ERROR });
+    }
+    this.log(chalk.hex(CLI_COLORS.NEUTRAL)(localSkillsCopied(result.copied.length)));
+  }
   /** Names what this run is switching, in the words `init` describes an install mode with. */
   logModeSwitch(count, modeDescription) {
     this.log(chalk.hex(CLI_COLORS.NEUTRAL)(`Switching ${count} skill(s) to ${modeDescription}`));
@@ -443,13 +942,13 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
     const { scopeChanges } = changes;
     for (const [skillId, change] of scopeChanges) {
       const skillConfig = filteredResult.skills.find((s) => s.id === skillId);
-      if (skillConfig?.source === EJECT_SOURCE) {
+      if (skillConfig?.origin === EJECT_SOURCE) {
         await migrateLocalSkillScope(skillId, change.from, cwd);
       }
     }
     const hasPluginScopeChanges = [...scopeChanges.keys()].some((skillId) => {
       const skillConfig = filteredResult.skills.find((s) => s.id === skillId);
-      return skillConfig && skillConfig.source !== EJECT_SOURCE;
+      return skillConfig && skillConfig.origin !== EJECT_SOURCE;
     });
     if (!hasPluginScopeChanges) return;
     const marketplace = await this.requireMarketplaceOrExit(
@@ -482,10 +981,10 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
   async applyPluginChanges(changes, filteredResult, activeOldSkills, context, cwd) {
     const { addedSkills, removedSkills } = changes;
     const addedPluginSkills = filteredResult.skills.filter(
-      (s) => addedSkills.includes(s.id) && s.source !== EJECT_SOURCE
+      (s) => addedSkills.includes(s.id) && s.origin !== EJECT_SOURCE
     );
     const removedPluginSkills = removedSkills.filter(
-      (id) => activeOldSkills.find((s) => s.id === id)?.source !== EJECT_SOURCE
+      (id) => activeOldSkills.find((s) => s.id === id)?.origin !== EJECT_SOURCE
     );
     if (addedPluginSkills.length === 0 && removedPluginSkills.length === 0) return;
     const marketplace = await this.requireMarketplaceOrExit(
@@ -493,7 +992,12 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
       "install or uninstall plugin skills"
     );
     if (addedPluginSkills.length > 0) {
-      await this.installPluginSkillsReported(addedPluginSkills, marketplace, cwd);
+      await this.installPluginSkillsReported(
+        addedPluginSkills,
+        marketplace,
+        cwd,
+        context.sourceResult.matrix
+      );
     }
     if (removedPluginSkills.length > 0) {
       const uninstallResult = await uninstallPluginSkills(
@@ -515,26 +1019,26 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
   async copyNewLocalSkills(changes, filteredResult, context, cwd) {
     const { addedSkills } = changes;
     const addedLocalSkills = filteredResult.skills.filter(
-      (s) => addedSkills.includes(s.id) && s.source === EJECT_SOURCE
+      (s) => addedSkills.includes(s.id) && s.origin === EJECT_SOURCE
     );
     if (addedLocalSkills.length > 0) {
       const copyResult = await copyLocalSkills(addedLocalSkills, cwd, context.sourceResult);
-      this.log(chalk.hex(CLI_COLORS.NEUTRAL)(`Copied ${copyResult.totalCopied} local skill(s)`));
+      this.log(chalk.hex(CLI_COLORS.NEUTRAL)(localSkillsCopied(copyResult.totalCopied)));
     }
   }
   async removeDeletedLocalSkills(changes, activeOldSkills, cwd) {
     const { removedSkills } = changes;
     for (const skillId of removedSkills) {
       const oldSkill = activeOldSkills.find((s) => s.id === skillId);
-      if (oldSkill?.source !== EJECT_SOURCE) continue;
+      if (oldSkill?.origin !== EJECT_SOURCE) continue;
       const deleteDir = installBaseDir(cwd, oldSkill.scope);
       await deleteLocalSkill(deleteDir, skillId);
     }
   }
-  async writeConfigAndCompile(result, context, cwd) {
+  async writeConfigAndCompile(result, context, cwd, authority) {
     let agentDefsResult;
     try {
-      agentDefsResult = await loadAgentDefs({});
+      agentDefsResult = await loadAgentDefs();
     } catch (error) {
       this.handleError(error);
     }
@@ -546,14 +1050,17 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
         projectDir: cwd,
         agents: agentDefsResult.agents,
         // A full `cc edit` pass is authoritative over the roster it owns, so deselected entries
-        // are removed rather than union-preserved (D-233 Scenario C). Global-context edit owns
-        // the entire config ("all"); a project edit owns only project-scoped entries and its own
-        // tombstones ("owned"), never inherited global-active entries.
-        authoritativeScope: isHomeDirectory(cwd) ? "all" : "owned"
+        // are removed rather than union-preserved (D-233 Scenario C). `applyAuthority` decides
+        // how much that is from the producer and the directory, and hands the same word to the
+        // merger and to the global config the project branch of the gate commits.
+        authoritativeScope: authority
       });
     } catch (error) {
-      this.warn(`Could not update config: ${getErrorMessage(error)}`);
+      this.error(`Could not update config: ${getErrorMessage(error)}`, {
+        exit: EXIT_CODES.ERROR
+      });
     }
+    this.reportUnassignedSkills(configResult.config);
     try {
       const agentScopeMap = activeAgentScopeMap(result.agentConfigs);
       const { allSkills } = await discoverInstalledSkills(cwd);
@@ -585,31 +1092,14 @@ ${chalk.hex(CLI_COLORS.WHITE).bold("Changes:")}`);
       this.warn(`Agent recompilation failed: ${getErrorMessage(error)}`);
       this.log(`You can manually recompile with '${CLI_INVOKE_COMMAND} compile'.`);
     }
-    if (configResult) {
-      this.reportPropagatedRecompile(configResult.propagation);
-    }
+    this.reportPropagatedRecompile(configResult.propagation);
   }
   async cleanupStaleAgentFiles(changes, oldAgents, cwd) {
-    const { agentScopeChanges, removedAgents } = changes;
-    for (const [agentName, change] of agentScopeChanges) {
-      if (change.from === "global") continue;
-      const oldAgentPath = path.join(
-        resolveInstallPaths(cwd, "project").agentsDir,
-        `${agentName}.md`
-      );
-      try {
-        await remove(oldAgentPath);
-      } catch (error) {
-        this.warn(`Could not remove old agent file ${oldAgentPath}: ${getErrorMessage(error)}`);
-      }
-    }
-    for (const agentName of removedAgents) {
-      const oldScope = oldAgents.find((a) => a.name === agentName)?.scope ?? "project";
-      const agentPath = path.join(resolveInstallPaths(cwd, oldScope).agentsDir, `${agentName}.md`);
-      try {
-        await remove(agentPath);
-      } catch (error) {
-        this.warn(`Could not remove agent file ${agentPath}: ${getErrorMessage(error)}`);
+    for (const removal of planStaleAgentRemovals(changes, oldAgents, cwd)) {
+      const { failed } = await removeCompiledAgents(removal);
+      for (const { name, error } of failed) {
+        const agentPath = path.join(removal.agentsDir, `${name}.md`);
+        this.warn(`Could not remove agent file ${agentPath}: ${error}`);
       }
     }
   }
@@ -647,7 +1137,7 @@ function detectConfigChanges(oldConfig, wizardResult, fullEntries) {
       wizardResult.skills,
       oldSkillsById,
       (s) => s.id,
-      (s) => s.source
+      (s) => s.origin
     ),
     scopeChanges,
     agentScopeChanges,
@@ -688,6 +1178,24 @@ function detectDualScopeTransitions(scopeChanges, fullNew, fullOld, getKey) {
   }
   return result;
 }
+var STALE_AGENT_SCOPES = ["project", "global"];
+var UNRECORDED_AGENT_SCOPE = "project";
+function installedScope(name, oldAgents) {
+  return oldAgents.find((agent) => agent.name === name)?.scope ?? UNRECORDED_AGENT_SCOPE;
+}
+function planStaleAgentRemovals(changes, oldAgents, cwd) {
+  const supersededByGlobal = [...changes.agentScopeChanges].filter(([, change]) => change.from !== "global").map(([name]) => ({ name, scope: "project" }));
+  const deselected = changes.removedAgents.map((name) => ({
+    name,
+    scope: installedScope(name, oldAgents)
+  }));
+  const stale = [...supersededByGlobal, ...deselected];
+  const removalAtScope = (scope) => ({
+    agentsDir: resolveInstallPaths(cwd, scope).agentsDir,
+    agents: stale.filter((agent) => agent.scope === scope).map((agent) => agent.name)
+  });
+  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;
 }
@@ -696,7 +1204,7 @@ async function migratePluginSkillScopes(scopeChanges, skills, marketplace, proje
   const failed = [];
   for (const [skillId, change] of scopeChanges) {
     const skillConfig = skills.find((s) => s.id === skillId);
-    if (!skillConfig || skillConfig.source === EJECT_SOURCE) {
+    if (!skillConfig || skillConfig.origin === EJECT_SOURCE) {
       continue;
     }
     const newPluginScope = toClaudePluginScope(change.to);