agents-inc 0.168.0 → 0.170.1

package/dist/chunk-7RDMTR64.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/lib/operations/source/load-source.ts","../src/cli/lib/operations/project/detect-project.ts","../src/cli/lib/operations/project/detect-both-installations.ts","../src/cli/lib/config-gate/index.ts","../src/cli/lib/config-gate/classify.ts","../src/cli/lib/config-gate/deps.ts","../src/cli/lib/config-gate/pair-writer.ts","../src/cli/lib/config-gate/propagate.ts","../../compile/src/global-config.ts","../src/cli/lib/config-gate/recompile.ts","../src/cli/lib/operations/project/write-project-config.ts","../src/cli/lib/operations/project/compile-agents-all-scopes.ts"],"sourcesContent":["import { loadSkillsMatrixFromSource, type SourceLoadResult } from \"../../loading/index.js\";\nimport type { SourceCaller } from \"../../configuration/index.js\";\nimport {\n  enableBuffering,\n  drainBuffer,\n  disableBuffering,\n  warn,\n  type StartupMessage,\n} from \"../../../utils/logger.js\";\n\nexport type LoadSourceOptions = {\n  /** Whether this load may reach the init-time source rungs — see {@link SourceCaller}. */\n  caller?: SourceCaller;\n  sourceFlag?: string;\n  projectDir: string;\n  /** When true, enables message buffering and captures startup messages. Default: false. */\n  captureStartupMessages?: boolean;\n};\n\nexport type LoadedSource = {\n  sourceResult: SourceLoadResult;\n  /** Empty array when captureStartupMessages is false. */\n  startupMessages: StartupMessage[];\n};\n\n/**\n * Loads the skills matrix from a resolved source.\n *\n * When `captureStartupMessages` is true, wraps the load in buffer mode so\n * warn() calls during loading are captured instead of written to stderr.\n *\n * @throws {Error} If source resolution or fetching fails.\n */\nexport async function loadSource(options: LoadSourceOptions): Promise<LoadedSource> {\n  const { caller, sourceFlag, projectDir, captureStartupMessages } = options;\n\n  if (captureStartupMessages) {\n    enableBuffering();\n  }\n\n  let sourceResult: SourceLoadResult;\n  try {\n    sourceResult = await loadSkillsMatrixFromSource({\n      ...(caller !== undefined && { caller }),\n      ...(sourceFlag !== undefined && { sourceFlag }),\n      projectDir,\n    });\n  } catch (error) {\n    if (captureStartupMessages) {\n      disableBuffering();\n    }\n    throw error;\n  }\n\n  let startupMessages: StartupMessage[] = [];\n  if (captureStartupMessages) {\n    startupMessages = drainBuffer();\n    disableBuffering();\n  }\n\n  return { sourceResult, startupMessages };\n}\n\n/**\n * Says what a captured load held back — a skill skipped for a file that will not parse, two\n * folders claiming one id, a marketplace served from a stale cache — in the words `compile` prints\n * them in.\n */\nexport function sayCapturedWarnings(messages: readonly StartupMessage[]): void {\n  for (const { text } of messages) warn(text);\n}\n","import { detectInstallation, type Installation } from \"../../installation/index.js\";\nimport { ConfigLoadError, loadProjectConfig } from \"../../configuration/index.js\";\nimport type { ProjectConfig } from \"../../../types/index.js\";\n\nexport type DetectedProject = {\n  installation: Installation;\n  config: ProjectConfig | null;\n  configPath: string | null;\n};\n\n/**\n * Detects an existing CLI installation and loads its project config.\n *\n * Uses detectInstallation() which checks project-level first, then falls back\n * to global. Returns the installation metadata plus the loaded config.\n *\n * Does NOT throw. Returns null when no installation is found OR when the config\n * file exists but is corrupt — the caller (doctor, edit) reports the resulting\n * null as a config/installation problem to the user. `compile` deliberately\n * does NOT use this wrapper: it detects scopes directly so it can hard-error on\n * a corrupt config instead of degrading to null.\n */\nexport async function detectProject(projectDir?: string): Promise<DetectedProject | null> {\n  const resolvedDir = projectDir ?? process.cwd();\n\n  let installation: Installation | null;\n  try {\n    installation = await detectInstallation(resolvedDir);\n  } catch (error) {\n    if (error instanceof ConfigLoadError) return null;\n    throw error;\n  }\n\n  if (!installation) {\n    return null;\n  }\n\n  const loaded = await loadProjectConfig(installation.projectDir);\n\n  return {\n    installation,\n    config: loaded?.config ?? null,\n    configPath: loaded?.configPath ?? null,\n  };\n}\n","import {\n  detectGlobalInstallation,\n  detectProjectInstallation,\n  isHomeDirectory,\n  type Installation,\n} from \"../../installation/index.js\";\n\nexport type BothInstallations = {\n  global: Installation | null;\n  project: Installation | null;\n  hasBoth: boolean;\n};\n\n/**\n * Detects both global and project installations.\n *\n * Skips project detection when projectDir is the home directory\n * to avoid double-compile. Returns a convenience `hasBoth` flag\n * used by callers to set scopeFilter on compile passes.\n */\nexport async function detectBothInstallations(projectDir: string): Promise<BothInstallations> {\n  const global = await detectGlobalInstallation();\n\n  const project = isHomeDirectory(projectDir) ? null : await detectProjectInstallation(projectDir);\n  return { global, project, hasBoth: !!global && !!project };\n}\n","import os from \"os\";\nimport path from \"path\";\nimport type { ProjectConfig } from \"../../types\";\nimport type { AuthoritativeScope } from \"../configuration/config-merger\";\nimport { CLI_INVOKE_COMMAND } from \"../../consts\";\nimport { ensureDir, writeFile } from \"../../utils/fs\";\nimport { verbose } from \"../../utils/logger\";\nimport { isHomeDirectory } from \"../installation/is-home-directory\";\nimport type { Provider } from \"../../consts\";\nimport { getInstalledConfigPath, getProjectConfigPath } from \"../installation/install-base-dir\";\nimport { providerInUse } from \"../installation/install-layout\";\nimport { loadProjectConfigFromDir } from \"../configuration/project-config\";\nimport { normalizeStackRecord } from \"../stacks/stacks-loader\";\nimport { splitConfigByScope } from \"../configuration/config-generator\";\n// The catalogue the renderers take as a parameter. It is the singleton this CLI seats at\n// startup, which is what `generateConfigSource` read directly before the renderers moved into\n// `@workspace/compile` and the editor became a second caller with a catalogue of its own.\nimport { matrix as activeMatrix } from \"../matrix/matrix-provider\";\nimport { generateConfigSource } from \"../configuration/config-writer\";\nimport {\n  buildConfigTypesBackgroundData,\n  regenerateConfigTypes,\n  type ConfigTypesExtras,\n} from \"../configuration/config-types-writer\";\nimport {\n  classifyGlobalChange,\n  consequenceTier,\n  tierPropagates,\n  tierRegeneratesTypes,\n  NO_CHANGES,\n  type GlobalChangeSet,\n} from \"./classify.js\";\nimport { resolveGateDeps, type GateDeps, type LoadedGateDeps } from \"./deps.js\";\nimport { GlobalPairWriteViolation, withGateToken } from \"./gate-token.js\";\nimport {\n  ensureBlankPair as ensureBlankPairInternal,\n  writeGlobalConfigHalf,\n  writeGlobalPair,\n  writeGlobalTypesHalf,\n} from \"./pair-writer.js\";\nimport {\n  buildProjectTypesExtras,\n  mergeGlobalConfigs,\n  normalizeProjectPath,\n  propagateGlobalChangesToProjects,\n  pruneGlobalEntriesFromRegisteredProjects,\n  reconcileProjectSplitAgainstGlobal,\n  resolveEffectiveGlobalConfig,\n  writeProjectConfigPair,\n  type PropagationResult,\n} from \"./propagate.js\";\nimport { NOTHING_RECOMPILED, recompilePropagated } from \"./recompile.js\";\nimport type { PropagatedRecompileSummary } from \"../operations/project/recompile-project-agents.js\";\n\nexport type { GateDeps } from \"./deps.js\";\nexport type { ConsequenceTier, GlobalChangeSet } from \"./classify.js\";\nexport { GlobalPairWriteViolation } from \"./gate-token.js\";\n\n/**\n * What one gated write did, for the caller to render.\n *\n * A write that propagates recompiles the propagated projects' agents itself:\n * both audited gaps in the previous contract (a project-context source\n * migration, a global uninstall) were instances of a caller forgetting to. A\n * report the caller may only log cannot go stale the same way, and per-project\n * failure isolation already lives in `recompilePropagatedProjectAgents`, so\n * internalizing the recompile adds no new failure mode.\n */\nexport type GateReport = {\n  /** True when either half of the global pair was actually rewritten. */\n  globalWritten: boolean;\n  changes: GlobalChangeSet;\n  propagated: PropagationResult;\n  recompile: PropagatedRecompileSummary;\n};\n\n/**\n * The gate's public entry points are the ONLY code that mints the pair-write\n * privilege, and each one holds it across its whole consequence flow rather than\n * around the individual write.\n *\n * `pair-writer.ts` used to open the token inside each of its own functions, which\n * meant reaching that module by any route — a dynamic import, a re-export — came\n * with the privilege attached, and the runtime tripwire in `utils/fs.ts` had\n * nothing left to refuse. Moving the mint here inverts that: the private writers\n * REQUIRE a token they cannot produce, so authorization is a property of how the\n * write was ENTERED, which is exactly what the gate is meant to guarantee.\n *\n * The window is wider than the write itself — propagation and the recompile run\n * inside it too. That is accepted: everything in the window is the gate's own\n * code carrying out consequences the same entry already owes.\n *\n * Every entry below that writes or drives a write opens the token with\n * `withGateToken`, including `propagateGlobalRemoval`, which today reaches only\n * project pairs — the rule is \"a gate entry holds the privilege for its flow\",\n * not \"the ones whose current implementation happens to need it\".\n *\n * The one exception is `writeProjectPartial`. It refuses the home directory as its\n * first act and then writes a PROJECT's own config, which the tripwire never\n * guards; handing it the global-pair privilege would only blunt the refusal it\n * exists to make.\n */\n\n/** A write whose classification obliged nothing beyond the global pair. */\nconst NOTHING_PROPAGATED: PropagationResult = {\n  updated: [],\n  unreadable: [],\n  gone: [],\n  notOurs: [],\n  failed: [],\n};\n\n/**\n * Whether a gated write moved anything the global install's compiled sub-agents are built from —\n * the question a caller asks before deciding its global compile pass has work to do.\n */\nexport function movedGlobalAgentInputs(written: GateReport): boolean {\n  return tierRegeneratesTypes(consequenceTier(written.changes));\n}\n\nfunction report(\n  globalWritten: boolean,\n  changes: GlobalChangeSet,\n  propagated: PropagationResult = NOTHING_PROPAGATED,\n  recompile: PropagatedRecompileSummary = NOTHING_RECOMPILED,\n): GateReport {\n  return { globalWritten, changes, propagated, recompile };\n}\n\n/**\n * Carries out a classified global change's consequences: fan the change out to\n * every registered project, then recompile the ones it rewrote.\n *\n * `currentProjectDir` is excluded from the fan-out — its own pair is written by\n * the call that triggered this, and its agents are compiled by the command.\n */\nasync function applyConsequences(\n  globalConfig: ProjectConfig,\n  changes: GlobalChangeSet,\n  deps: LoadedGateDeps,\n  provider: Provider,\n  currentProjectDir?: string,\n): Promise<{ propagated: PropagationResult; recompile: PropagatedRecompileSummary }> {\n  const tier = consequenceTier(changes);\n  if (!tierPropagates(tier) || !globalConfig.projects?.length) {\n    return { propagated: NOTHING_PROPAGATED, recompile: NOTHING_RECOMPILED };\n  }\n\n  const propagated = await propagateGlobalChangesToProjects(\n    globalConfig,\n    deps.agents,\n    provider,\n    currentProjectDir,\n    { regenerateTypes: tierRegeneratesTypes(tier) },\n  );\n  if (propagated.updated.length > 0) {\n    verbose(`Propagated global changes to ${propagated.updated.length} project(s)`);\n  }\n\n  const recompile = tierRegeneratesTypes(tier)\n    ? await recompilePropagated(propagated.updated)\n    : NOTHING_RECOMPILED;\n\n  return { propagated, recompile };\n}\n\n/**\n * Loaders for a caller that holds no matrix of its own. Nothing is fetched\n * unless classification proves the write has consequences that read it, so a\n * registration-only mutation stays offline.\n *\n * `matrixOnly` + `skipExtraSources` are the offline policy the other config\n * readers already use: extra-source loading never changes the emitted config or\n * types.\n */\nexport function lazyGateDeps(projectDir: string): GateDeps {\n  return {\n    loadMatrix: async () => {\n      const { loadSkillsMatrixFromSource } = await import(\"../loading/source-loader.js\");\n      const { matrix } = await loadSkillsMatrixFromSource({\n        projectDir,\n        skipExtraSources: true,\n        matrixOnly: true,\n      });\n      return matrix;\n    },\n    loadAgents: async () => {\n      const { loadAgentDefs } = await import(\"../operations/project/load-agent-defs.js\");\n      return (await loadAgentDefs()).agents;\n    },\n  };\n}\n\nexport type WriteConfigByScopeArgs = {\n  finalConfig: ProjectConfig;\n  matrix: LoadedGateDeps[\"matrix\"];\n  agents: LoadedGateDeps[\"agents\"];\n  projectDir: string;\n  projectConfigPath: string;\n  projectInstallationExists: boolean;\n  /**\n   * How much of what it can see this session owns, from `mergeConfigs`' own vocabulary.\n   *\n   * Read by the PROJECT branch only, and only to decide whether the global config is made to\n   * MATCH this session or merely absorb it. The home branch writes the whole global config from\n   * `finalConfig` either way, and `undefined` (init) keeps the additive default.\n   */\n  authoritativeScope?: AuthoritativeScope;\n};\n\n/**\n * Writes config.ts and config-types.ts split by scope.\n * When installing into a project directory:\n * - Global config/types go to the home scope's source folder\n * - Project config/types go to the project's own (with import from global)\n * When installing from home directory, writes a single standalone config.\n */\nexport async function writeConfigByScope(args: WriteConfigByScopeArgs): Promise<GateReport> {\n  return withGateToken(async () => {\n    const { finalConfig, matrix, agents, projectDir, projectConfigPath } = args;\n    // os.homedir() at call time, so the path agrees with getGlobalConfigImportPath(),\n    // which reaches the same home through globalInstallRoot()\n    const homeDir = os.homedir();\n    const deps: LoadedGateDeps = { matrix, agents };\n\n    if (!isHomeDirectory(projectDir)) {\n      return writeFromProjectContext(args, homeDir, deps);\n    }\n\n    // Installing from ~/ — write directly to global config (no import preamble). The provider\n    // is the one the home root's own installation is on: at this scope the project IS the\n    // global installation.\n    const provider = providerInUse(homeDir);\n    const priorGlobal = await loadProjectConfigFromDir(homeDir, provider);\n    const changes = classifyGlobalChange(priorGlobal?.config, finalConfig);\n    const globalWritten = await writeGlobalPair(finalConfig, projectConfigPath, matrix, agents);\n\n    const { propagated, recompile } = await applyConsequences(finalConfig, changes, deps, provider);\n    return report(globalWritten, changes, propagated, recompile);\n  });\n}\n\nasync function writeFromProjectContext(\n  args: WriteConfigByScopeArgs,\n  homeDir: string,\n  deps: LoadedGateDeps,\n): Promise<GateReport> {\n  const { finalConfig, projectDir } = args;\n\n  // Installing from project — split by scope for project config generation.\n  const { global: globalConfig, project: projectSplitConfig } = splitConfigByScope(finalConfig);\n  // The PROJECT's provider decides which global installation this run inherits from and writes\n  // to: each provider family inherits and propagates only within itself.\n  const provider = providerInUse(projectDir);\n  const globalConfigPath = getProjectConfigPath(homeDir, provider);\n\n  // Merge new global-scoped items into the existing global config.\n  // - Existing items are preserved (never removed from global during project init)\n  // - New global items are added\n  // - If no existing global config, write the full global split\n  const existingGlobal = await loadProjectConfigFromDir(homeDir, provider);\n  const effective = await resolveEffectiveGlobalConfig(\n    globalConfig,\n    existingGlobal?.config,\n    projectDir,\n    args.authoritativeScope,\n  );\n  const effectiveGlobalConfig = effective.config;\n\n  const changes = classifyGlobalChange(existingGlobal?.config, effectiveGlobalConfig);\n  const globalWritten = await writeGlobalPairWhenChanged(effective, globalConfigPath, deps);\n\n  const { propagated, recompile } = await applyConsequences(\n    effectiveGlobalConfig,\n    changes,\n    deps,\n    provider,\n    projectDir,\n  );\n\n  // Reconcile the project's own entries against the global config this write inlines.\n  // Without it this branch hands the raw split straight to the inlining writer, so a\n  // skill/agent the project owns at project scope AND a colliding live global install\n  // both land as active entries in the same project config.\n  const reconciledProjectConfig = reconcileProjectSplitAgainstGlobal(\n    projectSplitConfig,\n    effectiveGlobalConfig,\n    deps.matrix,\n  );\n  await writeProjectPairWhenOwed(\n    args,\n    provider,\n    reconciledProjectConfig,\n    effectiveGlobalConfig,\n    deps,\n  );\n\n  return report(globalWritten, changes, propagated, recompile);\n}\n\n/** Writes the resolved global pair when resolving it changed anything; answers whether it did. */\nasync function writeGlobalPairWhenChanged(\n  effective: { config: ProjectConfig; changed: boolean },\n  globalConfigPath: string,\n  deps: LoadedGateDeps,\n): Promise<boolean> {\n  if (!effective.changed) {\n    verbose(\"Global config unchanged, skipping write\");\n    return false;\n  }\n\n  await ensureDir(path.dirname(globalConfigPath));\n  const written = await writeGlobalPair(\n    effective.config,\n    globalConfigPath,\n    deps.matrix,\n    deps.agents,\n  );\n  verbose(`Updated global config at ${globalConfigPath}`);\n  return written;\n}\n\n/**\n * Writes the project's own pair if the project installation already exists OR if there is\n * anything of the project's own to record. Skips only when no existing project installation AND\n * nothing project-owned — creating an empty project config with just `import globalConfig` and\n * `{ ...globalConfig }` is pointless.\n */\nasync function writeProjectPairWhenOwed(\n  project: Pick<\n    WriteConfigByScopeArgs,\n    \"projectDir\" | \"projectConfigPath\" | \"projectInstallationExists\"\n  >,\n  provider: Provider,\n  reconciledProjectConfig: ProjectConfig,\n  effectiveGlobalConfig: ProjectConfig,\n  deps: LoadedGateDeps,\n): Promise<void> {\n  if (!project.projectInstallationExists && !holdsAnythingOfItsOwn(reconciledProjectConfig)) {\n    verbose(\n      \"Skipped project config — no existing project installation and no project-scoped items\",\n    );\n    return;\n  }\n\n  await ensureDir(path.dirname(project.projectConfigPath));\n  await writeProjectConfigPair(\n    project.projectDir,\n    provider,\n    reconciledProjectConfig,\n    effectiveGlobalConfig,\n    deps.matrix,\n    deps.agents,\n  );\n  verbose(`Updated project config at ${project.projectConfigPath}`);\n}\n\n/** Whether the project's split carries anything of the project's own to record. */\nfunction holdsAnythingOfItsOwn(projectConfig: ProjectConfig): boolean {\n  return projectConfig.skills.length > 0 || projectConfig.agents.length > 0;\n}\n\n/**\n * Regenerates a single scope's config-types.ts from its persisted config,\n * matching `writeConfigByScope`'s writer selection exactly:\n * - global scope (home dir): standalone unions narrowed to the config's entries\n * - project scope: import-and-extend form (falls back to standalone when no\n *   global config-types.ts exists)\n *\n * Writes no config half at either scope: the config on disk is the input.\n * Returns whether a file was actually rewritten (always false at project scope,\n * where the writer does not report).\n */\nexport async function writeScopeConfigTypes(\n  projectDir: string,\n  config: ProjectConfig,\n  deps: LoadedGateDeps,\n  extras?: ConfigTypesExtras,\n): Promise<boolean> {\n  return withGateToken(async () => {\n    if (isHomeDirectory(projectDir)) {\n      return writeGlobalTypesHalf(\n        config,\n        getInstalledConfigPath(projectDir),\n        deps.matrix,\n        deps.agents,\n        extras,\n      );\n    }\n\n    await regenerateConfigTypes(\n      projectDir,\n      Promise.resolve(buildConfigTypesBackgroundData(deps.matrix, deps.agents)),\n      extras ?? buildProjectTypesExtras(config, deps.matrix),\n    );\n    return false;\n  });\n}\n\n/**\n * Regenerates a scope's config-types.ts from the config already on disk, which\n * is the truth and is never rewritten — the documented hand-edit workflow is\n * \"edit config.ts, then compile\", so the file the user edited must survive it.\n *\n * At the home directory the types are the standalone unions narrowed to that\n * config, and the fan-out is UNCONDITIONAL: a hand edit leaves no prior state to\n * diff against, so there is nothing to classify and the only safe assumption is\n * that every registered project's inlined copy is stale. At project and\n * marketplace directories the import-and-extend writer applies and nothing is\n * propagated — a project config is nobody else's input.\n */\nexport async function reconcileTypesFromDisk(\n  projectDir: string,\n  config: ProjectConfig,\n  deps: LoadedGateDeps,\n  options?: { extras?: ConfigTypesExtras; currentProjectDir?: string },\n): Promise<GateReport> {\n  return withGateToken(async () => {\n    const changes = classifyGlobalChange(undefined, config);\n    const globalWritten = await writeScopeConfigTypes(projectDir, config, deps, options?.extras);\n\n    if (!isHomeDirectory(projectDir)) return report(false, changes);\n    if (!config.projects?.length) return report(globalWritten, changes);\n\n    const propagated = await propagateGlobalChangesToProjects(\n      config,\n      deps.agents,\n      providerInUse(projectDir),\n      options?.currentProjectDir,\n    );\n    if (propagated.updated.length > 0) {\n      verbose(`Propagated global changes to ${propagated.updated.length} project(s)`);\n    }\n    const recompile = await recompilePropagated(propagated.updated);\n\n    return report(globalWritten, changes, propagated, recompile);\n  });\n}\n\n/**\n * The transforms the gate will apply to the global config on a caller's behalf.\n *\n * A closed union rather than a caller-supplied function: every variant is\n * analysable and testable on its own, and no caller-authored transform runs\n * inside the only code allowed to write the pair.\n */\nexport type GlobalMutation =\n  | { kind: \"deregister-project\"; projectDir: string }\n  | { kind: \"set-source\"; source: string; fallbackName: string };\n\n/**\n * The config a partial write commits: the scalars and arrays already on disk,\n * with the required fields filled. Mirrors what the partial writer has always\n * defaulted, so a scalar mutation cannot silently empty an install.\n */\nfunction fillRequiredFields(\n  partial: Partial<ProjectConfig>,\n  fallbackName: string | undefined,\n): ProjectConfig {\n  const name = partial.name ?? fallbackName;\n  if (!name) {\n    throw new Error(\n      `Cannot write config: no project config found. Run \\`${CLI_INVOKE_COMMAND} init\\` first.`,\n    );\n  }\n  return { ...partial, name, skills: partial.skills ?? [], agents: partial.agents ?? [] };\n}\n\n/** Applies a mutation to the config on disk, or null when it is a no-op. */\nfunction applyMutation(\n  mutation: GlobalMutation,\n  current: Partial<ProjectConfig>,\n): Partial<ProjectConfig> | null {\n  switch (mutation.kind) {\n    case \"deregister-project\": {\n      const projects = current.projects ?? [];\n      if (projects.length === 0) return null;\n      const normalized = normalizeProjectPath(mutation.projectDir);\n      const filtered = projects.filter((p) => p !== normalized);\n      return filtered.length === projects.length ? null : { ...current, projects: filtered };\n    }\n    case \"set-source\":\n      return { ...current, marketplace: mutation.source };\n    default: {\n      const _exhaustive: never = mutation;\n      return _exhaustive;\n    }\n  }\n}\n\n/** The name a mutation invents when the global config has none yet. */\nfunction fallbackNameFor(mutation: GlobalMutation): string | undefined {\n  return mutation.kind === \"set-source\" ? mutation.fallbackName : undefined;\n}\n\n/**\n * Applies a typed transform to the global config and carries out whatever its\n * classification obliges. No variant is exempt from classification by\n * construction: a source change propagates because project configs inline the\n * global scalars, and a deregistration does not because nothing inlines the\n * registration list.\n */\nexport async function mutateGlobal(mutation: GlobalMutation, deps: GateDeps): Promise<GateReport> {\n  return withGateToken(async () => {\n    const homeDir = os.homedir();\n    // The full loader, not the scalar one: it normalizes every stack assignment\n    // back to `SkillAssignment[]`. The writer compacts an exclusive category to its\n    // bare value on the way out, and re-emitting that bare form without\n    // normalization drops the category — so a scalar mutation would silently strip\n    // every exclusive category from the global stack.\n    const provider = providerInUse(homeDir);\n    const loadedGlobal = await loadProjectConfigFromDir(homeDir, provider);\n    if (!loadedGlobal) return report(false, NO_CHANGES);\n\n    const current = loadedGlobal.config;\n    const mutated = applyMutation(mutation, current);\n    if (!mutated) return report(false, NO_CHANGES);\n\n    const prior = fillRequiredFields(current, fallbackNameFor(mutation));\n    const next = fillRequiredFields(mutated, fallbackNameFor(mutation));\n    const changes = classifyGlobalChange(prior, next);\n\n    const globalWritten = await writeGlobalConfigHalf(\n      next,\n      getProjectConfigPath(homeDir, provider),\n    );\n    if (!next.projects?.length) return report(globalWritten, changes);\n\n    const loaded = await resolveGateDeps(deps, consequenceTier(changes));\n    if (!loaded) return report(globalWritten, changes);\n\n    const { propagated, recompile } = await applyConsequences(next, changes, loaded, provider);\n    return report(globalWritten, changes, propagated, recompile);\n  });\n}\n\n/**\n * Prunes the CLI-inlined global entries from every registered project after a\n * GLOBAL uninstall, and recompiles their agents.\n *\n * Writes no pair: the pair this would derive from has just been deleted. That is\n * the reason this is its own entry rather than a flag on a writing one — the\n * removal case must not be reachable from a code path whose job is to write.\n *\n * Call AFTER the global manifest has been removed so the regenerated project\n * types fall back to the standalone form instead of importing from the\n * now-deleted global config-types.ts.\n *\n * `provider` is the installation that was removed, and it is a parameter rather than a read:\n * the folder that would answer it has just been deleted, so by the time this runs the disk no\n * longer records which installation the pruning belongs to.\n */\nexport async function propagateGlobalRemoval(\n  preRemovalGlobalConfig: ProjectConfig,\n  deps: LoadedGateDeps,\n  provider: Provider,\n): Promise<GateReport> {\n  return withGateToken(async () => {\n    const changes = classifyGlobalChange(preRemovalGlobalConfig, {\n      ...preRemovalGlobalConfig,\n      skills: [],\n      agents: [],\n    });\n\n    const propagated = await pruneGlobalEntriesFromRegisteredProjects(\n      preRemovalGlobalConfig,\n      deps.agents,\n      provider,\n    );\n    const recompile = await recompilePropagated(propagated.updated);\n\n    return report(false, changes, propagated, recompile);\n  });\n}\n\n/**\n * Creates the blank global pair when none exists. No classification and no\n * fan-out: the registration list propagation reads lives in the file that was\n * just found absent, so a pair created here has no registered projects.\n */\nexport async function ensureBlankPair(provider: Provider): Promise<boolean> {\n  return withGateToken(() => ensureBlankPairInternal(provider));\n}\n\nexport type WriteProjectPartialOptions = {\n  /** Name to invent when the partial has none. Absent → a missing name is an error. */\n  fallbackName?: string;\n};\n\n/**\n * The partial with every stack assignment normalized back to `SkillAssignment[]`.\n *\n * Every caller of this entry reads the config with the LENIENT loader\n * (`loadProjectSourceConfig`), overlays one scalar, and hands the result back.\n * That loader passes the on-disk stack through untouched, and the writer emits an\n * exclusive category in its BARE form (`\"web-framework\": \"web-framework-react\"`,\n * no array) — so on a load / re-emit round trip `compactCategories`, which keeps\n * only non-empty arrays, drops the category and the user silently loses an\n * assignment they never touched.\n *\n * Normalizing at this boundary rather than inside the writer keeps the fix on the\n * one path that can present a denormalized stack: the full loader\n * (`loadProjectConfigFromDir`) already runs `normalizeStackRecord`, so every other\n * writer input arrives normalized.\n */\nfunction withNormalizedStack(partial: Partial<ProjectConfig>): Partial<ProjectConfig> {\n  if (!partial.stack) return partial;\n  return { ...partial, stack: normalizeStackRecord(partial.stack) };\n}\n\n/**\n * Writes a partial config to a PROJECT's own `config.ts`, filling\n * required defaults. Refuses the home directory: the global pair's config half\n * may never be written without its types sibling and without classification.\n */\nexport async function writeProjectPartial(\n  projectDir: string,\n  partial: Partial<ProjectConfig>,\n  options: WriteProjectPartialOptions = {},\n): Promise<void> {\n  if (isHomeDirectory(projectDir)) {\n    throw new GlobalPairWriteViolation(getInstalledConfigPath(projectDir));\n  }\n\n  const configPath = getInstalledConfigPath(projectDir);\n  await ensureDir(path.dirname(configPath));\n  await writeFile(\n    configPath,\n    generateConfigSource(\n      fillRequiredFields(withNormalizedStack(partial), options.fallbackName),\n      activeMatrix,\n    ),\n  );\n}\n\n/**\n * `normalizeProjectPath` is the single rule for any value compared against the\n * global config's `projects` array, so a reader that only wants to MATCH a\n * registration (never write one) gets it from here rather than reimplementing\n * `fs.realpathSync` and drifting from the rule the registrations were stored\n * under. It writes nothing, so exporting it hands out no privilege.\n */\nexport { mergeGlobalConfigs, normalizeProjectPath };\n","import { isDeepEqual } from \"remeda\";\nimport type { AgentName, ProjectConfig, SkillId } from \"../../types\";\nimport type { AgentScopeConfig, SkillConfig } from \"../../types/config\";\n\n/**\n * The work one global config write owes, decided from what actually moved\n * between the config on disk and the config being written.\n *\n * T1 — the generated type unions or the compiled agents are derived from what\n *      changed: rewrite both halves of the pair, propagate to every registered\n *      project, recompile those projects' agents.\n * T2 — a scalar the unions do not encode changed. Project configs inline the\n *      global scalars verbatim, so the config half propagates; no union moves,\n *      so no types are regenerated and no agent is recompiled.\n * T3 — only the `projects[]` registration list changed. Nothing is propagated,\n *      and the matrix / agent definitions propagation would need are never\n *      loaded.\n * T4 — nothing moved. No file is touched.\n */\nexport type ConsequenceTier = \"T1\" | \"T2\" | \"T3\" | \"T4\";\n\nexport type GlobalChangeSet = {\n  skills: {\n    added: SkillId[];\n    removed: SkillId[];\n    /**\n     * Ids whose `origin` moved — the field's name on `SkillConfig`; this one keeps the\n     * older word. Separate from `otherChanged` because the per-skill value decides the\n     * reference form a compiled agent emits\n     * (`<id>:<id>` for a marketplace-sourced skill, the bare id for an ejected\n     * one), so a source change that skipped the recompile leaves every\n     * registered project's agents naming a reference that no longer resolves.\n     */\n    sourceChanged: SkillId[];\n    otherChanged: SkillId[];\n  };\n  agents: {\n    added: AgentName[];\n    removed: AgentName[];\n    changed: AgentName[];\n  };\n  stackChanged: boolean;\n  selectedDomainsChanged: boolean;\n  /** Names of the inlined scalar fields that moved, in config key order. */\n  scalarsChanged: string[];\n  projectsChanged: boolean;\n};\n\n/** The identity element of {@link GlobalChangeSet} — nothing moved, so T4. */\nexport const NO_CHANGES: GlobalChangeSet = {\n  skills: { added: [], removed: [], sourceChanged: [], otherChanged: [] },\n  agents: { added: [], removed: [], changed: [] },\n  stackChanged: false,\n  selectedDomainsChanged: false,\n  scalarsChanged: [],\n  projectsChanged: false,\n};\n\n/** The four fields the config writer extracts into typed named variables. */\nconst EXTRACTED_FIELDS = new Set([\"skills\", \"agents\", \"stack\", \"selectedDomains\"]);\n\n/** The registration list — bookkeeping, never emitted into a project config. */\nconst REGISTRATION_FIELD = \"projects\";\n\n/**\n * Normalizes a config the way the writer does immediately before emission: a\n * JSON round-trip, so an explicitly-`undefined` field and an absent one compare\n * equal. Without it every write that merely reconstructs an object produces\n * phantom diffs.\n */\nfunction normalize(config: ProjectConfig): Record<string, unknown> {\n  // Boundary cast: `JSON.parse` is typed `any`, and round-tripping an object\n  // always yields one — the whole point of the call is that the result is the\n  // same record with its undefined-valued keys gone.\n  return JSON.parse(JSON.stringify(config)) as Record<string, unknown>;\n}\n\n/** Field value as the writer would emit it, or undefined when absent. */\nfunction field(config: Record<string, unknown>, key: string): unknown {\n  return config[key];\n}\n\nfunction skillsById(config: Record<string, unknown>): Map<SkillId, SkillConfig> {\n  const skills = (config.skills ?? []) as SkillConfig[];\n  return new Map(skills.map((skill) => [skill.id, skill]));\n}\n\nfunction agentsByName(config: Record<string, unknown>): Map<AgentName, AgentScopeConfig> {\n  const agents = (config.agents ?? []) as AgentScopeConfig[];\n  return new Map(agents.map((agent) => [agent.name, agent]));\n}\n\n/** The scalar keys either side carries, in `next`-first order with `prev` extras appended. */\nfunction scalarKeys(prev: Record<string, unknown>, next: Record<string, unknown>): string[] {\n  const isScalarKey = (key: string): boolean =>\n    !EXTRACTED_FIELDS.has(key) && key !== REGISTRATION_FIELD;\n  const nextKeys = Object.keys(next).filter(isScalarKey);\n  const extraPrevKeys = Object.keys(prev).filter(\n    (key) => isScalarKey(key) && !nextKeys.includes(key),\n  );\n  return [...nextKeys, ...extraPrevKeys];\n}\n\nfunction diffSkills(\n  prev: Record<string, unknown>,\n  next: Record<string, unknown>,\n): GlobalChangeSet[\"skills\"] {\n  const before = skillsById(prev);\n  const after = skillsById(next);\n\n  const added = [...after.keys()].filter((id) => !before.has(id));\n  const removed = [...before.keys()].filter((id) => !after.has(id));\n\n  const sourceChanged: SkillId[] = [];\n  const otherChanged: SkillId[] = [];\n  for (const [id, afterEntry] of after) {\n    const beforeEntry = before.get(id);\n    if (!beforeEntry || isDeepEqual(beforeEntry, afterEntry)) continue;\n    if (beforeEntry.origin !== afterEntry.origin) sourceChanged.push(id);\n    else otherChanged.push(id);\n  }\n\n  return { added, removed, sourceChanged, otherChanged };\n}\n\nfunction diffAgents(\n  prev: Record<string, unknown>,\n  next: Record<string, unknown>,\n): GlobalChangeSet[\"agents\"] {\n  const before = agentsByName(prev);\n  const after = agentsByName(next);\n\n  return {\n    added: [...after.keys()].filter((name) => !before.has(name)),\n    removed: [...before.keys()].filter((name) => !after.has(name)),\n    changed: [...after.keys()].filter((name) => {\n      const beforeEntry = before.get(name);\n      return beforeEntry !== undefined && !isDeepEqual(beforeEntry, after.get(name));\n    }),\n  };\n}\n\n/**\n * Diffs the config on disk against the config about to be written. `prev` is\n * undefined when no global config exists yet, which every field reads as a\n * change from absent.\n */\nexport function classifyGlobalChange(\n  prev: ProjectConfig | undefined,\n  next: ProjectConfig,\n): GlobalChangeSet {\n  const before = prev ? normalize(prev) : {};\n  const after = normalize(next);\n  const moved = (key: string): boolean => !isDeepEqual(field(before, key), field(after, key));\n\n  return {\n    skills: diffSkills(before, after),\n    agents: diffAgents(before, after),\n    stackChanged: moved(\"stack\"),\n    selectedDomainsChanged: moved(\"selectedDomains\"),\n    scalarsChanged: scalarKeys(before, after).filter(moved),\n    projectsChanged: moved(REGISTRATION_FIELD),\n  };\n}\n\n/** True when something the type unions or the compiled agents derive from moved. */\nfunction movesTypesOrCompiledAgents(changes: GlobalChangeSet): boolean {\n  const { skills, agents } = changes;\n  return (\n    skills.added.length > 0 ||\n    skills.removed.length > 0 ||\n    skills.sourceChanged.length > 0 ||\n    skills.otherChanged.length > 0 ||\n    agents.added.length > 0 ||\n    agents.removed.length > 0 ||\n    agents.changed.length > 0 ||\n    changes.stackChanged ||\n    changes.selectedDomainsChanged\n  );\n}\n\n/** The work tier a change set obliges. */\nexport function consequenceTier(changes: GlobalChangeSet): ConsequenceTier {\n  if (movesTypesOrCompiledAgents(changes)) return \"T1\";\n  if (changes.scalarsChanged.length > 0) return \"T2\";\n  if (changes.projectsChanged) return \"T3\";\n  return \"T4\";\n}\n\n/** True when the tier's consequences need the matrix and agent definitions. */\nexport function tierNeedsDeps(tier: ConsequenceTier): boolean {\n  return tier === \"T1\" || tier === \"T2\";\n}\n\n/** True when the tier regenerates the types half and recompiles propagated agents. */\nexport function tierRegeneratesTypes(tier: ConsequenceTier): boolean {\n  return tier === \"T1\";\n}\n\n/** True when the tier fans the change out to every registered project. */\nexport function tierPropagates(tier: ConsequenceTier): boolean {\n  return tier === \"T1\" || tier === \"T2\";\n}\n","import type { AgentDefinition, AgentName, MergedSkillsMatrix } from \"../../types\";\nimport { tierNeedsDeps, tierRegeneratesTypes, type ConsequenceTier } from \"./classify.js\";\n\n/** The matrix and agent definitions propagation and type generation read. */\nexport type LoadedGateDeps = {\n  matrix: MergedSkillsMatrix;\n  agents: Partial<Record<AgentName, AgentDefinition>>;\n};\n\n/**\n * What a gate entry needs to carry out a write's consequences.\n *\n * The lazy form exists so a caller that cannot cheaply produce the matrix — an\n * offline uninstall, a deregistration — hands over loaders instead. Whether they\n * run is decided by classification: a registration-only or no-op write has no\n * consequences to carry out, so nothing is loaded and the write stays offline.\n */\nexport type GateDeps =\n  | LoadedGateDeps\n  | {\n      loadMatrix: () => Promise<MergedSkillsMatrix>;\n      loadAgents: () => Promise<Partial<Record<AgentName, AgentDefinition>>>;\n    };\n\nfunction isLoaded(deps: GateDeps): deps is LoadedGateDeps {\n  return \"matrix\" in deps;\n}\n\n/**\n * Resolves `deps` only when `tier` has consequences that read them. Returns null\n * otherwise, and the lazy loaders are never called.\n */\nexport async function resolveGateDeps(\n  deps: GateDeps,\n  tier: ConsequenceTier,\n): Promise<LoadedGateDeps | null> {\n  if (!tierNeedsDeps(tier)) return null;\n  if (isLoaded(deps)) return deps;\n\n  // Agent definitions are read only where the types half is regenerated, so a\n  // config-half-only tier never pays for loading them.\n  const [matrix, agents] = await Promise.all([\n    deps.loadMatrix(),\n    tierRegeneratesTypes(tier) ? deps.loadAgents() : NO_AGENTS,\n  ]);\n  return { matrix, agents };\n}\n\n/** Agent definitions a tier that regenerates no types never reads. */\nconst NO_AGENTS: Promise<Partial<Record<AgentName, AgentDefinition>>> = Promise.resolve({});\n","import os from \"os\";\nimport path from \"path\";\nimport type { AgentDefinition, AgentName, MergedSkillsMatrix, ProjectConfig } from \"../../types\";\nimport type { Provider } from \"../../consts\";\nimport { STANDARD_FILES } from \"../../consts\";\nimport { sourceFolderInUse } from \"../installation/install-layout\";\nimport { ensureDir, fileExists, readFile, writeFile } from \"../../utils/fs\";\nimport { verbose } from \"../../utils/logger\";\nimport {\n  generateBlankGlobalConfigSource,\n  generateConfigSource,\n} from \"../configuration/config-writer\";\nimport {\n  buildConfigTypesBackgroundData,\n  generateBlankGlobalConfigTypesSource,\n  generateConfigTypesSource,\n  type ConfigTypesExtras,\n} from \"../configuration/config-types-writer\";\n// The catalogue the renderers take as a parameter. It is the singleton this CLI seats at\n// startup, which is what `generateConfigSource` read directly before the renderers moved into\n// `@workspace/compile` and the editor became a second caller with a catalogue of its own.\nimport { matrix as activeMatrix } from \"../matrix/matrix-provider\";\nimport { assertGateToken } from \"./gate-token.js\";\n\n/**\n * Nothing in this module MINTS the write privilege — every function below\n * REQUIRES it, and `writeIfChanged` is where that requirement is asserted. The\n * token is opened by the gate's public entry points in `index.ts`, each of which\n * wraps its whole consequence flow.\n *\n * That split is the point (D-309): a callee that opens the privilege on its own\n * behalf hands it to whoever reached it, so a caller that got past module\n * privacy — a dynamic import, a re-export added for convenience — arrived\n * already authorized and the runtime tripwire in `utils/fs.ts` waved it through.\n * Requiring the token instead makes reaching the private writer useless on its\n * own: the privilege belongs to the entry points, not to the writers.\n */\n\n/** Absolute paths of the two halves of the global config pair. */\nexport type GlobalPairPaths = {\n  configPath: string;\n  typesPath: string;\n};\n\n/**\n * Resolves `provider`'s global pair paths. `os.homedir()` at call time, so they agree\n * with every other home-dir reader and with test home mocks.\n *\n * The provider is the asking run's, because the home root can hold a global installation of\n * each and the pair belongs to exactly one of them.\n */\nexport function globalPairPaths(provider: Provider): GlobalPairPaths {\n  const dir = sourceFolderInUse(os.homedir(), provider).dir;\n  return {\n    configPath: path.join(dir, STANDARD_FILES.CONFIG_TS),\n    typesPath: path.join(dir, STANDARD_FILES.CONFIG_TYPES_TS),\n  };\n}\n\n/** The types sibling of a config path — the two always share a directory. */\nexport function typesPathFor(configPath: string): string {\n  return path.join(path.dirname(configPath), STANDARD_FILES.CONFIG_TYPES_TS);\n}\n\n/**\n * Writes `source` to `filePath` unless the file already holds exactly those\n * bytes. Both halves are derived from the same config on every write, so pair\n * coherence holds by derivation and the comparison only suppresses the mtime\n * churn a projects-only or scalar-only change would otherwise inflict on every\n * consumer watching these files. Returns true when the file was written.\n */\nasync function writeIfChanged(filePath: string, source: string): Promise<boolean> {\n  assertGateToken(filePath);\n  if ((await fileExists(filePath)) && (await readFile(filePath)) === source) return false;\n  await writeFile(filePath, source);\n  return true;\n}\n\n/**\n * Standalone (non-importing) type unions narrowed to `config`'s own entries,\n * widened by `extras` — the literals a just-created skill or agent needs before\n * it reaches the config.\n */\nfunction renderStandaloneTypes(\n  config: ProjectConfig,\n  matrix: MergedSkillsMatrix,\n  agents: Partial<Record<AgentName, AgentDefinition>>,\n  extras?: ConfigTypesExtras,\n): string {\n  const data = buildConfigTypesBackgroundData(matrix, agents);\n  return generateConfigTypesSource(\n    data.matrix,\n    data.agentNames,\n    data.customAgentNames,\n    extras,\n    config,\n  );\n}\n\n/**\n * Writes the config half of the pair at `configPath`. The global config never\n * takes the project writer's import/inline options — it is the file those\n * options resolve against.\n *\n * The one renderer call left reading the singleton rather than taking a\n * catalogue: its sole caller is `mutateGlobal`, which writes this half BEFORE\n * `resolveGateDeps` runs, deliberately — a mutation with no registered projects\n * must not pay for the catalogue load. There is no catalogue in scope to pass.\n */\nexport async function writeGlobalConfigHalf(\n  config: ProjectConfig,\n  configPath: string,\n): Promise<boolean> {\n  return writeIfChanged(configPath, generateConfigSource(config, activeMatrix));\n}\n\n/** Writes the types half of the pair beside `configPath`. */\nexport async function writeGlobalTypesHalf(\n  config: ProjectConfig,\n  configPath: string,\n  matrix: MergedSkillsMatrix,\n  agents: Partial<Record<AgentName, AgentDefinition>>,\n  extras?: ConfigTypesExtras,\n): Promise<boolean> {\n  return writeIfChanged(\n    typesPathFor(configPath),\n    renderStandaloneTypes(config, matrix, agents, extras),\n  );\n}\n\n/**\n * Writes both halves from one config AND one catalogue, so they cannot disagree.\n *\n * The catalogue is the caller's `matrix` for both halves. It was the caller's for\n * the types half and the module singleton for the config half, which is the\n * disagreement this function's name says cannot happen: the two are the same\n * object on every production path today, and the whole reason the renderers take\n * a catalogue parameter is that a second caller seats a different one.\n */\nexport async function writeGlobalPair(\n  config: ProjectConfig,\n  configPath: string,\n  matrix: MergedSkillsMatrix,\n  agents: Partial<Record<AgentName, AgentDefinition>>,\n): Promise<boolean> {\n  const configWritten = await writeIfChanged(configPath, generateConfigSource(config, matrix));\n  const typesWritten = await writeIfChanged(\n    typesPathFor(configPath),\n    renderStandaloneTypes(config, matrix, agents),\n  );\n  return configWritten || typesWritten;\n}\n\n/**\n * Creates a blank global pair in `provider`'s home-scope source folder when none exists: `config.ts`\n * with empty arrays and `config-types.ts` with `never` unions. Returns true when\n * the files were created, false when they already existed.\n */\nexport async function ensureBlankPair(provider: Provider): Promise<boolean> {\n  const { configPath, typesPath } = globalPairPaths(provider);\n\n  if (await fileExists(configPath)) {\n    verbose(\"Global config already exists, skipping blank creation\");\n    return false;\n  }\n\n  await ensureDir(path.dirname(configPath));\n\n  await writeIfChanged(configPath, generateBlankGlobalConfigSource());\n  await writeIfChanged(typesPath, generateBlankGlobalConfigTypesSource());\n\n  verbose(`Created blank global config at ${path.dirname(configPath)}`);\n  return true;\n}\n","import fs from \"fs\";\nimport { isDeepEqual, unique } from \"remeda\";\nimport type {\n  AgentDefinition,\n  AgentName,\n  Category,\n  MergedSkillsMatrix,\n  ProjectConfig,\n  SkillAssignment,\n  SkillId,\n  StackAgentConfig,\n} from \"../../types\";\nimport type { AgentScopeConfig, SkillConfig } from \"../../types/config\";\nimport { PROVIDERS, type Provider } from \"../../consts\";\nimport { getInstalledConfigPath, getProjectConfigPath } from \"../installation/install-base-dir\";\nimport { providerInUse, sourceFolderInUse } from \"../installation/install-layout\";\nimport { ConfigLoadError, loadInstalledConfig } from \"../configuration/project-config\";\nimport { mergeConfigs, type AuthoritativeScope } from \"../configuration/config-merger\";\nimport {\n  activeProjectAgentNames,\n  isActiveAt,\n  isGlobalTombstone,\n  type ScopedEntry,\n} from \"../configuration/scope-predicates\";\nimport { generateConfigSource, type ConfigSourceOptions } from \"../configuration/config-writer\";\nimport {\n  buildConfigTypesBackgroundData,\n  type ConfigTypesExtras,\n  deriveCategories,\n  deriveDomains,\n  regenerateConfigTypes,\n} from \"../configuration/config-types-writer\";\n// The catalogue the renderers take as a parameter. It is the singleton this CLI seats at\n// startup, which is what `generateConfigSource` read directly before the renderers moved into\n// `@workspace/compile` and the editor became a second caller with a catalogue of its own.\n// Inside the fan-out it is the seat `withCatalogueSeatedFor` has put the current project's\n// catalogue in, which is why the config half needs no catalogue argument to follow the types\n// half onto the right one.\nimport { matrix as activeMatrix } from \"../matrix/matrix-provider\";\nimport { withCatalogueSeatedFor } from \"../loading/catalogue-seat.js\";\nimport { fileExists, writeFile } from \"../../utils/fs\";\nimport { getErrorMessage } from \"../../utils/errors\";\nimport { verbose } from \"../../utils/logger\";\nimport { typedEntries, typedKeys } from \"../../utils/typed-object\";\nimport { LOCAL_PSEUDO_CATEGORY } from \"../../consts\";\n// The merge a project install resolves the global config through lives in `@workspace/compile`,\n// because the editor's output preview resolves the global config it draws through it too.\nimport { addSessionToGlobal, type ResolvedGlobalConfig } from \"@workspace/compile/global-config\";\n\nexport { mergeGlobalConfigs } from \"@workspace/compile/global-config\";\n\nexport async function writeConfigFile(\n  config: ProjectConfig,\n  configPath: string,\n  options?: ConfigSourceOptions,\n): Promise<void> {\n  const source = generateConfigSource(config, activeMatrix, options);\n  await writeFile(configPath, source);\n}\n\n/**\n * The single normalization for every value compared against the global config's\n * `projects` array — the one written by {@link registerProjectPath}, the one the\n * gate's `deregister-project` mutation filters against, and the current-project\n * skip in {@link propagateGlobalChangesToProjects}. Symlinks are resolved, so an entry\n * stored under one of them matches byte-for-byte under the others. The two ends\n * normalizing differently is what left symlinked layouts (macOS `/tmp`, a\n * `~/dev/repo` pointing at `/data/repo`) registered forever after an uninstall.\n *\n * Throws when the directory does not exist. That is deliberate: a path that\n * cannot be resolved is an error, not a cue to fall back to a weaker\n * normalization — a second tier would reintroduce exactly the asymmetry this\n * helper exists to remove. The one caller that must survive it (`uninstall`'s\n * deregistration) already wraps the call in a warn-and-continue guard.\n */\nexport function normalizeProjectPath(projectDir: string): string {\n  return fs.realpathSync(projectDir);\n}\n\n/**\n * Registers a project directory in the global config's `projects` array.\n * Paths are normalized via {@link normalizeProjectPath} to resolve symlinks.\n * Filters stale entries (where the project's config.ts no longer exists).\n */\nasync function registerProjectPath(\n  globalConfig: ProjectConfig,\n  projectDir: string,\n): Promise<{ config: ProjectConfig; changed: boolean }> {\n  const normalizedPath = normalizeProjectPath(projectDir);\n  const existing = globalConfig.projects ?? [];\n\n  // Filter stale entries\n  const staleChecks = await Promise.all(\n    existing.map(async (p) => ({\n      path: p,\n      hasConfig: await fileExists(getInstalledConfigPath(p)),\n    })),\n  );\n  const valid = staleChecks.filter((c) => c.hasConfig).map((c) => c.path);\n\n  if (valid.includes(normalizedPath)) {\n    const changed = valid.length !== existing.length;\n    return { config: changed ? { ...globalConfig, projects: valid } : globalConfig, changed };\n  }\n\n  return { config: { ...globalConfig, projects: [...valid, normalizedPath] }, changed: true };\n}\n\nfunction isProjectScopedEntry(entry: ScopedEntry): boolean {\n  return entry.scope === \"project\";\n}\n\n/** True when the global config still has an active (non-excluded) skill for this id. */\nfunction globalHasActiveSkill(globalConfig: ProjectConfig, id: SkillId): boolean {\n  return globalConfig.skills.some((s) => s.id === id && isActiveAt(s, \"global\"));\n}\n\n/** True when the global config still has an active (non-excluded) agent for this name. */\nfunction globalHasActiveAgent(globalConfig: ProjectConfig, name: AgentName): boolean {\n  return globalConfig.agents.some((a) => a.name === name && isActiveAt(a, \"global\"));\n}\n\n/**\n * Keeps a project's own skill entries when re-inlining fresh global data, dropping\n * tombstones that no longer correspond to a real global install.\n *\n * A tombstone (`scope === \"global\" && excluded`) only has meaning while the global entry\n * it masks still exists. Once the skill has been removed from the global config, the\n * tombstone is stale — carrying it forward would leave the project showing a masked\n * global item that no longer exists. Project-scoped entries are always retained.\n */\nfunction retainProjectOwnedSkills(\n  skills: SkillConfig[],\n  globalConfig: ProjectConfig,\n): SkillConfig[] {\n  return skills.filter(\n    (entry) =>\n      isProjectScopedEntry(entry) ||\n      (isGlobalTombstone(entry) && globalHasActiveSkill(globalConfig, entry.id)),\n  );\n}\n\n/** Agent mirror of {@link retainProjectOwnedSkills}. */\nfunction retainProjectOwnedAgents(\n  agents: AgentScopeConfig[],\n  globalConfig: ProjectConfig,\n): AgentScopeConfig[] {\n  return agents.filter(\n    (entry) =>\n      isProjectScopedEntry(entry) ||\n      (isGlobalTombstone(entry) && globalHasActiveAgent(globalConfig, entry.name)),\n  );\n}\n\n/**\n * Category a skill belongs to according to the MERGED matrix. `undefined` when the\n * matrix has no entry for the id (a user-authored local skill carries no matrix\n * record) or when the entry sits in the `local` pseudo-category — neither\n * participates in category rules, and neither may throw.\n */\nfunction categoryOfSkill(id: SkillId, matrix: MergedSkillsMatrix): Category | undefined {\n  const category = matrix.skills[id]?.category;\n  if (category === undefined || category === LOCAL_PSEUDO_CATEGORY) return undefined;\n  return category;\n}\n\n/**\n * True when the merged matrix DECLARES this category as holding at most one skill.\n * Read from the matrix passed in rather than `defaultCategories` so a source repo's\n * category overrides are honoured.\n *\n * A category the matrix does not declare is deliberately NOT treated as exclusive:\n * a rule that MASKS persisted entries must only fire on a flag the data actually\n * carries.\n */\nfunction isExclusiveCategory(category: Category, matrix: MergedSkillsMatrix): boolean {\n  return matrix.categories[category]?.exclusive === true;\n}\n\n/** Categories occupied by an active project-scoped skill, per the merged matrix. */\nfunction activeProjectCategories(\n  projectOwnedSkills: SkillConfig[],\n  matrix: MergedSkillsMatrix,\n): Set<Category> {\n  return new Set(\n    projectOwnedSkills\n      .filter((s) => isActiveAt(s, \"project\"))\n      .map((s) => categoryOfSkill(s.id, matrix))\n      .filter((category): category is Category => category !== undefined),\n  );\n}\n\n/**\n * The collision that justifies masking a live global skill. Two kinds, both read from the\n * project's OWN entries: IDENTITY — the project owns the same id at project scope; CATEGORY —\n * the project owns a different active skill in the same category and the matrix declares that\n * category exclusive.\n *\n * Shared by the mask producer ({@link maskCollidingGlobalSkills}) and the self-heal that\n * removes a mask once its collision clears ({@link dropOrphanedDerivedMasks}), so the two can\n * never disagree about what a mask means.\n */\nfunction buildProjectCollisionTest(\n  projectOwnedSkills: SkillConfig[],\n  matrix: MergedSkillsMatrix,\n): (id: SkillId) => boolean {\n  const ownedIds = new Set(\n    projectOwnedSkills.filter((s) => isActiveAt(s, \"project\")).map((s) => s.id),\n  );\n  const occupiedExclusiveCategories = new Set(\n    [...activeProjectCategories(projectOwnedSkills, matrix)].filter((category) =>\n      isExclusiveCategory(category, matrix),\n    ),\n  );\n\n  return (id) => {\n    if (ownedIds.has(id)) return true;\n    const category = categoryOfSkill(id, matrix);\n    return category !== undefined && occupiedExclusiveCategories.has(category);\n  };\n}\n\n/**\n * Drops a derived mask that no longer masks anything, so the global install becomes\n * visible again once the collision that produced it is gone.\n *\n * A derived mask and a user-authored tombstone are BYTE-IDENTICAL in config.ts — both are\n * `{ id, scope: \"global\", excluded: true }`. A mask is kept iff the collision that would\n * re-derive it is still there.\n */\nfunction dropOrphanedDerivedMasks(\n  projectOwnedSkills: SkillConfig[],\n  matrix: MergedSkillsMatrix,\n): SkillConfig[] {\n  const collidesWithProjectOwnership = buildProjectCollisionTest(projectOwnedSkills, matrix);\n  return projectOwnedSkills.filter(\n    (entry) => !isGlobalTombstone(entry) || collidesWithProjectOwnership(entry.id),\n  );\n}\n\n/**\n * Agent mirror of {@link dropOrphanedDerivedMasks}, identity collisions only: agents\n * have no categories, so the project-scoped sibling with the same name is the only thing a\n * mask can be justified by.\n */\nfunction dropOrphanedDerivedAgentMasks(projectOwnedAgents: AgentScopeConfig[]): AgentScopeConfig[] {\n  const ownedNames = new Set(activeProjectAgentNames(projectOwnedAgents));\n  return projectOwnedAgents.filter(\n    (entry) => !isGlobalTombstone(entry) || ownedNames.has(entry.name),\n  );\n}\n\n/**\n * Builds the tombstones that mask live global skills this project cannot show\n * alongside what it already owns at project scope. Two collision kinds, both keyed\n * against the SAME live global config:\n *\n * 1. IDENTITY — the project owns the same id at project scope. Without the\n *    mask, `partitionInlinedConfigEntries` re-inlines the global copy as a SECOND\n *    active entry, leaving one id active at BOTH scopes instead of rendering the\n *    dual-scope `[P][G]` pair.\n * 2. CATEGORY — the project owns a DIFFERENT active skill in the same category and\n *    the matrix declares that category exclusive. Reconciliation keyed on identity\n *    alone cannot see this, so a project owning Vue plus a global install of React\n *    ends up with two active skills in a category that permits one.\n *\n * The project-owned skill wins locally. Letting global win would silently uninstall the user's\n * own skill.\n *\n * Tombstones are spread from the global entry so they carry the global install's\n * `origin`. A skill the project merely inherits (no active project-scope entry, no\n * exclusive-category collision) is skipped — it stays a single active global entry.\n * A skill the project already tombstones is skipped so re-running is idempotent.\n */\nfunction maskCollidingGlobalSkills(\n  projectOwnedSkills: SkillConfig[],\n  globalConfig: ProjectConfig,\n  matrix: MergedSkillsMatrix,\n): SkillConfig[] {\n  const collidesWithProjectOwnership = buildProjectCollisionTest(projectOwnedSkills, matrix);\n  const alreadyTombstoned = new Set(projectOwnedSkills.filter(isGlobalTombstone).map((s) => s.id));\n\n  return globalConfig.skills\n    .filter(\n      (globalEntry) =>\n        isActiveAt(globalEntry, \"global\") &&\n        collidesWithProjectOwnership(globalEntry.id) &&\n        !alreadyTombstoned.has(globalEntry.id),\n    )\n    .map((globalEntry) => ({ ...globalEntry, excluded: true }));\n}\n\n/**\n * Agent mirror of {@link maskCollidingGlobalSkills}, identity collisions only.\n * Agents have no categories, so there is no grouping dimension to reconcile.\n */\nfunction maskCollidingGlobalAgents(\n  projectOwnedAgents: AgentScopeConfig[],\n  globalConfig: ProjectConfig,\n): AgentScopeConfig[] {\n  const ownedNames = new Set(activeProjectAgentNames(projectOwnedAgents));\n  const alreadyTombstoned = new Set(\n    projectOwnedAgents.filter(isGlobalTombstone).map((a) => a.name),\n  );\n\n  return globalConfig.agents\n    .filter(\n      (globalEntry) =>\n        isActiveAt(globalEntry, \"global\") &&\n        ownedNames.has(globalEntry.name) &&\n        !alreadyTombstoned.has(globalEntry.name),\n    )\n    .map((globalEntry) => ({ ...globalEntry, excluded: true }));\n}\n\n/**\n * Reconciles a project's OWN entries against the live global config, immediately\n * before the inlining writer merges the two.\n *\n * Applied at BOTH sites that write a project `config.ts` with `globalConfig` inlined:\n * `propagateGlobalChangesToProjects` (a global change fanning out to registered\n * projects) and the project-scope save branch of `writeConfigByScope` (an ordinary\n * project `init`/`edit` performed while the colliding skill is already active\n * globally). Either site alone can produce the malformed shape, so both must run it.\n *\n * Self-heal runs BEFORE masking on BOTH axes so a mask whose collision has cleared is\n * removed rather than immediately re-derived, and so masking's `alreadyTombstoned` guard\n * only sees tombstones that are still warranted.\n *\n * Masking is PROJECT-LOCAL: it is applied to the project split only. The global\n * config passed in is read, never rewritten — tombstones never belong in the\n * global config.ts.\n */\nexport function reconcileProjectSplitAgainstGlobal(\n  projectSplit: ProjectConfig,\n  globalConfig: ProjectConfig,\n  matrix: MergedSkillsMatrix,\n): ProjectConfig {\n  const healedSkills = dropOrphanedDerivedMasks(projectSplit.skills, matrix);\n  const healedAgents = dropOrphanedDerivedAgentMasks(projectSplit.agents);\n  return {\n    ...projectSplit,\n    skills: [...healedSkills, ...maskCollidingGlobalSkills(healedSkills, globalConfig, matrix)],\n    agents: [...healedAgents, ...maskCollidingGlobalAgents(healedAgents, globalConfig)],\n  };\n}\n\n/**\n * Computes the skill ids that this project inherited from global scope but that are\n * no longer active at global scope after the change being propagated — and that the\n * project does not own at project scope. These are the only ids that should be pruned\n * from the project's stack: a project-scoped agent may legitimately reference a\n * globally-installed skill, and once that skill is removed at global scope the\n * reference becomes dangling.\n *\n * `priorProjectSkills` is the project's pre-reconciliation (on-disk, inlined) skills.\n * A global skill that was just removed still appears here as a `scope: \"global\"`,\n * non-excluded entry, which is the signal we key on. Project-scoped skills and\n * user-authored local skills (which carry no SkillConfig entry at all) are never in\n * this set, so they are always preserved.\n */\nfunction computeRemovedGlobalSkillIds(\n  priorProjectSkills: SkillConfig[],\n  globalConfig: ProjectConfig,\n): Set<SkillId> {\n  const activeGlobalIds = new Set(\n    globalConfig.skills.filter((s) => isActiveAt(s, \"global\")).map((s) => s.id),\n  );\n  const projectOwnedIds = new Set(\n    priorProjectSkills.filter((s) => isActiveAt(s, \"project\")).map((s) => s.id),\n  );\n  return new Set(\n    priorProjectSkills\n      .filter(\n        (s) =>\n          s.scope === \"global\" &&\n          !s.excluded &&\n          !activeGlobalIds.has(s.id) &&\n          !projectOwnedIds.has(s.id),\n      )\n      .map((s) => s.id),\n  );\n}\n\n/**\n * Prunes stack references to global skills that were just removed at global scope,\n * so a project-scoped agent stops referencing a skill that no longer exists anywhere.\n * Only ids in `removedGlobalSkillIds` are dropped — every other assignment is kept\n * verbatim, in order, with its `preloaded` flag untouched. Categories and agents left\n * empty by the pruning are removed. When nothing was removed, the stack is returned\n * unchanged so unaffected projects produce byte-identical config output.\n */\nfunction retainReconciledStack(\n  stack: Record<string, StackAgentConfig> | undefined,\n  removedGlobalSkillIds: Set<SkillId>,\n): Record<string, StackAgentConfig> | undefined {\n  if (!stack || removedGlobalSkillIds.size === 0) return stack;\n\n  const reconciled: Record<string, StackAgentConfig> = {};\n  for (const [agent, agentStack] of Object.entries(stack)) {\n    const reconciledAgentStack = withoutRemovedAssignments(agentStack, removedGlobalSkillIds);\n    if (typedKeys<Category>(reconciledAgentStack).length > 0) {\n      reconciled[agent] = reconciledAgentStack;\n    }\n  }\n  return reconciled;\n}\n\n/**\n * One agent's stack with the removed ids' assignments dropped, keeping every other assignment in\n * order. A category the pruning empties is left out.\n */\nfunction withoutRemovedAssignments(\n  agentStack: StackAgentConfig,\n  removedGlobalSkillIds: Set<SkillId>,\n): StackAgentConfig {\n  const reconciledAgentStack: StackAgentConfig = {};\n  for (const [category, assignments] of typedEntries<Category, SkillAssignment[]>(agentStack)) {\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- typedEntries/Object.entries launders the `| undefined` a Partial<Record> admits out of its result type, so this guard reads as dead while still covering an explicitly-undefined slot\n    if (!assignments) continue;\n    const kept = assignments.filter((assignment) => !removedGlobalSkillIds.has(assignment.id));\n    if (kept.length > 0) reconciledAgentStack[category] = kept;\n  }\n  return reconciledAgentStack;\n}\n\n/**\n * The registered projects one fan-out rewrote, and the ones it left alone, by why. Each project is\n * in exactly one, so a run can say which and why for each.\n */\nexport type PropagationResult = {\n  updated: string[];\n  /** Its `config.ts` is there and cannot be loaded. */\n  unreadable: string[];\n  /** Nothing is installed at the registered path any more. */\n  gone: string[];\n  /** It holds another provider's installation, not this one's. */\n  notOurs: string[];\n  /** Its rewrite threw: its catalogue would not load, or its pair could not be written. */\n  failed: string[];\n};\n\nexport type PropagationOptions = {\n  /**\n   * Whether each project's config-types.ts is rewritten alongside its config.ts.\n   * False for a change that moves no type union — a project inlines the global\n   * scalars into its config half, but no union is derived from them.\n   */\n  regenerateTypes?: boolean;\n};\n\n/**\n * The single writer for a project's config pair, used by BOTH sites that emit\n * one: the per-project propagation step below and the project branch of\n * `writeConfigByScope`.\n *\n * `buildProjectTypesExtras` is fed the EFFECTIVE config — the project's own\n * reconciled rows plus the active global rows the writer is about to inline —\n * at both sites. The emitted config.ts names every one of those rows, so extras\n * derived from the project split alone declare fewer literals than the sibling\n * config.ts uses, and the pair stops type-checking against itself.\n */\nexport async function writeProjectConfigPair(\n  projectDir: string,\n  provider: Provider,\n  reconciledSplit: ProjectConfig,\n  effectiveGlobal: ProjectConfig,\n  matrix: MergedSkillsMatrix,\n  agents: Partial<Record<AgentName, AgentDefinition>>,\n  options: PropagationOptions = {},\n): Promise<void> {\n  const configPath = refuseAWriteOutsideTheInstallation(projectDir, provider);\n\n  // Reconcile-before-both-writes: the two halves are derived from the same\n  // reconciled data in the same call, so neither can describe a config the other\n  // does not.\n  await writeConfigFile(reconciledSplit, configPath, {\n    isProjectConfig: true,\n    globalConfig: effectiveGlobal,\n  });\n\n  if (options.regenerateTypes === false) return;\n\n  // Uses the same global-aware path for project types — emits\n  // `import type { SkillId as GlobalSkillId, ... }` and extends with any\n  // project-scoped items the project owns. Without this, a global-scope install\n  // would overwrite the project's import-form types with the standalone/inlined\n  // form.\n  await regenerateConfigTypes(\n    projectDir,\n    Promise.resolve(buildConfigTypesBackgroundData(matrix, agents)),\n    buildProjectTypesExtras(inlinedProjectView(reconciledSplit, effectiveGlobal), matrix),\n  );\n}\n\n/**\n * The rows the inlining writer draws a project's config.ts from: the project's\n * own reconciled entries plus everything the global config contributes. Union\n * membership is decided downstream by `buildProjectTypesExtras`, which reads the\n * active entries — a tombstone's id always arrives via the live global row it\n * masks.\n */\nfunction inlinedProjectView(\n  reconciledSplit: ProjectConfig,\n  effectiveGlobal: ProjectConfig,\n): ProjectConfig {\n  return {\n    ...reconciledSplit,\n    skills: [...effectiveGlobal.skills, ...reconciledSplit.skills],\n    agents: [...effectiveGlobal.agents, ...reconciledSplit.agents],\n    selectedDomains: unique([\n      ...(effectiveGlobal.selectedDomains ?? []),\n      ...(reconciledSplit.selectedDomains ?? []),\n    ]),\n    stack: { ...(effectiveGlobal.stack ?? {}), ...(reconciledSplit.stack ?? {}) },\n  };\n}\n\n/**\n * The project's OWN entries, reconciled against the now-current global config — the\n * half the inlining writer is about to merge fresh global data into.\n *\n * Project-scoped entries, plus tombstones that still correspond to a live global\n * install. Tombstones whose global entry has been removed are dropped here so the\n * project stops referencing a global item that no longer exists. The stack is\n * reconciled against the same now-current global data so a project-scoped agent stops\n * referencing a global skill that was just removed at global scope.\n *\n * `onDisk.skills` (pre-reconciliation) is what detects the removed globals, because a\n * skill the global scope just lost is still present there as a `scope: \"global\"`\n * reference.\n */\nfunction reconcileAgainstGlobal(\n  onDisk: ProjectConfig,\n  globalConfig: ProjectConfig,\n  matrix: MergedSkillsMatrix,\n): ProjectConfig {\n  const removedGlobalSkillIds = computeRemovedGlobalSkillIds(onDisk.skills, globalConfig);\n  const reconciledStack = retainReconciledStack(onDisk.stack, removedGlobalSkillIds);\n\n  return reconcileProjectSplitAgainstGlobal(\n    {\n      ...onDisk,\n      skills: retainProjectOwnedSkills(onDisk.skills, globalConfig),\n      agents: retainProjectOwnedAgents(onDisk.agents, globalConfig),\n      ...(reconciledStack !== undefined && { stack: reconciledStack }),\n    },\n    globalConfig,\n    matrix,\n  );\n}\n\n/**\n * The config path this project's pair is written to, checked against the installation that is\n * actually in that directory.\n *\n * C2's compile-time proof does not reach here. Propagation resolves its destination from a\n * config-derived STRING — a path out of the global config's `projects` array — so deleting the\n * provider default finds every typed caller and none of these. The assertion is the runtime half\n * of the same guarantee: a pair written into the source folder of a provider the directory does\n * not hold is a write into another installation, and the one thing this step must never do\n * quietly.\n *\n * **The two sides are two independent reads, and that is the whole of the fix.** It compared\n * `getInstalledConfigPath(projectDir)` against `sourceFolderInUse(projectDir, providerInUse(...))`\n * until 2026-09-21 — one `providerInUse` answer joined with `config.ts` on one side and left bare\n * on the other, so the comparison was `join(folder, \"config.ts\").startsWith(folder)` and no disk\n * state could make it fail. What the caller BELIEVES now arrives as `provider`; what the\n * installation IS is read here.\n */\nfunction refuseAWriteOutsideTheInstallation(projectDir: string, provider: Provider): string {\n  const installed = providerInUse(projectDir);\n  const configPath = getProjectConfigPath(projectDir, provider);\n\n  if (installed !== provider) {\n    throw new Error(\n      `Refusing to write ${configPath}: ${projectDir} holds the ${installed} installation at ` +\n        `${sourceFolderInUse(projectDir, installed).dir}, not a ${provider} one.`,\n    );\n  }\n  return configPath;\n}\n\n/**\n * Rewrites ONE registered project's pair against the now-current global config.\n * Answers false when the project has a config file the loader returns nothing for,\n * which is the caller's cue to record it as unreached.\n *\n * Every catalogue lookup this makes is against the catalogue\n * {@link withCatalogueSeatedFor} loads for THIS project — its own local skills, and the\n * skills of the marketplace its own config names — rather than the one belonging to the\n * command that triggered the fan-out. Three readers depend on it and none of them can be\n * satisfied by the triggering command's: {@link reconcileAgainstGlobal} decides which of\n * the project's entries survive by their categories, `buildProjectTypesExtras` derives\n * the project's `Category` and `Domain` unions from them, and the config half's writer\n * reads the seated singleton directly. A skill only this project's catalogue carries used\n * to resolve to nothing in all three.\n */\nasync function propagateToProject(\n  projectPath: string,\n  provider: Provider,\n  globalConfig: ProjectConfig,\n  agents: Partial<Record<AgentName, AgentDefinition>>,\n  options: PropagationOptions,\n): Promise<boolean> {\n  // Before the catalogue: its load reads this config too, and refuses it in words no caller can\n  // tell from any other failure, where this raises a ConfigLoadError.\n  const existingProject = await loadInstalledConfig(projectPath);\n  if (!existingProject?.config) return false;\n\n  return withCatalogueSeatedFor(projectPath, async (catalogue) => {\n    const projectSplit = reconcileAgainstGlobal(existingProject.config, globalConfig, catalogue);\n\n    await writeProjectConfigPair(\n      projectPath,\n      provider,\n      projectSplit,\n      globalConfig,\n      catalogue,\n      agents,\n      { regenerateTypes: options.regenerateTypes ?? true },\n    );\n    return true;\n  });\n}\n\n/**\n * Propagates global config changes to all registered project configs.\n * Updates each project's config-types.ts (type unions) and config.ts (inlined global data).\n * Skips stale project paths, the current project being installed, and any registered project\n * that belongs to a DIFFERENT provider's installation.\n *\n * There is deliberately NO catalogue parameter. Each project's own is loaded per project by\n * {@link propagateToProject}, and a parameter beside that could only ever be the wrong one —\n * which is what every caller used to pass. A project whose catalogue cannot be loaded lands\n * in `failed` through the same catch as any other failure: leaving it stale is recoverable\n * by a run from inside it, where rewriting its types from another installation's catalogue\n * is the fight this exists to end.\n */\nexport async function propagateGlobalChangesToProjects(\n  globalConfig: ProjectConfig,\n  agents: Partial<Record<AgentName, AgentDefinition>>,\n  provider: Provider,\n  currentProjectDir?: string,\n  options: PropagationOptions = {},\n): Promise<PropagationResult> {\n  const projects = globalConfig.projects ?? [];\n  const result: PropagationResult = {\n    updated: [],\n    unreadable: [],\n    gone: [],\n    notOurs: [],\n    failed: [],\n  };\n  if (projects.length === 0) return result;\n\n  const currentNormalized = currentProjectDir ? normalizeProjectPath(currentProjectDir) : null;\n\n  // One project at a time, never `Promise.all`: each propagation seats its project's catalogue\n  // in the module-wide matrix singleton and restores the previous one after, so two in flight\n  // would render against each other's.\n  for (const projectPath of projects) {\n    // Skip the project currently being installed (it's already being written)\n    if (currentNormalized && projectPath === currentNormalized) continue;\n\n    const outcome = await propagateToRegisteredProject(\n      projectPath,\n      provider,\n      globalConfig,\n      agents,\n      options,\n    );\n    result[outcome].push(projectPath);\n  }\n\n  return result;\n}\n\n/**\n * Brings one registered project's pair up to date with the global config, or leaves it alone and\n * answers why: nothing installed there any more, another provider's installation, a config that is\n * there and cannot be loaded, or a propagation that threw — loading its catalogue as much as\n * writing its pair. None of them stops the fan-out.\n *\n * Whether anything is installed there is asked first, of every provider, because the provider\n * policy cannot answer it: the layout reads a folder holding nothing as the provider a NEW\n * installation is made under, so to a global on the other provider a deleted project reads as\n * another provider's.\n */\nasync function propagateToRegisteredProject(\n  projectPath: string,\n  provider: Provider,\n  globalConfig: ProjectConfig,\n  agents: Partial<Record<AgentName, AgentDefinition>>,\n  options: PropagationOptions,\n): Promise<keyof PropagationResult> {\n  if (!(await holdsAnInstallation(projectPath))) {\n    verbose(`Skipped propagation to ${projectPath} (nothing installed there)`);\n    return \"gone\";\n  }\n\n  const notOurs = await whyThisProjectIsNotOurs(projectPath, provider);\n  if (notOurs !== null) {\n    verbose(`Skipped propagation to ${projectPath} (${notOurs})`);\n    return \"notOurs\";\n  }\n\n  try {\n    if (!(await propagateToProject(projectPath, provider, globalConfig, agents, options))) {\n      return \"gone\";\n    }\n    verbose(`Propagated global changes to ${projectPath}`);\n    return \"updated\";\n  } catch (error) {\n    verbose(`Failed to propagate to ${projectPath}: ${getErrorMessage(error)}`);\n    return error instanceof ConfigLoadError ? \"unreadable\" : \"failed\";\n  }\n}\n\n/** Whether any provider's installation is at `projectPath`, this fan-out's or another's. */\nasync function holdsAnInstallation(projectPath: string): Promise<boolean> {\n  const configs = await Promise.all(\n    PROVIDERS.map((installed) => fileExists(getProjectConfigPath(projectPath, installed))),\n  );\n  return configs.includes(true);\n}\n\n/**\n * Why a registered project that holds an installation is not this fan-out's to rewrite, or `null`\n * when it is.\n *\n * A global installation fans out only within its own provider family: `projects[]` is a list of\n * directories with nothing in it saying which installation each belongs to, so a project on the\n * other provider is a different installation that happens to be registered here, and rewriting\n * its pair from this global's data is the cross-installation write the folders exist to prevent.\n * A root the layout reads as this provider's while it holds no config of this provider's — a run\n * whose `--provider` named it — holds only the other provider's, so it is not ours either.\n *\n * **A refusal is a reason to skip, never a reason to abort the fan-out.** `providerInUse` refuses\n * a root whose installation this release has no host for, and a registered project it cannot act\n * on is one to leave alone — exactly as a project on the other provider is. The refusal's own\n * sentence becomes the reason, so the folder that produced it reaches the verbose log rather than\n * being replaced by a summary of it.\n */\nasync function whyThisProjectIsNotOurs(\n  projectPath: string,\n  provider: Provider,\n): Promise<string | null> {\n  const notOurs = `not a ${provider} installation`;\n  try {\n    if (providerInUse(projectPath) !== provider) return notOurs;\n  } catch (error) {\n    return getErrorMessage(error);\n  }\n  return (await fileExists(getProjectConfigPath(projectPath, provider))) ? null : notOurs;\n}\n\n/**\n * Prunes CLI-inlined global-scoped entries from every registered project after a\n * GLOBAL uninstall. Reuses {@link propagateGlobalChangesToProjects} with an\n * emptied global config so every global skill/agent reads as removed: project-\n * scoped entries are retained verbatim, inlined global rows and tombstones are\n * dropped, per-agent stack refs lose their global-only ids, and each project's\n * config-types.ts is regenerated.\n *\n * Call AFTER the global config manifest has been removed so the regenerated\n * project types fall back to the standalone form instead of importing from the\n * now-deleted global config-types.ts. Unreachable project dirs are reported by why,\n * never thrown.\n *\n * The per-project catalogue seat comes with the reuse, and this is the case that needs it\n * most: the standalone form these projects fall back to declares its unions from the\n * catalogue outright rather than extending an imported one, so a project's own skills are\n * the ONLY thing keeping their categories in the file. Derived from the uninstalling\n * command's catalogue, a global uninstall would take a project's own taxonomy with it.\n */\nexport async function pruneGlobalEntriesFromRegisteredProjects(\n  globalConfig: ProjectConfig,\n  agents: Partial<Record<AgentName, AgentDefinition>>,\n  provider: Provider,\n): Promise<PropagationResult> {\n  const emptiedGlobal: ProjectConfig = {\n    ...globalConfig,\n    skills: [],\n    agents: [],\n  };\n  return propagateGlobalChangesToProjects(emptiedGlobal, agents, provider);\n}\n\n/**\n * Resolves the global config a project install should write, and registers this project's path.\n * `globalDataChanged` gates propagation; `changed` gates the write itself.\n *\n * `authority` is `mergeConfigs`' own word for how much of what it can see the session owns, and\n * it selects between two resolutions: `matchGlobalToSession` below, and `addSessionToGlobal` from\n * `@workspace/compile`. Absent, or `\"owned\"`, keeps the standing additive behaviour.\n */\nexport async function resolveEffectiveGlobalConfig(\n  globalSplit: ProjectConfig,\n  existingGlobalConfig: ProjectConfig | undefined,\n  projectDir: string,\n  authority?: AuthoritativeScope,\n): Promise<{ config: ProjectConfig; globalDataChanged: boolean; changed: boolean }> {\n  const merged =\n    authority === \"all\"\n      ? matchGlobalToSession(globalSplit, existingGlobalConfig)\n      : addSessionToGlobal(globalSplit, existingGlobalConfig, activeMatrix);\n\n  const registration = await registerProjectPath(merged.config, projectDir);\n  return {\n    config: registration.config,\n    globalDataChanged: merged.changed,\n    changed: merged.changed || registration.changed,\n  };\n}\n\n/**\n * The resolution for a session that owns every scope it can see: the global config is made to\n * MATCH it, so a global entry the session left out is REMOVED rather than preserved.\n *\n * One caller reaches this — a confirmed `edit --from` — and it is not acting on its own\n * initiative: it states a whole roster, its plan showed every global removal under its own\n * heading, named every other registered project the removal reaches, and somebody answered yes.\n * Nothing else in the CLI may write the global config from a project, and this does not widen\n * that: the word arrives from the command, not from the shape of the data.\n *\n * `mergeConfigs` is what does it rather than a merge of this module's own, because \"absent from\n * the session means deselected\" is exactly what `authoritativeScope: \"all\"` already means at the\n * home root. It carries the global installation's identity, its stack fallback and its\n * `projects[]` registry across — a session's split says nothing about who the global\n * installation is or which projects read it, and the fan-out walks that registry.\n *\n * An empty session is a real answer here, so there is no `hasGlobalItems` shortcut: a\n * configuration that installs nothing globally removes what was.\n */\nfunction matchGlobalToSession(\n  globalSplit: ProjectConfig,\n  existingGlobalConfig: ProjectConfig | undefined,\n): ResolvedGlobalConfig {\n  if (!existingGlobalConfig) return { config: globalSplit, changed: true };\n\n  const config = mergeConfigs(globalSplit, existingGlobalConfig, { authoritativeScope: \"all\" });\n  return { config, changed: !isDeepEqual(config, existingGlobalConfig) };\n}\n\n/** Category keys the emitted stack holds, across every agent it configures. */\nfunction stackCategories(stack: ProjectConfig[\"stack\"]): Category[] {\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- typedEntries/Object.entries launders the `| undefined` a Partial<Record> admits out of its result type, so this guard reads as dead while still covering an explicitly-undefined slot\n  return Object.values(stack ?? {}).flatMap((agentStack) => typedKeys<Category>(agentStack ?? {}));\n}\n\n/**\n * Derives the extras for regenerateConfigTypes so a project's config-types.ts declares every\n * literal its sibling config.ts holds — the two are written from the same config and must not\n * be able to disagree.\n *\n * ALL active (non-excluded) entries, not just project-scoped ones:\n * generateProjectConfigWithInlinedGlobal writes the active global rows into the project's own\n * config.ts verbatim, and the imported Global* unions cover those rows only for as long as the\n * global config still happens to contain them. A later global-scope run narrows those unions\n * and a project nobody touched stops type-checking (TS2322 on a skill id or domain, TS2353 on a\n * stack's category key).\n *\n * Domains and stack categories are read off the config's own arrays as well as derived from its\n * skill rows: `selectedDomains` is a preference no skill row has to back, and neither it\n * nor a stack entry is pruned when the last skill that would derive it leaves.\n */\nexport function buildProjectTypesExtras(\n  finalConfig: ProjectConfig,\n  matrix: MergedSkillsMatrix,\n): Required<ConfigTypesExtras> {\n  const activeSkills = finalConfig.skills.filter((s) => !s.excluded);\n  const activeAgents = finalConfig.agents.filter((a) => !a.excluded);\n\n  const extraSkillIds = unique(activeSkills.map((s) => s.id));\n  const extraAgentNames = unique(activeAgents.map((a) => a.name));\n\n  const extraCategories = unique([\n    ...deriveCategories(extraSkillIds, matrix),\n    ...stackCategories(finalConfig.stack),\n  ]);\n  const extraDomains = unique([\n    ...deriveDomains(extraCategories, matrix),\n    ...(finalConfig.selectedDomains ?? []),\n  ]);\n\n  return { extraSkillIds, extraAgentNames, extraDomains, extraCategories };\n}\n","import { isDeepEqual } from \"remeda\"\n\nimport { skillDomain, type CompileCatalog } from \"./catalog.js\"\nimport { GLOBAL_CONFIG_NAME } from \"./paths.js\"\nimport { typedEntries } from \"./typed-object.js\"\nimport type {\n  AgentName,\n  Category,\n  ProjectConfig,\n  SkillAssignment,\n  StackAgentConfig,\n} from \"./types.js\"\n\n/**\n * THE GLOBAL CONFIG A PROJECT INSTALL WRITES.\n *\n * Run from a project directory, `init` never writes the session's global half\n * as it stands: it merges that half into the global config already on disk,\n * which on a clean machine is the blank pair `ensureBlankPair` has just\n * written. The CLI's `config-gate/propagate.ts` resolves the file it writes\n * through {@link addSessionToGlobal}, and the editor's output preview resolves\n * the file it draws through the same call over {@link blankGlobalConfig} — so\n * the fields this merge carries across are the fields the drawn global\n * `config.ts` holds, and a second copy would be a second answer to what that\n * file says.\n */\n\n/**\n * The configuration the CLI's blank global `config.ts` template\n * (`generateBlankGlobalConfigSource`) holds, as a loader reads it back.\n *\n * What a project install on a machine with nothing installed merges its global\n * half into. The editor's output preview has no file to read, so it starts from\n * this; the CLI's `project-config.test.ts` loads the template and holds it\n * against this, which is what keeps the two one claim.\n */\nexport function blankGlobalConfig(): ProjectConfig {\n  return {\n    name: GLOBAL_CONFIG_NAME,\n    skills: [],\n    agents: [],\n    selectedDomains: [],\n  }\n}\n\n/**\n * Deep-additive stack merge: appends any (agent, category, skill) triple present in\n * `incoming` but missing in `existing`. Never removes or overwrites existing entries\n * (including their `preloaded` flags). Returns a fresh stack object — inputs are not\n * mutated. `changed` is true iff at least one new agent, category, or skill assignment\n * was appended.\n */\nfunction additiveMergeStack(\n  existing: Partial<Record<AgentName, StackAgentConfig>> | undefined,\n  incoming: Partial<Record<AgentName, StackAgentConfig>> | undefined\n): { stack: Partial<Record<AgentName, StackAgentConfig>>; changed: boolean } {\n  const merged: Partial<Record<AgentName, StackAgentConfig>> = existing\n    ? structuredClone(existing)\n    : {}\n  if (!incoming) return { stack: merged, changed: false }\n\n  let changed = false\n  for (const [agentName, incomingAgentStack] of typedEntries<\n    AgentName,\n    StackAgentConfig\n  >(incoming)) {\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- typedEntries/Object.entries launders the `| undefined` a Partial<Record> admits out of its result type, so this guard reads as dead while still covering an explicitly-undefined slot\n    if (!incomingAgentStack) continue\n\n    const existingAgentStack = merged[agentName]\n    if (!existingAgentStack) {\n      merged[agentName] = structuredClone(incomingAgentStack)\n      changed = true\n      continue\n    }\n\n    if (mergeAgentCategories(existingAgentStack, incomingAgentStack)) {\n      changed = true\n    }\n  }\n\n  return { stack: merged, changed }\n}\n\n/**\n * Mutates `existingAgentStack` in place by appending any category or skill assignment\n * from `incomingAgentStack` that is not already present. Returns true if anything was\n * appended. Caller must pass a cloned `existingAgentStack` — this function is only\n * called on the merged copy, never on the original input.\n */\nfunction mergeAgentCategories(\n  existingAgentStack: StackAgentConfig,\n  incomingAgentStack: StackAgentConfig\n): boolean {\n  let changed = false\n  for (const [category, incomingAssignments] of typedEntries<\n    Category,\n    SkillAssignment[]\n  >(incomingAgentStack)) {\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- typedEntries/Object.entries launders the `| undefined` a Partial<Record> admits out of its result type, so this guard reads as dead while still covering an explicitly-undefined slot\n    if (!incomingAssignments) continue\n\n    const existingAssignments = existingAgentStack[category]\n    if (!existingAssignments) {\n      existingAgentStack[category] = incomingAssignments.map((a) => ({ ...a }))\n      changed = true\n      continue\n    }\n\n    if (appendMissingAssignments(existingAssignments, incomingAssignments)) {\n      changed = true\n    }\n  }\n  return changed\n}\n\n/**\n * Mutates `existingAssignments` in place by appending a copy of each incoming assignment whose id\n * it does not already hold — an id repeated within `incomingAssignments` is appended once. Returns\n * true if anything was appended. Called on the merged copy only, like\n * {@link mergeAgentCategories}.\n */\nfunction appendMissingAssignments(\n  existingAssignments: SkillAssignment[],\n  incomingAssignments: SkillAssignment[]\n): boolean {\n  const existingIds = new Set(existingAssignments.map((a) => a.id))\n  let changed = false\n  for (const assignment of incomingAssignments) {\n    if (existingIds.has(assignment.id)) continue\n    existingAssignments.push({ ...assignment })\n    existingIds.add(assignment.id)\n    changed = true\n  }\n  return changed\n}\n\n/**\n * Merges new global-scoped items into an existing global config.\n * Adds skills/agents that don't already exist. Never removes existing items.\n *\n * The CLI's unit tests for it are the `mergeGlobalConfigs` describe block in\n * `local-installer.test.ts`, which reach it through `config-gate/propagate.ts`.\n */\nexport function mergeGlobalConfigs(\n  existing: ProjectConfig,\n  incoming: ProjectConfig\n): { config: ProjectConfig; changed: boolean } {\n  const existingSkillIds = new Set(existing.skills.map((s) => s.id))\n  const existingAgentNames = new Set(existing.agents.map((a) => a.name))\n\n  const incomingActiveSkills = incoming.skills.filter((s) => !s.excluded)\n  const incomingActiveAgents = incoming.agents.filter((a) => !a.excluded)\n  const newSkills = incomingActiveSkills.filter(\n    (s) => !existingSkillIds.has(s.id)\n  )\n  const newAgents = incomingActiveAgents.filter(\n    (a) => !existingAgentNames.has(a.name)\n  )\n\n  const mergedSkills = [...existing.skills, ...newSkills]\n  const mergedAgents = [...existing.agents, ...newAgents]\n\n  // Per-agent stack merge policy: deep-additive. Project-context edits must NEVER remove\n  // or overwrite global state; individual projects express their local view via tombstones\n  // in the PROJECT config, not by rewriting the GLOBAL config (see commit 403df46:\n  // \"never modify global config from project-level operations\").\n  //\n  // Merge rule per triple (agent, category, skill):\n  //   - agent absent in existing    -> add from incoming\n  //   - category absent in existing -> add from incoming\n  //   - skill id absent in existing -> append from incoming\n  //   - everything already present  -> keep existing as-is (including its preloaded flag)\n  // Anything present only in `existing` is left untouched.\n  const { stack: mergedStack, changed: stackChanged } = additiveMergeStack(\n    existing.stack,\n    incoming.stack\n  )\n\n  // Merge selected domains (union, no duplicates)\n  const mergedSelectedDomains = [\n    ...new Set([\n      ...(existing.selectedDomains ?? []),\n      ...(incoming.selectedDomains ?? []),\n    ]),\n  ]\n\n  // Marketplace identity (`marketplace`, `marketplaceName`) travels on the global partition of\n  // `splitConfigByScope` but was previously lost here, leaving the global config with no\n  // record of where its plugins came from. `uninstall` reads `config.marketplaceName` to build\n  // the `<id>@<marketplace name>` registry key (getCliInstalledPluginKeys) — without it a global\n  // uninstall silently owns nothing and leaves registered plugins behind.\n  //\n  // Precedence is FILL-ONLY: existing wins, incoming is used solely when the global config\n  // has no value yet. Both fields are scalar but the merged config is multi-marketplace by\n  // construction — this merge never removes skills, so after a second project init from a\n  // different marketplace the skills array holds plugins from BOTH, and whichever label is\n  // recorded orphans the other's registry key. Repointing is therefore never a strict\n  // improvement, and doing it from a project context would silently rewrite global state on\n  // behalf of every other registered project (commit 403df46). This also matches\n  // `mergeConfigs`, which preserves `existingConfig.marketplaceName` on the home-root install\n  // path. Changing global marketplace identity stays an explicit global-scope operation\n  // (`init` run from ~), which writes the global config directly and bypasses this merge.\n  const addsEntries = newSkills.length > 0 || newAgents.length > 0\n\n  // No term for the marketplace identity: it is filled only alongside an added entry, and\n  // `addsEntries` already marks the merge dirty — which is what `writeGlobalPairWhenChanged` (the\n  // CLI's lib/config-gate/index.ts) tests before writing, so the fill is never dropped unwritten.\n  const changed =\n    addsEntries ||\n    stackChanged ||\n    !isDeepEqual(existing.selectedDomains ?? [], mergedSelectedDomains)\n\n  return {\n    config: {\n      ...existing,\n      skills: mergedSkills,\n      agents: mergedAgents,\n      stack: mergedStack,\n      selectedDomains: mergedSelectedDomains,\n      ...marketplaceIdentityFilledFrom(existing, addsEntries ? incoming : null),\n    },\n    changed,\n  }\n}\n\n/**\n * The marketplace identity the global config records after a merge: its own, with each field it\n * lacks filled from `arriving` — and `arriving` is `null` unless the merge ADDS an entry.\n *\n * The entries are what came from that marketplace. A project session inlines every global entry\n * it holds, so the incoming half names the project's marketplace even when each of those entries\n * is the global install's own; filling from it then would name, in the one config every project\n * inherits, a catalogue none of its entries came from.\n */\nfunction marketplaceIdentityFilledFrom(\n  existing: ProjectConfig,\n  arriving: ProjectConfig | null\n): Pick<ProjectConfig, \"marketplace\" | \"marketplaceName\"> {\n  const marketplaceName = existing.marketplaceName ?? arriving?.marketplaceName\n  const marketplace = existing.marketplace ?? arriving?.marketplace\n  return {\n    ...(marketplaceName !== undefined && { marketplaceName }),\n    ...(marketplace !== undefined && { marketplace }),\n  }\n}\n\n/** What one resolution decided: the config to commit, and whether the global data changed. */\nexport type ResolvedGlobalConfig = { config: ProjectConfig; changed: boolean }\n\n/**\n * The standing resolution, and the one every caller but `edit --from` gets: the session's global\n * items are ADDED and nothing is taken away.\n *\n * A project install has asked nobody about the machine, so it may not decide for it (commit\n * 403df46, \"never modify global config from project-level operations\"). The `hasGlobalItems`\n * shortcut is part of that: a session carrying nothing global is not a statement that the global\n * install should be empty. So is {@link withTheDomainsItAdds}: a domain the session picked for the\n * project alone is not one the global install takes on.\n */\nexport function addSessionToGlobal(\n  globalSplit: ProjectConfig,\n  existingGlobalConfig: ProjectConfig | undefined,\n  catalog: CompileCatalog\n): ResolvedGlobalConfig {\n  const hasGlobalItems =\n    globalSplit.skills.length > 0 || globalSplit.agents.length > 0\n  if (!hasGlobalItems) {\n    return {\n      config: existingGlobalConfig ?? {\n        name: GLOBAL_CONFIG_NAME,\n        skills: [],\n        agents: [],\n      },\n      changed: false,\n    }\n  }\n\n  const arriving = withTheDomainsItAdds(\n    globalSplit,\n    existingGlobalConfig,\n    catalog\n  )\n  if (!existingGlobalConfig) return { config: arriving, changed: true }\n  return mergeGlobalConfigs(existingGlobalConfig, arriving)\n}\n\n/**\n * The session's global half, with its domains narrowed to those a global skill it ADDS comes from.\n *\n * A split hands its global half the session's whole domain selection, the project's own picks\n * included, because a domain selection belongs to the config it is written in. Merged into the\n * global install as it stands, a project that picked an API skill for itself would widen the\n * domains every project inherits — and rewrite the global config while adding nothing to it.\n */\nfunction withTheDomainsItAdds(\n  globalSplit: ProjectConfig,\n  existingGlobalConfig: ProjectConfig | undefined,\n  catalog: CompileCatalog\n): ProjectConfig {\n  const installed = new Set(\n    existingGlobalConfig?.skills.map((skill) => skill.id)\n  )\n  const arrivingDomains = new Set(\n    globalSplit.skills\n      .filter((skill) => !skill.excluded && !installed.has(skill.id))\n      .map((skill) => skillDomain(catalog, skill.id))\n  )\n  return {\n    ...globalSplit,\n    selectedDomains: (globalSplit.selectedDomains ?? []).filter((domain) =>\n      arrivingDomains.has(domain)\n    ),\n  }\n}\n","import type { PropagatedRecompileSummary } from \"../operations/project/recompile-project-agents.js\";\n\n/** The summary of a fan-out that recompiled nothing, so callers render one shape. */\nexport const NOTHING_RECOMPILED: PropagatedRecompileSummary = {\n  rewrittenCount: 0,\n  unchangedCount: 0,\n  failedCount: 0,\n  warnings: [],\n};\n\n/**\n * Recompiles the agents of every project a global write propagated into.\n *\n * Imported lazily: `recompile-project-agents` lives in the operations layer,\n * which imports back into `installation`, so a static import here would form a\n * load-time cycle.\n * Per-project failure isolation lives in `recompilePropagatedProjectAgents` and\n * is unchanged by running it from inside the write.\n */\nexport async function recompilePropagated(\n  projectDirs: string[],\n): Promise<PropagatedRecompileSummary> {\n  if (projectDirs.length === 0) return NOTHING_RECOMPILED;\n\n  const { recompilePropagatedProjectAgents } =\n    await import(\"../operations/project/recompile-project-agents.js\");\n  return recompilePropagatedProjectAgents(projectDirs);\n}\n","import path from \"path\";\nimport {\n  buildAndMergeConfig,\n  resolveInstallPaths,\n  isHomeDirectory,\n} from \"../../installation/index.js\";\nimport type { SourceLoadResult } from \"../../loading/index.js\";\nimport type { AuthoritativeScope } from \"../../configuration/index.js\";\nimport { ensureBlankPair, writeConfigByScope, type GateReport } from \"../../config-gate/index.js\";\nimport { providerInUse } from \"../../installation/install-layout.js\";\nimport { loadAgentDefs, type AgentDefs } from \"./load-agent-defs.js\";\nimport { ensureDir } from \"../../../utils/fs.js\";\nimport type { ProjectConfig } from \"../../../types/index.js\";\nimport type { InstallSelection } from \"@workspace/compile/seed-to-config\";\n\nexport type ConfigWriteOptions = {\n  selection: InstallSelection;\n  sourceResult: SourceLoadResult;\n  projectDir: string;\n  sourceFlag?: string;\n  /**\n   * What {@link loadAgentDefs} answered, for a caller that has already asked it. Omitted, this\n   * function asks for itself.\n   *\n   * It takes the WHOLE value rather than the roster inside it, so the only thing a caller can\n   * hand over is what that one function produced. This used to be a bare\n   * `Partial<Record<AgentName, AgentDefinition>>` — any map at all — which made \"a roster\n   * different from the one the CLI would load\" a representable argument, and this function emits\n   * the `AgentName` / `SelectedAgentName` unions from whatever it is given. Deleting the option\n   * instead would cost `edit` a second uncached walk-and-parse of `src/agents/` per run, since\n   * it needs `sourcePath` off the same value for its compile pass — one fact loaded twice, where\n   * the second load is the one that can disagree.\n   */\n  agentDefs?: AgentDefs;\n  /**\n   * Authority of `cc edit`'s newConfig over absent entries:\n   * `\"all\"` (global edit) drops any deselected entry, `\"owned\"` (project edit) drops deselected\n   * project-owned entries only, `undefined` (init) keeps additive union-preserve.\n   */\n  authoritativeScope?: AuthoritativeScope;\n};\n\nexport type ConfigWriteResult = {\n  config: ProjectConfig;\n  configPath: string;\n  wasMerged: boolean;\n  existingConfigPath?: string;\n  /**\n   * What the gated write did: what moved in the global config, which registered\n   * projects it fanned out to, and the recompile it drove in them. The caller\n   * renders it; the work is already done.\n   */\n  propagation: GateReport;\n};\n\n/**\n * Builds, merges, and writes project configuration files.\n *\n * Handles the full config pipeline:\n * 1. buildAndMergeConfig() — generates config from the selection, merges with existing\n * 2. loadAgentDefs() — the CLI's own sub-agent definitions, for config-types generation\n * 3. ensureBlankPair() — ensures the global config pair exists (when in project context)\n * 4. writeConfigByScope() — writes config.ts and config-types.ts split by scope,\n *    fans global changes out to registered projects and recompiles their agents\n */\nexport async function writeProjectConfig(options: ConfigWriteOptions): Promise<ConfigWriteResult> {\n  const { selection, sourceResult, projectDir, sourceFlag } = options;\n  const projectPaths = resolveInstallPaths(projectDir, \"project\");\n\n  await ensureDir(path.dirname(projectPaths.configPath));\n\n  // The marketplace is deliberately NOT consulted for this roster. It names the sub-agents the\n  // emitted unions declare, and a marketplace-defined name in `AgentName` is one no compile pass\n  // can honour: agent partials resolve through `getLocalAgentDefinitions`, which answers the\n  // CLI's own root, and the generated `AGENT_NAMES` is built from that same directory. Reading\n  // `sourceResult.sourcePath` here is what made `init` and `edit` emit two different files from\n  // one config (owner ruling 2026-08-21).\n  const { agents } = options.agentDefs ?? (await loadAgentDefs());\n\n  const mergeResult = await buildAndMergeConfig(\n    selection,\n    sourceResult,\n    projectDir,\n    sourceFlag,\n    options.authoritativeScope,\n  );\n  const finalConfig = mergeResult.config;\n\n  const isProjectContext = !isHomeDirectory(projectDir);\n\n  if (isProjectContext) {\n    // The blank global pair belongs to the installation THIS project is on: a project\n    // inherits only from the global of its own provider, so creating the other provider's\n    // pair would leave the one it actually reads absent.\n    await ensureBlankPair(providerInUse(projectDir));\n  }\n\n  const propagation = await writeConfigByScope({\n    finalConfig,\n    matrix: sourceResult.matrix,\n    agents,\n    projectDir,\n    projectConfigPath: projectPaths.configPath,\n    projectInstallationExists: isProjectContext,\n    // The same word the merger above took. It decides the config ROW there and the GLOBAL\n    // config a project write commits here, and the two files disagree the moment it does not\n    // reach both: a row preserved for a skill whose directory the removal diff deleted.\n    ...(options.authoritativeScope !== undefined && {\n      authoritativeScope: options.authoritativeScope,\n    }),\n  });\n\n  return {\n    config: finalConfig,\n    configPath: projectPaths.configPath,\n    wasMerged: mergeResult.merged,\n    ...(mergeResult.existingConfigPath !== undefined && {\n      existingConfigPath: mergeResult.existingConfigPath,\n    }),\n    propagation,\n  };\n}\n","import os from \"os\";\nimport { compileAgents, type CompilationResult } from \"./compile-agents.js\";\nimport { isHomeDirectory, resolveInstallPaths } from \"../../installation/index.js\";\nimport type { AgentName, SkillDefinitionMap, SkillScope } from \"../../../types/index.js\";\n\nexport type CompileAllScopesOptions = {\n  /** Working directory of the command — a project root, or home for global context. */\n  projectDir: string;\n  sourcePath: string;\n  skills: SkillDefinitionMap;\n  agentScopeMap: Map<AgentName, SkillScope>;\n};\n\n/**\n * Compiles agents for every scope the current context owns.\n *\n * Home context: a single pass writing to the home agents directory.\n * Project context: a global pass (from home) then a project pass, each\n * filtered to its own scope so the project pass cannot overwrite global\n * agents with zero-skill versions. Results merge in pass order.\n */\nexport async function compileAgentsAllScopes(\n  options: CompileAllScopesOptions,\n): Promise<CompilationResult> {\n  const { projectDir, sourcePath, skills, agentScopeMap } = options;\n  const base = { sourcePath, skills, agentScopeMap };\n\n  if (isHomeDirectory(projectDir)) {\n    return compileAgents({\n      ...base,\n      projectDir,\n      outputDir: resolveInstallPaths(projectDir, \"project\").agentsDir,\n    });\n  }\n\n  const globalResult = await compileAgents({\n    ...base,\n    projectDir: os.homedir(),\n    outputDir: resolveInstallPaths(os.homedir(), \"global\").agentsDir,\n    scopeFilter: \"global\",\n  });\n  const projectResult = await compileProjectScope(options);\n  return mergeCompilationResults(globalResult, projectResult);\n}\n\n/**\n * The project pass alone, filtered to the project's own scope — what a project run compiles when\n * it leaves the global install exactly as installed, so its global pass would have nothing to\n * write but the drift it was never asked to repair.\n */\nexport async function compileProjectScope(\n  options: CompileAllScopesOptions,\n): Promise<CompilationResult> {\n  const { projectDir, sourcePath, skills, agentScopeMap } = options;\n  return compileAgents({\n    sourcePath,\n    skills,\n    agentScopeMap,\n    projectDir,\n    outputDir: resolveInstallPaths(projectDir, \"project\").agentsDir,\n    scopeFilter: \"project\",\n  });\n}\n\nfunction mergeCompilationResults(...results: CompilationResult[]): CompilationResult {\n  return {\n    compiled: results.flatMap((r) => r.compiled),\n    rewritten: results.flatMap((r) => r.rewritten),\n    failed: results.flatMap((r) => r.failed),\n    warnings: results.flatMap((r) => r.warnings),\n  };\n}\n"],"mappings":"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","names":["os","path","matrix","matrix","isDeepEqual","isDeepEqual","typedEntries","isDeepEqual","matrix","isDeepEqual","recompilePropagatedProjectAgents","loadSkillsMatrixFromSource","matrix","loadAgentDefs","os","path","ensureBlankPair","path","path","ensureBlankPair","os","os"]}

