agents-inc 0.152.1 → 0.154.0

package/dist/{chunk-PZIZNMHK.js → chunk-5MFJ24VM.js}

@@ -1,64 +1,70 @@
 #!/usr/bin/env node
+import {
+  SelectList
+} from "./chunk-XGMOXMS4.js";
 import {
   promptValue
-} from "./chunk-Q2KG7UV3.js";
+} from "./chunk-OJJLYHM3.js";
+import {
+  Spinner
+} from "./chunk-ZBPEFQ4G.js";
 import {
   runWizardSession
-} from "./chunk-MVR3SYMN.js";
+} from "./chunk-QUDQTO3O.js";
 import {
   useTerminalDimensions
-} from "./chunk-MWG4VU64.js";
-import {
-  SelectList
-} from "./chunk-RNJWAKMO.js";
-import {
-  Spinner
-} from "./chunk-IUQBOCSU.js";
-import {
-  STATUS_MESSAGES,
-  SUCCESS_MESSAGES
-} from "./chunk-ODNDXQH2.js";
+} from "./chunk-MJFIO5SX.js";
 import {
   compileAgentsAllScopes,
   loadSource,
   writeProjectConfig
-} from "./chunk-STMHDOZD.js";
+} from "./chunk-XMEIVWAS.js";
 import {
-  discoverInstalledSkills,
-  installPluginSkills,
-  pluginInstallFailureError
-} from "./chunk-SBHBBZKF.js";
+  discoverInstalledSkills
+} from "./chunk-ZU6DAR4S.js";
 import {
   copyLocalSkills
-} from "./chunk-IHUY4M22.js";
+} from "./chunk-UW44KSYL.js";
 import {
   loadAgentDefs
-} from "./chunk-QZZJFYUQ.js";
+} from "./chunk-PRJD5MMQ.js";
 import {
   render
 } from "./chunk-JFLVEFFP.js";
 import {
   orderDomains
-} from "./chunk-5UWKOOIS.js";
+} from "./chunk-QQTYMW7N.js";
 import {
   BaseCommand,
   EXIT_CODES
-} from "./chunk-KR65TPKC.js";
+} from "./chunk-FMYHWKGG.js";
 import {
   clearTerminalScreen
-} from "./chunk-ZL7PFNHN.js";
+} from "./chunk-K3O3YQYG.js";
 import {
+  DEFAULT_SELECTION_OPTIONS,
+  INSTALL_MODE_DESCRIPTIONS,
   INSTALL_MODE_LABELS,
+  STATUS_MESSAGES,
+  SUCCESS_MESSAGES,
+  activeAgentNames,
   buildAgentScopeMap,
   deriveInstallMode,
   detectGlobalInstallation,
   detectInstallation,
+  detectProjectInstallation,
   getInstallationInfo,
+  globalScopedAgentsHint,
   isHomeDirectory,
+  isScopePairCompatible,
   loadProjectConfig,
   loadProjectConfigFromDir,
-  resolveInstallPaths
-} from "./chunk-EEPELKOM.js";
+  resolveInstallPaths,
+  seedPayloadSchema,
+  sharedConfigExistingInstall,
+  sharedConfigGlobalInstall,
+  validateSelection
+} from "./chunk-CBF4ZYV3.js";
 import {
   AGENT_NAMES,
   fileExists,
@@ -66,10 +72,10 @@ import {
   readFileSafe,
   settingsFileSchema,
   warn
-} from "./chunk-PMM2MYMA.js";
+} from "./chunk-4VCWL2IG.js";
 import {
   getCategoryDomain
-} from "./chunk-WKTHWQKM.js";
+} from "./chunk-IPJOMAWC.js";
 import {
   ASCII_LOGO,
   CLAUDE_DIR,
@@ -82,50 +88,14 @@ import {
   EJECT_SOURCE,
   MAX_CONFIG_FILE_SIZE,
   STANDARD_FILES
-} from "./chunk-76ADG7LQ.js";
+} from "./chunk-R54KIGN2.js";
 
 // src/cli/commands/init.tsx
 import os from "os";
