agents-inc 0.170.0 → 0.170.2

package/dist/{chunk-7RDMTR64.js → chunk-66AEVERM.js}

@@ -2,18 +2,17 @@
 import {
   compileAgents,
   withCatalogueSeatedFor
-} from "./chunk-F2BHT5C4.js";
+} from "./chunk-IWY5IR4F.js";
 import {
   loadAgentDefs
-} from "./chunk-HED2DAXZ.js";
+} from "./chunk-THO7LO5B.js";
 import {
   ConfigLoadError,
   GlobalPairWriteViolation,
+  INDENT_STEP,
   assertGateToken,
+  brokenUnionLayout,
   buildAndMergeConfig,
-  buildConfigTypesBackgroundData,
-  deriveCategories,
-  deriveDomains,
   detectGlobalInstallation,
   detectInstallation,
   detectProjectInstallation,
@@ -22,14 +21,14 @@ import {
   enableBuffering,
   ensureDir,
   fileExists,
+  flatUnion,
   generateBlankGlobalConfigSource,
-  generateBlankGlobalConfigTypesSource,
   generateConfigSource,
-  generateConfigTypesSource,
   getErrorMessage,
   getInstalledConfigPath,
   getProjectConfigPath,
   isHomeDirectory,
+  isRecord,
   loadInstalledConfig,
   loadProjectConfig,
   loadProjectConfigFromDir,
@@ -37,59 +36,66 @@ import {
   mergeConfigs,
   normalizeStackRecord,
   providerInUse,
+  quoteText,
   readFile,
-  regenerateConfigTypes,
+  renderKey,
+  renderTypeImportLine,
+  renderUnionBody,
   resolveInstallPaths,
   sourceFolderInUse,
+  spaces,
   splitConfigByScope,
-  typedEntries as typedEntries2,
+  typedEntries,
+  typedEntries2,
+  typedKeys,
+  typedKeys2,
+  unionLayout,
   verbose,
   warn,
   withGateToken,
   writeFile
-} from "./chunk-MQ6CGZNJ.js";
+} from "./chunk-GAKVZNTX.js";
 import {
-  matrix,
-  typedEntries,
-  typedKeys
-} from "./chunk-52HDHJ7I.js";
+  matrix
+} from "./chunk-AUNRHWH4.js";
 import {
   CLI_INVOKE_COMMAND,
+  CODEX_MODEL_NAMES,
+  EFFORT_NAMES,
   GLOBAL_CONFIG_NAME,
   LOCAL_PSEUDO_CATEGORY,
+  MODEL_NAMES,
   PROVIDERS,
   STANDARD_FILES,
+  activeAgentNames,
   activeProjectAgentNames,
+  bytewise,
+  globalInstallRoot,
   isActiveAt,
+  isExclusiveCategory,
   isGlobalTombstone,
   skillDomain
-} from "./chunk-PJWGTNOX.js";
+} from "./chunk-7C3PFRBU.js";
 
 // src/cli/lib/operations/source/load-source.ts
 async function loadSource(options) {
   const { caller, sourceFlag, projectDir, captureStartupMessages } = options;
-  if (captureStartupMessages) {
-    enableBuffering();
-  }
-  let sourceResult;
+  const load = () => loadSkillsMatrixFromSource({
+    ...caller !== void 0 && { caller },
+    ...sourceFlag !== void 0 && { sourceFlag },
+    projectDir
+  });
+  if (!captureStartupMessages) return { sourceResult: await load(), startupMessages: [] };
+  return capturingStartupMessages(load);
+}
+async function capturingStartupMessages(load) {
+  enableBuffering();
   try {
-    sourceResult = await loadSkillsMatrixFromSource({
-      ...caller !== void 0 && { caller },
-      ...sourceFlag !== void 0 && { sourceFlag },
-      projectDir
-    });
-  } catch (error) {
-    if (captureStartupMessages) {
-      disableBuffering();
-    }
-    throw error;
-  }
-  let startupMessages = [];
-  if (captureStartupMessages) {
-    startupMessages = drainBuffer();
+    const sourceResult = await load();
+    return { sourceResult, startupMessages: drainBuffer() };
+  } finally {
     disableBuffering();
   }
-  return { sourceResult, startupMessages };
 }
 function sayCapturedWarnings(messages) {
   for (const { text } of messages) warn(text);
@@ -123,184 +129,451 @@ async function detectBothInstallations(projectDir) {
   return { global, project, hasBoth: !!global && !!project };
 }
 
-// src/cli/lib/config-gate/index.ts
-import os2 from "os";
-import path2 from "path";
+// src/cli/lib/config-gate/propagate.ts
+import fs from "fs";
+import { isDeepEqual as isDeepEqual2, unique as unique2 } from "remeda";
 
-// src/cli/lib/config-gate/classify.ts
-import { isDeepEqual } from "remeda";
-var NO_CHANGES = {
-  skills: { added: [], removed: [], sourceChanged: [], otherChanged: [] },
-  agents: { added: [], removed: [], changed: [] },
-  stackChanged: false,
-  selectedDomainsChanged: false,
-  scalarsChanged: [],
-  projectsChanged: false
-};
-var EXTRACTED_FIELDS = /* @__PURE__ */ new Set(["skills", "agents", "stack", "selectedDomains"]);
-var REGISTRATION_FIELD = "projects";
-function normalize(config) {
-  return JSON.parse(JSON.stringify(config));
+// ../compile/src/config-types-source.ts
+import { groupBy, unique } from "remeda";
+var EMPTY_UNION_TYPE = "never";
+function formatLiteralUnion(members) {
+  return flatUnion(members.map(quoteText));
 }
-function field(config, key) {
-  return config[key];
+var PROJECT_CONFIG_TYPES_BEFORE = `export type InstallMode = 'eject' | 'plugin' | 'mixed'
+
+export type SkillConfig = {
+  id: SkillId
+  scope: 'project' | 'global'
+  origin: string
+  excluded?: boolean
 }
-function skillsById(config) {
-  const skills = config.skills ?? [];
-  return new Map(skills.map((skill) => [skill.id, skill]));
+
+export type AgentScopeConfig = {
+  name: AgentName
+  scope: 'project' | 'global'
+  model?: ${formatLiteralUnion(MODEL_NAMES)}
+  codexModel?: ${formatLiteralUnion(CODEX_MODEL_NAMES)}
+  effort?: ${formatLiteralUnion(EFFORT_NAMES)}
+  excluded?: boolean
 }
-function agentsByName(config) {
-  const agents = config.agents ?? [];
-  return new Map(agents.map((agent) => [agent.name, agent]));
+
+export type SkillAssignment<S extends SkillId = SkillId> = S | { id: S; preloaded: boolean }
+`;
+var PROJECT_CONFIG_INTERFACE_AFTER = `export interface ProjectConfig {
+  /** Project/plugin name (kebab-case) */
+  name: string
+
+  /** Project description */
+  description?: string
+
+  /** Per-agent configuration with scope */
+  agents: AgentScopeConfig[]
+
+  /** Per-skill configuration with scope and provenance */
+  skills: SkillConfig[]
+
+  /** Author handle (e.g., "@vince") */
+  author?: string
+
+  /** Stack configuration: agent -> category -> skill assignment */
+  stack?: Partial<Record<ProjectAgentName, StackAgentConfig>>
+
+  /** The marketplace this install reads skills from, as a path or URL */
+  marketplace?: string
+
+  /** The name that marketplace's manifest gives it, which plugins are registered under */
+  marketplaceName?: string
+
+  /** Selected domains */
+  selectedDomains?: Domain[]
+
+  /** Branding overrides for white-labeling the CLI */
+  branding?: { name?: string }
+
+  /** Custom skills directory override (default: "src/skills") */
+  skillsDir?: string
+
+  /** Custom stacks file path override (default: "config/stacks.ts") */
+  stacksFile?: string
+
+  /** Custom categories file path override (default: "config/skill-categories.ts") */
+  categoriesFile?: string
+
+  /** Custom rules file path override (default: "config/skill-rules.ts") */
+  rulesFile?: string
+
+  /** Tracked project installation paths (global config only) */
+  projects?: string[]
 }
-function scalarKeys(prev, next) {
-  const isScalarKey = (key) => !EXTRACTED_FIELDS.has(key) && key !== REGISTRATION_FIELD;
-  const nextKeys = Object.keys(next).filter(isScalarKey);
-  const extraPrevKeys = Object.keys(prev).filter(
-    (key) => isScalarKey(key) && !nextKeys.includes(key)
-  );
-  return [...nextKeys, ...extraPrevKeys];
+`;
+var STACK_AGENT_CONFIG_LOOSE_LINE = "export type StackAgentConfig = Partial<Record<Category, SkillAssignment | SkillAssignment[]>>";
+function assembleConfigTypesSource(parts) {
+  const importSection = parts.importBlock ? `${parts.importBlock}
+
+` : "";
+  return `// AUTO-GENERATED by agents-inc \u2014 DO NOT EDIT
+
+${importSection}${renderAlias("SkillId", parts.skillId)}
+
+${renderAlias("AgentName", parts.agentName)}
+
+${renderAlias("SelectedAgentName", parts.selectedAgentName)}
+
+${renderAlias("ProjectAgentName", parts.projectAgentName)}
+
+${renderAlias("Domain", parts.domain)}
+
+${renderAlias("Category", parts.category)}
+
+${PROJECT_CONFIG_TYPES_BEFORE}
+${parts.stackAgentConfig}
+
+${PROJECT_CONFIG_INTERFACE_AFTER}`;
 }
-function diffSkills(prev, next) {
-  const before = skillsById(prev);
-  const after = skillsById(next);
-  const added = [...after.keys()].filter((id) => !before.has(id));
-  const removed = [...before.keys()].filter((id) => !after.has(id));
-  const sourceChanged = [];
-  const otherChanged = [];
-  for (const [id, afterEntry] of after) {
-    const beforeEntry = before.get(id);
-    if (!beforeEntry || isDeepEqual(beforeEntry, afterEntry)) continue;
-    if (beforeEntry.origin !== afterEntry.origin) sourceChanged.push(id);
-    else otherChanged.push(id);
+function literalUnion(members) {
+  return members.length === 0 ? typeReference(EMPTY_UNION_TYPE) : { kind: "plain", members: members.map(quoteText) };
+}
+function typeReference(name) {
+  return { kind: "plain", members: [name] };
+}
+function renderAlias(name, rhs) {
+  const head = `export type ${name} =`;
+  if (rhs.kind === "sectioned") {
+    return `${head}
+${renderSectionedUnion(rhs.custom, rhs.marketplace)}`;
   }
-  return { added, removed, sourceChanged, otherChanged };
+  const layout = unionLayout(rhs.members, {
+    headWidth: head.length + " ".length,
+    tailWidth: 0,
+    bodyIndent: INDENT_STEP
+  });
+  return layout === "inline" ? `${head} ${flatUnion(rhs.members)}` : `${head}
+${renderUnionBody(rhs.members, layout, INDENT_STEP)}`;
+}
+function renderSectionedUnion(custom, marketplace) {
+  if (marketplace.length > 0) {
+    return [
+      sectionHeading("Custom"),
+      renderUnionBody(custom, "stacked", INDENT_STEP),
+      sectionHeading("Marketplace"),
+      renderUnionBody(marketplace, "stacked", INDENT_STEP)
+    ].join("\n");
+  }
+  return [
+    sectionHeading("Custom"),
+    renderUnionBody(
+      custom,
+      brokenUnionLayout(custom, INDENT_STEP),
+      INDENT_STEP
+    )
+  ].join("\n");
 }
-function diffAgents(prev, next) {
-  const before = agentsByName(prev);
-  const after = agentsByName(next);
+function sectionHeading(text) {
+  return `${spaces(INDENT_STEP)}// ${text}`;
+}
+function generateStackAgentConfig(skillsByCategory, catalog) {
+  if (skillsByCategory.size === 0) {
+    return STACK_AGENT_CONFIG_LOOSE_LINE;
+  }
+  const properties = [...skillsByCategory.entries()].sort(([a], [b]) => bytewise(a, b)).map(([category, skills]) => renderStackProperty(category, skills, catalog));
+  return ["export type StackAgentConfig = {", ...properties, "}"].join("\n");
+}
+function renderStackProperty(category, skills, catalog) {
+  const members = [...skills].sort().map(quoteText);
+  const tail = `>${isExclusiveCategory(catalog, category) ? "" : "[]"}`;
+  const head = `${spaces(INDENT_STEP)}${renderKey(category)}?: SkillAssignment<`;
+  const bodyIndent = INDENT_STEP * 2;
+  const layout = unionLayout(members, {
+    headWidth: head.length,
+    tailWidth: tail.length,
+    bodyIndent
+  });
+  if (layout === "inline") return `${head}${flatUnion(members)}${tail}`;
+  return [
+    head,
+    renderUnionBody(members, layout, bodyIndent),
+    `${spaces(INDENT_STEP)}${tail}`
+  ].join("\n");
+}
+function buildSkillsByCategory(skillIds, categories, catalog) {
+  const categorySet = new Set(categories);
+  const eligible = [...new Set(skillIds)].map((id) => ({ id, category: catalog.skills[id]?.category })).filter(
+    (entry) => entry.category !== void 0 && entry.category !== LOCAL_PSEUDO_CATEGORY && // Boundary cast: `string` on the narrow catalogue shape; `has` is the runtime check.
+    categorySet.has(entry.category)
+  );
+  return new Map(
+    typedEntries2(groupBy(eligible, (entry) => entry.category)).map(
+      ([category, entries]) => [category, entries.map((entry) => entry.id)]
+    )
+  );
+}
+function isUndeclaredCategory(category, catalog) {
+  return catalog.categories[category] === void 0;
+}
+function isCustomSkill(skillId, catalog) {
+  const declared = catalog.skills[skillId];
+  return declared === void 0 || declared.custom === true;
+}
+function isCustomAgent(agentName, declared, flaggedCustom) {
+  return !declared.has(agentName) || flaggedCustom.has(agentName);
+}
+function isCustomDomain(domain, declared) {
+  return !declared.has(domain);
+}
+function generateConfigTypesSource(catalog, agentNames, customAgentNames = [], extras, config) {
+  const extra = extraMembers(extras);
+  const { skillIds, agents, domains, categories } = config ? configMembers(config, extra, catalog) : catalogueMembers(agentNames, extra, catalog);
+  const declaredAgents = new Set(agentNames);
+  const flaggedCustomAgents = new Set(customAgentNames);
+  const declaredDomains = new Set(extractDomains(catalog));
+  const skillIdLine = formatMaybeSectionedUnion(
+    skillIds,
+    (id) => isCustomSkill(id, catalog)
+  );
+  const agentNameLine = formatMaybeSectionedUnion(
+    agents,
+    (name) => isCustomAgent(name, declaredAgents, flaggedCustomAgents)
+  );
+  const domainLine = formatMaybeSectionedUnion(
+    domains,
+    (domain) => isCustomDomain(domain, declaredDomains)
+  );
+  const categoryLine = formatMaybeSectionedUnion(
+    categories,
+    (category) => isUndeclaredCategory(category, catalog)
+  );
+  const configAgents = config?.agents ?? [];
+  const selectedAgentNameLine = narrowedUnion(
+    activeAgentNames(configAgents),
+    "AgentName"
+  );
+  const projectAgentNameLine = narrowedUnion(
+    activeProjectAgentNames(configAgents),
+    "SelectedAgentName"
+  );
+  const skillsByCategory = buildSkillsByCategory(skillIds, categories, catalog);
+  const stackAgentConfigType = generateStackAgentConfig(
+    skillsByCategory,
+    catalog
+  );
+  return assembleConfigTypesSource({
+    skillId: skillIdLine,
+    agentName: agentNameLine,
+    selectedAgentName: selectedAgentNameLine,
+    projectAgentName: projectAgentNameLine,
+    domain: domainLine,
+    category: categoryLine,
+    stackAgentConfig: stackAgentConfigType
+  });
+}
+function extraMembers(extras) {
   return {
-    added: [...after.keys()].filter((name) => !before.has(name)),
-    removed: [...before.keys()].filter((name) => !after.has(name)),
-    changed: [...after.keys()].filter((name) => {
-      const beforeEntry = before.get(name);
-      return beforeEntry !== void 0 && !isDeepEqual(beforeEntry, after.get(name));
-    })
+    skillIds: extras?.extraSkillIds ?? [],
+    agents: extras?.extraAgentNames ?? [],
+    domains: extras?.extraDomains ?? [],
+    categories: extras?.extraCategories ?? []
   };
 }
-function classifyGlobalChange(prev, next) {
-  const before = prev ? normalize(prev) : {};
-  const after = normalize(next);
-  const moved = (key) => !isDeepEqual(field(before, key), field(after, key));
+function configMembers(config, extra, catalog) {
+  const configSkillIds = config.skills.map((s) => s.id);
+  const categories = sortedUnion(
+    deriveCategories(configSkillIds, catalog),
+    extra.categories
+  );
   return {
-    skills: diffSkills(before, after),
-    agents: diffAgents(before, after),
-    stackChanged: moved("stack"),
-    selectedDomainsChanged: moved("selectedDomains"),
-    scalarsChanged: scalarKeys(before, after).filter(moved),
-    projectsChanged: moved(REGISTRATION_FIELD)
+    skillIds: sortedUnion(configSkillIds, extra.skillIds),
+    agents: sortedUnion(
+      config.agents.map((a) => a.name),
+      extra.agents
+    ),
+    // selectedDomains may carry domains with no skills in this scope.
+    domains: sortedUnion(
+      deriveDomains(categories, catalog),
+      config.selectedDomains ?? [],
+      extra.domains
+    ),
+    categories
   };
 }
-function movesTypesOrCompiledAgents(changes) {
-  const { skills, agents } = changes;
-  return skills.added.length > 0 || skills.removed.length > 0 || skills.sourceChanged.length > 0 || skills.otherChanged.length > 0 || agents.added.length > 0 || agents.removed.length > 0 || agents.changed.length > 0 || changes.stackChanged || changes.selectedDomainsChanged;
+function catalogueMembers(agentNames, extra, catalog) {
+  return {
+    skillIds: sortedUnion(typedKeys2(catalog.skills), extra.skillIds),
+    agents: sortedUnion(agentNames, extra.agents),
+    domains: sortedUnion(extractDomains(catalog), extra.domains),
+    categories: sortedUnion(
+      typedKeys2(catalog.categories),
+      extra.categories
+    )
+  };
 }
-function consequenceTier(changes) {
-  if (movesTypesOrCompiledAgents(changes)) return "T1";
-  if (changes.scalarsChanged.length > 0) return "T2";
-  if (changes.projectsChanged) return "T3";
-  return "T4";
+function sortedUnion(...lists) {
+  return unique(lists.flat()).sort();
 }
-function tierNeedsDeps(tier) {
-  return tier === "T1" || tier === "T2";
+function narrowedUnion(members, fallback) {
+  return members.length > 0 ? literalUnion(members) : typeReference(fallback);
 }
-function tierRegeneratesTypes(tier) {
-  return tier === "T1";
+function extractDomains(catalog) {
+  return deriveDomains(typedKeys2(catalog.categories), catalog).sort();
 }
-function tierPropagates(tier) {
-  return tier === "T1" || tier === "T2";
+var isNonLocalCategory = (category) => Boolean(category) && category !== LOCAL_PSEUDO_CATEGORY;
+function deriveCategories(skillIds, catalog) {
+  return unique(
+    skillIds.map((id) => catalog.skills[id]?.category).filter(isNonLocalCategory)
+  );
 }
-
-// src/cli/lib/config-gate/deps.ts
-function isLoaded(deps) {
-  return "matrix" in deps;
+function deriveDomains(categories, catalog) {
+  return unique(
+    categories.map((cat) => catalog.categories[cat]?.domain).filter((domain) => domain !== void 0)
+  );
 }
-async function resolveGateDeps(deps, tier) {
-  if (!tierNeedsDeps(tier)) return null;
-  if (isLoaded(deps)) return deps;
-  const [matrix2, agents] = await Promise.all([
-    deps.loadMatrix(),
-    tierRegeneratesTypes(tier) ? deps.loadAgents() : NO_AGENTS
-  ]);
-  return { matrix: matrix2, agents };
+function formatMaybeSectionedUnion(members, isCustom) {
+  if (members.length === 0) {
+    return typeReference(EMPTY_UNION_TYPE);
+  }
+  const custom = members.filter(isCustom);
+  const marketplace = members.filter((m) => !isCustom(m));
+  if (custom.length === 0) {
+    return literalUnion(members);
+  }
+  return {
+    kind: "sectioned",
+    custom: custom.map(quoteText),
+    marketplace: marketplace.map(quoteText)
+  };
 }
-var NO_AGENTS = Promise.resolve({});
-
-// src/cli/lib/config-gate/pair-writer.ts
-import os from "os";
-import path from "path";
-function globalPairPaths(provider) {
-  const dir = sourceFolderInUse(os.homedir(), provider).dir;
+function generateProjectConfigTypesSource(options) {
+  const importPath = `${options.globalTypesImportPath}/config-types`;
+  const skillIdUnion = formatExtendedUnion(
+    "GlobalSkillId",
+    options.projectSkillIds
+  );
+  const agentNameUnion = formatExtendedUnion(
+    "GlobalAgentName",
+    options.projectAgentNames
+  );
+  const domainUnion = formatExtendedUnion(
+    "GlobalDomain",
+    options.projectDomains
+  );
+  const categoryUnion = formatExtendedUnion(
+    "GlobalCategory",
+    options.projectCategories ?? []
+  );
+  const selectedAgentNameUnion = narrowedUnion(
+    options.selectedAgentNames ?? [],
+    "AgentName"
+  );
+  const projectAgentNameUnion = narrowedUnion(
+    options.projectScopedAgentNames ?? [],
+    "SelectedAgentName"
+  );
+  const importBlock = renderTypeImportLine(
+    [
+      "SkillId as GlobalSkillId",
+      "AgentName as GlobalAgentName",
+      "Domain as GlobalDomain",
+      "Category as GlobalCategory"
+    ],
+    importPath
+  );
+  return assembleConfigTypesSource({
+    importBlock,
+    skillId: skillIdUnion,
+    agentName: agentNameUnion,
+    selectedAgentName: selectedAgentNameUnion,
+    projectAgentName: projectAgentNameUnion,
+    domain: domainUnion,
+    category: categoryUnion,
+    stackAgentConfig: STACK_AGENT_CONFIG_LOOSE_LINE
+  });
+}
+function generateBlankGlobalConfigTypesSource() {
+  return assembleConfigTypesSource({
+    skillId: typeReference(EMPTY_UNION_TYPE),
+    agentName: typeReference(EMPTY_UNION_TYPE),
+    selectedAgentName: typeReference(EMPTY_UNION_TYPE),
+    projectAgentName: typeReference("SelectedAgentName"),
+    domain: typeReference(EMPTY_UNION_TYPE),
+    category: typeReference(EMPTY_UNION_TYPE),
+    stackAgentConfig: STACK_AGENT_CONFIG_LOOSE_LINE
+  });
+}
+function formatExtendedUnion(globalTypeName, projectMembers) {
+  if (projectMembers.length === 0) {
+    return typeReference(globalTypeName);
+  }
   return {
-    configPath: path.join(dir, STANDARD_FILES.CONFIG_TS),
-    typesPath: path.join(dir, STANDARD_FILES.CONFIG_TYPES_TS)
+    kind: "plain",
+    members: [globalTypeName, ...[...projectMembers].sort().map(quoteText)]
   };
 }
-function typesPathFor(configPath) {
-  return path.join(path.dirname(configPath), STANDARD_FILES.CONFIG_TYPES_TS);
+
+// src/cli/lib/configuration/config-types-io.ts
+import path from "path";
+async function getGlobalConfigTypesPath(provider) {
+  const globalConfigTypesPath = path.join(
+    sourceFolderInUse(globalInstallRoot(), provider).dir,
+    STANDARD_FILES.CONFIG_TYPES_TS
+  );
+  if (await fileExists(globalConfigTypesPath)) {
+    return globalConfigTypesPath;
+  }
+  return null;
 }
-async function writeIfChanged(filePath, source) {
-  assertGateToken(filePath);
-  if (await fileExists(filePath) && await readFile(filePath) === source) return false;
-  await writeFile(filePath, source);
-  return true;
+function computeGlobalTypesImportPath(projectDir, provider) {
+  const projectSourceDir = sourceFolderInUse(projectDir, provider).dir;
+  const globalSourceDir = sourceFolderInUse(globalInstallRoot(), provider).dir;
+  const relativePath = path.relative(projectSourceDir, globalSourceDir);
+  return relativePath.split(path.sep).join("/");
 }
-function renderStandaloneTypes(config, matrix2, agents, extras) {
-  const data = buildConfigTypesBackgroundData(matrix2, agents);
-  return generateConfigTypesSource(
+function buildConfigTypesBackgroundData(matrix2, agents) {
+  const agentNames = typedKeys(agents);
+  return {
+    matrix: matrix2,
+    agentNames,
+    customAgentNames: agentNames.filter((name) => agents[name]?.custom === true)
+  };
+}
+async function regenerateConfigTypes(projectDir, backgroundData, extras) {
+  const provider = providerInUse(projectDir);
+  const configTypesPath = path.join(
+    sourceFolderInUse(projectDir, provider).dir,
+    STANDARD_FILES.CONFIG_TYPES_TS
+  );
+  if (isHomeDirectory(projectDir)) throw new GlobalPairWriteViolation(configTypesPath);
+  const [data, globalConfigTypes, loadedConfig] = await Promise.all([
+    backgroundData,
+    getGlobalConfigTypesPath(provider),
+    loadProjectConfigFromDir(projectDir, provider)
+  ]);
+  const source = globalConfigTypes ? renderTypesExtendingGlobal(projectDir, provider, loadedConfig?.config.agents, extras) : generateConfigTypesSource(
     data.matrix,
     data.agentNames,
     data.customAgentNames,
     extras,
-    config
-  );
-}
-async function writeGlobalConfigHalf(config, configPath) {
-  return writeIfChanged(configPath, generateConfigSource(config, matrix));
-}
-async function writeGlobalTypesHalf(config, configPath, matrix2, agents, extras) {
-  return writeIfChanged(
-    typesPathFor(configPath),
-    renderStandaloneTypes(config, matrix2, agents, extras)
-  );
-}
-async function writeGlobalPair(config, configPath, matrix2, agents) {
-  const configWritten = await writeIfChanged(configPath, generateConfigSource(config, matrix2));
-  const typesWritten = await writeIfChanged(
-    typesPathFor(configPath),
-    renderStandaloneTypes(config, matrix2, agents)
+    loadedConfig?.config
   );
-  return configWritten || typesWritten;
-}
-async function ensureBlankPair(provider) {
-  const { configPath, typesPath } = globalPairPaths(provider);
-  if (await fileExists(configPath)) {
-    verbose("Global config already exists, skipping blank creation");
-    return false;
-  }
-  await ensureDir(path.dirname(configPath));
-  await writeIfChanged(configPath, generateBlankGlobalConfigSource());
-  await writeIfChanged(typesPath, generateBlankGlobalConfigTypesSource());
-  verbose(`Created blank global config at ${path.dirname(configPath)}`);
-  return true;
+  await writeFile(configTypesPath, source);
+  verbose(`Regenerated ${STANDARD_FILES.CONFIG_TYPES_TS}`);
+}
+function renderTypesExtendingGlobal(projectDir, provider, agents, extras) {
+  const selectedAgentNames = agents ? activeAgentNames(agents) : void 0;
+  const projectScopedAgentNames = agents ? activeProjectAgentNames(agents) : void 0;
+  const source = generateProjectConfigTypesSource({
+    globalTypesImportPath: computeGlobalTypesImportPath(projectDir, provider),
+    projectSkillIds: extras?.extraSkillIds ?? [],
+    projectAgentNames: extras?.extraAgentNames ?? [],
+    projectDomains: extras?.extraDomains ?? [],
+    projectCategories: extras?.extraCategories ?? [],
+    ...selectedAgentNames?.length ? { selectedAgentNames } : {},
+    ...projectScopedAgentNames?.length ? { projectScopedAgentNames } : {}
+  });
+  verbose("Using project config-types.ts that imports from global");
+  return source;
 }
 
-// src/cli/lib/config-gate/propagate.ts
-import fs from "fs";
-import { isDeepEqual as isDeepEqual3, unique } from "remeda";
-
 // ../compile/src/global-config.ts
-import { isDeepEqual as isDeepEqual2 } from "remeda";
+import { isDeepEqual } from "remeda";
 function additiveMergeStack(existing, incoming) {
   const merged = existing ? structuredClone(existing) : {};
   if (!incoming) return { stack: merged, changed: false };
@@ -347,15 +620,15 @@ function appendMissingAssignments(existingAssignments, incomingAssignments) {
   return changed;
 }
 function mergeGlobalConfigs(existing, incoming) {
-  const existingSkillIds = new Set(existing.skills.map((s) => s.id));
-  const existingAgentNames = new Set(existing.agents.map((a) => a.name));
-  const incomingActiveSkills = incoming.skills.filter((s) => !s.excluded);
-  const incomingActiveAgents = incoming.agents.filter((a) => !a.excluded);
-  const newSkills = incomingActiveSkills.filter(
-    (s) => !existingSkillIds.has(s.id)
+  const newSkills = activeEntriesNotIn(
+    incoming.skills,
+    existing.skills,
+    (s) => s.id
   );
-  const newAgents = incomingActiveAgents.filter(
-    (a) => !existingAgentNames.has(a.name)
+  const newAgents = activeEntriesNotIn(
+    incoming.agents,
+    existing.agents,
+    (a) => a.name
   );
   const mergedSkills = [...existing.skills, ...newSkills];
   const mergedAgents = [...existing.agents, ...newAgents];
@@ -370,7 +643,7 @@ function mergeGlobalConfigs(existing, incoming) {
     ])
   ];
   const addsEntries = newSkills.length > 0 || newAgents.length > 0;
-  const changed = addsEntries || stackChanged || !isDeepEqual2(existing.selectedDomains ?? [], mergedSelectedDomains);
+  const changed = addsEntries || stackChanged || !isDeepEqual(existing.selectedDomains ?? [], mergedSelectedDomains);
   return {
     config: {
       ...existing,
@@ -383,6 +656,10 @@ function mergeGlobalConfigs(existing, incoming) {
     changed
   };
 }
+function activeEntriesNotIn(incoming, existing, keyOf) {
+  const held = new Set(existing.map(keyOf));
+  return incoming.filter((entry) => !entry.excluded && !held.has(keyOf(entry)));
+}
 function marketplaceIdentityFilledFrom(existing, arriving) {
   const marketplaceName = existing.marketplaceName ?? arriving?.marketplaceName;
   const marketplace = existing.marketplace ?? arriving?.marketplace;
@@ -437,21 +714,18 @@ function normalizeProjectPath(projectDir) {
 async function registerProjectPath(globalConfig, projectDir) {
   const normalizedPath = normalizeProjectPath(projectDir);
   const existing = globalConfig.projects ?? [];
-  const staleChecks = await Promise.all(
-    existing.map(async (p) => ({
-      path: p,
-      hasConfig: await fileExists(getInstalledConfigPath(p))
-    }))
-  );
-  const valid = staleChecks.filter((c) => c.hasConfig).map((c) => c.path);
+  const valid = await projectsStillInstalled(existing);
   if (valid.includes(normalizedPath)) {
     const changed = valid.length !== existing.length;
     return { config: changed ? { ...globalConfig, projects: valid } : globalConfig, changed };
   }
   return { config: { ...globalConfig, projects: [...valid, normalizedPath] }, changed: true };
 }
-function isProjectScopedEntry(entry) {
-  return entry.scope === "project";
+async function projectsStillInstalled(projects) {
+  const installed = await Promise.all(
+    projects.map((project) => fileExists(getInstalledConfigPath(project)))
+  );
+  return projects.filter((_, index) => installed[index] === true);
 }
 function globalHasActiveSkill(globalConfig, id) {
   return globalConfig.skills.some((s) => s.id === id && isActiveAt(s, "global"));
@@ -461,12 +735,12 @@ function globalHasActiveAgent(globalConfig, name) {
 }
 function retainProjectOwnedSkills(skills, globalConfig) {
   return skills.filter(
-    (entry) => isProjectScopedEntry(entry) || isGlobalTombstone(entry) && globalHasActiveSkill(globalConfig, entry.id)
+    (entry) => entry.scope === "project" || isGlobalTombstone(entry) && globalHasActiveSkill(globalConfig, entry.id)
   );
 }
 function retainProjectOwnedAgents(agents, globalConfig) {
   return agents.filter(
-    (entry) => isProjectScopedEntry(entry) || isGlobalTombstone(entry) && globalHasActiveAgent(globalConfig, entry.name)
+    (entry) => entry.scope === "project" || isGlobalTombstone(entry) && globalHasActiveAgent(globalConfig, entry.name)
   );
 }
 function categoryOfSkill(id, matrix2) {
@@ -474,7 +748,7 @@ function categoryOfSkill(id, matrix2) {
   if (category === void 0 || category === LOCAL_PSEUDO_CATEGORY) return void 0;
   return category;
 }
-function isExclusiveCategory(category, matrix2) {
+function isExclusiveCategory2(category, matrix2) {
   return matrix2.categories[category]?.exclusive === true;
 }
 function activeProjectCategories(projectOwnedSkills, matrix2) {
@@ -488,7 +762,7 @@ function buildProjectCollisionTest(projectOwnedSkills, matrix2) {
   );
   const occupiedExclusiveCategories = new Set(
     [...activeProjectCategories(projectOwnedSkills, matrix2)].filter(
-      (category) => isExclusiveCategory(category, matrix2)
+      (category) => isExclusiveCategory2(category, matrix2)
     )
   );
   return (id) => {
@@ -543,7 +817,7 @@ function computeRemovedGlobalSkillIds(priorProjectSkills, globalConfig) {
   );
   return new Set(
     priorProjectSkills.filter(
-      (s) => s.scope === "global" && !s.excluded && !activeGlobalIds.has(s.id) && !projectOwnedIds.has(s.id)
+      (s) => isActiveAt(s, "global") && !activeGlobalIds.has(s.id) && !projectOwnedIds.has(s.id)
     ).map((s) => s.id)
   );
 }
@@ -585,7 +859,7 @@ function inlinedProjectView(reconciledSplit, effectiveGlobal) {
     ...reconciledSplit,
     skills: [...effectiveGlobal.skills, ...reconciledSplit.skills],
     agents: [...effectiveGlobal.agents, ...reconciledSplit.agents],
-    selectedDomains: unique([
+    selectedDomains: unique2([
       ...effectiveGlobal.selectedDomains ?? [],
       ...reconciledSplit.selectedDomains ?? []
     ]),
@@ -678,6 +952,23 @@ async function propagateToRegisteredProject(projectPath, provider, globalConfig,
     return error instanceof ConfigLoadError ? "unreadable" : "failed";
   }
 }
+async function projectsAFanOutReaches(projects, provider) {
+  const reached = await Promise.all(
+    projects.map(
+      async (projectPath) => await wouldBeRewritten(projectPath, provider) ? [projectPath] : []
+    )
+  );
+  return reached.flat();
+}
+async function wouldBeRewritten(projectPath, provider) {
+  if (!await holdsAnInstallation(projectPath)) return false;
+  if (await whyThisProjectIsNotOurs(projectPath, provider) !== null) return false;
+  try {
+    return await loadInstalledConfig(projectPath) !== null;
+  } catch {
+    return false;
+  }
+}
 async function holdsAnInstallation(projectPath) {
   const configs = await Promise.all(
     PROVIDERS.map((installed) => fileExists(getProjectConfigPath(projectPath, installed)))
@@ -713,7 +1004,7 @@ async function resolveEffectiveGlobalConfig(globalSplit, existingGlobalConfig, p
 function matchGlobalToSession(globalSplit, existingGlobalConfig) {
   if (!existingGlobalConfig) return { config: globalSplit, changed: true };
   const config = mergeConfigs(globalSplit, existingGlobalConfig, { authoritativeScope: "all" });
-  return { config, changed: !isDeepEqual3(config, existingGlobalConfig) };
+  return { config, changed: !isDeepEqual2(config, existingGlobalConfig) };
 }
 function stackCategories(stack) {
   return Object.values(stack ?? {}).flatMap((agentStack) => typedKeys(agentStack ?? {}));
@@ -721,19 +1012,197 @@ function stackCategories(stack) {
 function buildProjectTypesExtras(finalConfig, matrix2) {
   const activeSkills = finalConfig.skills.filter((s) => !s.excluded);
   const activeAgents = finalConfig.agents.filter((a) => !a.excluded);
-  const extraSkillIds = unique(activeSkills.map((s) => s.id));
-  const extraAgentNames = unique(activeAgents.map((a) => a.name));
-  const extraCategories = unique([
+  const extraSkillIds = unique2(activeSkills.map((s) => s.id));
+  const extraAgentNames = unique2(activeAgents.map((a) => a.name));
+  const extraCategories = unique2([
     ...deriveCategories(extraSkillIds, matrix2),
     ...stackCategories(finalConfig.stack)
   ]);
-  const extraDomains = unique([
+  const extraDomains = unique2([
     ...deriveDomains(extraCategories, matrix2),
     ...finalConfig.selectedDomains ?? []
   ]);
   return { extraSkillIds, extraAgentNames, extraDomains, extraCategories };
 }
 
+// src/cli/lib/config-gate/index.ts
+import os2 from "os";
+import path3 from "path";
+
+// src/cli/lib/config-gate/classify.ts
+import { isDeepEqual as isDeepEqual3 } from "remeda";
+var NO_CHANGES = {
+  skills: { added: [], removed: [], sourceChanged: [], otherChanged: [] },
+  agents: { added: [], removed: [], changed: [] },
+  stackChanged: false,
+  selectedDomainsChanged: false,
+  scalarsChanged: [],
+  projectsChanged: false
+};
+var EXTRACTED_FIELDS = /* @__PURE__ */ new Set(["skills", "agents", "stack", "selectedDomains"]);
+var REGISTRATION_FIELD = "projects";
+var EMPTY_MEANS_ABSENT = /* @__PURE__ */ new Set(["stack", "selectedDomains"]);
+function isEmptyCollection(value) {
+  return Array.isArray(value) ? value.length === 0 : isRecord(value) && Object.keys(value).length === 0;
+}
+function normalize(config) {
+  const record = JSON.parse(JSON.stringify(config));
+  return Object.fromEntries(
+    Object.entries(record).filter(
+      ([key, value]) => !(EMPTY_MEANS_ABSENT.has(key) && isEmptyCollection(value))
+    )
+  );
+}
+function skillsById(config) {
+  const skills = config.skills ?? [];
+  return new Map(skills.map((skill) => [skill.id, skill]));
+}
+function agentsByName(config) {
+  const agents = config.agents ?? [];
+  return new Map(agents.map((agent) => [agent.name, agent]));
+}
+function scalarKeys(prev, next) {
+  const isScalarKey = (key) => !EXTRACTED_FIELDS.has(key) && key !== REGISTRATION_FIELD;
+  const nextKeys = Object.keys(next).filter(isScalarKey);
+  const extraPrevKeys = Object.keys(prev).filter(
+    (key) => isScalarKey(key) && !nextKeys.includes(key)
+  );
+  return [...nextKeys, ...extraPrevKeys];
+}
+function diffSkills(prev, next) {
+  const before = skillsById(prev);
+  const after = skillsById(next);
+  const added = [...after.keys()].filter((id) => !before.has(id));
+  const removed = [...before.keys()].filter((id) => !after.has(id));
+  const sourceChanged = [];
+  const otherChanged = [];
+  for (const [id, afterEntry] of after) {
+    const beforeEntry = before.get(id);
+    if (!beforeEntry || isDeepEqual3(beforeEntry, afterEntry)) continue;
+    if (beforeEntry.origin !== afterEntry.origin) sourceChanged.push(id);
+    else otherChanged.push(id);
+  }
+  return { added, removed, sourceChanged, otherChanged };
+}
+function diffAgents(prev, next) {
+  const before = agentsByName(prev);
+  const after = agentsByName(next);
+  return {
+    added: [...after.keys()].filter((name) => !before.has(name)),
+    removed: [...before.keys()].filter((name) => !after.has(name)),
+    changed: [...after.keys()].filter((name) => {
+      const beforeEntry = before.get(name);
+      return beforeEntry !== void 0 && !isDeepEqual3(beforeEntry, after.get(name));
+    })
+  };
+}
+function classifyGlobalChange(prev, next) {
+  const before = prev ? normalize(prev) : {};
+  const after = normalize(next);
+  const moved = (key) => !isDeepEqual3(before[key], after[key]);
+  return {
+    skills: diffSkills(before, after),
+    agents: diffAgents(before, after),
+    stackChanged: moved("stack"),
+    selectedDomainsChanged: moved("selectedDomains"),
+    scalarsChanged: scalarKeys(before, after).filter(moved),
+    projectsChanged: moved(REGISTRATION_FIELD)
+  };
+}
+function movesTypesOrCompiledAgents(changes) {
+  const { skills, agents } = changes;
+  return skills.added.length > 0 || skills.removed.length > 0 || skills.sourceChanged.length > 0 || skills.otherChanged.length > 0 || agents.added.length > 0 || agents.removed.length > 0 || agents.changed.length > 0 || changes.stackChanged || changes.selectedDomainsChanged;
+}
+function consequenceTier(changes) {
+  if (movesTypesOrCompiledAgents(changes)) return "T1";
+  if (changes.scalarsChanged.length > 0) return "T2";
+  if (changes.projectsChanged) return "T3";
+  return "T4";
+}
+function tierNeedsDeps(tier) {
+  return tier === "T1" || tier === "T2";
+}
+function tierRegeneratesTypes(tier) {
+  return tier === "T1";
+}
+function tierPropagates(tier) {
+  return tier === "T1" || tier === "T2";
+}
+
+// src/cli/lib/config-gate/deps.ts
+function isLoaded(deps) {
+  return "matrix" in deps;
+}
+async function resolveGateDeps(deps, tier) {
+  if (!tierNeedsDeps(tier)) return null;
+  if (isLoaded(deps)) return deps;
+  const [matrix2, agents] = await Promise.all([
+    deps.loadMatrix(),
+    tierRegeneratesTypes(tier) ? deps.loadAgents() : NO_AGENTS
+  ]);
+  return { matrix: matrix2, agents };
+}
+var NO_AGENTS = Promise.resolve({});
+
+// src/cli/lib/config-gate/pair-writer.ts
+import os from "os";
+import path2 from "path";
+function globalPairPaths(provider) {
+  const dir = sourceFolderInUse(os.homedir(), provider).dir;
+  return {
+    configPath: path2.join(dir, STANDARD_FILES.CONFIG_TS),
+    typesPath: path2.join(dir, STANDARD_FILES.CONFIG_TYPES_TS)
+  };
+}
+function typesPathFor(configPath) {
+  return path2.join(path2.dirname(configPath), STANDARD_FILES.CONFIG_TYPES_TS);
+}
+async function writeIfChanged(filePath, source) {
+  assertGateToken(filePath);
+  if (await fileExists(filePath) && await readFile(filePath) === source) return false;
+  await writeFile(filePath, source);
+  return true;
+}
+function renderStandaloneTypes(config, matrix2, agents, extras) {
+  const data = buildConfigTypesBackgroundData(matrix2, agents);
+  return generateConfigTypesSource(
+    data.matrix,
+    data.agentNames,
+    data.customAgentNames,
+    extras,
+    config
+  );
+}
+async function writeGlobalConfigHalf(config, configPath) {
+  return writeIfChanged(configPath, generateConfigSource(config, matrix));
+}
+async function writeGlobalTypesHalf(config, configPath, matrix2, agents, extras) {
+  return writeIfChanged(
+    typesPathFor(configPath),
+    renderStandaloneTypes(config, matrix2, agents, extras)
+  );
+}
+async function writeGlobalPair(config, configPath, matrix2, agents) {
+  const configWritten = await writeIfChanged(configPath, generateConfigSource(config, matrix2));
+  const typesWritten = await writeIfChanged(
+    typesPathFor(configPath),
+    renderStandaloneTypes(config, matrix2, agents)
+  );
+  return configWritten || typesWritten;
+}
+async function ensureBlankPair(provider) {
+  const { configPath, typesPath } = globalPairPaths(provider);
+  if (await fileExists(configPath)) {
+    verbose("Global config already exists, skipping blank creation");
+    return false;
+  }
+  await ensureDir(path2.dirname(configPath));
+  await writeIfChanged(configPath, generateBlankGlobalConfigSource());
+  await writeIfChanged(typesPath, generateBlankGlobalConfigTypesSource());
+  verbose(`Created blank global config at ${path2.dirname(configPath)}`);
+  return true;
+}
+
 // src/cli/lib/config-gate/recompile.ts
 var NOTHING_RECOMPILED = {
   rewrittenCount: 0,
@@ -741,10 +1210,55 @@ var NOTHING_RECOMPILED = {
   failedCount: 0,
   warnings: []
 };
-async function recompilePropagated(projectDirs) {
+async function recompilePropagated(projectDirs, pairsRewritten) {
   if (projectDirs.length === 0) return NOTHING_RECOMPILED;
-  const { recompilePropagatedProjectAgents: recompilePropagatedProjectAgents2 } = await import("./recompile-project-agents-SZ76WNTW.js");
-  return recompilePropagatedProjectAgents2(projectDirs);
+  const { recompilePropagatedProjectAgents } = await import("./recompile-project-agents-I33KQJFB.js");
+  return recompilePropagatedProjectAgents(projectDirs, pairsRewritten);
+}
+function pairRewriteSummary(projectDirs, pairsRewritten) {
+  const rewrittenCount = projectDirs.filter((dir) => pairsRewritten.has(dir)).length;
+  return {
+    rewrittenCount,
+    unchangedCount: projectDirs.length - rewrittenCount,
+    failedCount: 0,
+    warnings: []
+  };
+}
+
+// src/cli/lib/config-gate/pair-snapshot.ts
+async function readHalf(filePath) {
+  try {
+    return await fileExists(filePath) ? await readFile(filePath) : null;
+  } catch {
+    return Symbol(filePath);
+  }
+}
+async function readPair(projectDir, provider) {
+  const configPath = getProjectConfigPath(projectDir, provider);
+  return Promise.all([readHalf(configPath), readHalf(typesPathFor(configPath))]);
+}
+async function snapshotProjectPairs(projectDirs, provider) {
+  const pairs = await Promise.all(
+    projectDirs.map(async (dir) => [dir, await readPair(dir, provider)])
+  );
+  return new Map(pairs);
+}
+async function pairsRewrittenSince(before, projectDirs, provider) {
+  const judged = await Promise.all(
+    projectDirs.map(async (dir) => ({
+      dir,
+      rewritten: !samePair(snapshotOf(before, dir), await readPair(dir, provider))
+    }))
+  );
+  return new Set(judged.filter(({ rewritten }) => rewritten).map(({ dir }) => dir));
+}
+function snapshotOf(before, dir) {
+  const pair = before.get(dir);
+  if (pair === void 0) throw new Error(`No snapshot of ${dir} was taken before the fan-out`);
+  return pair;
+}
+function samePair([config, types], [configNow, typesNow]) {
+  return config === configNow && types === typesNow;
 }
 
 // src/cli/lib/config-gate/index.ts
@@ -761,28 +1275,40 @@ function movedGlobalAgentInputs(written) {
 function report(globalWritten, changes, propagated = NOTHING_PROPAGATED, recompile = NOTHING_RECOMPILED) {
   return { globalWritten, changes, propagated, recompile };
 }
+async function fanOut(projects, provider, propagate, recompiles) {
+  const pairsBefore = await snapshotProjectPairs(projects, provider);
+  const propagated = await propagate();
+  const pairsRewritten = await pairsRewrittenSince(pairsBefore, propagated.updated, provider);
+  const recompile = recompiles ? await recompilePropagated(propagated.updated, pairsRewritten) : pairRewriteSummary(propagated.updated, pairsRewritten);
+  return { propagated, recompile };
+}
+function sayPropagated(propagated) {
+  if (propagated.updated.length > 0) {
+    verbose(`Propagated global changes to ${propagated.updated.length} project(s)`);
+  }
+}
 async function applyConsequences(globalConfig, changes, deps, provider, currentProjectDir) {
   const tier = consequenceTier(changes);
-  if (!tierPropagates(tier) || !globalConfig.projects?.length) {
+  const projects = globalConfig.projects ?? [];
+  if (!tierPropagates(tier) || projects.length === 0) {
     return { propagated: NOTHING_PROPAGATED, recompile: NOTHING_RECOMPILED };
   }
-  const propagated = await propagateGlobalChangesToProjects(
-    globalConfig,
-    deps.agents,
+  const regenerateTypes = tierRegeneratesTypes(tier);
+  const reached = await fanOut(
+    projects,
     provider,
-    currentProjectDir,
-    { regenerateTypes: tierRegeneratesTypes(tier) }
+    () => propagateGlobalChangesToProjects(globalConfig, deps.agents, provider, currentProjectDir, {
+      regenerateTypes
+    }),
+    regenerateTypes
   );
-  if (propagated.updated.length > 0) {
-    verbose(`Propagated global changes to ${propagated.updated.length} project(s)`);
-  }
-  const recompile = tierRegeneratesTypes(tier) ? await recompilePropagated(propagated.updated) : NOTHING_RECOMPILED;
-  return { propagated, recompile };
+  sayPropagated(reached.propagated);
+  return reached;
 }
 function lazyGateDeps(projectDir) {
   return {
     loadMatrix: async () => {
-      const { loadSkillsMatrixFromSource: loadSkillsMatrixFromSource2 } = await import("./source-loader-C5SQXZXI.js");
+      const { loadSkillsMatrixFromSource: loadSkillsMatrixFromSource2 } = await import("./source-loader-TTJVW2ER.js");
       const { matrix: matrix2 } = await loadSkillsMatrixFromSource2({
         projectDir,
         skipExtraSources: true,
@@ -791,27 +1317,33 @@ function lazyGateDeps(projectDir) {
       return matrix2;
     },
     loadAgents: async () => {
-      const { loadAgentDefs: loadAgentDefs2 } = await import("./load-agent-defs-YMDWBFDP.js");
+      const { loadAgentDefs: loadAgentDefs2 } = await import("./load-agent-defs-6QUUMGHK.js");
       return (await loadAgentDefs2()).agents;
     }
   };
 }
 async function writeConfigByScope(args) {
   return withGateToken(async () => {
-    const { finalConfig, matrix: matrix2, agents, projectDir, projectConfigPath } = args;
+    const { matrix: matrix2, agents, projectDir } = args;
     const homeDir = os2.homedir();
     const deps = { matrix: matrix2, agents };
-    if (!isHomeDirectory(projectDir)) {
-      return writeFromProjectContext(args, homeDir, deps);
-    }
-    const provider = providerInUse(homeDir);
-    const priorGlobal = await loadProjectConfigFromDir(homeDir, provider);
-    const changes = classifyGlobalChange(priorGlobal?.config, finalConfig);
-    const globalWritten = await writeGlobalPair(finalConfig, projectConfigPath, matrix2, agents);
-    const { propagated, recompile } = await applyConsequences(finalConfig, changes, deps, provider);
-    return report(globalWritten, changes, propagated, recompile);
+    return isHomeDirectory(projectDir) ? writeFromHome(args, homeDir, deps) : writeFromProjectContext(args, homeDir, deps);
   });
 }
+async function writeFromHome(args, homeDir, deps) {
+  const { finalConfig, projectConfigPath } = args;
+  const provider = providerInUse(homeDir);
+  const priorGlobal = await loadProjectConfigFromDir(homeDir, provider);
+  const changes = classifyGlobalChange(priorGlobal?.config, finalConfig);
+  const globalWritten = await writeGlobalPair(
+    finalConfig,
+    projectConfigPath,
+    deps.matrix,
+    deps.agents
+  );
+  const { propagated, recompile } = await applyConsequences(finalConfig, changes, deps, provider);
+  return report(globalWritten, changes, propagated, recompile);
+}
 async function writeFromProjectContext(args, homeDir, deps) {
   const { finalConfig, projectDir } = args;
   const { global: globalConfig, project: projectSplitConfig } = splitConfigByScope(finalConfig);
@@ -853,7 +1385,7 @@ async function writeGlobalPairWhenChanged(effective, globalConfigPath, deps) {
     verbose("Global config unchanged, skipping write");
     return false;
   }
-  await ensureDir(path2.dirname(globalConfigPath));
+  await ensureDir(path3.dirname(globalConfigPath));
   const written = await writeGlobalPair(
     effective.config,
     globalConfigPath,
@@ -870,7 +1402,7 @@ async function writeProjectPairWhenOwed(project, provider, reconciledProjectConf
     );
     return;
   }
-  await ensureDir(path2.dirname(project.projectConfigPath));
+  await ensureDir(path3.dirname(project.projectConfigPath));
   await writeProjectConfigPair(
     project.projectDir,
     provider,
@@ -909,16 +1441,14 @@ async function reconcileTypesFromDisk(projectDir, config, deps, options) {
     const globalWritten = await writeScopeConfigTypes(projectDir, config, deps, options?.extras);
     if (!isHomeDirectory(projectDir)) return report(false, changes);
     if (!config.projects?.length) return report(globalWritten, changes);
-    const propagated = await propagateGlobalChangesToProjects(
-      config,
-      deps.agents,
-      providerInUse(projectDir),
-      options?.currentProjectDir
+    const provider = providerInUse(projectDir);
+    const { propagated, recompile } = await fanOut(
+      config.projects,
+      provider,
+      () => propagateGlobalChangesToProjects(config, deps.agents, provider, options?.currentProjectDir),
+      true
     );
-    if (propagated.updated.length > 0) {
-      verbose(`Propagated global changes to ${propagated.updated.length} project(s)`);
-    }
-    const recompile = await recompilePropagated(propagated.updated);
+    sayPropagated(propagated);
     return report(globalWritten, changes, propagated, recompile);
   });
 }
@@ -981,12 +1511,12 @@ async function propagateGlobalRemoval(preRemovalGlobalConfig, deps, provider) {
       skills: [],
       agents: []
     });
-    const propagated = await pruneGlobalEntriesFromRegisteredProjects(
-      preRemovalGlobalConfig,
-      deps.agents,
-      provider
+    const { propagated, recompile } = await fanOut(
+      preRemovalGlobalConfig.projects ?? [],
+      provider,
+      () => pruneGlobalEntriesFromRegisteredProjects(preRemovalGlobalConfig, deps.agents, provider),
+      true
     );
-    const recompile = await recompilePropagated(propagated.updated);
     return report(false, changes, propagated, recompile);
   });
 }
@@ -1002,7 +1532,7 @@ async function writeProjectPartial(projectDir, partial, options = {}) {
     throw new GlobalPairWriteViolation(getInstalledConfigPath(projectDir));
   }
   const configPath = getInstalledConfigPath(projectDir);
-  await ensureDir(path2.dirname(configPath));
+  await ensureDir(path3.dirname(configPath));
   await writeFile(
     configPath,
     generateConfigSource(
@@ -1013,11 +1543,11 @@ async function writeProjectPartial(projectDir, partial, options = {}) {
 }
 
 // src/cli/lib/operations/project/write-project-config.ts
-import path3 from "path";
+import path4 from "path";
 async function writeProjectConfig(options) {
   const { selection, sourceResult, projectDir, sourceFlag } = options;
   const projectPaths = resolveInstallPaths(projectDir, "project");
-  await ensureDir(path3.dirname(projectPaths.configPath));
+  await ensureDir(path4.dirname(projectPaths.configPath));
   const { agents } = options.agentDefs ?? await loadAgentDefs();
   const mergeResult = await buildAndMergeConfig(
     selection,
@@ -1038,9 +1568,7 @@ async function writeProjectConfig(options) {
     projectDir,
     projectConfigPath: projectPaths.configPath,
     projectInstallationExists: isProjectContext,
-    // The same word the merger above took. It decides the config ROW there and the GLOBAL
-    // config a project write commits here, and the two files disagree the moment it does not
-    // reach both: a row preserved for a skill whose directory the removal diff deleted.
+    // Must match the merger's, or the global config and the project rows disagree.
     ...options.authoritativeScope !== void 0 && {
       authoritativeScope: options.authoritativeScope
     }
@@ -1102,6 +1630,7 @@ export {
   sayCapturedWarnings,
   detectProject,
   detectBothInstallations,
+  projectsAFanOutReaches,
   movedGlobalAgentInputs,
   lazyGateDeps,
   reconcileTypesFromDisk,
@@ -1113,4 +1642,4 @@ export {
   compileAgentsAllScopes,
   compileProjectScope
 };
-//# sourceMappingURL=chunk-7RDMTR64.js.map
+//# sourceMappingURL=chunk-66AEVERM.js.map