package/dist/{chunk-3LZNY46H.js → chunk-BMRUNMPV.js}

@@ -29,12 +29,12 @@ import {
   sourceFolderName,
   verbose,
   writeFile
-} from "./chunk-C2UISKIM.js";
+} from "./chunk-MQ6CGZNJ.js";
 import {
   typedEntries,
   typedFromEntries,
   typedKeys
-} from "./chunk-NU2K5G54.js";
+} from "./chunk-52HDHJ7I.js";
 import {
   CLAUDE_DIR,
   DIRS,
@@ -42,7 +42,7 @@ import {
   STANDARD_DIRS,
   STANDARD_FILES,
   effectivelyExcludedSkillIds
-} from "./chunk-AG3ZVM3B.js";
+} from "./chunk-PJWGTNOX.js";
 
 // src/cli/lib/agents/list-compiled-agents.ts
 import path from "path";
@@ -372,4 +372,4 @@ export {
   withoutExcludedAssignments,
   recompileAgents
 };
-//# sourceMappingURL=chunk-3LZNY46H.js.map
+//# sourceMappingURL=chunk-BMRUNMPV.js.map

package/dist/{chunk-VVRI35SK.js → chunk-CLPUWOSA.js}

@@ -4,11 +4,11 @@ import {
   getErrorMessage,
   hostAt,
   isLocalOnlySkill
-} from "./chunk-C2UISKIM.js";
+} from "./chunk-MQ6CGZNJ.js";
 import {
   CLI_INVOKE_COMMAND,
   EJECT_SOURCE
-} from "./chunk-AG3ZVM3B.js";
+} from "./chunk-PJWGTNOX.js";
 
 // src/cli/lib/operations/skills/install-plugin-skills.ts
 function pluginInstallFailureError(failedCount) {
@@ -18,7 +18,7 @@ function unbackedPluginSkillIds(skills, matrix) {
   return skills.filter((skill) => skill.origin !== EJECT_SOURCE).filter((skill) => isLocalOnlySkill(matrix.skills[skill.id])).map((skill) => skill.id);
 }
 function unbackedPluginInstallError(ids) {
-  return `Cannot install ${ids.length} skill(s) as plugins \u2014 no marketplace carries them: ${ids.join(", ")}. A skill that exists only in this project can only be installed as a local copy. Set it to Local on the Sources step, or publish it to a marketplace first.`;
+  return `Cannot install ${ids.length} skill(s) as plugins \u2014 no marketplace carries them: ${ids.join(", ")}. A skill that exists only in this project can only be installed as a local copy. Set its Install mode to eject in the editor, or publish it to a marketplace first.`;
 }
 async function installPluginSkills(skills, marketplace, projectDir) {
   const host = hostAt(projectDir);
@@ -43,4 +43,4 @@ export {
   unbackedPluginInstallError,
   installPluginSkills
 };
-//# sourceMappingURL=chunk-VVRI35SK.js.map
+//# sourceMappingURL=chunk-CLPUWOSA.js.map

package/dist/{chunk-VVRI35SK.js.map → chunk-CLPUWOSA.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/cli/lib/operations/skills/install-plugin-skills.ts"],"sourcesContent":["import { hostAt } from \"../../hosts/host-for.js\";\nimport { isLocalOnlySkill } from \"../../loading/multi-source-loader.js\";\nimport { buildMarketplacePluginRef } from \"../../plugins/index.js\";\nimport { getErrorMessage } from \"../../../utils/errors.js\";\nimport { CLI_INVOKE_COMMAND, EJECT_SOURCE } from \"../../../consts.js\";\nimport type { MergedSkillsMatrix, SkillId } from \"../../../types/index.js\";\nimport type { SkillConfig } from \"../../../types/config.js\";\n\nexport type PluginInstallResult = {\n  installed: Array<{ id: SkillId; ref: string }>;\n  failed: Array<{ id: SkillId; error: string }>;\n};\n\n/**\n * Hard-error message for failed plugin installs. Plugin install intent is\n * inviolable (never fall back to eject) — callers MUST error with this BEFORE\n * config is written, or config.ts gains orphan entries claiming the skill\n * is installed.\n */\nexport function pluginInstallFailureError(failedCount: number): string {\n  return `Failed to install ${failedCount} plugin skill(s). Plugin install intent could not be honored. Verify the skill id matches the marketplace, run '${CLI_INVOKE_COMMAND} update' to refresh the marketplace, or switch affected skills to eject mode.`;\n}\n\n/**\n * Skills asking to be installed as plugins that no marketplace carries.\n *\n * A skill that exists only in this project cannot be pulled from anywhere, so the ask is\n * refusable BEFORE anything is attempted — which is what separates it from an install\n * that was tried and failed. The Sources grid reads {@link isLocalOnlySkill} to decide\n * whether to offer the plugin cell at all, so this guard shares it: a caller reaching\n * past that surface must meet the same rule it did.\n */\nexport function unbackedPluginSkillIds(\n  skills: SkillConfig[],\n  matrix: MergedSkillsMatrix,\n): SkillId[] {\n  return skills\n    .filter((skill) => skill.origin !== EJECT_SOURCE)\n    .filter((skill) => isLocalOnlySkill(matrix.skills[skill.id]))\n    .map((skill) => skill.id);\n}\n\n/**\n * The refusal text for {@link unbackedPluginSkillIds}. Deliberately NOT\n * {@link pluginInstallFailureError}: refreshing a marketplace and checking an id against\n * it are impossible instructions for a skill the user wrote themselves, so the two\n * failures owe different advice.\n */\nexport function unbackedPluginInstallError(ids: SkillId[]): string {\n  return `Cannot install ${ids.length} skill(s) as plugins — no marketplace carries them: ${ids.join(\", \")}. A skill that exists only in this project can only be installed as a local copy. Set it to Local on the Sources step, or publish it to a marketplace first.`;\n}\n\n/**\n * Installs skill plugins through the host this installation belongs to, routing by scope.\n *\n * For each skill, constructs the plugin ref as `{skillId}@{marketplace}` and asks the host to\n * install it at the skill's own scope. The host is read off the folder under `projectDir`,\n * because the folder is the only record of a provider — which is also the limit of it: a run\n * creating a folder that is not there yet must hand the provider down instead (C4).\n */\nexport async function installPluginSkills(\n  skills: SkillConfig[],\n  marketplace: string,\n  projectDir: string,\n): Promise<PluginInstallResult> {\n  const host = hostAt(projectDir);\n  const pluginSkills = skills.filter((s) => s.origin !== EJECT_SOURCE);\n  const installed: PluginInstallResult[\"installed\"] = [];\n  const failed: PluginInstallResult[\"failed\"] = [];\n\n  for (const skill of pluginSkills) {\n    const pluginRef = buildMarketplacePluginRef(skill.id, marketplace);\n    try {\n      await host.installPlugin(pluginRef, skill.scope, projectDir);\n      installed.push({ id: skill.id, ref: pluginRef });\n    } catch (error) {\n      failed.push({ id: skill.id, error: getErrorMessage(error) });\n    }\n  }\n\n  return { installed, failed };\n}\n"],"mappings":";;;;;;;;;;;;;AAmBO,SAAS,0BAA0B,aAA6B;AACrE,SAAO,qBAAqB,WAAW,mHAAmH,kBAAkB;AAC9K;AAWO,SAAS,uBACd,QACA,QACW;AACX,SAAO,OACJ,OAAO,CAAC,UAAU,MAAM,WAAW,YAAY,EAC/C,OAAO,CAAC,UAAU,iBAAiB,OAAO,OAAO,MAAM,EAAE,CAAC,CAAC,EAC3D,IAAI,CAAC,UAAU,MAAM,EAAE;AAC5B;AAQO,SAAS,2BAA2B,KAAwB;AACjE,SAAO,kBAAkB,IAAI,MAAM,4DAAuD,IAAI,KAAK,IAAI,CAAC;AAC1G;AAUA,eAAsB,oBACpB,QACA,aACA,YAC8B;AAC9B,QAAM,OAAO,OAAO,UAAU;AAC9B,QAAM,eAAe,OAAO,OAAO,CAAC,MAAM,EAAE,WAAW,YAAY;AACnE,QAAM,YAA8C,CAAC;AACrD,QAAM,SAAwC,CAAC;AAE/C,aAAW,SAAS,cAAc;AAChC,UAAM,YAAY,0BAA0B,MAAM,IAAI,WAAW;AACjE,QAAI;AACF,YAAM,KAAK,cAAc,WAAW,MAAM,OAAO,UAAU;AAC3D,gBAAU,KAAK,EAAE,IAAI,MAAM,IAAI,KAAK,UAAU,CAAC;AAAA,IACjD,SAAS,OAAO;AACd,aAAO,KAAK,EAAE,IAAI,MAAM,IAAI,OAAO,gBAAgB,KAAK,EAAE,CAAC;AAAA,IAC7D;AAAA,EACF;AAEA,SAAO,EAAE,WAAW,OAAO;AAC7B;","names":[]}
+{"version":3,"sources":["../src/cli/lib/operations/skills/install-plugin-skills.ts"],"sourcesContent":["import { hostAt } from \"../../hosts/host-for.js\";\nimport { isLocalOnlySkill } from \"../../loading/multi-source-loader.js\";\nimport { buildMarketplacePluginRef } from \"../../plugins/index.js\";\nimport { getErrorMessage } from \"../../../utils/errors.js\";\nimport { CLI_INVOKE_COMMAND, EJECT_SOURCE } from \"../../../consts.js\";\nimport type { MergedSkillsMatrix, SkillId } from \"../../../types/index.js\";\nimport type { SkillConfig } from \"../../../types/config.js\";\n\nexport type PluginInstallResult = {\n  installed: Array<{ id: SkillId; ref: string }>;\n  failed: Array<{ id: SkillId; error: string }>;\n};\n\n/**\n * Hard-error message for failed plugin installs. Plugin install intent is\n * inviolable (never fall back to eject) — callers MUST error with this BEFORE\n * config is written, or config.ts gains orphan entries claiming the skill\n * is installed.\n */\nexport function pluginInstallFailureError(failedCount: number): string {\n  return `Failed to install ${failedCount} plugin skill(s). Plugin install intent could not be honored. Verify the skill id matches the marketplace, run '${CLI_INVOKE_COMMAND} update' to refresh the marketplace, or switch affected skills to eject mode.`;\n}\n\n/**\n * Skills asking to be installed as plugins that no marketplace carries.\n *\n * A skill that exists only in this project cannot be pulled from anywhere, so the ask is\n * refusable BEFORE anything is attempted — which is what separates it from an install\n * that was tried and failed.\n */\nexport function unbackedPluginSkillIds(\n  skills: SkillConfig[],\n  matrix: MergedSkillsMatrix,\n): SkillId[] {\n  return skills\n    .filter((skill) => skill.origin !== EJECT_SOURCE)\n    .filter((skill) => isLocalOnlySkill(matrix.skills[skill.id]))\n    .map((skill) => skill.id);\n}\n\n/**\n * The refusal text for {@link unbackedPluginSkillIds}. Deliberately NOT\n * {@link pluginInstallFailureError}: refreshing a marketplace and checking an id against\n * it are impossible instructions for a skill the user wrote themselves, so the two\n * failures owe different advice.\n */\nexport function unbackedPluginInstallError(ids: SkillId[]): string {\n  return `Cannot install ${ids.length} skill(s) as plugins — no marketplace carries them: ${ids.join(\", \")}. A skill that exists only in this project can only be installed as a local copy. Set its Install mode to eject in the editor, or publish it to a marketplace first.`;\n}\n\n/**\n * Installs skill plugins through the host this installation belongs to, routing by scope.\n *\n * For each skill, constructs the plugin ref as `{skillId}@{marketplace}` and asks the host to\n * install it at the skill's own scope. The host is read off the folder under `projectDir`,\n * because the folder is the only record of a provider — which is also the limit of it: a run\n * creating a folder that is not there yet must hand the provider down instead (C4).\n */\nexport async function installPluginSkills(\n  skills: SkillConfig[],\n  marketplace: string,\n  projectDir: string,\n): Promise<PluginInstallResult> {\n  const host = hostAt(projectDir);\n  const pluginSkills = skills.filter((s) => s.origin !== EJECT_SOURCE);\n  const installed: PluginInstallResult[\"installed\"] = [];\n  const failed: PluginInstallResult[\"failed\"] = [];\n\n  for (const skill of pluginSkills) {\n    const pluginRef = buildMarketplacePluginRef(skill.id, marketplace);\n    try {\n      await host.installPlugin(pluginRef, skill.scope, projectDir);\n      installed.push({ id: skill.id, ref: pluginRef });\n    } catch (error) {\n      failed.push({ id: skill.id, error: getErrorMessage(error) });\n    }\n  }\n\n  return { installed, failed };\n}\n"],"mappings":";;;;;;;;;;;;;AAmBO,SAAS,0BAA0B,aAA6B;AACrE,SAAO,qBAAqB,WAAW,mHAAmH,kBAAkB;AAC9K;AASO,SAAS,uBACd,QACA,QACW;AACX,SAAO,OACJ,OAAO,CAAC,UAAU,MAAM,WAAW,YAAY,EAC/C,OAAO,CAAC,UAAU,iBAAiB,OAAO,OAAO,MAAM,EAAE,CAAC,CAAC,EAC3D,IAAI,CAAC,UAAU,MAAM,EAAE;AAC5B;AAQO,SAAS,2BAA2B,KAAwB;AACjE,SAAO,kBAAkB,IAAI,MAAM,4DAAuD,IAAI,KAAK,IAAI,CAAC;AAC1G;AAUA,eAAsB,oBACpB,QACA,aACA,YAC8B;AAC9B,QAAM,OAAO,OAAO,UAAU;AAC9B,QAAM,eAAe,OAAO,OAAO,CAAC,MAAM,EAAE,WAAW,YAAY;AACnE,QAAM,YAA8C,CAAC;AACrD,QAAM,SAAwC,CAAC;AAE/C,aAAW,SAAS,cAAc;AAChC,UAAM,YAAY,0BAA0B,MAAM,IAAI,WAAW;AACjE,QAAI;AACF,YAAM,KAAK,cAAc,WAAW,MAAM,OAAO,UAAU;AAC3D,gBAAU,KAAK,EAAE,IAAI,MAAM,IAAI,KAAK,UAAU,CAAC;AAAA,IACjD,SAAS,OAAO;AACd,aAAO,KAAK,EAAE,IAAI,MAAM,IAAI,OAAO,gBAAgB,KAAK,EAAE,CAAC;AAAA,IAC7D;AAAA,EACF;AAEA,SAAO,EAAE,WAAW,OAAO;AAC7B;","names":[]}

package/dist/{chunk-TW35AEB4.js → chunk-F2BHT5C4.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   loadAgentDefs
-} from "./chunk-GE7NUPMI.js";
+} from "./chunk-HED2DAXZ.js";
 import {
   pruneStaleCompiledAgents,
   recompileAgents
-} from "./chunk-3LZNY46H.js";
+} from "./chunk-BMRUNMPV.js";
 import {
   agentCodec,
   buildAgentScopeMap,
@@ -24,19 +24,20 @@ import {
   remove,
   removeDirIfEmpty,
   resolveInstallPaths,
+  sayingEachWarningOnce,
   skillsDir,
   skillsPathPrefix,
   verbose
-} from "./chunk-C2UISKIM.js";
+} from "./chunk-MQ6CGZNJ.js";
 import {
   initializeMatrix,
   matrix,
   typedEntries,
   typedKeys
-} from "./chunk-NU2K5G54.js";
+} from "./chunk-52HDHJ7I.js";
 import {
   globalInstallRoot
-} from "./chunk-AG3ZVM3B.js";
+} from "./chunk-PJWGTNOX.js";
 
 // src/cli/lib/operations/project/remove-compiled-agents.ts
 import path from "path";