+import "react";
 import { Flags } from "@oclif/core";
 import { Box as Box2, Text as Text2, useApp } from "ink";
 
-// src/cli/lib/seed/seed-schema.ts
-import { z } from "zod";
-var SEED_VERSION = 3;
-var seedModelSchema = z.enum(["opus", "fable", "sonnet", "haiku"]);
-var seedEffortSchema = z.enum(["low", "medium", "high", "xhigh", "max"]);
-var seedLoadStateSchema = z.enum(["lazy", "preloaded"]);
-var seedSkillSchema = z.object({
-  install: z.enum(["plugin", "eject"]),
-  scope: z.enum(["project", "global"]),
-  /** Sub-agent id -> load state; presence is assignment. */
-  assignments: z.record(z.string(), seedLoadStateSchema)
-});
-var seedAgentSchema = z.object({
-  /** Explicitly switched on (bare) or off. Absent means "whatever the assignments imply". */
-  on: z.boolean().optional(),
-  model: seedModelSchema.optional(),
-  effort: seedEffortSchema.optional(),
-  /**
-   * Which `.claude/agents` directory this sub-agent's front-matter is written to. Absent means
-   * `project` — the CLI's own default, so a resting choice never has to travel.
-   */
-  scope: z.enum(["project", "global"]).optional()
-});
-var seedPayloadSchema = z.object({
-  v: z.literal(SEED_VERSION),
-  /**
-   * Diagnostics only. A mismatch with this CLI's matrix must never fail a decode — it explains
-   * why some ids were skipped, it does not decide whether to try.
-   */
-  matrixVersion: z.string(),
-  stackId: z.string().nullable(),
-  /** Sparse — presence is selection. `remembered` never leaves the browser. */
-  skills: z.record(z.string(), seedSkillSchema),
-  /** Sparse — an agent with nothing to say has no entry. */
-  agents: z.record(z.string(), seedAgentSchema)
-});
-
 // src/cli/lib/seed/fetch-seed.ts
 var SEED_API_URL = process.env.AGENTS_INC_API_URL ?? "https://api.agentsinc.sh";
 var SEED_USER_AGENT = "agents-inc-cli";
@@ -190,19 +160,30 @@ function readAgentMap(agents) {
   }
   return { known, switchedOff, unknown };
 }
+function seedAgentScope(entry) {
+  return entry?.scope ?? DEFAULT_SELECTION_OPTIONS.scope;
+}
 function agentScopeConfig(name, entry) {
   return {
     name,
-    scope: entry?.scope ?? "project",
+    scope: seedAgentScope(entry),
     ...entry?.model !== void 0 && { model: entry.model },
     ...entry?.effort !== void 0 && { effort: entry.effort }
   };
 }
+function unwritableAssignmentsError(assignments) {
+  return [
+    "This configuration cannot be installed: a project-scoped skill never reaches a sub-agent that rests at global scope, so these assignments have nowhere to be written:",
+    ...assignments.map(({ skillId, agent }) => `  ${skillId} -> ${agent}`),
+    "Re-share it with each sub-agent above pinned to the project, or each skill above at global scope."
+  ].join("\n");
+}
 function seedToWizardResult(payload, matrix) {
   const domainSelections = {};
   const assignedStack = {};
   const skills = [];
   const skippedSkillIds = [];
+  const unwritable = [];
   const agentNames = /* @__PURE__ */ new Set();
   const agentMap = readAgentMap(payload.agents);
   const skippedAgentNames = new Set(agentMap.unknown);
@@ -229,10 +210,15 @@ function seedToWizardResult(payload, matrix) {
         continue;
       }
       const agent = agentName;
+      if (!isScopePairCompatible(entry.scope, seedAgentScope(agentMap.known.get(agent)))) {
+        unwritable.push({ skillId: id, agent });
+        continue;
+      }
       agentNames.add(agent);
       addToAgentStack(assignedStack, agent, category, toSkillAssignment(id, load));
     }
   }
+  if (unwritable.length > 0) throw new Error(unwritableAssignmentsError(unwritable));
   for (const [name, entry] of agentMap.known) {
     if (entry.on === true) agentNames.add(name);
   }
