agents-inc 0.164.0 → 0.166.0

package/dist/{chunk-G2JJ5BO5.js → chunk-G4JK7WVO.js}

@@ -1,93 +1,126 @@
 #!/usr/bin/env node
 import {
   SelectList
-} from "./chunk-7REKOTKG.js";
+} from "./chunk-6LF4CQBY.js";
 import {
-  openUrl
-} from "./chunk-7ANJQLPJ.js";
+  holdInstalledGlobal,
+  installPlanLines,
+  notInstalledGlobally,
+  openUrl,
+  readInstalledGlobal
+} from "./chunk-V3I7VQ7N.js";
 import {
   runWizardSession
-} from "./chunk-RGYDFBCT.js";
+} from "./chunk-HHIYT3PI.js";
 import {
   useTerminalDimensions
-} from "./chunk-ARYNOWKF.js";
+} from "./chunk-4NDBUJHK.js";
 import {
-  Spinner
-} from "./chunk-ZBPEFQ4G.js";
+  awaitUnderSpinner
+} from "./chunk-VRXX4D6K.js";
 import {
-  fetchSeedConfig,
-  registerExternalSkills,
-  writeExternalSkills
-} from "./chunk-X4SSJZLY.js";
+  fetchSeedConfig
+} from "./chunk-25MPBIK3.js";
 import {
+  promptConfirm,
   promptValue
-} from "./chunk-JCPANDNR.js";
+} from "./chunk-4AAOOAIN.js";
+import {
+  Confirm
+} from "./chunk-OZXAJNLA.js";
+import {
+  hostCompileNotices
+} from "./chunk-ZXKBERQU.js";
 import {
   compileAgentsAllScopes,
+  compileProjectScope,
   loadSource,
+  movedGlobalAgentInputs,
+  sayCapturedWarnings,
   writeProjectConfig
-} from "./chunk-X37UYIE3.js";
+} from "./chunk-G6UREQ4V.js";
 import {
   copyLocalSkills,
   discoverInstalledSkills
-} from "./chunk-2CQNPLVF.js";
+} from "./chunk-HWEKHVLE.js";
 import {
   loadAgentDefs
-} from "./chunk-B6FSLXYN.js";
+} from "./chunk-PMJWD27C.js";
 import {
   render
 } from "./chunk-JFLVEFFP.js";
+import {
+  providerFlag,
+  providerNamedBy,
+  providerNeedsAConfigurationToInstall
+} from "./chunk-NBXXFIIW.js";
 import {
   BaseCommand,
-  EXIT_CODES
-} from "./chunk-JIERYE6B.js";
+  EXIT_CODES,
+  registerExternalSkills,
+  writeExternalSkills
+} from "./chunk-Y3VIRVVE.js";
 import {
   clearTerminalScreen
-} from "./chunk-PHCPUQVR.js";
+} from "./chunk-RZDXDMT6.js";
 import {
   INCOMPLETE_WORK_RECOVERY,
   INSTALL_MODE_DESCRIPTIONS,
   INSTALL_MODE_LABELS,
+  SHARED_CONFIG_ARRIVALS,
   STATUS_MESSAGES,
+  advisesOnPermissions,
+  agentCodec,
   agentsNotCompiled,
+  applySharedConfigHere,
   buildAgentScopeMap,
   carriedSkillsWritten,
+  chooseProviderForThisRun,
   deriveInstallMode,
-  detectGlobalInstallation,
   detectInstallation,
   detectProjectInstallation,
+  editorLoadsItsOwnMarketplace,
   fileExists,
   getErrorMessage,
   getInstallationInfo,
   globalScopedAgentsHint,
+  holdsItsOwnInstallation,
+  hostAt,
   initSucceeded,
+  installBaseDir,
   isHomeDirectory,
+  isSameMarketplace,
+  keptAsInstalledGlobally,
   loadProjectConfig,
+  marketplaceFixedAtInstall,
+  permissionFiles,
+  plural,
+  providerInUse,
   readFileSafe,
+  relativeConfigPath,
   resolveBranding,
   resolveInstallPaths,
+  resolveSource,
   seedToWizardResult,
   settingsFileSchema,
   sharedConfigExistingInstall,
-  sharedConfigGlobalInstall,
   skippedUnknownAgents,
   skippedUnknownSkills,
-  warn
-} from "./chunk-XPDVAJDH.js";
+  warn,
+  wizardNeedsTerminal
+} from "./chunk-A4KDXNOT.js";
 import {
   ASCII_LOGO,
-  CLAUDE_DIR,
-  CLAUDE_SRC_DIR,
   CLI_COLORS,
   CLI_INVOKE_COMMAND,
   DEFAULT_BRANDING,
   EDITOR_URL,
   EDIT_PROJECT_SETUP_FLAG,
+  EDIT_PROJECT_SETUP_MARKETPLACE_FLAG,
   EJECT_SOURCE,
   MAX_CONFIG_FILE_SIZE,
-  STANDARD_FILES,
   editorConfigUrl
-} from "./chunk-UITEKY2R.js";
+} from "./chunk-ENGYJCTF.js";
 
 // src/cli/commands/init.tsx
 import "react";
