agents-inc 0.170.1 → 0.170.2

package/dist/{chunk-NCWDK6L7.js → chunk-YXKTY5WM.js}

@@ -1,27 +1,23 @@
 #!/usr/bin/env node
 import {
   SelectList
-} from "./chunk-44TE3RKH.js";
+} from "./chunk-3ED3KHHD.js";
 import {
-  holdInstalledGlobal,
-  installPlanLines,
-  notInstalledGlobally,
-  openUrl,
-  readInstalledGlobal
-} from "./chunk-6HNXYYVF.js";
+  openUrl
+} from "./chunk-PLFANHRZ.js";
 import {
   fetchSeedConfig
-} from "./chunk-OYJQUA3D.js";
+} from "./chunk-YGDWHDOY.js";
 import {
   promptConfirm,
   promptValue
-} from "./chunk-4AAOOAIN.js";
+} from "./chunk-P6CYS4JK.js";
 import {
   Confirm
 } from "./chunk-OZXAJNLA.js";
 import {
   hostCompileNotices
-} from "./chunk-F5EBEATU.js";
+} from "./chunk-PSUTNOQ2.js";
 import {
   compileAgentsAllScopes,
   compileProjectScope,
@@ -29,30 +25,36 @@ import {
   movedGlobalAgentInputs,
   sayCapturedWarnings,
   writeProjectConfig
-} from "./chunk-7RDMTR64.js";
+} from "./chunk-66AEVERM.js";
 import {
   copyLocalSkills,
   discoverInstalledSkills
-} from "./chunk-F2BHT5C4.js";
+} from "./chunk-IWY5IR4F.js";
 import {
   loadAgentDefs
-} from "./chunk-HED2DAXZ.js";
+} from "./chunk-THO7LO5B.js";
 import {
   render
-} from "./chunk-JFLVEFFP.js";
+} from "./chunk-KIK5EZYD.js";
 import {
   providerFlag,
   providerNamedBy,
   providerNeedsAConfigurationToInstall
-} from "./chunk-RIPSGNLU.js";
+} from "./chunk-OCAVW6N5.js";
 import {
   BaseCommand,
   EXIT_CODES,
   clearTerminalScreen,
+  holdInstalledGlobal,
+  installPlanLines,
+  installsAtHome,
+  notInstalledGlobally,
+  readInstalledGlobal,
   registerExternalSkills,
   writeExternalSkills
-} from "./chunk-V3KTSP3Q.js";
+} from "./chunk-GEMW5RQ2.js";
 import {
+  ERROR_MESSAGES,
   INCOMPLETE_WORK_RECOVERY,
   INSTALL_MODE_DESCRIPTIONS,
   INSTALL_MODE_LABELS,
@@ -63,6 +65,7 @@ import {
   agentCodec,
   agentsNotCompiled,
   applySharedConfigHere,
+  assertNamedSourceUsable,
   buildAgentScopeMap,
   carriedSkillsWritten,
   chooseProviderForThisRun,
@@ -71,7 +74,7 @@ import {
   detectProjectInstallation,
   fileExists,
   getErrorMessage,
-  getInstallationInfo,
+  getInstallationsByProvider,
   globalScopedAgentsHint,
   holdsItsOwnInstallation,
   hostAt,
@@ -80,10 +83,9 @@ import {
   isHomeDirectory,
   isLocalSource,
   keptAsInstalledGlobally,
-  loadProjectConfig,
   permissionFiles,
-  plural,
   providerInUse,
+  providerToNameAt,
   readFileSafe,
   relativeConfigPath,
   resolveBranding,
@@ -91,10 +93,11 @@ import {
   seedToInstallSelection,
   settingsFileSchema,
   sharedConfigExistingInstall,
-  skippedUnknownAgents,
-  skippedUnknownSkills,
   warn
-} from "./chunk-MQ6CGZNJ.js";
+} from "./chunk-GAKVZNTX.js";
+import {
+  plural
+} from "./chunk-AUNRHWH4.js";
 import {
   ASCII_LOGO,
   CLI_COLORS,
@@ -104,30 +107,31 @@ import {
   EJECT_SOURCE,
   MAX_CONFIG_FILE_SIZE,
   editorConfigUrl
-} from "./chunk-PJWGTNOX.js";
+} from "./chunk-7C3PFRBU.js";
 
 // src/cli/commands/init.tsx
 import "react";
 import { Flags } from "@oclif/core";
 import { Box as Box2, Text as Text2, useApp } from "ink";
+import { partition } from "remeda";
 
 // src/cli/components/hooks/use-terminal-dimensions.ts
 import { useState, useEffect } from "react";
 import { useStdout } from "ink";
 var DEFAULT_COLUMNS = 80;
 var DEFAULT_ROWS = 24;
-function useTerminalDimensions() {
-  const { stdout } = useStdout();
-  const [dimensions, setDimensions] = useState(() => ({
+function dimensionsOf(stdout) {
+  return {
     columns: stdout.columns || DEFAULT_COLUMNS,
     rows: stdout.rows || DEFAULT_ROWS
-  }));
+  };
+}
+function useTerminalDimensions() {
+  const { stdout } = useStdout();
+  const [dimensions, setDimensions] = useState(() => dimensionsOf(stdout));
   useEffect(() => {
     const handleResize = () => {
-      setDimensions({
-        columns: stdout.columns || DEFAULT_COLUMNS,
-        rows: stdout.rows || DEFAULT_ROWS
-      });
+      setDimensions(dimensionsOf(stdout));
     };
     stdout.on("resize", handleResize);
     return () => {
@@ -248,16 +252,24 @@ var Dashboard = ({ data, onSelect, onCancel }) => {
     )
   ] });
 };
-function dashboardCountLines(data) {
-  const lines = [
-    `  Skills:       ${data.skillCount} installed`,
-    `  Agents:       ${data.agentCount} compiled`,
-    `  Mode:         ${INSTALL_MODE_LABELS[data.mode]}`
+function dashboardCountLines({ installations }) {
+  const named = installations.length > 1;
+  const blocks = installations.map((installation) => [
+    ...named ? [`  Provider:     ${installation.provider}`] : [],
+    ...installationCountLines(installation)
+  ]);
+  return blankLineBetween(blocks);
+}
+function blankLineBetween(blocks) {
+  return blocks.flatMap((block, index) => index === 0 ? block : ["", ...block]);
+}
+function installationCountLines(installation) {
+  return [
+    `  Skills:       ${installation.skillCount} installed`,
+    `  Agents:       ${installation.agentCount} compiled`,
+    `  Mode:         ${INSTALL_MODE_LABELS[installation.mode]}`,
+    ...installation.marketplace ? [`  Marketplace:  ${installation.marketplace}`] : []
   ];
-  if (data.source) {
-    lines.push(`  Marketplace:  ${data.source}`);
-  }
-  return lines;
 }
 function formatDashboardText(data) {
   return [data.name, "", ...dashboardCountLines(data), "", DASHBOARD_OPTIONS_LINE].join("\n");
@@ -301,12 +313,7 @@ function sharedConfigSourceFlags(flags, payload) {
   return { marketplace: flags.marketplace ?? payload.marketplace };
 }
 var Init = class _Init extends BaseCommand {
-  /**
-   * The name this run prints itself under, resolved once on {@link install}'s spine because the
-   * closing line is printed several calls below it. Same shape and same reason as `uninstall`'s
-   * field: a plain `string` holding the shipped default rather than an optional every reader
-   * would have to answer for.
-   */
+  /** Resolved once in {@link install}; the closing line is printed several calls below. */
   brandingName = DEFAULT_BRANDING.NAME;
   static summary = `Initialize ${DEFAULT_BRANDING.NAME} in this project`;
   static description = "Build a configuration in agentsinc.sh/editor, or install one by id with --from. Over an existing installation, shows its dashboard.";
@@ -340,95 +347,57 @@ var Init = class _Init extends BaseCommand {
     }),
     provider: providerFlag()
   };
-  /**
-   * The command in two statements: do the work, then answer for it.
-   *
-   * {@link install} owns every path through the setup and returns however it likes; the exit
-   * code is decided once, here, after the last of them. Deciding it inside would mean deciding
-   * it at each of that method's endings, and an ending added later would inherit the exit-0
-   * default silently — which is the defect this pair exists to close. `edit` is two statements
-   * for the same reason.
-   */
+  /** The exit code is decided once, after every path through {@link install} has ended. */
   async run() {
     await this.install();
     this.exitIfWorkIncomplete();
   }
-  /**
-   * The editor, opened on whatever `--from` named — or on nothing when it named nothing.
-   *
-   * **One rule, both commands (owner ruling 2026-08-24): `--ui` opens the command's SUBJECT, and
-   * `--from` is what supplies one.** `edit --ui` alone opens this installation because that is
-   * `edit`'s subject; `init --ui` alone opens the catalogue because a fresh directory has none.
-   * Given an id, either opens that id — which is what makes a shared configuration something a
-   * recipient can look at rather than only apply blind.
-   *
-   * No publish happens here and none is needed. `edit --ui` mints an id because an installation
-   * is not a configuration the store holds yet; an id already IS one, so this is
-   * `editorConfigUrl` and nothing else — no network, no marketplace, no catalogue load.
-   *
-   * The link is PRINTED first and opened second. Over a pipe, in CI, and on a machine with no
-   * desktop session there is no browser to be anybody's — a link nobody can copy is the whole
-   * loss, so opening one is the convenience on top and a failure to open is a warning beside a
-   * link that still works.
-   *
-   * A marketplace named here cannot ride along: the address carries an id and nothing else, so
-   * the line under the link says how to add it in the editor.
-   */
-  async openEditor(projectDir, id, marketplace) {
+  /** The link is printed before it is opened, so it still works where no browser can open. */
+  async openEditor(projectDir, provider, id, marketplace) {
     const url = id === void 0 ? EDITOR_URL : editorConfigUrl(id);
     const marketplaceLine = marketplace === void 0 ? void 0 : this.addMarketplaceLineOrFail(marketplace);
     this.log(id === void 0 ? `Build it at ${url}` : `Open it at ${url}`);
     if (marketplaceLine !== void 0) this.log(marketplaceLine);
-    this.log(applySharedConfigHere(id, await holdsItsOwnInstallation(projectDir)));
+    this.log(applySharedConfigHere(id, await holdsItsOwnInstallation(projectDir), provider));
     if (!process.stdin.isTTY) return;
     const opened = await openUrl(url);
     if (!opened.ok) this.warn(opened.error);
   }
-  /**
-   * Every route `init` has, in the order they are tried: the editor for `--ui` and for a
-   * marketplace named without `--from`; for a bare run, the installation's dashboard — or the
-   * editor where nothing is installed; and the install of the configuration `--from` names.
-   */
   async install() {
     const { flags } = await this.parse(_Init);
     const projectDir = process.cwd();
     this.settleTheProviderForThisRun(flags);
-    if (opensTheEditor(flags)) return this.openEditor(projectDir, flags.from, flags.marketplace);
+    if (opensTheEditor(flags)) {
+      return this.openEditor(
+        projectDir,
+        providerNamedBy(flags.provider),
+        flags.from,
+        flags.marketplace
+      );
+    }
     await this.ensureConfigReadable(projectDir);
     if (flags.from === void 0) return this.showDashboardOrOpenEditor(projectDir);
     this.brandingName = await this.resolveBrandingName(projectDir);
     const selection = await this.selectionFromSharedConfig(flags.from, flags, projectDir);
     if (!selection) this.exit(EXIT_CODES.CANCELLED);
     this.reportValidationErrors(selection.result.validation);
-    await this.handleInstallation(selection);
+    await this.handleInstallation(selection, projectDir);
   }
-  /** A bare `init`: the installation's dashboard, or the editor where nothing is installed. */
   async showDashboardOrOpenEditor(projectDir) {
     const dashboard = await runDashboardFlow(projectDir, this.config, (msg) => this.log(msg));
     if (dashboard === "cancelled") this.error("Cancelled", { exit: EXIT_CODES.CANCELLED });
-    if (dashboard === "not-installed") await this.openEditor(projectDir);
+    if (dashboard === "not-installed") await this.openEditor(projectDir, void 0);
   }
-  /** The editor's marketplace line, or the refusal the install route gives a ref it cannot read. */
+  /** Refused as the install route refuses it, since the line echoes the ref it was given. */
   addMarketplaceLineOrFail(ref) {
     try {
+      assertNamedSourceUsable(ref);
       return addMarketplaceInTheEditor(ref, isLocalSource(ref));
     } catch (error) {
       this.handleError(error);
     }
   }
-  /**
-   * Commits this run to the provider `--provider` named, or refuses a flag with nothing to name.
-   *
-   * **`--provider` is a LOCATION parameter, not a feature switch**, and the control that proves it
-   * is `--provider claude`: naming the default out loud installs byte-for-byte what no flag
-   * installs, because all the flag decides is which folder this run creates. Without that half
-   * "the flag selects an installation" would be indistinguishable from "the flag means Codex".
-   *
-   * **And it is meaningless without `--from` (D15).** The provider is chosen in the web app, so
-   * the only run that can be told one is the run that installs what the app produced. It also
-   * gives the placement refusal something to refuse BEFORE anything is written: with `--from`
-   * required, a provider always arrives beside a payload the pre-flight can read.
-   */
+  /** `--provider` only picks which folder an install creates, so it needs `--from`. */
   settleTheProviderForThisRun(flags) {
     const named = providerNamedBy(flags.provider);
     if (named === void 0) return;
@@ -437,46 +406,21 @@ var Init = class _Init extends BaseCommand {
     }
     chooseProviderForThisRun(named);
   }
-  /**
-   * The `--from <id>` producer: fetch and map — and, at a terminal, one question.
-   *
-   * It installs into a clean directory, which is what the first refusal is: a shared
-   * configuration is installed whole, so a directory already holding one has it applied with
-   * `edit --from` instead, or is uninstalled first. The second is about the LOCATION rather than what is already in it — a global
-   * installation holds only global-scoped content. Both fire before anything is written.
-   *
-   * A global installation ABOVE a project is not in the way. It is not this project's, so the run
-   * adds to it what it lacks and states every entry it already holds as installed (see
-   * `holdInstalledGlobal`).
-   *
-   * Before writing anything the run lists what goes into the project and what into the global
-   * install. At a terminal it then asks, and a no writes nothing. With no terminal — a CI job or a
-   * script — it prints the same lists and carries on: running headless is most of why the flag
-   * exists.
-   */
+  /** Every refusal fires before anything is written. */
   async selectionFromSharedConfig(id, flags, projectDir) {
     await this.refuseInstalledProject(projectDir, id);
-    this.log(`Fetching configuration ${id}...`);
-    const fetched = await fetchSeedConfig(id);
-    if (!fetched.ok) {
-      this.error(fetched.error, { exit: EXIT_CODES.ERROR });
-    }
-    const sourceFlags = sharedConfigSourceFlags(flags, fetched.payload);
-    const { sourceResult, startupMessages } = await this.loadSourceOrFail(sourceFlags);
+    const payload = await this.fetchSharedConfigOrFail(id);
+    const sourceFlags = sharedConfigSourceFlags(flags, payload);
+    const { sourceResult, startupMessages } = await this.loadSourceOrFail(sourceFlags, projectDir);
     const carriedSkills = this.registerExternalSkillsOrFail(
-      fetched.payload,
+      payload,
       sourceResult.matrix,
       projectDir
     );
-    const { result, skippedSkillIds, skippedAgentNames } = this.decodeSeedOrFail(
-      fetched.payload,
-      sourceResult.matrix
-    );
+    const mapping = this.decodeSeedOrFail(payload, sourceResult.matrix);
+    const { result } = mapping;
     this.refuseProjectScopedContentAtHome(result, projectDir);
-    const held = holdInstalledGlobal(
-      result,
-      isHomeDirectory(projectDir) ? null : await readInstalledGlobal(projectDir)
-    );
+    const held = holdInstalledGlobal(result, await installedGlobalToHold(projectDir));
     const arrivingCarried = notInstalledGlobally(carriedSkills, held);
     await this.refuseSharedConfigBeforeAsking(
       held.result,
@@ -485,26 +429,15 @@ var Init = class _Init extends BaseCommand {
       sourceResult
     );
     sayCapturedWarnings(startupMessages);
-    if (skippedSkillIds.length > 0) this.warn(skippedUnknownSkills(skippedSkillIds));
-    if (skippedAgentNames.length > 0) this.warn(skippedUnknownAgents(skippedAgentNames));
-    if (selectsNothing(held.result)) {
-      this.error(`Configuration '${id}' contains no skills this catalog can install.`, {
-        exit: EXIT_CODES.ERROR
-      });
-    }
-    this.logWhatGoesWhere(held);
+    this.warnOfSkippedEntries(mapping, held.result.selectedAgents);
+    this.refuseAnEmptySelection(held.result, id);
+    this.logWhatGoesWhere(held, installsAtHome(result) ? id : void 0);
     if (process.stdin.isTTY && !await this.confirmInstall()) {
       this.log("Setup cancelled");
       return null;
     }
     await this.writeCarriedSkills(arrivingCarried);
-    const arriving = notInstalledGlobally(held.result.skills, held);
-    if (arriving.length > 0) {
-      this.log(
-        `Installing ${arriving.length} skill(s) across ${result.selectedAgents.length} sub-agent(s)
-`
-      );
-    }
+    this.announceArrivingSkills(held, result.selectedAgents.length);
     return {
       result: held.result,
       sourceResult,
@@ -512,22 +445,29 @@ var Init = class _Init extends BaseCommand {
       installedAlready: new Set(held.installed.skillIds)
     };
   }
-  /**
-   * The two lists — what goes into this project, and what into the global install — then the
-   * global skills skipped as already installed, the held sub-agents a new skill joins, and the
-   * global entries the configuration states otherwise than they are installed, which stay.
-   */
-  logWhatGoesWhere(held) {
+  /** `idAppliedAtHome` is the id only where a run from home would take the configuration. */
+  logWhatGoesWhere(held, idAppliedAtHome) {
     for (const line of installPlanLines(held)) {
       this.log(line);
     }
     const { skillIds, agentNames } = held.keptAsInstalled;
     if (skillIds.length > 0 || agentNames.length > 0) {
-      this.log(keptAsInstalledGlobally(skillIds, agentNames));
+      this.log(keptAsInstalledGlobally(skillIds, agentNames, idAppliedAtHome));
     }
     this.log("");
   }
-  /** The question under the lists, defaulting to no: nothing has been written yet. */
+  refuseAnEmptySelection(result, id) {
+    if (!selectsNothing(result)) return;
+    this.error(`Configuration '${id}' contains no skills this catalog can install.`, {
+      exit: EXIT_CODES.ERROR
+    });
+  }
+  announceArrivingSkills(held, agentCount) {
+    const arriving = notInstalledGlobally(held.result.skills, held);
+    if (arriving.length === 0) return;
+    this.log(`Installing ${arriving.length} skill(s) across ${agentCount} sub-agent(s)
+`);
+  }
   async confirmInstall() {
     const outcome = await promptConfirm(({ onConfirm, onCancel }) => /* @__PURE__ */ jsx2(
       Confirm,
@@ -539,28 +479,23 @@ var Init = class _Init extends BaseCommand {
     ));
     return outcome === "confirmed";
   }
-  /**
-   * Refuses to install a shared configuration into a directory that already has one.
-   *
-   * Project-scoped detection rather than `detectInstallation`, whose global fallback would refuse
-   * every clean project on a machine with a global install. A global install above the project is
-   * added to rather than refused over — see {@link selectionFromSharedConfig}.
-   *
-   * This runs before the fetch: there is nothing to learn from the network about a directory that
-   * is already spoken for.
-   */
+  /** Project-scoped: `detectInstallation`'s global fallback would refuse every clean project. */
   async refuseInstalledProject(projectDir, id) {
     const installation = await detectProjectInstallation(projectDir);
     if (!installation) return;
-    this.error(sharedConfigExistingInstall(installation.configPath, id), {
+    const provider = providerToNameAt(projectDir, providerInUse(projectDir));
+    this.error(sharedConfigExistingInstall(installation.configPath, id, provider), {
       exit: EXIT_CODES.ERROR
     });
   }
-  /**
-   * The decode refuses a payload the config model has nowhere to write (see
-   * `seedToInstallSelection`). That is a failure of this command, reported with this command's exit
-   * code rather than left to surface as an unhandled throw.
-   */
+  async fetchSharedConfigOrFail(id) {
+    this.log(`Fetching configuration ${id}...`);
+    const fetched = await fetchSeedConfig(id);
+    if (!fetched.ok) {
+      this.error(fetched.error, { exit: EXIT_CODES.ERROR });
+    }
+    return fetched.payload;
+  }
   decodeSeedOrFail(payload, matrix) {
     try {
       return seedToInstallSelection(payload, matrix);
@@ -568,14 +503,6 @@ var Init = class _Init extends BaseCommand {
       this.handleError(error);
     }
   }
-  /**
-   * Seats the catalogue entries the payload carries with it, or refuses the run.
-   *
-   * The refusals are `registerExternalSkills`' own — a carried skill asked for as a plugin, which
-   * no marketplace serves, and a carried skill claiming an id the loaded catalogue already owns,
-   * whose bytes would be written over that catalogue's own copy — and are reported with this
-   * command's exit code for the same reason the decode's is.
-   */
   registerExternalSkillsOrFail(payload, matrix, projectDir) {
     try {
       return registerExternalSkills(payload, matrix, projectDir);
@@ -583,19 +510,18 @@ var Init = class _Init extends BaseCommand {
       this.handleError(error);
     }
   }
-  /** Writes the skills the payload 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)));
   }
-  async loadSourceOrFail(flags) {
+  async loadSourceOrFail(flags, projectDir) {
     try {
       const loaded = await loadSource({
-        // The one load that may CHOOSE a marketplace rather than read the stored one.
+        // The one load that may choose a marketplace rather than read the stored one.
         caller: "init",
         ...flags.marketplace !== void 0 && { sourceFlag: flags.marketplace },
-        projectDir: process.cwd(),
+        projectDir,
         captureStartupMessages: true
       });
       return { sourceResult: loaded.sourceResult, startupMessages: loaded.startupMessages };
@@ -605,88 +531,83 @@ var Init = class _Init extends BaseCommand {
       });
     }
   }
-  async handleInstallation({
-    result,
-    sourceResult,
-    sourceFlags,
-    installedAlready
-  }) {
-    const projectDir = process.cwd();
-    const activeSkills = result.skills.filter((s) => !s.excluded);
-    const toInstall = activeSkills.filter((s) => !installedAlready.has(s.id));
-    const installMode = deriveInstallMode(toInstall);
-    const ejectedSkills = toInstall.filter((s) => s.origin === EJECT_SOURCE);
-    const pluginSkills = toInstall.filter((s) => s.origin !== EJECT_SOURCE);
-    this.logInstallPlan(installMode, ejectedSkills, pluginSkills);
-    const resolvedMarketplace = pluginSkills.length > 0 ? await this.requireMarketplaceOrExit(
+  async handleInstallation({ result, sourceResult, sourceFlags, installedAlready }, projectDir) {
+    const plan = planInstall(result, installedAlready);
+    this.logInstallPlan(plan);
+    const resolvedMarketplace = await this.marketplaceForPluginSkills(
+      plan.pluginSkills,
       sourceResult,
-      "install plugin skills",
-      hostAt(projectDir),
-      (marketplace) => this.log(`Registering marketplace "${marketplace}"...`)
-    ) : null;
-    const copyResult = ejectedSkills.length > 0 ? await this.copyEjectSkillsStep(ejectedSkills, projectDir, sourceResult, installMode) : null;
+      projectDir
+    );
+    const copyResult = await this.copyEjectedSkills(plan, projectDir, sourceResult);
     if (resolvedMarketplace !== null) {
       await this.installPluginSkillsReported(
-        pluginSkills,
+        plan.pluginSkills,
         resolvedMarketplace,
         projectDir,
         sourceResult.matrix
       );
     }
-    const pluginModeSucceeded = resolvedMarketplace !== null;
     try {
-      const { configResult, compileResult, agentScopeMap } = await this.writeConfigAndCompile(
+      const written = await this.writeConfigAndCompile(
         result,
         sourceResult,
-        sourceFlags
-      );
-      this.reportSuccess(
-        configResult,
-        compileResult,
-        agentScopeMap,
-        installMode,
-        pluginModeSucceeded,
-        copyResult
+        sourceFlags,
+        projectDir
       );
+      this.reportSuccess(written, copyResult, projectDir);
       await this.showPermissionNotice(projectDir);
     } catch (error) {
       this.handleError(error);
     }
   }
-  /**
-   * The permission notice, where there is one to show. It is an Ink app with no exit of its own,
-   * so one frame is rendered and let go: the notice is information, not a prompt, and `--from`
-   * has to complete over a pipe and in CI.
-   */
+  async marketplaceForPluginSkills(pluginSkills, sourceResult, projectDir) {
+    if (pluginSkills.length === 0) return null;
+    return this.requireMarketplaceOrExit(
+      sourceResult,
+      "install plugin skills",
+      hostAt(projectDir),
+      (marketplace) => this.log(`Registering marketplace "${marketplace}"...`)
+    );
+  }
+  /** One frame, then unmount: the notice has no exit of its own and `--from` must run headless. */
   async showPermissionNotice(projectDir) {
     const permissionWarning = await checkPermissions(projectDir);
     if (!permissionWarning) return;
     const { unmount } = render(permissionWarning);
     unmount();
   }
-  logInstallPlan(installMode, ejectedSkills, pluginSkills) {
+  logInstallPlan(plan) {
     this.log("\n");
-    this.log(`Selected ${plural(ejectedSkills.length + pluginSkills.length, "skill")}`);
-    this.log(
-      `Install mode: ${installMode === "mixed" ? `${INSTALL_MODE_LABELS.mixed} (${ejectedSkills.length} eject, ${pluginSkills.length} plugin)` : INSTALL_MODE_DESCRIPTIONS[installMode]}`
-    );
+    this.log(`Selected ${plural(plan.ejectedSkills.length + plan.pluginSkills.length, "skill")}`);
+    this.log(`Install mode: ${installModeDescription(plan)}`);
   }
-  /**
-   * Copies the ejected skills and says how many landed at each scope, in the words
-   * {@link skillsCopiedLine} chooses.
-   */
-  async copyEjectSkillsStep(localSkills, projectDir, sourceResult, installMode) {
+  async copyEjectedSkills({ ejectedSkills, installMode }, projectDir, sourceResult) {
+    if (ejectedSkills.length === 0) return null;
     this.log("Copying skills to local directory...");
-    const copyResult = await copyLocalSkills(localSkills, projectDir, sourceResult);
+    const copyResult = await copyLocalSkills(ejectedSkills, projectDir, sourceResult);
     this.log(skillsCopiedLine(copyResult, installMode, projectDir));
     return copyResult;
   }
-  async writeConfigAndCompile(result, sourceResult, flags) {
+  async writeConfigAndCompile(result, sourceResult, flags, projectDir) {
+    const configResult = await this.writeConfigReported(result, sourceResult, flags, projectDir);
+    const agentScopeMap = buildAgentScopeMap(configResult.config);
+    const compileResult = await this.compileInstalledAgents(
+      configResult.propagation,
+      agentScopeMap,
+      projectDir
+    );
+    this.reportCompilation(compileResult);
+    await this.reportWhatThisHostCannotCarry(projectDir);
+    this.reportFanOut(configResult.propagation);
+    return { configResult, compileResult, agentScopeMap };
+  }
+  async writeConfigReported(result, sourceResult, flags, projectDir) {
     this.log("Generating configuration...");
     const configResult = await writeProjectConfig({
       selection: result,
       sourceResult,
-      projectDir: process.cwd(),
+      projectDir,
       ...flags.marketplace !== void 0 && { sourceFlag: flags.marketplace }
     });
     if (configResult.wasMerged) {
@@ -695,51 +616,28 @@ var Init = class _Init extends BaseCommand {
     this.log(`Configuration saved (${plural(configResult.config.agents.length, "agent")})
 `);
     this.reportUnassignedSkills(configResult.config, result.skills);
+    return configResult;
+  }
+  async compileInstalledAgents(written, agentScopeMap, projectDir) {
     this.log(STATUS_MESSAGES.COMPILING_AGENTS);
-    const cwd = process.cwd();
     const agentDefs = await loadAgentDefs();
-    const { allSkills } = await discoverInstalledSkills(cwd);
-    const agentScopeMap = buildAgentScopeMap(configResult.config);
-    const compile = compilesGlobalScope(cwd, configResult.propagation) ? compileAgentsAllScopes : compileProjectScope;
-    const compileResult = await compile({
-      projectDir: cwd,
+    const { allSkills } = await discoverInstalledSkills(projectDir);
+    const compile = compilesGlobalScope(projectDir, written) ? compileAgentsAllScopes : compileProjectScope;
+    return compile({
+      projectDir,
       sourcePath: agentDefs.sourcePath,
       skills: allSkills,
       agentScopeMap
     });
-    this.reportCompilation(compileResult);
-    await this.reportWhatThisHostCannotCarry(cwd);
-    this.reportFanOut(configResult.propagation);
-    return { configResult, compileResult, agentScopeMap };
   }
-  /**
-   * What this host could not carry, after the compile summary and once per run.
-   *
-   * `init --from` is the door a configuration somebody ELSE wrote arrives through, so it is
-   * precisely the run that must not be silent about the parts of it that did not survive the
-   * translation. `compile` prints the same lines in the same order — see
-   * {@link hostCompileNotices}, which is the one place either of them gets them from.
-   *
-   * A Claude install expresses every setting and carries every sub-agent, so it gets one line at
-   * most: the trust dialog, while its project sub-agents' completion gate cannot run in this
-   * folder.
-   */
-  async reportWhatThisHostCannotCarry(cwd) {
-    for (const notice of await hostCompileNotices(providerInUse(cwd), cwd)) {
+  async reportWhatThisHostCannotCarry(projectDir) {
+    for (const notice of await hostCompileNotices(providerInUse(projectDir), projectDir)) {
       this.log(notice);
     }
   }
   /**
-   * What the compile pass did, including the half this command used to drop.
-   *
-   * It read `compiled` and nothing else, so a pass that lost a sub-agent printed a number that
-   * looked perfectly right — `compiled` counts successes, so it is correct either way — and the
-   * failures reached no surface at all: no count, no reason, no exit code. A user's FIRST
-   * install could silently land a roster missing a sub-agent.
-   *
-   * The compile is the last thing `init` does, so a failure here cannot be answered by aborting:
-   * the skills are on disk and `config.ts` and `config-types.ts` describe them. What is owed is
-   * the account, which {@link BaseCommand.exitIfWorkIncomplete} prints and answers for.
+   * Failures are recorded rather than aborted on: the skills and config are already written, and
+   * {@link BaseCommand.exitIfWorkIncomplete} answers for them.
    */
   reportCompilation(compileResult) {
     const { compiled, failed, warnings } = compileResult;
@@ -756,104 +654,41 @@ var Init = class _Init extends BaseCommand {
     }
     this.recordIncompleteWork(agentsNotCompiled(failed), INCOMPLETE_WORK_RECOVERY.RECOMPILE);
   }
-  reportSuccess(configResult, compileResult, agentScopeMap, installMode, pluginModeSucceeded, copyResult) {
+  reportSuccess({ configResult, compileResult, agentScopeMap }, copyResult, projectDir) {
     if (!this.hasIncompleteWork) this.log(`${initSucceeded(this.brandingName)}
 `);
-    const isEjectOutput = installMode === "eject" || installMode === "mixed" && !pluginModeSucceeded;
-    if (isEjectOutput && copyResult && copyResult.totalCopied > 0) {
-      this.reportSkillsCopied(copyResult);
+    if (copyResult !== null && copyResult.totalCopied > 0) {
+      this.logDirectoryBlocks("Skills copied to:", skillsCopiedBlocks(projectDir, copyResult));
     }
-    this.reportAgentsCompiled(compileResult.compiled, agentScopeMap);
-    this.reportConfiguration(configResult.configPath, agentScopeMap);
+    this.logDirectoryBlocks(
+      "Agents compiled to:",
+      agentsCompiledBlocks(projectDir, compileResult.compiled, agentScopeMap)
+    );
+    this.reportConfiguration(configResult, agentScopeMap, projectDir);
   }
-  /**
-   * Names the config that actually holds this install's assignments, and where a
-   * recompile of them has to be run from.
-   *
-   * Split by the same `agentScopeMap` the two reporters above split on, because the
-   * same scope decides both. A project config's `stack` is filtered down to
-   * project-scoped agents on the way out, so a wholly GLOBAL install leaves it
-   * carrying no assignment at all — naming it sends the user to a file with nothing
-   * in it — and `compile` in this cwd runs the PROJECT pass, which recompiles no
-   * global agent. At the home root both scopes resolve to one file and one pass, so
-   * there is nothing to split and the project wording stands.
-   */
-  reportConfiguration(projectConfigPath, agentScopeMap) {
-    const cwd = process.cwd();
+  reportConfiguration({ configPath, propagation }, agentScopeMap, projectDir) {
     const paths = {
-      global: resolveInstallPaths(cwd, "global").configPath,
-      project: projectConfigPath
+      global: resolveInstallPaths(projectDir, "global").configPath,
+      project: configPath
     };
-    const split = splitAgentScopes(cwd, agentScopeMap);
+    const split = splitAgentScopes(projectDir, agentScopeMap);
     this.log("Configuration:");
-    for (const configPath of configsHoldingAssignments(split, paths)) {
-      this.log(`  ${configPath}`);
+    for (const written of configsWritten(projectDir, paths, propagation.globalWritten)) {
+      this.log(`  ${written}`);
     }
     this.log("");
     this.log("To customize agent-skill assignments:");
-    for (const [index, step] of customizationSteps(split, paths.global, cwd).entries()) {
+    for (const [index, step] of customizationSteps(split, paths.global, projectDir).entries()) {
       this.log(`  ${index + 1}. ${step}`);
     }
     this.log("");
   }
-  /**
-   * Reports where the skills actually landed. `copyLocalSkills` splits by scope,
-   * so a default install driven from a project directory writes every skill
-   * under HOME — reporting the project path there names a directory that was
-   * never written.
-   *
-   * This block is a filesystem listing, so the entries are the on-disk directory
-   * names — skill ids, not display names. `copySkillsToLocalFlattened` names each
-   * destination directory after `skill.id`, so a user can copy any line and `cd`
-   * into it.
-   */
-  reportSkillsCopied(copyResult) {
-    const cwd = process.cwd();
-    const groups = isHomeDirectory(cwd) ? [
-      {
-        dir: resolveInstallPaths(cwd, "project").skillsDir,
-        copied: [...copyResult.globalCopied, ...copyResult.projectCopied]
-      }
-    ] : [
-      { dir: resolveInstallPaths(cwd, "global").skillsDir, copied: copyResult.globalCopied },
-      { dir: resolveInstallPaths(cwd, "project").skillsDir, copied: copyResult.projectCopied }
-    ].filter((group) => group.copied.length > 0);
-    for (const group of groups) {
-      this.log("Skills copied to:");
-      this.log(`  ${group.dir}`);
-      for (const copied of group.copied) {
-        this.log(`    ${copied.skillId}/`);
-      }
-      this.log("");
-    }
-  }
-  /**
-   * Reports where the agents actually landed, mirroring the scope split
-   * `compileAgentsAllScopes` performs: one pass at the home root, otherwise a
-   * global pass under HOME and a project pass under the project directory.
-   *
-   * **The EXTENSION is the host's, per scope, and was Claude's literal `.md` until C5.** This
-   * block describes the filesystem, so every line under a path header has to be a name a user can
-   * copy out and open — and a Codex install printed `web-developer.md` above a directory holding
-   * `web-developer.toml`. The two scopes are read separately because they can be on two hosts.
-   */
-  reportAgentsCompiled(compiled, agentScopeMap) {
-    const cwd = process.cwd();
-    const groups = isHomeDirectory(cwd) ? [{ ...compiledInto(cwd, "project"), agents: compiled }] : [
-      {
-        ...compiledInto(cwd, "global"),
-        agents: compiled.filter((name) => agentScopeMap.get(name) === "global")
-      },
-      {
-        ...compiledInto(cwd, "project"),
-        agents: compiled.filter((name) => agentScopeMap.get(name) !== "global")
-      }
-    ].filter((group) => group.agents.length > 0);
-    for (const group of groups) {
-      this.log("Agents compiled to:");
-      this.log(`  ${group.dir}`);
-      for (const agentName of group.agents) {
-        this.log(`    ${agentName}${group.extension}`);
+  logDirectoryBlocks(heading, blocks) {
+    for (const { dir, entries } of blocks) {
+      this.log(heading);
+      this.log(`  ${dir}`);
+      for (const entry of entries) {
+        this.log(`    ${entry}`);
       }
       this.log("");
     }
@@ -865,6 +700,24 @@ function opensTheEditor(flags) {
 function selectsNothing(result) {
   return result.skills.length === 0 && result.selectedAgents.length === 0;
 }
+async function installedGlobalToHold(projectDir) {
+  if (isHomeDirectory(projectDir)) return null;
+  return await readInstalledGlobal(projectDir);
+}
+function planInstall(result, installedAlready) {
+  const toInstall = result.skills.filter(
+    (skill) => !skill.excluded && !installedAlready.has(skill.id)
+  );
+  const [ejectedSkills, pluginSkills] = partition(
+    toInstall,
+    (skill) => skill.origin === EJECT_SOURCE
+  );
+  return { installMode: deriveInstallMode(toInstall), ejectedSkills, pluginSkills };
+}
+function installModeDescription({ installMode, ejectedSkills, pluginSkills }) {
+  if (installMode !== "mixed") return INSTALL_MODE_DESCRIPTIONS[installMode];
+  return `${INSTALL_MODE_LABELS.mixed} (${ejectedSkills.length} eject, ${pluginSkills.length} plugin)`;
+}
 function compilesGlobalScope(cwd, written) {
   return isHomeDirectory(cwd) || movedGlobalAgentInputs(written);
 }
@@ -881,10 +734,47 @@ function skillsCopiedLine(copyResult, installMode, projectDir) {
   const landedAt = globalCount > 0 ? "global" : "project";
   return `Copied ${copied} to ${resolveInstallPaths(projectDir, landedAt).skillsDir}/${lineEnd}`;
 }
-function compiledInto(cwd, scope) {
+function hasEntries(block) {
+  return block.entries.length > 0;
+}
+function oneBlockPerDir(blocks) {
+  const dirs = [...new Set(blocks.map((block) => block.dir))];
+  return dirs.map((dir) => ({
+    dir,
+    entries: blocks.filter((block) => block.dir === dir).flatMap((block) => block.entries)
+  }));
+}
+function skillsCopiedBlocks(projectDir, copyResult) {
+  return oneBlockPerDir(
+    [
+      copiedSkillsBlock(projectDir, "global", copyResult.globalCopied),
+      copiedSkillsBlock(projectDir, "project", copyResult.projectCopied)
+    ].filter(hasEntries)
+  );
+}
+function copiedSkillsBlock(projectDir, scope, copied) {
   return {
-    dir: resolveInstallPaths(cwd, scope).agentsDir,
-    extension: agentCodec(providerInUse(installBaseDir(cwd, scope))).extension
+    dir: resolveInstallPaths(projectDir, scope).skillsDir,
+    entries: copied.map(({ skillId }) => `${skillId}/`)
+  };
+}
+function agentsCompiledBlocks(projectDir, compiled, agentScopeMap) {
+  const [globalAgents, projectAgents] = partition(
+    compiled,
+    (name) => agentScopeMap.get(name) === "global"
+  );
+  return oneBlockPerDir(
+    [
+      compiledAgentsBlock(projectDir, "global", globalAgents),
+      compiledAgentsBlock(projectDir, "project", projectAgents)
+    ].filter(hasEntries)
+  );
+}
+function compiledAgentsBlock(projectDir, scope, agents) {
+  const { extension } = agentCodec(providerInUse(installBaseDir(projectDir, scope)));
+  return {
+    dir: resolveInstallPaths(projectDir, scope).agentsDir,
+    entries: agents.map((name) => `${name}${extension}`)
   };
 }
 function splitAgentScopes(cwd, agentScopeMap) {
@@ -896,10 +786,9 @@ function splitAgentScopes(cwd, agentScopeMap) {
     isGlobalOnly: globalAgentCount > 0 && globalAgentCount === scopes.length
   };
 }
-function configsHoldingAssignments(split, paths) {
-  if (split.isGlobalOnly) return [paths.global];
-  if (split.globalAgentCount > 0) return [paths.global, paths.project];
-  return [paths.project];
+function configsWritten(projectDir, paths, globalWritten) {
+  if (isHomeDirectory(projectDir)) return [paths.project];
+  return globalWritten ? [paths.global, paths.project] : [paths.project];
 }
 function customizationSteps(split, globalConfigPath, projectDir) {
   if (split.isGlobalOnly) {
@@ -912,32 +801,18 @@ function customizationSteps(split, globalConfigPath, projectDir) {
   ];
 }
 async function getDashboardData(projectDir) {
-  const [info, loaded, branding] = await Promise.all([
-    getInstallationInfo(),
-    loadProjectConfig(projectDir),
+  const [installations, branding] = await Promise.all([
+    getInstallationsByProvider(projectDir),
     resolveBranding(projectDir)
   ]);
-  const activeSkills = loaded?.config.skills.filter((s) => !s.excluded);
-  const skillCount = info?.skillCount ?? 0;
-  const agentCount = info?.agentCount ?? 0;
-  const mode = info?.mode ?? (activeSkills ? deriveInstallMode(activeSkills) : "eject");
-  const source = loaded?.config.marketplace;
-  return {
-    name: branding.name,
-    skillCount,
-    agentCount,
-    mode,
-    ...source !== void 0 && { source }
-  };
+  if (installations.length === 0) throw new Error(ERROR_MESSAGES.NO_INSTALLATION);
+  return { name: branding.name, installations };
 }
 
 export {
   Dashboard,
-  dashboardCountLines,
   formatDashboardText,
-  showDashboard,
   runDashboardFlow,
-  Init,
-  getDashboardData
+  Init
 };
-//# sourceMappingURL=chunk-NCWDK6L7.js.map
+//# sourceMappingURL=chunk-YXKTY5WM.js.map