agents-inc 0.149.2 → 0.151.0

package/dist/commands/edit.js

@@ -0,0 +1,765 @@
+#!/usr/bin/env node
+import {
+  runWizardSession
+} from "../chunk-SI5FOARI.js";
+import {
+  Spinner
+} from "../chunk-OZZGXBCN.js";
+import "../chunk-EZ7STXUV.js";
+import "../chunk-UTFN6UJS.js";
+import "../chunk-EVXG3X6G.js";
+import "../chunk-OJIESW5B.js";
+import "../chunk-UFURYGD3.js";
+import "../chunk-RBHYLCUB.js";
+import "../chunk-LAXAQ3PZ.js";
+import "../chunk-NM3EDGB5.js";
+import "../chunk-NHCGC6DG.js";
+import "../chunk-BNE4HHIH.js";
+import "../chunk-TYJLR32W.js";
+import "../chunk-IOJR5TOY.js";
+import "../chunk-3YGUHWLR.js";
+import "../chunk-QQLRX4KI.js";
+import "../chunk-WK4J2CHH.js";
+import "../chunk-NIKUMXE7.js";
+import "../chunk-KOPEM3Q7.js";
+import "../chunk-2RSNKBXC.js";
+import "../chunk-DUVWGO6E.js";
+import "../chunk-KIR7VYQD.js";
+import "../chunk-6RBQBOBS.js";
+import "../chunk-LYYXX2W5.js";
+import "../chunk-SHHOMVWC.js";
+import "../chunk-YA4QQKKE.js";
+import "../chunk-XA57SX4T.js";
+import "../chunk-FYPUUYSG.js";
+import "../chunk-DAG2ULNF.js";
+import "../chunk-VG2TVBFN.js";
+import "../chunk-IHO75PMZ.js";
+import {
+  ERROR_MESSAGES,
+  STATUS_MESSAGES
+} from "../chunk-GYG5SE2D.js";
+import {
+  compileAgentsAllScopes,
+  detectProject,
+  loadSource,
+  writeProjectConfig
+} from "../chunk-Y4CXDA3I.js";
+import {
+  discoverInstalledSkills,
+  installPluginSkills,
+  pluginInstallFailureError,
+  uninstallPluginSkills
+} from "../chunk-4R6PGHQQ.js";
+import {
+  copyLocalSkills
+} from "../chunk-3XFUQ6OL.js";
+import {
+  loadAgentDefs
+} from "../chunk-YBVA7GPW.js";
+import "../chunk-NGLQ5W7U.js";
+import "../chunk-5V2O6C3T.js";
+import {
+  formatScopeTag
+} from "../chunk-44LLPS2N.js";
+import {
+  BaseCommand,
+  EXIT_CODES
+} from "../chunk-7QIHKQL5.js";
+import {
+  source_default
+} from "../chunk-SYUOXSPU.js";
+import "../chunk-P3PN5SVI.js";
+import {
+  activeAgentScopeMap,
+  applyMigratedGlobalSources,
+  buildMarketplacePluginRef,
+  claudePluginInstall,
+  claudePluginUninstall,
+  deleteLocalSkill,
+  detectMigrations,
+  discoverAllPluginSkills,
+  executeMigration,
+  installBaseDir,
+  isActiveAt,
+  isHomeDirectory,
+  migrateLocalSkillScope,
+  mutateGlobal,
+  resolveInstallPaths,
+  toClaudePluginScope
+} from "../chunk-TVHRMRD3.js";
+import {
+  getErrorMessage,
+  remove
+} from "../chunk-3LIU2ZEF.js";
+import {
+  getSkillById,
+  getSkillDisplayName,
+  matrix
+} from "../chunk-DG2NGZ7S.js";
+import {
+  typedKeys
+} from "../chunk-VEP23B5W.js";
+import {
+  CLI_COLORS,
+  CLI_INVOKE_COMMAND,
+  EDIT_PROJECT_SETUP_FLAG,
+  EJECT_SOURCE,
+  formatSourceDisplayName
+} from "../chunk-O5ASLZ2K.js";
+import "../chunk-YU2VGX5R.js";
+import {
+  init_esm_shims
+} from "../chunk-P56WJ5FA.js";
+
+// src/cli/commands/edit.tsx
+init_esm_shims();
+import path from "path";
+import { Flags } from "@oclif/core";
+import { render } from "ink";
+import { difference, indexBy } from "remeda";
+import { jsx } from "react/jsx-runtime";
+function formatDualScopeTransition(displayName, to) {
+  const isAdd = to === "project";
+  const prefix = isAdd ? "+" : "-";
+  const color = isAdd ? CLI_COLORS.SUCCESS : CLI_COLORS.ERROR;
+  return source_default.hex(color)(`  ${prefix} ${displayName} [P]`);
+}
+var Edit = class _Edit extends BaseCommand {
+  static summary = "Edit skills in the plugin";
+  static description = "Modify the currently installed skills via interactive wizard";
+  static examples = [
+    {
+      description: "Open the edit wizard",
+      command: "<%= config.bin %> <%= command.id %>"
+    },
+    {
+      description: "Edit with a custom source",
+      command: "<%= config.bin %> <%= command.id %> --source github:org/marketplace"
+    },
+    {
+      description: "Force refresh skills from remote",
+      command: "<%= config.bin %> <%= command.id %> --refresh"
+    }
+  ];
+  static flags = {
+    ...BaseCommand.baseFlags,
+    refresh: Flags.boolean({
+      description: "Force refresh from remote sources",
+      default: false
+    }),
+    [EDIT_PROJECT_SETUP_FLAG]: Flags.boolean({
+      description: "Internal: this run continues an `init` project setup",
+      default: false,
+      hidden: true
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_Edit);
+    const cwd = process.cwd();
+    const { unmount, clear: clearSpinner } = render(
+      /* @__PURE__ */ jsx(Spinner, { label: STATUS_MESSAGES.LOADING_SKILLS })
+    );
+    const context = await this.loadContext(flags);
+    clearSpinner();
+    unmount();
+    const result = await this.runEditWizard(context, cwd);
+    if (!result) this.error("Cancelled", { exit: EXIT_CODES.CANCELLED });
+    this.reportValidationErrors(result);
+    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 changes = detectConfigChanges(filteredOldConfig, filteredResult, {
+      newSkills: result.skills,
+      oldSkills: context.projectConfig?.skills ?? [],
+      newAgents: result.agentConfigs,
+      oldAgents: context.projectConfig?.agents ?? []
+    });
+    const isProjectSetup = flags[EDIT_PROJECT_SETUP_FLAG] && !isHomeDirectory(cwd);
+    if (!hasAnyChanges(changes)) {
+      this.log(source_default.hex(CLI_COLORS.NEUTRAL)("No changes made."));
+      if (!isProjectSetup) return;
+      await this.writeConfigAndCompile(result, context, flags, cwd);
+      this.logCompletionSummary(changes);
+      return;
+    }
+    this.logChangeSummary(changes, filteredResult.skills, filteredOldConfig?.skills ?? []);
+    const migratedSkillIds = await this.applyMigrations(
+      changes,
+      filteredResult,
+      activeOldSkills,
+      context,
+      cwd
+    );
+    await this.recordGlobalSourceMigrations(migratedSkillIds, filteredResult.skills, cwd, context);
+    await this.applyScopeChanges(changes, filteredResult, context, cwd);
+    await this.applySourceChanges(changes, activeOldSkills, cwd, migratedSkillIds);
+    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, flags, cwd);
+    await this.cleanupStaleAgentFiles(changes, activeOldAgents, cwd);
+    this.logCompletionSummary(changes);
+  }
+  async loadContext(flags) {
+    const detected = await detectProject();
+    if (!detected) {
+      this.error(ERROR_MESSAGES.NO_INSTALLATION, {
+        exit: EXIT_CODES.ERROR
+      });
+    }
+    const { installation, config: projectConfig } = detected;
+    const projectDir = installation.projectDir;
+    let sourceResult;
+    let startupMessages = [];
+    try {
+      const loaded = await loadSource({
+        sourceFlag: flags.source,
+        projectDir,
+        forceRefresh: flags.refresh,
+        captureStartupMessages: true
+      });
+      sourceResult = loaded.sourceResult;
+      startupMessages = loaded.startupMessages;
+      const sourceInfo = sourceResult.isLocal ? "local" : sourceResult.sourceConfig.sourceOrigin;
+      startupMessages.push({
+        level: "info",
+        text: `Loaded ${Object.keys(matrix.skills).length} skills (${sourceInfo})`
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+    let currentSkillIds;
+    try {
+      const discoveredSkills = await discoverAllPluginSkills(projectDir);
+      const pluginSkillIds = typedKeys(discoveredSkills);
+      const excludedConfigIds = new Set(
+        projectConfig?.skills?.filter((s) => s.excluded).map((s) => s.id) ?? []
+      );
+      const configSkillIds = projectConfig?.skills?.filter((s) => !s.excluded).map((s) => s.id) ?? [];
+      const filteredPluginSkillIds = pluginSkillIds.filter((id) => !excludedConfigIds.has(id));
+      const mergedIds = /* @__PURE__ */ new Set([...filteredPluginSkillIds, ...configSkillIds]);
+      currentSkillIds = [...mergedIds];
+      startupMessages.push({
+        level: "info",
+        text: `Found ${currentSkillIds.length} installed skills`
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+    return {
+      installation,
+      projectConfig,
+      projectDir,
+      sourceResult,
+      startupMessages,
+      currentSkillIds
+    };
+  }
+  async runEditWizard(context, cwd) {
+    const { projectConfig, projectDir, currentSkillIds } = context;
+    return runWizardSession({
+      hydrate: {
+        initialStep: "build",
+        initialDomains: projectConfig?.domains,
+        initialAgents: projectConfig?.selectedAgents,
+        installedSkillIds: currentSkillIds,
+        installedSkillConfigs: projectConfig?.skills,
+        installedAgentConfigs: projectConfig?.agents,
+        isEditingFromGlobalScope: isHomeDirectory(cwd)
+      },
+      props: {
+        version: this.config.version,
+        initialAgents: projectConfig?.selectedAgents,
+        installedSkillIds: currentSkillIds,
+        projectDir,
+        startupMessages: context.startupMessages
+      },
+      onCancel: () => this.log("\nEdit cancelled"),
+      clearTerminal: () => this.clearTerminal()
+    });
+  }
+  /**
+   * Records, in the GLOBAL config, the install-mode migrations this run already performed
+   * under `$HOME`.
+   *
+   * A project-context edit otherwise never writes global config (commit 403df46, "never
+   * modify global config from project-level operations"), and `authoritativeScope: "owned"`
+   * enforces that for the roster — an inherited global-active entry is read-only, so
+   * `mergeGlobalConfigs` preserves it verbatim. That protection is correct for selection and
+   * scope, but `executeMigration` resolves each skill's paths from ITS OWN scope: switching a
+   * global-scoped skill's source has already copied it under `$HOME` (or deleted it) and
+   * added/removed its user-scope plugin registration by the time the config is written.
+   * Leaving the global config alone there protects nothing — it only makes the recorded
+   * 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
+   * 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).
+   *
+   * Runs BEFORE `writeConfigAndCompile`, so the global config written here is the one
+   * the wizard write reloads, keeps (existing wins in `mergeGlobalConfigs`) and inlines
+   * into the project config — both files then tell the same story. That second write
+   * 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
+   * 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])
+    );
+    if (migratedSources.size === 0) return;
+    try {
+      const report = await mutateGlobal(
+        { kind: "migrate-skill-sources", sources: migratedSources },
+        {
+          loadMatrix: async () => context.sourceResult.matrix,
+          loadAgents: async () => (await loadAgentDefs({ projectDir: cwd })).agents
+        }
+      );
+      this.reportPropagatedRecompile(report);
+    } catch (error) {
+      this.warn(`Could not record global source change: ${getErrorMessage(error)}`);
+    }
+  }
+  reportValidationErrors(result) {
+    if (result.validation.errors.length > 0) {
+      for (const err of result.validation.errors) {
+        this.warn(err.message);
+      }
+    }
+  }
+  logChangeSummary(changes, newSkills, oldSkills) {
+    const {
+      addedSkills,
+      removedSkills,
+      addedAgents,
+      removedAgents,
+      sourceChanges,
+      scopeChanges,
+      agentScopeChanges,
+      dualScopeSkillTransitions,
+      dualScopeAgentTransitions
+    } = changes;
+    this.log(`
+${source_default.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(
+        source_default.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(source_default.hex(CLI_COLORS.ERROR)(`  - ${getSkillDisplayName(skillId)}${scopeLabel}`));
+    }
+    for (const agentName of addedAgents) {
+      this.log(
+        source_default.hex(CLI_COLORS.SUCCESS)(`  + ${agentName}`) + source_default.hex(CLI_COLORS.NEUTRAL)(" (agent)")
+      );
+    }
+    for (const agentName of removedAgents) {
+      this.log(
+        source_default.hex(CLI_COLORS.ERROR)(`  - ${agentName}`) + source_default.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(
+        source_default.hex(CLI_COLORS.WARNING)(`  ~ ${displayName}`) + source_default.hex(CLI_COLORS.NEUTRAL)(` (${fromLabel} \u2192 ${toLabel})`)
+      );
+    }
+    for (const [skillId, change] of scopeChanges) {
+      const displayName = getSkillDisplayName(skillId);
+      if (dualScopeSkillTransitions.has(skillId)) {
+        this.log(formatDualScopeTransition(displayName, change.to));
+        continue;
+      }
+      const fromLabel = formatScopeTag(change.from);
+      const toLabel = formatScopeTag(change.to);
+      const isGlobalToProject = change.from === "global" && change.to === "project";
+      const prefix = isGlobalToProject ? "+" : "~";
+      const color = isGlobalToProject ? CLI_COLORS.SUCCESS : CLI_COLORS.WARNING;
+      this.log(
+        source_default.hex(color)(`  ${prefix} ${displayName}`) + source_default.hex(CLI_COLORS.NEUTRAL)(` (${fromLabel} \u2192 ${toLabel})`)
+      );
+    }
+    for (const [agentName, change] of agentScopeChanges) {
+      if (dualScopeAgentTransitions.has(agentName)) {
+        this.log(
+          formatDualScopeTransition(agentName, change.to) + source_default.hex(CLI_COLORS.NEUTRAL)(" (agent)")
+        );
+        continue;
+      }
+      const fromLabel = formatScopeTag(change.from);
+      const toLabel = formatScopeTag(change.to);
+      this.log(
+        source_default.hex(CLI_COLORS.WARNING)(`  ~ ${agentName}`) + source_default.hex(CLI_COLORS.NEUTRAL)(` (${fromLabel} \u2192 ${toLabel})`)
+      );
+    }
+    this.log("");
+  }
+  async applyMigrations(_changes, filteredResult, activeOldSkills, context, cwd) {
+    const migrationPlan = detectMigrations(activeOldSkills, filteredResult.skills);
+    const hasMigrations = migrationPlan.toEject.length > 0 || migrationPlan.toPlugin.length > 0;
+    if (hasMigrations) {
+      if (migrationPlan.toEject.length > 0) {
+        this.log(
+          source_default.hex(CLI_COLORS.NEUTRAL)(
+            `Switching ${migrationPlan.toEject.length} skill(s) to eject`
+          )
+        );
+      }
+      if (migrationPlan.toPlugin.length > 0) {
+        this.log(
+          source_default.hex(CLI_COLORS.NEUTRAL)(
+            `Switching ${migrationPlan.toPlugin.length} skill(s) to plugin`
+          )
+        );
+        await this.requireMarketplaceOrExit(context.sourceResult, "migrate skills to plugin mode");
+      }
+      const migrationResult = await executeMigration(migrationPlan, cwd, context.sourceResult);
+      for (const warning of migrationResult.warnings) {
+        this.warn(warning);
+      }
+      for (const item of migrationResult.failedPluginInstalls) {
+        this.warn(`Failed to install plugin ${item.id}: ${item.error}`);
+      }
+      if (migrationResult.failedPluginInstalls.length > 0) {
+        this.error(pluginInstallFailureError(migrationResult.failedPluginInstalls.length), {
+          exit: EXIT_CODES.ERROR
+        });
+      }
+    }
+    return /* @__PURE__ */ new Set([
+      ...migrationPlan.toEject.map((m) => m.id),
+      ...migrationPlan.toPlugin.map((m) => m.id)
+    ]);
+  }
+  async applyScopeChanges(changes, filteredResult, context, cwd) {
+    const { scopeChanges } = changes;
+    for (const [skillId, change] of scopeChanges) {
+      const skillConfig = filteredResult.skills.find((s) => s.id === skillId);
+      if (skillConfig?.source === 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;
+    });
+    if (!hasPluginScopeChanges) return;
+    const marketplace = await this.requireMarketplaceOrExit(
+      context.sourceResult,
+      "migrate plugin skill scopes"
+    );
+    const pluginScopeResult = await migratePluginSkillScopes(
+      scopeChanges,
+      filteredResult.skills,
+      marketplace,
+      cwd
+    );
+    for (const item of pluginScopeResult.failed) {
+      this.warn(`Failed to migrate plugin scope for ${item.id}: ${item.error}`);
+    }
+  }
+  async applySourceChanges(changes, activeOldSkills, cwd, 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);
+        const deleteDir = installBaseDir(cwd, oldSkill?.scope);
+        await deleteLocalSkill(deleteDir, skillId);
+      }
+    }
+  }
+  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
+    );
+    const removedPluginSkills = removedSkills.filter(
+      (id) => activeOldSkills.find((s) => s.id === id)?.source !== EJECT_SOURCE
+    );
+    if (addedPluginSkills.length === 0 && removedPluginSkills.length === 0) return;
+    const marketplace = await this.requireMarketplaceOrExit(
+      context.sourceResult,
+      "install or uninstall plugin skills"
+    );
+    if (addedPluginSkills.length > 0) {
+      const pluginResult = await installPluginSkills(addedPluginSkills, marketplace, cwd);
+      if (pluginResult.installed.length > 0) {
+        this.log(
+          source_default.hex(CLI_COLORS.NEUTRAL)(`Installed ${pluginResult.installed.length} plugin(s)`)
+        );
+      }
+      for (const item of pluginResult.failed) {
+        this.warn(`Failed to install plugin ${item.id}: ${item.error}`);
+      }
+      if (pluginResult.failed.length > 0) {
+        this.error(pluginInstallFailureError(pluginResult.failed.length), {
+          exit: EXIT_CODES.ERROR
+        });
+      }
+    }
+    if (removedPluginSkills.length > 0) {
+      const uninstallResult = await uninstallPluginSkills(
+        removedPluginSkills,
+        activeOldSkills,
+        marketplace,
+        cwd
+      );
+      if (uninstallResult.uninstalled.length > 0) {
+        this.log(
+          source_default.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, cwd) {
+    const { addedSkills } = changes;
+    const addedLocalSkills = filteredResult.skills.filter(
+      (s) => addedSkills.includes(s.id) && s.source === EJECT_SOURCE
+    );
+    if (addedLocalSkills.length > 0) {
+      const copyResult = await copyLocalSkills(addedLocalSkills, cwd, context.sourceResult);
+      this.log(source_default.hex(CLI_COLORS.NEUTRAL)(`Copied ${copyResult.totalCopied} local skill(s)`));
+    }
+  }
+  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;
+      const deleteDir = installBaseDir(cwd, oldSkill.scope);
+      await deleteLocalSkill(deleteDir, skillId);
+    }
+  }
+  async writeConfigAndCompile(result, context, flags, cwd) {
+    let agentDefsResult;
+    try {
+      agentDefsResult = await loadAgentDefs({
+        forceRefresh: flags.refresh
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+    let configResult;
+    try {
+      configResult = await writeProjectConfig({
+        wizardResult: result,
+        sourceResult: context.sourceResult,
+        projectDir: cwd,
+        sourceFlag: flags.source,
+        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"
+      });
+    } catch (error) {
+      this.warn(`Could not update config: ${getErrorMessage(error)}`);
+    }
+    try {
+      const agentScopeMap = activeAgentScopeMap(result.agentConfigs);
+      const { allSkills } = await discoverInstalledSkills(cwd);
+      const compilationResult = await compileAgentsAllScopes({
+        projectDir: cwd,
+        sourcePath: agentDefsResult.sourcePath,
+        skills: allSkills,
+        agentScopeMap
+      });
+      if (compilationResult.failed.length > 0) {
+        this.log(
+          source_default.hex(CLI_COLORS.NEUTRAL)(`Recompiled ${compilationResult.compiled.length} agents`) + source_default.hex(CLI_COLORS.WARNING)(` (${compilationResult.failed.length} failed)`)
+        );
+        for (const warning of compilationResult.warnings) {
+          this.warn(warning);
+        }
+      } else if (compilationResult.compiled.length > 0) {
+        this.log(
+          source_default.hex(CLI_COLORS.NEUTRAL)(`Recompiled ${compilationResult.compiled.length} agents`)
+        );
+      } else {
+        this.log(source_default.hex(CLI_COLORS.NEUTRAL)("No agents to recompile"));
+      }
+    } catch (error) {
+      this.warn(`Agent recompilation failed: ${getErrorMessage(error)}`);
+      this.log(`You can manually recompile with '${CLI_INVOKE_COMMAND} compile'.`);
+    }
+    if (configResult) {
+      this.reportPropagatedRecompile(configResult.propagation);
+    }
+  }
+  /**
+   * Renders the recompile the gated write already performed on every OTHER
+   * registered project this run's global change was propagated into.
+   */
+  reportPropagatedRecompile(propagation) {
+    if (propagation.propagated.updated.length === 0) return;
+    const { recompiledCount, failedCount, warnings } = propagation.recompile;
+    for (const warning of warnings) {
+      this.warn(warning);
+    }
+    const summary = source_default.hex(CLI_COLORS.NEUTRAL)(
+      `Recompiled agents in ${recompiledCount} registered project(s)`
+    );
+    this.log(
+      failedCount > 0 ? summary + source_default.hex(CLI_COLORS.WARNING)(` (${failedCount} failed)`) : summary
+    );
+  }
+  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)}`);
+      }
+    }
+  }
+  logCompletionSummary(_changes) {
+    this.log(`
+${source_default.hex(CLI_COLORS.SUCCESS)("\u2713 Done")}
+`);
+  }
+};
+function detectConfigChanges(oldConfig, wizardResult, fullEntries) {
+  const oldSkillIds = oldConfig?.skills?.map((s) => s.id) ?? [];
+  const newSkillIds = wizardResult.skills.map((s) => s.id);
+  const oldAgentNames = oldConfig?.agents?.map((a) => a.name) ?? [];
+  const newAgentNames = wizardResult.agentConfigs.map((a) => a.name);
+  const oldSkillsById = indexBy(oldConfig?.skills ?? [], (s) => s.id);
+  const oldAgentsByName = indexBy(oldConfig?.agents ?? [], (a) => a.name);
+  const scopeChanges = detectPropertyChanges(
+    wizardResult.skills,
+    oldSkillsById,
+    (s) => s.id,
+    (s) => s.scope
+  );
+  const agentScopeChanges = detectPropertyChanges(
+    wizardResult.agentConfigs,
+    oldAgentsByName,
+    (a) => a.name,
+    (a) => a.scope
+  );
+  return {
+    addedSkills: difference(newSkillIds, oldSkillIds),
+    removedSkills: difference(oldSkillIds, newSkillIds),
+    addedAgents: difference(newAgentNames, oldAgentNames),
+    removedAgents: difference(oldAgentNames, newAgentNames),
+    sourceChanges: detectPropertyChanges(
+      wizardResult.skills,
+      oldSkillsById,
+      (s) => s.id,
+      (s) => s.source
+    ),
+    scopeChanges,
+    agentScopeChanges,
+    dualScopeSkillTransitions: detectDualScopeTransitions(
+      scopeChanges,
+      fullEntries?.newSkills ?? [],
+      fullEntries?.oldSkills ?? [],
+      (s) => s.id
+    ),
+    dualScopeAgentTransitions: detectDualScopeTransitions(
+      agentScopeChanges,
+      fullEntries?.newAgents ?? [],
+      fullEntries?.oldAgents ?? [],
+      (a) => a.name
+    )
+  };
+}
+function detectPropertyChanges(newItems, oldByKey, getKey, getValue) {
+  const changes = /* @__PURE__ */ new Map();
+  for (const item of newItems) {
+    const key = getKey(item);
+    const old = oldByKey[key];
+    if (old && getValue(old) !== getValue(item)) {
+      changes.set(key, { from: getValue(old), to: getValue(item) });
+    }
+  }
+  return changes;
+}
+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;
+}
+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;
+}
+async function migratePluginSkillScopes(scopeChanges, skills, marketplace, projectDir) {
+  const migrated = [];
+  const failed = [];
+  for (const [skillId, change] of scopeChanges) {
+    const skillConfig = skills.find((s) => s.id === skillId);
+    if (!skillConfig || skillConfig.source === EJECT_SOURCE) {
+      continue;
+    }
+    const newPluginScope = toClaudePluginScope(change.to);
+    const pluginRef = buildMarketplacePluginRef(skillId, marketplace);
+    try {
+      if (change.from === "project") {
+        await claudePluginUninstall(pluginRef, "project", projectDir);
+      }
+      await claudePluginInstall(pluginRef, newPluginScope, projectDir);
+      migrated.push(skillId);
+    } catch (error) {
+      failed.push({ id: skillId, error: getErrorMessage(error) });
+    }
+  }
+  return { migrated, failed };
+}
+export {
+  applyMigratedGlobalSources,
+  Edit as default,
+  detectConfigChanges,
+  migratePluginSkillScopes
+};
+//# sourceMappingURL=edit.js.map