@@ -113,24 +146,40 @@ async function readSettingsPermissions(filePath) {
     return void 0;
   }
 }
-async function loadPermissions(projectRoot) {
-  const settingsPath = path.join(projectRoot, CLAUDE_DIR, STANDARD_FILES.SETTINGS_JSON);
-  const localSettingsPath = path.join(projectRoot, CLAUDE_DIR, STANDARD_FILES.SETTINGS_LOCAL_JSON);
-  for (const filePath of [localSettingsPath, settingsPath]) {
+function settingsFilesFor(projectRoot) {
+  return permissionFiles(providerInUse(projectRoot), "project", projectRoot);
+}
+async function loadPermissions(files) {
+  for (const filePath of [...files].reverse()) {
     const permissions = await readSettingsPermissions(filePath);
     if (permissions) return permissions;
   }
   return void 0;
 }
+function asUserWritesIt(projectRoot, file) {
+  return path.relative(projectRoot, file).split(path.sep).join("/");
+}
 async function checkPermissions(projectRoot) {
-  const permissions = await loadPermissions(projectRoot);
+  if (!advisesOnPermissions(providerInUse(projectRoot))) return null;
+  const files = settingsFilesFor(projectRoot);
+  const [base] = files;
+  if (base === void 0) return null;
+  const permissions = await loadPermissions(files);
+  const settingsFile = asUserWritesIt(projectRoot, base);
   if (!permissions) {
     return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: CLI_COLORS.WARNING, padding: 1, children: [
       /* @__PURE__ */ jsx(Text, { bold: true, color: CLI_COLORS.WARNING, children: "Permission Notice" }),
-      /* @__PURE__ */ jsx(Text, { children: "No permissions configured in .claude/settings.json" }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "No permissions configured in ",
+        settingsFile
+      ] }),
       /* @__PURE__ */ jsx(Text, { children: "Agents will prompt for approval on each tool use." }),
       /* @__PURE__ */ jsx(Text, { children: " " }),
-      /* @__PURE__ */ jsx(Text, { children: "For autonomous operation, add to .claude/settings.json:" }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "For autonomous operation, add to ",
+        settingsFile,
+        ":"
+      ] }),
       /* @__PURE__ */ jsx(Text, { children: " " }),
       /* @__PURE__ */ jsx(Text, { color: CLI_COLORS.DIM, children: "{" }),
       /* @__PURE__ */ jsx(Text, { color: CLI_COLORS.DIM, children: '  "permissions": {' }),
@@ -208,6 +257,7 @@ function formatDashboardText(data) {
     `  [Edit]  [Compile]  [Doctor]  [List]`
   ].join("\n");
 }