@@ -122,10 +123,11 @@ async function pruneStaleAgentsForPass(options, recompileResult) {
 var NO_LOCAL_SKILLS = { skills: {}, unusableMetadata: [] };
 async function discoverLocalProjectSkills(projectDir, scope) {
   const provider = providerInUse(installBaseDir(projectDir, scope));
-  return loadSkillsFromDir(skillsDir(provider, scope, projectDir), {
+  const scan = () => loadSkillsFromDir(skillsDir(provider, scope, projectDir), {
     pathPrefix: skillsPathPrefix(provider, scope, projectDir),
     requireMetadata: true
   });
+  return scope === "global" ? sayingEachWarningOnce(scan) : scan();
 }
 function globalSkillsRoot() {
   const home = globalInstallRoot();
@@ -294,4 +296,4 @@ export {
   recompileRegisteredProjectAgents,
   recompilePropagatedProjectAgents
 };
-//# sourceMappingURL=chunk-TW35AEB4.js.map
+//# sourceMappingURL=chunk-F2BHT5C4.js.map

package/dist/chunk-F2BHT5C4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/lib/operations/project/remove-compiled-agents.ts","../src/cli/lib/operations/project/compile-agents.ts","../src/cli/lib/operations/skills/discover-skills.ts","../src/cli/lib/operations/skills/copy-local-skills.ts","../src/cli/lib/operations/skills/uninstall-plugin-skills.ts","../src/cli/lib/loading/catalogue-seat.ts","../src/cli/lib/operations/project/recompile-project-agents.ts"],"sourcesContent":["import path from \"path\";\nimport { pruneStaleCompiledAgents } from \"../../agents/list-compiled-agents.js\";\nimport type { AgentCodec } from \"../../installation/install-layout.js\";\nimport { getErrorMessage } from \"../../../utils/errors.js\";\nimport { remove, removeDirIfEmpty } from \"../../../utils/fs.js\";\nimport type { AgentName } from \"../../../types/index.js\";\n\nconst AGENT_FILE_EXTENSION = \".md\";\n\nexport type RemoveCompiledAgentsOptions = {\n  /** The scope's `.claude/agents/` directory holding the compiled files. */\n  agentsDir: string;\n  agents: readonly AgentName[];\n};\n\nexport type PruneCompiledAgentsOptions = {\n  agentsDir: string;\n  /**\n   * The COMPLETE set of agents that belong in `agentsDir` — every other\n   * CLI-compiled agent there is stale. Only an authoritative pass can say this.\n   */\n  keep: ReadonlySet<AgentName>;\n  /** The host's agent file format — Claude's `.md` when absent. */\n  codec?: AgentCodec;\n};\n\nexport type RemoveCompiledAgentsResult = {\n  /** Agents whose compiled file this call disposed of; an absent file counts. */\n  removed: AgentName[];\n  /** Agents whose file survived an error, for the caller to report. */\n  failed: Array<{ name: AgentName; error: string }>;\n};\n\ntype RemovalOutcome = { name: AgentName; ok: true } | { name: AgentName; ok: false; error: string };\n\n/**\n * Deletes the named agents' compiled `.md` files from `agentsDir`, then takes the\n * directory itself when nothing at all is left in it — the shape `deleteLocalSkill`\n * models for skills.\n *\n * A scope's `.claude/agents/` is an artefact of what it holds, so the removal that\n * empties it owns the tidy and no caller has to remember. An agent with no file on\n * disk is nothing to do rather than an error.\n */\nexport async function removeCompiledAgents(\n  options: RemoveCompiledAgentsOptions,\n): Promise<RemoveCompiledAgentsResult> {\n  const outcomes = await Promise.all(\n    options.agents.map((name) => removeCompiledAgentFile(options.agentsDir, name)),\n  );\n  await tidyEmptiedAgentsDir(options.agentsDir);\n\n  return {\n    removed: outcomes.flatMap((outcome) => (outcome.ok ? [outcome.name] : [])),\n    failed: outcomes.flatMap((outcome) =>\n      outcome.ok ? [] : [{ name: outcome.name, error: outcome.error }],\n    ),\n  };\n}\n\n/**\n * Deletes every CLI-compiled agent in `agentsDir` outside `keep`, then takes the\n * directory on the same terms as `removeCompiledAgents`.\n *\n * Hand-authored agents are preserved by `pruneStaleCompiledAgents`'s `isAgentName`\n * predicate, so a directory this leaves empty is one nothing at all remains in.\n */\nexport async function pruneCompiledAgents(options: PruneCompiledAgentsOptions): Promise<void> {\n  await pruneStaleCompiledAgents(options.agentsDir, options.keep, options.codec);\n  await tidyEmptiedAgentsDir(options.agentsDir);\n}\n\nasync function removeCompiledAgentFile(\n  agentsDir: string,\n  name: AgentName,\n): Promise<RemovalOutcome> {\n  try {\n    await remove(path.join(agentsDir, `${name}${AGENT_FILE_EXTENSION}`));\n    return { name, ok: true };\n  } catch (error) {\n    return { name, ok: false, error: getErrorMessage(error) };\n  }\n}\n\n/**\n * Emptiness is FILESYSTEM emptiness, never roster emptiness: a hand-authored agent\n * or any user-owned file keeps the directory alive whatever a config says. The\n * agents directory only — `.claude/` above it is uninstall's decision, not a\n * removal path's.\n */\nasync function tidyEmptiedAgentsDir(agentsDir: string): Promise<void> {\n  await removeDirIfEmpty(agentsDir);\n}\n","import { pruneCompiledAgents } from \"./remove-compiled-agents.js\";\nimport { recompileAgents } from \"../../agents/index.js\";\nimport { loadInstalledConfig } from \"../../configuration/index.js\";\nimport { buildAgentScopeMap } from \"../../installation/index.js\";\nimport { agentCodec, providerInUse } from \"../../installation/install-layout.js\";\nimport type { AgentName, SkillDefinitionMap, SkillScope } from \"../../../types/index.js\";\n\nexport type CompileAgentsOptions = {\n  projectDir: string;\n  sourcePath: string;\n  pluginDir?: string;\n  skills?: SkillDefinitionMap;\n  agentScopeMap?: Map<AgentName, SkillScope>;\n  agents?: AgentName[];\n  /** When set, loads config and filters agents to only those matching this scope. */\n  scopeFilter?: SkillScope;\n  outputDir?: string;\n};\n\nexport type CompilationResult = {\n  compiled: AgentName[];\n  /**\n   * The subset of `compiled` whose file this pass actually wrote. A pass whose\n   * `rewritten` is empty changed nothing on disk, which is exactly what the\n   * recompile summary reports and what the count it replaced could not say.\n   */\n  rewritten: AgentName[];\n  failed: AgentName[];\n  warnings: string[];\n};\n\n/**\n * Compiles agent markdown files from templates + skill content.\n *\n * Thin wrapper around recompileAgents() that standardizes options.\n * The caller invokes this once (edit, update) or twice with scopeFilter (compile).\n */\nexport async function compileAgents(options: CompileAgentsOptions): Promise<CompilationResult> {\n  const { agents: resolvedAgents, agentScopeMap: resolvedAgentScopeMap } = options.scopeFilter\n    ? await rosterForScope(options, options.scopeFilter)\n    : { agents: options.agents, agentScopeMap: options.agentScopeMap };\n\n  const recompileResult = await recompileAgents({\n    pluginDir: options.pluginDir ?? options.projectDir,\n    sourcePath: options.sourcePath,\n    ...(resolvedAgents !== undefined && { agents: resolvedAgents }),\n    ...(options.skills !== undefined && { skills: options.skills }),\n    projectDir: options.projectDir,\n    ...(options.outputDir !== undefined && { outputDir: options.outputDir }),\n    ...(resolvedAgentScopeMap !== undefined && { agentScopeMap: resolvedAgentScopeMap }),\n  });\n\n  await pruneStaleAgentsForPass(options, recompileResult);\n\n  return {\n    compiled: recompileResult.compiled,\n    rewritten: recompileResult.rewritten,\n    failed: recompileResult.failed,\n    warnings: recompileResult.warnings,\n  };\n}\n\n/**\n * What a scope-filtered pass compiles, read off the installed config: the requested agents\n * narrowed to those active at `scope` (all of those when none were requested), and the caller's\n * scope routing — auto-built from the config when the caller passed none. With no installed\n * config, both are the caller's as passed.\n */\nasync function rosterForScope(\n  options: CompileAgentsOptions,\n  scope: SkillScope,\n): Promise<{\n  agents: AgentName[] | undefined;\n  agentScopeMap: Map<AgentName, SkillScope> | undefined;\n}> {\n  const config = (await loadInstalledConfig(options.projectDir))?.config;\n  const activeAtScope = config?.agents\n    .filter((agent) => !agent.excluded && agent.scope === scope)\n    .map((agent) => agent.name);\n\n  return {\n    agents: requestedAgentsAmong(options.agents, activeAtScope),\n    agentScopeMap: options.agentScopeMap ?? (config ? buildAgentScopeMap(config) : undefined),\n  };\n}\n\n/** The requested agents that appear in `activeAtScope`; either list alone when the other is absent. */\nfunction requestedAgentsAmong(\n  requested: AgentName[] | undefined,\n  activeAtScope: AgentName[] | undefined,\n): AgentName[] | undefined {\n  if (activeAtScope === undefined) return requested;\n  if (requested === undefined) return activeAtScope;\n\n  const atScope = new Set(activeAtScope);\n  return requested.filter((name) => atScope.has(name));\n}\n\n/**\n * Compiled-agent writes are additive, so a deselected or stale agent's `.md`\n * lingers after recompile. An authoritative, scope-UNfiltered pass owns its\n * entire `outputDir` (its resolved roster is the full set for that directory),\n * so it prunes built-in agents no longer compiled there. A scope-FILTERED pass\n * (the hasBoth two-pass compile, or the registered-project recompile)\n * sees only one scope's agents and must never delete another scope's files, so\n * it skips pruning. Removing the stale files and tidying the directory they\n * emptied is one operation's job, not this pass's.\n */\nasync function pruneStaleAgentsForPass(\n  options: CompileAgentsOptions,\n  recompileResult: CompilationResult,\n): Promise<void> {\n  if (options.scopeFilter || !options.outputDir) return;\n\n  const compiledForDir = new Set<AgentName>([\n    ...recompileResult.compiled,\n    ...recompileResult.failed,\n  ]);\n  await pruneCompiledAgents({\n    agentsDir: options.outputDir,\n    keep: compiledForDir,\n    // The host this installation compiles for — a Codex role is a `.toml`, and a prune that only\n    // knew `.md` left a deselected role in place for Codex to keep offering (CLI-896's sibling).\n    codec: agentCodec(providerInUse(options.projectDir)),\n  });\n}\n","import { discoverAllPluginSkills } from \"../../plugins/index.js\";\nimport { isHomeDirectory } from \"../../installation/is-home-directory.js\";\n// loadSkillsFromDir lives in loading/ (a leaf) so both this module and\n// plugins/plugin-discovery can share it without an operations↔plugins cycle.\nimport { loadSkillsFromDir, type LoadedSkills } from \"../../loading/index.js\";\nimport { sayingEachWarningOnce, verbose } from \"../../../utils/logger.js\";\nimport { globalInstallRoot } from \"../../../consts.js\";\nimport {\n  installBaseDir,\n  providerInUse,\n  skillsDir,\n  skillsPathPrefix,\n} from \"../../installation/install-layout.js\";\nimport { typedEntries, typedKeys } from \"../../../utils/typed-object.js\";\nimport type { UnusableSkillMetadata } from \"../../loading/index.js\";\nimport type {\n  SkillDefinition,\n  SkillDefinitionMap,\n  SkillId,\n  SkillScope,\n} from \"../../../types/index.js\";\n\nexport type DiscoveredSkills = {\n  allSkills: SkillDefinitionMap;\n  totalSkillCount: number;\n  pluginSkillCount: number;\n  localSkillCount: number;\n  globalPluginSkillCount: number;\n  globalLocalSkillCount: number;\n  /**\n   * Installed skills whose metadata.yaml exists but describes no skill, from either\n   * scope. Nothing was loaded for them; `compile` refuses the run over any entry\n   * here rather than compile agents around a skill its metadata does not describe.\n   */\n  unusableMetadata: UnusableSkillMetadata[];\n};\n\n/** The result of a local-skill scan that was not performed. */\nconst NO_LOCAL_SKILLS: LoadedSkills = { skills: {}, unusableMetadata: [] };\n\n/**\n * Discovers the skills copied in rather than installed as plugins, at one scope of one project.\n *\n * **It composed `<rootDir>/.claude/skills` until 2026-09-22, for every provider**, which made this\n * the last Claude literal on the eject READ path: a Codex installation copies its skills to\n * `$CODEX_HOME/skills` and `<repo>/.agents/skills` — the WRITE path routes through the layout\n * already — and this read went on looking in a directory that host never writes to. Nothing failed:\n * the scan answered \"no skills\", which is the same answer an empty installation gives.\n *\n * The scope is a required argument rather than a defaulted one, for the reason C2 deleted\n * `DEFAULT_PROVIDER`: a default is invisible at the call site, and the two call sites below mean\n * different things by it. The provider is READ off the scope root the same way\n * `resolveInstallPaths` reads it, from one probe, so the directory and the prefix cannot name two\n * different installations.\n *\n * What a GLOBAL scan finds wrong is said once per run: that scope is one directory whichever\n * project asks, and a global change's fan-out asks once per registered project. Only the saying is\n * held — each scan still reads the directory, which the run may have written to since. A project\n * scan is not held: its lines name a skill relative to its project, so two projects' copies read\n * alike while being two files to fix.\n */\nexport async function discoverLocalProjectSkills(\n  projectDir: string,\n  scope: SkillScope,\n): Promise<LoadedSkills> {\n  const provider = providerInUse(installBaseDir(projectDir, scope));\n  const scan = () =>\n    loadSkillsFromDir(skillsDir(provider, scope, projectDir), {\n      pathPrefix: skillsPathPrefix(provider, scope, projectDir),\n      requireMetadata: true,\n    });\n\n  return scope === \"global\" ? sayingEachWarningOnce(scan) : scan();\n}\n\n/** Where the global scope's copied-in skills are, for the diagnostic line that names them. */\nfunction globalSkillsRoot(): string {\n  const home = globalInstallRoot();\n  return skillsDir(providerInUse(home), \"global\", home);\n}\n\n/** The same, for whichever scope the project pass asked. */\nfunction projectSkillsRoot(projectDir: string, scope: SkillScope): string {\n  return skillsDir(providerInUse(installBaseDir(projectDir, scope)), scope, projectDir);\n}\n\n/** Merges skill maps — later sources take precedence over earlier ones. */\nexport function mergeSkills(...skillSources: SkillDefinitionMap[]): SkillDefinitionMap {\n  const merged: SkillDefinitionMap = {};\n\n  for (const source of skillSources) {\n    for (const [id, skill] of typedEntries<SkillId, SkillDefinition | undefined>(source)) {\n      if (skill) {\n        merged[id] = skill;\n      }\n    }\n  }\n\n  return merged;\n}\n\n/**\n * Discovers all installed skills for a project directory using a 4-way merge: the global scope's\n * plugins and copied-in skills, then the project's own of each, so the project wins on conflict.\n *\n * **Every one of the four is resolved per PROVIDER rather than spelled as a Claude path.** The\n * plugin halves go through `hostAt(...).listPlugins` and the copied-in halves through\n * {@link discoverLocalProjectSkills}; on Claude that is `~/.claude/{plugins,skills}` and\n * `<project>/.claude/{plugins,skills}` exactly as it always was, and on Codex it is the Codex\n * state root and the repository's own `.agents/skills`.\n *\n * Pure function — no user-facing logging. Callers add their own log messages.\n * Uses verbose() for diagnostic output only.\n */\nexport async function discoverInstalledSkills(projectDir: string): Promise<DiscoveredSkills> {\n  const isGlobalProject = isHomeDirectory(projectDir);\n\n  // 1. Global plugins\n  const globalPluginSkills = isGlobalProject\n    ? {}\n    : await discoverAllPluginSkills(globalInstallRoot());\n  const globalPluginSkillCount = typedKeys<SkillId>(globalPluginSkills).length;\n  if (globalPluginSkillCount > 0) {\n    verbose(`  Found ${globalPluginSkillCount} skills from global plugins`);\n  }\n\n  // 2. Global local skills\n  const globalLocal = isGlobalProject\n    ? NO_LOCAL_SKILLS\n    : await discoverLocalProjectSkills(projectDir, \"global\");\n  const globalLocalSkillCount = typedKeys<SkillId>(globalLocal.skills).length;\n  if (globalLocalSkillCount > 0) {\n    verbose(`  Found ${globalLocalSkillCount} global local skills from ${globalSkillsRoot()}`);\n  }\n\n  // 3. Project plugins\n  const pluginSkills = await discoverAllPluginSkills(projectDir);\n  const pluginSkillCount = typedKeys<SkillId>(pluginSkills).length;\n  verbose(`  Found ${pluginSkillCount} skills from installed plugins`);\n\n  // 4. Project local skills.\n  //\n  // At the HOME root the two scopes are one installation, so the project pass asks the GLOBAL\n  // scope — which is the same directory on Claude and is `$CODEX_HOME/skills` rather than\n  // `<home>/.agents/skills` on Codex. Asking both and merging would double the local count on\n  // every Claude run for no gain.\n  const localScope: SkillScope = isGlobalProject ? \"global\" : \"project\";\n  const local = await discoverLocalProjectSkills(projectDir, localScope);\n  const localSkillCount = typedKeys<SkillId>(local.skills).length;\n  verbose(\n    `  Found ${localSkillCount} local skills from ${projectSkillsRoot(projectDir, localScope)}`,\n  );\n\n  // Merge: global first, project second — project wins on conflict\n  const allSkills = mergeSkills(globalPluginSkills, globalLocal.skills, pluginSkills, local.skills);\n  const totalSkillCount = typedKeys<SkillId>(allSkills).length;\n\n  return {\n    allSkills,\n    totalSkillCount,\n    pluginSkillCount: globalPluginSkillCount + pluginSkillCount,\n    localSkillCount: globalLocalSkillCount + localSkillCount,\n    globalPluginSkillCount,\n    globalLocalSkillCount,\n    unusableMetadata: [...globalLocal.unusableMetadata, ...local.unusableMetadata],\n  };\n}\n","import { resolveInstallPaths } from \"../../installation/index.js\";\nimport { copySkillsToLocalFlattened, type CopiedSkill } from \"../../skills/index.js\";\nimport { ensureDir } from \"../../../utils/fs.js\";\nimport type { SkillConfig } from \"../../../types/config.js\";\nimport type { SourceLoadResult } from \"../../loading/source-loader.js\";\n\nexport type SkillCopyResult = {\n  projectCopied: CopiedSkill[];\n  globalCopied: CopiedSkill[];\n  totalCopied: number;\n};\n\n/** Copies one scope's local skills into its skills directory. */\nasync function copyScopedLocalSkills(\n  scopeSkills: SkillConfig[],\n  skillsDir: string,\n  sourceResult: SourceLoadResult,\n): Promise<CopiedSkill[]> {\n  if (scopeSkills.length === 0) return [];\n\n  await ensureDir(skillsDir);\n\n  return copySkillsToLocalFlattened(\n    scopeSkills.map((s) => s.id),\n    skillsDir,\n    sourceResult,\n  );\n}\n\n/**\n * Copies local-source skills to their scope-appropriate directories.\n *\n * Splits skills by scope (project vs global), resolves install paths,\n * ensures directories exist, and copies from source.\n */\nexport async function copyLocalSkills(\n  skills: SkillConfig[],\n  projectDir: string,\n  sourceResult: SourceLoadResult,\n): Promise<SkillCopyResult> {\n  const projectLocalSkills = skills.filter((s) => s.scope !== \"global\");\n  const globalLocalSkills = skills.filter((s) => s.scope === \"global\");\n\n  const projectPaths = resolveInstallPaths(projectDir, \"project\");\n  const globalPaths = resolveInstallPaths(projectDir, \"global\");\n\n  const projectCopied = await copyScopedLocalSkills(\n    projectLocalSkills,\n    projectPaths.skillsDir,\n    sourceResult,\n  );\n  const globalCopied = await copyScopedLocalSkills(\n    globalLocalSkills,\n    globalPaths.skillsDir,\n    sourceResult,\n  );\n\n  return {\n    projectCopied,\n    globalCopied,\n    totalCopied: projectCopied.length + globalCopied.length,\n  };\n}\n","import { hostAt } from \"../../hosts/host-for.js\";\nimport { buildMarketplacePluginRef } from \"../../plugins/index.js\";\nimport { getErrorMessage } from \"../../../utils/errors.js\";\nimport type { SkillId } from \"../../../types/index.js\";\nimport type { SkillConfig, SkillScope } from \"../../../types/config.js\";\n\n/**\n * Where a plugin is looked for when the old config has no entry naming the skill at all.\n *\n * The scope translation swallowed this until C3 — an absent scope and a project one mapped to the\n * same Claude scope word — so the behaviour is unchanged and only the silence is gone. It is the\n * safe direction of the two: a project-scoped removal cannot take a plugin away from every other\n * project under one HOME.\n */\nconst SCOPE_OF_AN_UNRECORDED_SKILL: SkillScope = \"project\";\n\nexport type PluginUninstallResult = {\n  /**\n   * The skills whose plugin registration this run really dropped.\n   *\n   * OBSERVED rather than asked for: a host's `uninstallPlugin` answers `removed` or\n   * `absent`, and until that answer was read this list held every id the caller named — so a\n   * plugin the user had already removed themselves was reported as one `edit` had just taken\n   * away. Neither is a failure, which is why the distinction cannot be an exception and has to be\n   * the return value.\n   */\n  uninstalled: SkillId[];\n  failed: Array<{ id: SkillId; error: string }>;\n};\n\n/**\n * Uninstalls skill plugins through the host this installation belongs to, using the scope the\n * old config filed each one under.\n *\n * Each plugin reference is qualified as `{skillId}@{marketplace}` to match\n * the form used at install time — bare skill IDs will not match the registry.\n */\nexport async function uninstallPluginSkills(\n  skillIds: SkillId[],\n  oldSkills: SkillConfig[],\n  marketplace: string,\n  projectDir: string,\n): Promise<PluginUninstallResult> {\n  const host = hostAt(projectDir);\n  const uninstalled: SkillId[] = [];\n  const failed: PluginUninstallResult[\"failed\"] = [];\n\n  for (const skillId of skillIds) {\n    const oldSkill = oldSkills.find((s) => s.id === skillId);\n    const pluginScope = oldSkill?.scope ?? SCOPE_OF_AN_UNRECORDED_SKILL;\n    const pluginRef = buildMarketplacePluginRef(skillId, marketplace);\n    try {\n      const outcome = await host.uninstallPlugin(pluginRef, pluginScope, projectDir);\n      if (outcome === \"removed\") uninstalled.push(skillId);\n    } catch (error) {\n      failed.push({ id: skillId, error: getErrorMessage(error) });\n    }\n  }\n\n  return { uninstalled, failed };\n}\n","import type { MergedSkillsMatrix } from \"../../types\";\nimport { initializeMatrix, matrix } from \"../matrix/matrix-provider.js\";\nimport { loadSkillsMatrixFromSource } from \"./source-loader.js\";\n\n/**\n * Runs `body` with the skills catalogue seated for `projectDir`, hands it the catalogue\n * that was seated, and puts the caller's own seat back afterwards.\n *\n * A registered project's own local skills, and the skills of the marketplace ITS config\n * names, are in that project's catalogue and in nobody else's. Two things a fan-out does to\n * such a project read a catalogue, and both used to read the TRIGGERING command's:\n *\n *   - The RENDER of a compiled agent, which reaches the catalogue through the module-level\n *     singleton (`matrix` in `matrix-provider.ts`) that `statedUsageFor` and `liveCategoryOf`\n *     in `stacks/stacks-loader.ts` read directly, so no argument reaches it. Rendered against\n *     somebody else's seat, each of the project's own skills loses the `usageGuidance` it\n *     states and falls back to the per-category placeholder.\n *   - The DERIVATION of that project's `config-types.ts` unions, which looks each configured\n *     skill's category up in the catalogue (`deriveCategories` / `deriveDomains`). Against\n *     somebody else's, a skill only this project's catalogue carries resolves to nothing and\n *     its category and domain leave the project's `Category` and `Domain` unions.\n *\n * Both have the same ending: the project's own next `compile` writes the value back from its\n * own catalogue, so the two commands undo each other for as long as they are both run.\n *\n * The catalogue is PASSED to the body as well as seated, so a derivation that can take one as\n * an argument does — a body reading the singleton it just asked to be seated cannot say which\n * seat it got, which is the distinction the whole helper exists to keep. `compile.ts`'s\n * `seatMatrixForPass` returns its catalogue for the same reason.\n *\n * The seat is restored rather than left standing because this is a side trip: the caller has\n * its own pass to finish — `init` and `edit` compile their own agents after the gate returns —\n * and would otherwise render them against the last registered project's catalogue.\n *\n * The load sits outside the `try` deliberately. It seats nothing when it throws, so there is\n * no seat to restore, and a project whose catalogue cannot be loaded is left to the caller's\n * own failure handling rather than silently processed against somebody else's — which is the\n * whole defect this exists to stop. Both callers count such a project as one they could not\n * reach and carry on with the rest.\n *\n * The load is an `\"upkeep\"` one: a fan-out rewrites a project that is already installed, so a\n * marketplace that has since lost its manifest does not leave the project naming global content\n * a change elsewhere just removed.\n */\nexport async function withCatalogueSeatedFor<T>(\n  projectDir: string,\n  body: (catalogue: MergedSkillsMatrix) => Promise<T>,\n): Promise<T> {\n  const callersCatalogue = matrix;\n  const { matrix: seated } = await loadSkillsMatrixFromSource({\n    projectDir,\n    purpose: \"upkeep\",\n    skipExtraSources: true,\n    matrixOnly: true,\n  });\n  try {\n    return await body(seated);\n  } finally {\n    initializeMatrix(callersCatalogue);\n  }\n}\n","import { compileAgents, type CompilationResult } from \"./compile-agents.js\";\nimport { loadAgentDefs } from \"./load-agent-defs.js\";\nimport { discoverInstalledSkills } from \"../skills/index.js\";\nimport { resolveInstallPaths } from \"../../installation/index.js\";\nimport { withCatalogueSeatedFor } from \"../../loading/catalogue-seat.js\";\nimport { getErrorMessage } from \"../../../utils/errors.js\";\n\n/**\n * Recompiles the PROJECT-scoped agents of a registered project after a global\n * config change was propagated into that project's `config.ts`.\n *\n * Propagation (`propagateGlobalChangesToProjects`) rewrites a registered\n * project's `config.ts` / `config-types.ts` but never touches its compiled\n * `.claude/agents/*.md`, so the compiled agents keep emitting whatever skill\n * reference form the OLD global data dictated. Run this per propagated project,\n * after propagation, to bring the compiled artifacts back in step.\n *\n * Scope: project only. The global agents were already recompiled by the\n * triggering operation's own pass; repeating a global pass per project would\n * rewrite `~/.claude/agents` once per registered project for no gain.\n *\n * Both inputs a compiled agent's bytes depend on are resolved from THIS\n * project's directory, and neither is inherited from the command that triggered\n * the fan-out: `skills` is passed explicitly, because without it\n * `recompileAgents` falls back to `discoverAllPluginSkills`, which sees plugin\n * skills only and would silently strip every global-local and project-local\n * skill; and the catalogue is seated by {@link withCatalogueSeatedFor}, because\n * the render reads it from a module-level singleton no argument reaches.\n *\n * Agent partials always come from the CLI itself (`getLocalAgentDefinitions`\n * returns `sourcePath: PROJECT_ROOT`), so no per-project marketplace source\n * resolution is needed.\n */\nexport async function recompileRegisteredProjectAgents(\n  projectDir: string,\n): Promise<CompilationResult> {\n  return withCatalogueSeatedFor(projectDir, async () => {\n    const { allSkills } = await discoverInstalledSkills(projectDir);\n    const { sourcePath } = await loadAgentDefs();\n\n    return compileAgents({\n      projectDir,\n      sourcePath,\n      skills: allSkills,\n      scopeFilter: \"project\",\n      outputDir: resolveInstallPaths(projectDir, \"project\").agentsDir,\n    });\n  });\n}\n\nexport type PropagatedRecompileSummary = {\n  /** Projects where at least one compiled agent's content actually moved. */\n  rewrittenCount: number;\n  /**\n   * Projects the fan-out reached whose agents all came back byte-identical. They\n   * were visited and left alone, which is a different fact from being recompiled\n   * and the one the old single count could not tell apart.\n   */\n  unchangedCount: number;\n  failedCount: number;\n  /** Per-project warnings in processing order — the caller surfaces them via warn(). */\n  warnings: string[];\n};\n\n/**\n * Runs {@link recompileRegisteredProjectAgents} over every propagated project,\n * isolating per-project failures: one project's unreadable config or broken\n * template must not abort the loop or leave the remaining projects stale.\n * Projects are processed sequentially so the collected warnings keep a\n * deterministic per-project order.\n */\nexport async function recompilePropagatedProjectAgents(\n  projectDirs: string[],\n): Promise<PropagatedRecompileSummary> {\n  let rewrittenCount = 0;\n  let unchangedCount = 0;\n  let failedCount = 0;\n  const warnings: string[] = [];\n\n  for (const dir of projectDirs) {\n    try {\n      const result = await recompileRegisteredProjectAgents(dir);\n      if (result.failed.length > 0) {\n        failedCount++;\n        warnings.push(...result.warnings);\n        continue;\n      }\n      if (result.rewritten.length > 0) rewrittenCount++;\n      else unchangedCount++;\n    } catch (error) {\n      failedCount++;\n      warnings.push(`Could not recompile agents in ${dir}: ${getErrorMessage(error)}`);\n    }\n  }\n\n  return { rewrittenCount, unchangedCount, failedCount, warnings };\n}\n"],"mappings":"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","names":["skillsDir"]}

package/dist/{chunk-27AVGFXH.js → chunk-F5EBEATU.js}

@@ -13,7 +13,7 @@ import {
   readFileOptional,
   unexpressibleOnCodexMessage,
   writeFile
-} from "./chunk-C2UISKIM.js";
+} from "./chunk-MQ6CGZNJ.js";
 
 // src/cli/lib/hosts/claude-project-trust.ts
 import path from "path";
@@ -247,4 +247,4 @@ async function hostCompileNotices(provider, projectDir) {
 export {
   hostCompileNotices
 };
-//# sourceMappingURL=chunk-27AVGFXH.js.map
+//# sourceMappingURL=chunk-F5EBEATU.js.map

package/dist/{chunk-GE7NUPMI.js → chunk-HED2DAXZ.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   getAgentDefinitions
-} from "./chunk-JIBCVXXL.js";
+} from "./chunk-3G7X2WKI.js";
 import {
   loadMergedAgents
-} from "./chunk-C2UISKIM.js";
+} from "./chunk-MQ6CGZNJ.js";
 
 // src/cli/lib/operations/project/load-agent-defs.ts
 async function loadAgentDefs() {
@@ -20,4 +20,4 @@ async function loadAgentDefs() {
 export {
   loadAgentDefs
 };
-//# sourceMappingURL=chunk-GE7NUPMI.js.map
+//# sourceMappingURL=chunk-HED2DAXZ.js.map