@@ -247,12 +233,17 @@ function seedToWizardResult(payload, matrix) {
       domainSelections,
       selectedDomains: orderDomains(Object.keys(domainSelections)),
       // Nothing was dropped from a *saved config* — the skipped ids came off the wire and are
-      // reported to the user directly, so there is no existing entry to preserve.
+      // reported to the user directly, so there is no config removal to explain.
       unresolvableSkillIds: [],
       cancelled: false,
-      // A shared configuration was already validated by the app that built it; this path has no
-      // interactive step in which a validation warning could be acted on.
-      validation: { valid: true, errors: [], warnings: [] }
+      // Revalidated here rather than taken on trust from the app that built the payload. That app
+      // validated against ITS catalog; this one skips ids it does not know and carries its own
+      // relationship rules, so a configuration that was consistent where it was authored can
+      // arrive with a requirement genuinely unmet. Running the same validator the wizard runs
+      // makes that this catalog's verdict on what it can install — reported through the spine
+      // `init` already has, beside the skips that explain it — rather than a fault in what was
+      // shared.
+      validation: validateSelection(skills.map((skill) => skill.id))
     },
     skippedSkillIds,
     skippedAgentNames: [...skippedAgentNames]
@@ -260,6 +251,8 @@ function seedToWizardResult(payload, matrix) {
 }
 
 // src/cli/lib/permission-checker.tsx
+import "react";
+import "zod";
 import { Text, Box } from "ink";
 import path from "path";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -392,6 +385,9 @@ async function runDashboardFlow(projectDir, config, origin, log) {
   }
   return true;
 }