+var DASHBOARD_INTERRUPTED = "interrupted";
 async function showDashboard(projectDir, log) {
   const data = await getDashboardData(projectDir);
   if (!process.stdin.isTTY) {
@@ -224,26 +274,28 @@ async function showDashboard(projectDir, log) {
         onCancel: () => resolve(null)
       }
     ),
-    { onExit: null, clearOnResolve: true }
+    { onExit: DASHBOARD_INTERRUPTED, clearOnResolve: true }
   );
   clearTerminalScreen();
   return selectedCommand;
 }
-function dashboardCommandArgv(command, origin) {
+function dashboardCommandArgv(command, origin, setupMarketplace) {
   if (command !== "edit" || origin !== "init") return [];
-  return [`--${EDIT_PROJECT_SETUP_FLAG}`];
+  const marketplaceArgv = setupMarketplace === void 0 ? [] : [`--${EDIT_PROJECT_SETUP_MARKETPLACE_FLAG}`, setupMarketplace];
+  return [`--${EDIT_PROJECT_SETUP_FLAG}`, ...marketplaceArgv];
 }
-async function runDashboardFlow(projectDir, config, origin, log) {
+async function runDashboardFlow(projectDir, config, origin, log, setupMarketplace) {
   const installation = await detectInstallation(projectDir);
-  if (!installation) return false;
+  if (!installation) return "not-installed";
   const selectedCommand = await showDashboard(projectDir, log);
+  if (selectedCommand === DASHBOARD_INTERRUPTED) return "cancelled";
   if (selectedCommand) {
-    await config.runCommand(selectedCommand, dashboardCommandArgv(selectedCommand, origin));
+    await config.runCommand(
+      selectedCommand,
+      dashboardCommandArgv(selectedCommand, origin, setupMarketplace)
+    );
   }
-  return true;
-}
-function writesGlobalContent(result) {
-  return result.skills.some((skill) => skill.scope === "global") || result.agentConfigs.some((agent) => agent.scope === "global");
+  return "shown";
 }
 function sharedConfigSourceFlags(flags, payload) {
   return { marketplace: flags.marketplace ?? payload.marketplace };
@@ -281,7 +333,8 @@ var Init = class _Init extends BaseCommand {
     ui: Flags.boolean({
       description: "Open agentsinc.sh/editor instead of the terminal \u2014 the id --from names, or the catalogue",
       default: false
-    })
+    }),
+    provider: providerFlag()
   };
   /**
    * The command in two statements: do the work, then answer for it.
@@ -314,97 +367,123 @@ var Init = class _Init extends BaseCommand {
    * loss, so opening one is the convenience on top and a failure to open is a warning beside a
    * link that still works.
    */
-  async openEditor(id) {
+  async openEditor(id, projectDir) {
     const url = id === void 0 ? EDITOR_URL : editorConfigUrl(id);
     this.log(id === void 0 ? `Build it at ${url}` : `Open it at ${url}`);
-    if (id === void 0) {
-      this.log(`Then install what it gives you with '${CLI_INVOKE_COMMAND} init --from <id>'.`);
-    } else {
-      this.log(`To install it here instead, run '${CLI_INVOKE_COMMAND} init --from ${id}'.`);
-    }
+    this.log(applySharedConfigHere(id, await holdsItsOwnInstallation(projectDir)));
     if (!process.stdin.isTTY) return;
     const opened = await openUrl(url);
     if (!opened.ok) this.warn(opened.error);
   }
   /**
    * One spine, two producers. The wizard and a shared id differ only in *where the selection
-   * comes from* — everything after it (the empty guard, the install pipeline) is identical, so it
-   * lives here once rather than being written twice and drifting.
+   * comes from* — everything after it (the install pipeline) is identical, so it lives here once
+   * rather than being written twice and drifting. What each producer refuses, it refuses itself:
+   * `--from` asks a question the wizard does not, and every refusal it makes comes before it.
    */
   async install() {
     const { flags } = await this.parse(_Init);
     const projectDir = process.cwd();
-    if (flags.ui) return this.openEditor(flags.from);
+    this.settleTheProviderForThisRun(flags);
+    if (flags.ui) {
+      this.refuseMarketplaceForTheEditor(flags.marketplace);
+      return this.openEditor(flags.from, projectDir);
+    }
     await this.ensureConfigReadable(projectDir);
     this.brandingName = await this.resolveBrandingName(projectDir);
-    if (!flags.from && await this.showDashboardIfInitialized(projectDir)) return;
+    if (!flags.from) {
+      await this.refuseMarketplaceOtherThanTheInstalledOne(projectDir, flags.marketplace);
+      const dashboard = await this.showDashboardIfInitialized(projectDir, flags.marketplace);
+      if (dashboard === "cancelled") this.error("Cancelled", { exit: EXIT_CODES.CANCELLED });
+      if (dashboard === "shown") return;
+    }
     const selection = flags.from ? await this.selectionFromSharedConfig(flags.from, flags, projectDir) : await this.selectionFromWizard(flags, projectDir);
     if (!selection) this.exit(EXIT_CODES.CANCELLED);
     this.reportValidationErrors(selection.result.validation);
-    if (selection.result.skills.length === 0 && selection.result.selectedAgents.length === 0) {
-      this.error(selection.emptyMessage, { exit: EXIT_CODES.ERROR });
-    }
     await this.handleInstallation(
       selection.result,
       selection.sourceResult,
       selection.sourceFlags,
-      selection.interactive
+      selection.interactive,
+      selection.installedAlready
     );
   }
+  /**
+   * 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. There is no
+   * wizard step to choose a provider in and none is planned — which is what makes "the interactive
+   * flow is Claude-only" provable rather than conventional. 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.
+   */
+  settleTheProviderForThisRun(flags) {
+    const named = providerNamedBy(flags.provider);
+    if (named === void 0) return;
+    if (flags.from === void 0) {
+      this.error(providerNeedsAConfigurationToInstall(), { exit: EXIT_CODES.INVALID_ARGS });
+    }
+    chooseProviderForThisRun(named);
+  }
   /** The interactive producer: load the source, run the wizard, return what was chosen. */
   async selectionFromWizard(flags, projectDir) {
     const isGlobalRoot = isHomeDirectory(projectDir);
     const { sourceResult, startupMessages } = await this.loadWizardInputsUnderSpinner(flags);
+    if (!process.stdin.isTTY) {
+      this.error(wizardNeedsTerminal("init"), { exit: EXIT_CODES.ERROR });
+    }
     const result = await this.runWizard(startupMessages, isGlobalRoot);
     if (!result) return null;
+    if (selectsNothing(result)) this.error("No skills selected", { exit: EXIT_CODES.ERROR });
     return {
       result,
       sourceResult,
       sourceFlags: flags,
       // A person is already at the terminal, so the permission notice can wait for them.
       interactive: true,
-      emptyMessage: "No skills selected"
+      // The wizard opens only where nothing is installed at all — see `runWizard`.
+      installedAlready: /* @__PURE__ */ new Set()
     };
   }
   /**
    * Everything the wizard needs, loaded behind a spinner that comes down whichever way the
-   * await ends.
-   *
-   * The cleanup is a `finally` because a source that cannot be loaded refuses the run from
-   * inside this await, 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 exit code change with it.
+   * await ends — a source that cannot be loaded refuses the run from inside it.
    */
   async loadWizardInputsUnderSpinner(flags) {
-    const { unmount, clear: clearSpinner } = render(
-      /* @__PURE__ */ jsx2(Spinner, { label: STATUS_MESSAGES.LOADING_SKILLS })
-    );
-    try {
-      return await this.loadSourceOrFail(flags);
-    } finally {
-      clearSpinner();
-      unmount();
-    }
+    return awaitUnderSpinner(STATUS_MESSAGES.LOADING_SKILLS, () => this.loadSourceOrFail(flags));
   }
   /**
-   * The `--from <id>` producer: fetch and map, no wizard. Nothing here may assume a TTY — running
-   * headless is most of why the flag exists.
+   * The `--from <id>` producer: fetch and map, no wizard — 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`).
    *
-   * It is also greenfield-only, which is what two of the three refusals are: a shared
-   * configuration is installed whole, so anything it would have to install over has to be
-   * uninstalled first. The third is about the LOCATION rather than what is already in it — a
-   * global installation holds only global-scoped content, and this is the one producer that never
-   * asked. All three fire before anything is written.
+   * 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.
    */
   async selectionFromSharedConfig(id, flags, projectDir) {
-    await this.refuseInstalledProject(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 } = await this.loadSourceOrFail(sourceFlags);
+    const { sourceResult, startupMessages } = await this.loadSourceOrFail(sourceFlags);
     const carriedSkills = this.registerExternalSkillsOrFail(
       fetched.payload,
       sourceResult.matrix,
@@ -415,50 +494,87 @@ var Init = class _Init extends BaseCommand {
       sourceResult.matrix
     );
     this.refuseProjectScopedContentAtHome(result, projectDir);
-    await this.refuseBlockingGlobalInstall(result);
-    await this.writeCarriedSkills(carriedSkills);
+    const held = holdInstalledGlobal(
+      result,
+      isHomeDirectory(projectDir) ? null : await readInstalledGlobal(projectDir)
+    );
+    const arrivingCarried = notInstalledGlobally(carriedSkills, held);
+    await this.refuseSharedConfigBeforeAsking(
+      held.result,
+      arrivingCarried,
+      projectDir,
+      sourceResult
+    );
+    sayCapturedWarnings(startupMessages);
     if (skippedSkillIds.length > 0) this.warn(skippedUnknownSkills(skippedSkillIds));
     if (skippedAgentNames.length > 0) this.warn(skippedUnknownAgents(skippedAgentNames));
-    if (result.skills.length > 0) {
+    if (selectsNothing(held.result)) {
+      this.error(`Configuration '${id}' contains no skills this catalog can install.`, {
+        exit: EXIT_CODES.ERROR
+      });
+    }
+    this.logWhatGoesWhere(held);
+    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 ${result.skills.length} skill(s) across ${result.selectedAgents.length} sub-agent(s)
+        `Installing ${arriving.length} skill(s) across ${result.selectedAgents.length} sub-agent(s)
 `
       );
     }
     return {
-      result,
+      result: held.result,
       sourceResult,
       sourceFlags,
       interactive: false,
-      emptyMessage: `Configuration '${id}' contains no skills this catalog can install.`
+      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, and the global entries the configuration states
+   * otherwise than they are installed, which stay.
+   */
+  logWhatGoesWhere(held) {
+    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("");
+  }
+  /** The question under the lists, defaulting to no: nothing has been written yet. */
+  async confirmInstall() {
+    const outcome = await promptConfirm(({ onConfirm, onCancel }) => /* @__PURE__ */ jsx2(
+      Confirm,
+      {
+        message: SHARED_CONFIG_ARRIVALS.INSTALL_CONFIRM,
+        onConfirm,
+        onCancel
+      }
+    ));
+    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 — including for a payload that never
-   * goes near it. Whether a global install is in the way is a question about the PAYLOAD, and
-   * {@link refuseBlockingGlobalInstall} is where it is asked.
+   * 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.
    */
-  async refuseInstalledProject(projectDir) {
+  async refuseInstalledProject(projectDir, id) {
     const installation = await detectProjectInstallation(projectDir);
     if (!installation) return;
-    this.error(sharedConfigExistingInstall(installation.configPath), { exit: EXIT_CODES.ERROR });
-  }
-  /**
-   * The other half of the same rule. A payload carrying global-scoped skills or sub-agents writes
-   * into the user's own ~/.claude, so an installation there is in its way even when this project
-   * is spotless. A payload with nothing global cannot reach that far and is never refused for it.
-   */
-  async refuseBlockingGlobalInstall(result) {
-    if (!writesGlobalContent(result)) return;
-    const globalInstallation = await detectGlobalInstallation();
-    if (!globalInstallation) return;
-    this.error(sharedConfigGlobalInstall(globalInstallation.configPath), {
+    this.error(sharedConfigExistingInstall(installation.configPath, id), {
       exit: EXIT_CODES.ERROR
     });
   }
@@ -495,8 +611,45 @@ var Init = class _Init extends BaseCommand {
     await writeExternalSkills(carried);
     this.log(carriedSkillsWritten(carried.map((skill) => skill.id)));
   }
-  async showDashboardIfInitialized(projectDir) {
-    return runDashboardFlow(projectDir, this.config, "init", (msg) => this.log(msg));
+  async showDashboardIfInitialized(projectDir, setupMarketplace) {
+    return runDashboardFlow(
+      projectDir,
+      this.config,
+      "init",
+      (msg) => this.log(msg),
+      setupMarketplace
+    );
+  }
+  /**
+   * Refuses `--marketplace` beside `--ui`. The editor's address carries a configuration id and
+   * nothing else, so the marketplace would be dropped on the way — and the editor loads
+   * marketplaces itself.
+   */
+  refuseMarketplaceForTheEditor(named) {
+    if (named === void 0) return;
+    this.error(editorLoadsItsOwnMarketplace(named), { exit: EXIT_CODES.INVALID_ARGS });
+  }
+  /**
+   * Refuses a marketplace other than the one this folder's OWN installation was made from.
+   *
+   * An installation's marketplace is chosen once, when it is made, and the dashboard every route
+   * here ends on reads the one it stored — so naming another would be dropped, and a flag dropped
+   * reads as honoured. Project-scoped detection, because a project with no installation of its
+   * own is not refused for the global one above it: that is two installations, and the setup the
+   * dashboard's Edit runs there takes the named marketplace. At the home directory the folder's
+   * own installation IS the global one, and the same detection finds it.
+   *
+   * The stored marketplace is resolved the way every later command resolves it — this folder's
+   * config, then the global one, then the default — so an installation that recorded none is
+   * held to the one it has actually been reading. A folder named back by another spelling of its
+   * path is that same marketplace.
+   */
+  async refuseMarketplaceOtherThanTheInstalledOne(projectDir, named) {
+    if (named === void 0) return;
+    if (!await detectProjectInstallation(projectDir)) return;
+    const { source: stored } = await resolveSource({ caller: "stored", projectDir });
+    if (isSameMarketplace(named, stored, projectDir)) return;
+    this.error(marketplaceFixedAtInstall(stored, named), { exit: EXIT_CODES.INVALID_ARGS });
   }
   async loadSourceOrFail(flags) {
     try {
@@ -533,19 +686,22 @@ var Init = class _Init extends BaseCommand {
       clearTerminal: () => this.clearTerminal()
     });
   }
-  async handleInstallation(result, sourceResult, flags, interactive = true) {
+  async handleInstallation(result, sourceResult, flags, interactive, installedAlready) {
     const projectDir = process.cwd();
     const activeSkills = result.skills.filter((s) => !s.excluded);
-    const installMode = deriveInstallMode(activeSkills);
-    const ejectedSkills = activeSkills.filter((s) => s.origin === EJECT_SOURCE);
-    const pluginSkills = activeSkills.filter((s) => s.origin !== EJECT_SOURCE);
+    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.refuseUnofferablePlacementsBeforeWriting(activeSkills, projectDir);
     this.logInstallPlan(installMode, ejectedSkills, pluginSkills);
     const resolvedMarketplace = pluginSkills.length > 0 ? await this.requireMarketplaceOrExit(
       sourceResult,
       "install plugin skills",
+      hostAt(projectDir),
       (marketplace) => this.log(`Registering marketplace "${marketplace}"...`)
     ) : null;
-    const copyResult = installMode === "eject" || installMode === "mixed" ? await this.copyEjectSkillsStep(ejectedSkills, projectDir, sourceResult, installMode) : null;
+    const copyResult = ejectedSkills.length > 0 ? await this.copyEjectSkillsStep(ejectedSkills, projectDir, sourceResult, installMode) : null;
     if (resolvedMarketplace !== null) {
       await this.installPluginSkillsReported(
         pluginSkills,
@@ -594,28 +750,19 @@ var Init = class _Init extends BaseCommand {
   }
   logInstallPlan(installMode, ejectedSkills, pluginSkills) {
     this.log("\n");
-    this.log(`Selected ${ejectedSkills.length + pluginSkills.length} skills`);
+    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]}`
     );
   }
+  /**
+   * Copies the ejected skills and says how many landed at each scope, in the words
+   * {@link skillsCopiedLine} chooses.
+   */
   async copyEjectSkillsStep(localSkills, projectDir, sourceResult, installMode) {
     this.log("Copying skills to local directory...");
     const copyResult = await copyLocalSkills(localSkills, projectDir, sourceResult);
-    if (installMode === "mixed") {
-      if (copyResult.projectCopied.length > 0 && copyResult.globalCopied.length > 0) {
-        this.log(
-          `Copied ${copyResult.totalCopied} local skills (${copyResult.projectCopied.length} project, ${copyResult.globalCopied.length} global)`
-        );
-      } else if (copyResult.globalCopied.length > 0) {
-        this.log(`Copied ${copyResult.globalCopied.length} local skills to ~/.claude/skills/`);
-      } else {
-        this.log(`Copied ${copyResult.projectCopied.length} local skills to .claude/skills/`);
-      }
-    } else {
-      this.log(`Copied ${copyResult.totalCopied} skills to .claude/skills/
-`);
-    }
+    this.log(skillsCopiedLine(copyResult, installMode, projectDir));
     return copyResult;
   }
   async writeConfigAndCompile(result, sourceResult, flags) {
@@ -629,24 +776,43 @@ var Init = class _Init extends BaseCommand {
     if (configResult.wasMerged) {
       this.log(`Merged with existing config at ${configResult.existingConfigPath}`);
     }
-    this.log(`Configuration saved (${configResult.config.agents.length} agents)
+    this.log(`Configuration saved (${plural(configResult.config.agents.length, "agent")})
 `);
-    this.reportUnassignedSkills(configResult.config);
+    this.reportUnassignedSkills(configResult.config, result.skills);
     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 compileResult = await compileAgentsAllScopes({
+    const compile = compilesGlobalScope(cwd, configResult.propagation) ? compileAgentsAllScopes : compileProjectScope;
+    const compileResult = await compile({
       projectDir: cwd,
       sourcePath: agentDefs.sourcePath,
       skills: allSkills,
       agentScopeMap
     });
     this.reportCompilation(compileResult);
-    this.reportPropagatedRecompile(configResult.propagation);
+    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)) {
+      this.log(notice);
+    }
+  }
   /**
    * What the compile pass did, including the half this command used to drop.
    *
@@ -661,7 +827,7 @@ var Init = class _Init extends BaseCommand {
    */
   reportCompilation(compileResult) {
     const { compiled, failed, warnings } = compileResult;
-    const summary = `Compiled ${compiled.length} agents`;
+    const summary = `Compiled ${plural(compiled.length, "agent")}`;
     if (failed.length === 0) {
       this.log(`${summary}
 `);
@@ -709,7 +875,7 @@ var Init = class _Init extends BaseCommand {
     }
     this.log("");
     this.log("To customize agent-skill assignments:");
-    for (const [index, step] of customizationSteps(split, paths.global).entries()) {
+    for (const [index, step] of customizationSteps(split, paths.global, cwd).entries()) {
       this.log(`  ${index + 1}. ${step}`);
     }
     this.log("");
@@ -749,16 +915,21 @@ var Init = class _Init extends BaseCommand {
    * 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) ? [{ dir: resolveInstallPaths(cwd, "project").agentsDir, agents: compiled }] : [
+    const groups = isHomeDirectory(cwd) ? [{ ...compiledInto(cwd, "project"), agents: compiled }] : [
       {
-        dir: resolveInstallPaths(cwd, "global").agentsDir,
+        ...compiledInto(cwd, "global"),
         agents: compiled.filter((name) => agentScopeMap.get(name) === "global")
       },
       {
-        dir: resolveInstallPaths(cwd, "project").agentsDir,
+        ...compiledInto(cwd, "project"),
         agents: compiled.filter((name) => agentScopeMap.get(name) !== "global")
       }
     ].filter((group) => group.agents.length > 0);
@@ -766,12 +937,37 @@ var Init = class _Init extends BaseCommand {
       this.log("Agents compiled to:");
       this.log(`  ${group.dir}`);
       for (const agentName of group.agents) {
-        this.log(`    ${agentName}.md`);
+        this.log(`    ${agentName}${group.extension}`);
       }
       this.log("");
     }
   }
 };
+function selectsNothing(result) {
+  return result.skills.length === 0 && result.selectedAgents.length === 0;
+}
+function compilesGlobalScope(cwd, written) {
+  return isHomeDirectory(cwd) || movedGlobalAgentInputs(written);
+}
+function skillsCopiedLine(copyResult, installMode, projectDir) {
+  const isMixed = installMode === "mixed";
+  const copied = plural(copyResult.totalCopied, isMixed ? "local skill" : "skill");
+  const lineEnd = isMixed ? "" : "\n";
+  const projectCount = copyResult.projectCopied.length;
+  const globalCount = copyResult.globalCopied.length;
+  const landedAtBothScopes = projectCount > 0 && globalCount > 0;
+  if (landedAtBothScopes) {
+    return `Copied ${copied} (${projectCount} project, ${globalCount} global)${lineEnd}`;
+  }
+  const landedAt = globalCount > 0 ? "global" : "project";
+  return `Copied ${copied} to ${resolveInstallPaths(projectDir, landedAt).skillsDir}/${lineEnd}`;
+}
+function compiledInto(cwd, scope) {
+  return {
+    dir: resolveInstallPaths(cwd, scope).agentsDir,
+    extension: agentCodec(providerInUse(installBaseDir(cwd, scope))).extension
+  };
+}
 function splitAgentScopes(cwd, agentScopeMap) {
   if (isHomeDirectory(cwd)) return { globalAgentCount: 0, isGlobalOnly: false };
   const scopes = [...agentScopeMap.values()];
@@ -786,12 +982,12 @@ function configsHoldingAssignments(split, paths) {
   if (split.globalAgentCount > 0) return [paths.global, paths.project];
   return [paths.project];
 }
-function customizationSteps(split, globalConfigPath) {
+function customizationSteps(split, globalConfigPath, projectDir) {
   if (split.isGlobalOnly) {
     return [`Edit ${globalConfigPath}`, globalScopedAgentsHint(split.globalAgentCount)];
   }
   return [
-    `Edit ${CLAUDE_SRC_DIR}/${STANDARD_FILES.CONFIG_TS}`,
+    `Edit ${relativeConfigPath(projectDir, providerInUse(projectDir))}`,
     `Run '${CLI_INVOKE_COMMAND} compile' to regenerate agents`,
     ...split.globalAgentCount > 0 ? [globalScopedAgentsHint(split.globalAgentCount)] : []
   ];
@@ -825,4 +1021,4 @@ export {
   Init,
   getDashboardData
 };
-//# sourceMappingURL=chunk-G2JJ5BO5.js.map
+//# sourceMappingURL=chunk-G4JK7WVO.js.map