+function writesGlobalContent(result) {
+  return result.skills.some((skill) => skill.scope === "global") || result.agentConfigs.some((agent) => agent.scope === "global");
+}
 var Init = class _Init extends BaseCommand {
   static summary = `Initialize ${DEFAULT_BRANDING.NAME} in this project`;
   static description = "Interactive wizard to set up skills and agents. Supports Plugin Mode (native install) and Eject Mode (copy to .claude/).";
@@ -403,17 +399,13 @@ var Init = class _Init extends BaseCommand {
     {
       description: "Initialize from a custom marketplace",
       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 source",
-      default: false
+    source: Flags.string({
+      char: "s",
+      description: "Skills source path or URL",
+      required: false
     }),
     from: Flags.string({
       description: "Install a configuration shared from agentsinc.sh by its id, without the wizard",
@@ -428,9 +420,11 @@ var Init = class _Init extends BaseCommand {
   async run() {
     const { flags } = await this.parse(_Init);
     const projectDir = process.cwd();
+    await this.ensureConfigReadable(projectDir);
     if (!flags.from && await this.showDashboardIfInitialized(projectDir)) return;
-    const selection = flags.from ? await this.selectionFromSharedConfig(flags.from, flags) : await this.selectionFromWizard(flags, projectDir);
+    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 });
     }
@@ -444,15 +438,7 @@ var Init = class _Init extends BaseCommand {
   /** The interactive producer: load the source, run the wizard, return what was chosen. */
   async selectionFromWizard(flags, projectDir) {
     const isGlobalRoot = isHomeDirectory(projectDir);
-    const { unmount, clear: clearSpinner } = render(
-      /* @__PURE__ */ jsx2(Spinner, { label: STATUS_MESSAGES.LOADING_SKILLS })
-    );
-    const [{ sourceResult, startupMessages }, globalConfig] = await Promise.all([
-      this.loadSourceOrFail(flags),
-      this.loadGlobalConfigIfExists()
-    ]);
-    clearSpinner();
-    unmount();
+    const { sourceResult, startupMessages, globalConfig } = await this.loadWizardInputsUnderSpinner(flags);
     const result = await this.runWizard(
       sourceResult,
       startupMessages,
@@ -469,21 +455,50 @@ var Init = class _Init extends BaseCommand {
       emptyMessage: "No skills selected"
     };
   }
+  /**
+   * 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.
+   */
+  async loadWizardInputsUnderSpinner(flags) {
+    const { unmount, clear: clearSpinner } = render(
+      /* @__PURE__ */ jsx2(Spinner, { label: STATUS_MESSAGES.LOADING_SKILLS })
+    );
+    try {
+      const [source, globalConfig] = await Promise.all([
+        this.loadSourceOrFail(flags),
+        this.loadGlobalConfigIfExists()
+      ]);
+      return { ...source, globalConfig };
+    } finally {
+      clearSpinner();
+      unmount();
+    }
+  }
   /**
    * The `--from <id>` producer: fetch and map, no wizard. Nothing here may assume a TTY — running
    * headless is most of why the flag exists.
+   *
+   * It is also greenfield-only, which is what the two refusals are: a shared configuration is
+   * installed whole, so anything it would have to install over has to be uninstalled first.
    */
-  async selectionFromSharedConfig(id, flags) {
+  async selectionFromSharedConfig(id, flags, projectDir) {
+    await this.refuseInstalledProject(projectDir);
     this.log(`Fetching configuration ${id}...`);
     const fetched = await fetchSeedConfig(id);
     if (!fetched.ok) {
       this.error(fetched.error, { exit: EXIT_CODES.ERROR });
     }
     const { sourceResult } = await this.loadSourceOrFail(flags);
-    const { result, skippedSkillIds, skippedAgentNames } = seedToWizardResult(
+    const { result, skippedSkillIds, skippedAgentNames } = this.decodeSeedOrFail(
       fetched.payload,
       sourceResult.matrix
     );
+    await this.refuseBlockingGlobalInstall(result);
     if (skippedSkillIds.length > 0) {
       this.warn(
         `Skipped ${skippedSkillIds.length} skill(s) this catalog does not know: ${skippedSkillIds.join(", ")}`
@@ -507,6 +522,47 @@ var Init = class _Init extends BaseCommand {
       emptyMessage: `Configuration '${id}' contains no skills this catalog can install.`
     };
   }
+  /**
+   * 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.
+   *
+   * This runs before the fetch: there is nothing to learn from the network about a directory that
+   * is already spoken for.
+   */
+  async refuseInstalledProject(projectDir) {
+    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), {
+      exit: EXIT_CODES.ERROR
+    });
+  }
+  /**
+   * The decode refuses a payload the config model has nowhere to write (see `seedToWizardResult`).
+   * That is a failure of this command, reported with this command's exit code rather than left to
+   * surface as an unhandled throw.
+   */
+  decodeSeedOrFail(payload, matrix) {
+    try {
+      return seedToWizardResult(payload, matrix);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
   async showDashboardIfInitialized(projectDir) {
     return runDashboardFlow(projectDir, this.config, "init", (msg) => this.log(msg));
   }
@@ -519,9 +575,10 @@ var Init = class _Init extends BaseCommand {
   async loadSourceOrFail(flags) {
     try {
       const loaded = await loadSource({
-        sourceFlag: flags.source,
+        // The one load that may CHOOSE a source rather than read the stored one.
+        caller: "init",
+        ...flags.source !== void 0 && { sourceFlag: flags.source },
         projectDir: process.cwd(),
-        forceRefresh: flags.refresh,
         captureStartupMessages: true
       });
       return { sourceResult: loaded.sourceResult, startupMessages: loaded.startupMessages };
@@ -532,20 +589,23 @@ var Init = class _Init extends BaseCommand {
     }
   }
   async runWizard(sourceResult, startupMessages, projectDir, globalConfig, isGlobalRoot) {
+    const selectedAgents = globalConfig?.agents && activeAgentNames(globalConfig.agents);
+    const globalSkills = globalConfig?.skills;
     return runWizardSession({
       hydrate: {
-        initialAgents: globalConfig?.selectedAgents,
-        installedSkillIds: globalConfig?.skills?.map((s) => s.id),
-        installedSkillConfigs: globalConfig?.skills,
-        installedAgentConfigs: globalConfig?.agents,
+        ...selectedAgents !== void 0 && { initialAgents: selectedAgents },
+        ...globalSkills !== void 0 && {
+          installedSkillIds: globalSkills.map((s) => s.id),
+          installedSkillConfigs: globalSkills
+        },
+        ...globalConfig?.agents !== void 0 && { installedAgentConfigs: globalConfig.agents },
         isEditingFromGlobalScope: isGlobalRoot
       },
       props: {
         version: this.config.version,
         logo: ASCII_LOGO,
-        initialAgents: globalConfig?.selectedAgents,
-        installedSkillIds: globalConfig?.skills?.map((s) => s.id),
-        projectDir,
+        initialAgents: selectedAgents,
+        installedSkillIds: globalConfig?.skills.map((s) => s.id),
         startupMessages
       },
       onCancel: () => this.log("Setup cancelled"),
@@ -566,7 +626,7 @@ var Init = class _Init extends BaseCommand {
     ) : null;
     const copyResult = installMode === "eject" || installMode === "mixed" ? await this.copyEjectSkillsStep(ejectedSkills, projectDir, sourceResult, installMode) : null;
     if (resolvedMarketplace !== null) {
-      await this.installPluginsStep(pluginSkills, resolvedMarketplace, projectDir);
+      await this.installPluginSkillsReported(pluginSkills, resolvedMarketplace, projectDir);
     }
     const pluginModeSucceeded = resolvedMarketplace !== null;
     try {
@@ -583,25 +643,34 @@ var Init = class _Init extends BaseCommand {
         pluginModeSucceeded,
         copyResult
       );
-      const permissionWarning = await checkPermissions(projectDir);
-      if (permissionWarning) {
-        if (interactive) {
-          const { waitUntilExit } = render(permissionWarning);
-          await waitUntilExit();
-        } else {
-          const { unmount } = render(permissionWarning);
-          unmount();
-        }
-      }
+      await this.showPermissionNotice(projectDir, interactive);
     } 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 `waitUntilExit()` only ever resolves because a person is there to end it — which is fine
+   * after the wizard and a hang everywhere else. Without a terminal to hold, one frame is
+   * rendered and let go: the notice is information, not a prompt, so there is nothing to answer
+   * and nothing to wait for.
+   */
+  async showPermissionNotice(projectDir, interactive) {
+    const permissionWarning = await checkPermissions(projectDir);
+    if (!permissionWarning) return;
+    if (!interactive) {
+      const { unmount } = render(permissionWarning);
+      unmount();
+      return;
+    }
+    const { waitUntilExit } = render(permissionWarning);
+    await waitUntilExit();
+  }
   logInstallPlan(installMode, ejectedSkills, pluginSkills) {
     this.log("\n");
     this.log(`Selected ${ejectedSkills.length + pluginSkills.length} skills`);
     this.log(
-      `Install mode: ${installMode === "plugin" ? `${INSTALL_MODE_LABELS.plugin} (native install)` : installMode === "mixed" ? `${INSTALL_MODE_LABELS.mixed} (${ejectedSkills.length} eject, ${pluginSkills.length} plugin)` : `${INSTALL_MODE_LABELS.eject} (copy to .claude/skills/)`}`
+      `Install mode: ${installMode === "mixed" ? `${INSTALL_MODE_LABELS.mixed} (${ejectedSkills.length} eject, ${pluginSkills.length} plugin)` : INSTALL_MODE_DESCRIPTIONS[installMode]}`
     );
   }
   async copyEjectSkillsStep(localSkills, projectDir, sourceResult, installMode) {
@@ -623,36 +692,20 @@ var Init = class _Init extends BaseCommand {
     }
     return copyResult;
   }
-  async installPluginsStep(pluginSkills, marketplace, projectDir) {
-    this.log("Installing skill plugins...");
-    const pluginResult = await installPluginSkills(pluginSkills, marketplace, projectDir);
-    for (const item of pluginResult.installed) {
-      this.log(`  Installed ${item.ref}`);
-    }
-    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
-      });
-    }
-    this.log(`Installed ${pluginResult.installed.length} skill plugins
-`);
-  }
   async writeConfigAndCompile(result, sourceResult, flags) {
     this.log("Generating configuration...");
     const configResult = await writeProjectConfig({
       wizardResult: result,
       sourceResult,
       projectDir: process.cwd(),
-      sourceFlag: flags.source
+      ...flags.source !== void 0 && { sourceFlag: flags.source }
     });
     if (configResult.wasMerged) {
       this.log(`Merged with existing config at ${configResult.existingConfigPath}`);
     }
     this.log(`Configuration saved (${configResult.config.agents.length} agents)
 `);
+    this.reportUnassignedSkills(configResult.config);
     this.log(STATUS_MESSAGES.COMPILING_AGENTS);
     const cwd = process.cwd();
     const agentDefs = await loadAgentDefs();
@@ -669,20 +722,6 @@ var Init = class _Init extends BaseCommand {
     this.reportPropagatedRecompile(configResult.propagation);
     return { configResult, compileResult, agentScopeMap };
   }
-  /**
-   * 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 failureSuffix = failedCount > 0 ? ` (${failedCount} failed)` : "";
-    this.log(`Recompiled agents in ${recompiledCount} registered projects${failureSuffix}
-`);
-  }
   reportSuccess(configResult, compileResult, agentScopeMap, installMode, pluginModeSucceeded, copyResult) {
     this.log(`${SUCCESS_MESSAGES.INIT_SUCCESS}
 `);
@@ -691,12 +730,36 @@ var Init = class _Init extends BaseCommand {
       this.reportSkillsCopied(copyResult);
     }
     this.reportAgentsCompiled(compileResult.compiled, agentScopeMap);
+    this.reportConfiguration(configResult.configPath, agentScopeMap);
+  }
+  /**
+   * 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();
+    const paths = {
+      global: resolveInstallPaths(cwd, "global").configPath,
+      project: projectConfigPath
+    };
+    const split = splitAgentScopes(cwd, agentScopeMap);
     this.log("Configuration:");
-    this.log(`  ${configResult.configPath}`);
+    for (const configPath of configsHoldingAssignments(split, paths)) {
+      this.log(`  ${configPath}`);
+    }
     this.log("");
     this.log("To customize agent-skill assignments:");
-    this.log(`  1. Edit ${CLAUDE_SRC_DIR}/${STANDARD_FILES.CONFIG_TS}`);
-    this.log(`  2. Run '${CLI_INVOKE_COMMAND} compile' to regenerate agents`);
+    for (const [index, step] of customizationSteps(split, paths.global).entries()) {
+      this.log(`  ${index + 1}. ${step}`);
+    }
     this.log("");
   }
   /**
@@ -757,14 +820,38 @@ var Init = class _Init extends BaseCommand {
     }
   }
 };
+function splitAgentScopes(cwd, agentScopeMap) {
+  if (isHomeDirectory(cwd)) return { globalAgentCount: 0, isGlobalOnly: false };
+  const scopes = [...agentScopeMap.values()];
+  const globalAgentCount = scopes.filter((scope) => scope === "global").length;
+  return {
+    globalAgentCount,
+    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 customizationSteps(split, globalConfigPath) {
+  if (split.isGlobalOnly) {
+    return [`Edit ${globalConfigPath}`, globalScopedAgentsHint(split.globalAgentCount)];
+  }
+  return [
+    `Edit ${CLAUDE_SRC_DIR}/${STANDARD_FILES.CONFIG_TS}`,
+    `Run '${CLI_INVOKE_COMMAND} compile' to regenerate agents`,
+    ...split.globalAgentCount > 0 ? [globalScopedAgentsHint(split.globalAgentCount)] : []
+  ];
+}
 async function getDashboardData(projectDir) {
   const [info, loaded] = await Promise.all([getInstallationInfo(), loadProjectConfig(projectDir)]);
-  const activeSkills = loaded?.config?.skills?.filter((s) => !s.excluded);
+  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?.source;
-  return { skillCount, agentCount, mode, source };
+  const source = loaded?.config.source;
+  return { skillCount, agentCount, mode, ...source !== void 0 && { source } };
 }
 
 export {
@@ -774,4 +861,4 @@ export {
   Init,
   getDashboardData
 };
-//# sourceMappingURL=chunk-PZIZNMHK.js.map
+//# sourceMappingURL=chunk-5MFJ24VM.js.map