agents-inc 0.164.0 → 0.166.0

package/dist/{chunk-X37UYIE3.js → chunk-G6UREQ4V.js}

@@ -2,18 +2,16 @@
 import {
   compileAgents,
   withCatalogueSeatedFor
-} from "./chunk-2CQNPLVF.js";
+} from "./chunk-HWEKHVLE.js";
 import {
   loadAgentDefs
-} from "./chunk-B6FSLXYN.js";
+} from "./chunk-PMJWD27C.js";
 import {
   ConfigLoadError,
   GlobalPairWriteViolation,
-  INDENT_STEP,
   assertGateToken,
   buildAndMergeConfig,
   buildConfigTypesBackgroundData,
-  commentEntry,
   deriveCategories,
   deriveDomains,
   detectGlobalInstallation,
@@ -24,50 +22,48 @@ import {
   enableBuffering,
   ensureDir,
   fileExists,
+  generateBlankGlobalConfigSource,
   generateBlankGlobalConfigTypesSource,
+  generateConfigSource,
   generateConfigTypesSource,
   getErrorMessage,
+  getInstalledConfigPath,
   getProjectConfigPath,
   isHomeDirectory,
-  isKeyedRecord,
+  loadInstalledConfig,
   loadProjectConfig,
   loadProjectConfigFromDir,
   loadSkillsMatrixFromSource,
   mergeConfigs,
   normalizeStackRecord,
-  quoteText,
+  providerInUse,
   readFile,
   regenerateConfigTypes,
-  renderArrayLine,
-  renderKey,
-  renderTypeImportLine,
-  renderValueLine,
   resolveInstallPaths,
-  sourceEntry,
+  sourceFolderInUse,
   splitConfigByScope,
-  valueEntries,
+  typedEntries as typedEntries2,
   verbose,
+  warn,
   withGateToken,
   writeFile
-} from "./chunk-XPDVAJDH.js";
+} from "./chunk-A4KDXNOT.js";
 import {
   matrix,
   typedEntries,
   typedKeys
-} from "./chunk-AVK2HEKB.js";
+} from "./chunk-V5WXIM2F.js";
 import {
-  CLAUDE_SRC_DIR,
   CLI_INVOKE_COMMAND,
-  DEFAULT_PLUGIN_NAME,
   GLOBAL_CONFIG_NAME,
   LOCAL_PSEUDO_CATEGORY,
+  PROVIDERS,
   STANDARD_FILES,
   activeProjectAgentNames,
-  byCategoryDeclarationOrder,
   isActiveAt,
-  isExclusiveCategory,
-  isGlobalTombstone
-} from "./chunk-UITEKY2R.js";
+  isGlobalTombstone,
+  skillDomain
+} from "./chunk-ENGYJCTF.js";
 
 // src/cli/lib/operations/source/load-source.ts
 async function loadSource(options) {
@@ -95,6 +91,11 @@ async function loadSource(options) {
   }
   return { sourceResult, startupMessages };
 }
+function sayCapturedWarnings(messages) {
+  for (const { level, text } of messages) {
+    if (level === "warn") warn(text);
+  }
+}
 
 // src/cli/lib/operations/project/detect-project.ts
 async function detectProject(projectDir) {
@@ -124,459 +125,189 @@ async function detectBothInstallations(projectDir) {
   return { global, project, hasBoth: !!global && !!project };
 }
 
-// src/cli/lib/config-gate/propagate.ts
-import fs from "fs";
-import { isDeepEqual, unique } from "remeda";
+// src/cli/lib/config-gate/index.ts
+import os2 from "os";
+import path2 from "path";
 
-// ../compile/src/config-source.ts
-var EXTRACTED_FIELDS = /* @__PURE__ */ new Set([
-  "skills",
-  "agents",
-  "stack",
-  "selectedDomains"
-]);
-var CANONICAL_FIELD_ORDER = [
-  "name",
-  "description",
-  "agents",
-  "skills",
-  "author",
-  "selectedDomains",
-  "stack",
-  "marketplace",
-  "marketplaceName",
-  "agentsSource",
-  "projects"
-];
-var CANONICAL_SKILL_ENTRY_ORDER = [
-  "id",
-  "scope",
-  "origin",
-  "excluded"
-];
-var CANONICAL_AGENT_ENTRY_ORDER = [
-  "name",
-  "scope",
-  "model",
-  "effort",
-  "excluded"
-];
-var CANONICAL_ASSIGNMENT_ORDER = [
-  "id",
-  "preloaded",
-  "local",
-  "path"
-];
-function withKeysInSchemaOrder(record, schemaOrder) {
-  const named = new Set(schemaOrder);
-  const inSchemaOrder = schemaOrder.filter((key) => key in record).map((key) => [key, record[key]]);
-  const passthrough = Object.entries(record).filter(([key]) => !named.has(key));
-  return Object.fromEntries([...inSchemaOrder, ...passthrough]);
-}
-function canonicalizeFieldOrder(cleaned) {
-  return withKeysInSchemaOrder(cleaned, CANONICAL_FIELD_ORDER);
-}
-function withEntriesInSchemaOrder(cleaned) {
-  const reordered = { ...cleaned };
-  if (Array.isArray(reordered.skills)) {
-    reordered.skills = entriesInSchemaOrder(
-      reordered.skills,
-      CANONICAL_SKILL_ENTRY_ORDER
-    );
-  }
-  if (Array.isArray(reordered.agents)) {
-    reordered.agents = entriesInSchemaOrder(
-      reordered.agents,
-      CANONICAL_AGENT_ENTRY_ORDER
-    );
-  }
-  return reordered;
+// 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));
 }
-function entriesInSchemaOrder(entries, schemaOrder) {
-  return entries.map(
-    (entry) => isKeyedRecord(entry) ? withKeysInSchemaOrder(entry, schemaOrder) : entry
-  );
+function field(config, key) {
+  return config[key];
 }
-function withKeysOrderedBy(record, compareKeys) {
-  return Object.fromEntries(
-    Object.entries(record).sort(([a], [b]) => compareKeys(a, b))
-  );
+function skillsById(config) {
+  const skills = config.skills ?? [];
+  return new Map(skills.map((skill) => [skill.id, skill]));
 }
-function compareNamesInCodeUnitOrder(a, b) {
-  if (a === b) return 0;
-  return a < b ? -1 : 1;
+function agentsByName(config) {
+  const agents = config.agents ?? [];
+  return new Map(agents.map((agent) => [agent.name, agent]));
 }
-function canonicalizeStackOrder(stack, catalog) {
-  const byDeclaration = byCategoryDeclarationOrder(catalog);
-  const withCategoriesInOrder = Object.entries(stack).map(
-    ([agent, categories]) => [agent, withKeysOrderedBy(categories, byDeclaration)]
-  );
-  return withKeysOrderedBy(
-    Object.fromEntries(withCategoriesInOrder),
-    compareNamesInCodeUnitOrder
+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 CONFIG_TYPES_SPECIFIER = "./config-types";
-var STACK_TYPE = "Partial<Record<ProjectAgentName, StackAgentConfig>>";
-function declarationPosition(name, type) {
-  return { indent: 0, prefix: `const ${name}: ${type} = `, suffix: "" };
-}
-function declaration(name, type, value) {
-  return ["", renderValueLine(value, declarationPosition(name, type))];
-}
-function entryDeclaration(name, type, entries) {
-  return ["", renderArrayLine(entries, declarationPosition(name, type))];
+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);
+  }
+  return { added, removed, sourceChanged, otherChanged };
 }
-function exportFieldPosition(key) {
+function diffAgents(prev, next) {
+  const before = agentsByName(prev);
+  const after = agentsByName(next);
   return {
-    indent: INDENT_STEP,
-    prefix: `${renderKey(key)}: `,
-    suffix: ","
+    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));
+    })
   };
 }
-function renderScalarField(key, value) {
-  return renderValueLine(value, exportFieldPosition(key));
-}
-function extractConfigArrays(cleaned) {
+function classifyGlobalChange(prev, next) {
+  const before = prev ? normalize(prev) : {};
+  const after = normalize(next);
+  const moved = (key) => !isDeepEqual(field(before, key), field(after, key));
   return {
-    skills: cleaned.skills ?? [],
-    agents: cleaned.agents ?? [],
-    stack: cleaned.stack,
-    selectedDomains: cleaned.selectedDomains ?? []
+    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 cleanForEmission(config, catalog, options) {
-  const cleaned = JSON.parse(JSON.stringify(config));
-  if (options.dropProjects) {
-    delete cleaned.projects;
-  }
-  if (cleaned.stack) {
-    const compacted = compactStackAssignments(
-      cleaned.stack,
-      catalog
-    );
-    cleaned.stack = canonicalizeStackOrder(compacted, catalog);
-  }
-  return canonicalizeFieldOrder(withEntriesInSchemaOrder(cleaned));
+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 generateConfigSource(config, catalog, options) {
-  if (options?.isProjectConfig) {
-    return generateProjectConfig(config, catalog, options);
-  }
-  return generateStandaloneConfig(
-    cleanForEmission(config, catalog, { dropProjects: false })
-  );
+function consequenceTier(changes) {
+  if (movesTypesOrCompiledAgents(changes)) return "T1";
+  if (changes.scalarsChanged.length > 0) return "T2";
+  if (changes.projectsChanged) return "T3";
+  return "T4";
 }
-function generateProjectConfig(config, catalog, options) {
-  const cleaned = cleanForEmission(config, catalog, { dropProjects: true });
-  if (options.globalConfig) {
-    return generateProjectConfigWithInlinedGlobal(
-      cleaned,
-      cleanForEmission(options.globalConfig, catalog, { dropProjects: true })
-    );
-  }
-  if (options.globalImportPath !== void 0) {
-    return generateProjectConfigWithGlobalImport(
-      cleaned,
-      options.globalImportPath
-    );
-  }
-  throw new Error(
-    "A project config needs the global config it extends: pass `globalConfig` to inline its entries, or `globalImportPath` to import and spread them. Neither was given, and the standalone writer this used to fall through to emits a global-shaped config carrying the `projects` tracking array a project root must never hold."
-  );
+function tierNeedsDeps(tier) {
+  return tier === "T1" || tier === "T2";
 }
-function generateProjectConfigWithGlobalImport(cleaned, globalImportPath) {
-  const importPath = `${globalImportPath}/config`;
-  const { skills, agents, stack, selectedDomains } = extractConfigArrays(cleaned);
-  const hasProjectDomains = selectedDomains.length > 0;
-  const hasStack = stack != null && Object.keys(stack).length > 0;
-  const typeImports = buildTypeImports({
-    // Always present, spread from global.
-    hasSkills: true,
-    hasAgents: true,
-    hasStack,
-    hasSelectedDomains: hasProjectDomains
-  });
-  const lines = [
-    `import globalConfig from ${quoteText(importPath)}`,
-    renderTypeImportLine(typeImports, CONFIG_TYPES_SPECIFIER)
-  ];
-  lines.push(
-    ...entryDeclaration("skills", "SkillConfig[]", [
-      sourceEntry("...globalConfig.skills"),
-      ...valueEntries(skills)
-    ])
-  );
-  lines.push(
-    ...entryDeclaration("agents", "AgentScopeConfig[]", [
-      sourceEntry("...globalConfig.agents"),
-      ...valueEntries(agents)
-    ])
-  );
-  if (hasStack) {
-    lines.push(...declaration("stack", STACK_TYPE, stack));
-  }
-  if (hasProjectDomains) {
-    lines.push(
-      ...entryDeclaration("selectedDomains", "Domain[]", [
-        sourceEntry("...(globalConfig.selectedDomains ?? [])"),
-        ...valueEntries(selectedDomains)
-      ])
-    );
-  }
-  const scalarFields = Object.entries(cleaned).filter(([key]) => !EXTRACTED_FIELDS.has(key) && key !== "name").map(([key, value]) => renderScalarField(key, value));
-  const exportFields = [
-    `  ...globalConfig,`,
-    renderScalarField("name", resolveProjectName(cleaned)),
-    `  skills,`,
-    `  agents,`,
-    ...hasStack ? [`  stack,`] : [],
-    ...hasProjectDomains ? [`  selectedDomains,`] : [],
-    ...scalarFields
-  ];
-  lines.push(``);
-  lines.push(`export default {`);
-  lines.push(...exportFields);
-  lines.push(`} satisfies ProjectConfig`);
-  lines.push(``);
-  return lines.join("\n");
-}
-function generateStandaloneConfig(cleaned) {
-  const { skills, agents, stack, selectedDomains } = extractConfigArrays(cleaned);
-  const hasSkills = skills.length > 0;
-  const hasAgents = agents.length > 0;
-  const hasStack = stack != null && Object.keys(stack).length > 0;
-  const hasSelectedDomains = selectedDomains.length > 0;
-  const typeImports = buildTypeImports({
-    hasSkills,
-    hasAgents,
-    hasStack,
-    hasSelectedDomains
-  });
-  const lines = [
-    renderTypeImportLine(typeImports, CONFIG_TYPES_SPECIFIER)
-  ];
-  if (hasSkills) {
-    lines.push(...declaration("skills", "SkillConfig[]", skills));
-  }
-  if (hasAgents) {
-    lines.push(...declaration("agents", "AgentScopeConfig[]", agents));
-  }
-  if (hasStack) {
-    lines.push(...declaration("stack", STACK_TYPE, stack));
-  }
-  if (hasSelectedDomains) {
-    lines.push(...declaration("selectedDomains", "Domain[]", selectedDomains));
-  }
-  const renderExportField = (key, value) => {
-    if (!EXTRACTED_FIELDS.has(key)) return [renderScalarField(key, value)];
-    if (key === "skills") return [`  skills${hasSkills ? "" : ": []"},`];
-    if (key === "agents") return [`  agents${hasAgents ? "" : ": []"},`];
-    if (key === "stack") return hasStack ? [`  stack,`] : [];
-    return [`  selectedDomains${hasSelectedDomains ? "" : ": []"},`];
-  };
-  const exportFields = Object.entries(cleaned).flatMap(
-    ([key, value]) => renderExportField(key, value)
-  );
-  lines.push(``);
-  lines.push(`export default {`);
-  lines.push(...exportFields);
-  lines.push(`} satisfies ProjectConfig`);
-  lines.push(``);
-  return lines.join("\n");
-}
-function buildTypeImports(flags) {
-  return [
-    flags.hasSelectedDomains && "Domain",
-    "ProjectConfig",
-    flags.hasStack && "ProjectAgentName",
-    flags.hasAgents && "AgentScopeConfig",
-    flags.hasSkills && "SkillConfig",
-    flags.hasStack && "StackAgentConfig"
-  ].filter((t) => Boolean(t));
-}
-function resolveProjectName(cleaned) {
-  return cleaned.name && cleaned.name !== GLOBAL_CONFIG_NAME ? cleaned.name : DEFAULT_PLUGIN_NAME;
-}
-function partitionInlinedConfigEntries(cleaned, cleanedGlobal) {
-  const project = extractConfigArrays(cleaned);
-  const global = extractConfigArrays(cleanedGlobal);
-  const isExcluded = (entry) => entry.excluded === true;
-  const idOf = (entry) => entry.id;
-  const nameOf = (entry) => entry.name;
-  const excludedGlobalSkills = project.skills.filter(isExcluded);
-  const excludedGlobalAgents = project.agents.filter(isExcluded);
-  const projectSkills = project.skills.filter((s) => !isExcluded(s));
-  const projectAgents = project.agents.filter((a) => !isExcluded(a));
-  const excludedSkillIds = new Set(excludedGlobalSkills.map(idOf));
-  const excludedAgentNames = new Set(excludedGlobalAgents.map(nameOf));
-  const globalSkills = [
-    ...global.skills.filter((s) => !excludedSkillIds.has(idOf(s))),
-    ...excludedGlobalSkills
-  ];
-  const globalAgents = [
-    ...global.agents.filter((a) => !excludedAgentNames.has(nameOf(a))),
-    ...excludedGlobalAgents
-  ];
-  const projectAgentNames = new Set(projectAgents.map(nameOf));
-  const filteredStack = project.stack ? Object.fromEntries(
-    Object.entries(project.stack).filter(
-      ([agent]) => projectAgentNames.has(agent)
-    )
-  ) : void 0;
+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 path from "path";
+function globalPairPaths(provider) {
+  const dir = sourceFolderInUse(os.homedir(), provider).dir;
   return {
-    globalSkills,
-    globalAgents,
-    projectSkills,
-    projectAgents,
-    filteredStack,
-    selectedDomains: [
-      .../* @__PURE__ */ new Set([...global.selectedDomains, ...project.selectedDomains])
-    ]
+    configPath: path.join(dir, STANDARD_FILES.CONFIG_TS),
+    typesPath: path.join(dir, STANDARD_FILES.CONFIG_TYPES_TS)
   };
 }
-function mergeInlinedScalarFields(cleaned, cleanedGlobal) {
-  return Object.entries(
-    canonicalizeFieldOrder({ ...cleanedGlobal, ...cleaned })
-  ).filter(([key]) => !EXTRACTED_FIELDS.has(key) && key !== "name");
-}
-function generateProjectConfigWithInlinedGlobal(cleaned, cleanedGlobal) {
-  const partition = partitionInlinedConfigEntries(cleaned, cleanedGlobal);
-  const {
-    globalSkills,
-    globalAgents,
-    projectSkills,
-    projectAgents,
-    filteredStack
-  } = partition;
-  const hasGlobalSkills = globalSkills.length > 0;
-  const hasProjectSkills = projectSkills.length > 0;
-  const hasSkills = hasGlobalSkills || hasProjectSkills;
-  const hasGlobalAgents = globalAgents.length > 0;
-  const hasProjectAgents = projectAgents.length > 0;
-  const hasAgents = hasGlobalAgents || hasProjectAgents;
-  const hasStack = filteredStack != null && Object.keys(filteredStack).length > 0;
-  const hasSelectedDomains = partition.selectedDomains.length > 0;
-  const typeImports = buildTypeImports({
-    hasSkills,
-    hasAgents,
-    hasStack,
-    hasSelectedDomains
-  });
-  const lines = [
-    renderTypeImportLine(typeImports, CONFIG_TYPES_SPECIFIER)
-  ];
-  if (hasSkills) {
-    lines.push(
-      ...entryDeclaration(
-        "skills",
-        "SkillConfig[]",
-        scopeSectionEntries(globalSkills, projectSkills)
-      )
-    );
-  }
-  if (hasAgents) {
-    lines.push(
-      ...entryDeclaration(
-        "agents",
-        "AgentScopeConfig[]",
-        scopeSectionEntries(globalAgents, projectAgents)
-      )
-    );
-  }
-  if (hasStack) {
-    lines.push(...declaration("stack", STACK_TYPE, filteredStack));
-  }
-  if (hasSelectedDomains) {
-    lines.push(
-      ...declaration("selectedDomains", "Domain[]", partition.selectedDomains)
-    );
-  }
-  const scalarFields = mergeInlinedScalarFields(cleaned, cleanedGlobal);
-  const exportFields = [
-    renderScalarField("name", resolveProjectName(cleaned)),
-    ...scalarFields.map(([key, value]) => renderScalarField(key, value)),
-    hasSkills ? `  skills,` : `  skills: [],`,
-    hasAgents ? `  agents,` : `  agents: [],`,
-    ...hasStack ? [`  stack,`] : [],
-    ...hasSelectedDomains ? [`  selectedDomains,`] : []
-  ];
-  lines.push(``);
-  lines.push(`export default {`);
-  lines.push(...exportFields);
-  lines.push(`} satisfies ProjectConfig`);
-  lines.push(``);
-  return lines.join("\n");
-}
-function scopeSectionEntries(global, project) {
-  return [
-    ...global.length > 0 ? [commentEntry("global"), ...valueEntries(global)] : [],
-    ...project.length > 0 ? [commentEntry("project"), ...valueEntries(project)] : []
-  ];
+function typesPathFor(configPath) {
+  return path.join(path.dirname(configPath), STANDARD_FILES.CONFIG_TYPES_TS);
 }
-function carriesFlags(assignment) {
-  return Boolean(assignment.preloaded || assignment.local || assignment.path);
+async function writeIfChanged(filePath, source) {
+  assertGateToken(filePath);
+  if (await fileExists(filePath) && await readFile(filePath) === source) return false;
+  await writeFile(filePath, source);
+  return true;
 }
-function isSkillAssignment(value) {
-  if (typeof value !== "object" || value === null) return false;
-  return typeof value.id === "string";
+function renderStandaloneTypes(config, matrix2, agents, extras) {
+  const data = buildConfigTypesBackgroundData(matrix2, agents);
+  return generateConfigTypesSource(
+    data.matrix,
+    data.agentNames,
+    data.customAgentNames,
+    extras,
+    config
+  );
 }
-function compactAssignment(assignment) {
-  if (!isSkillAssignment(assignment)) return assignment;
-  if (!carriesFlags(assignment)) return assignment.id;
-  return withKeysInSchemaOrder(assignment, CANONICAL_ASSIGNMENT_ORDER);
+async function writeGlobalConfigHalf(config, configPath) {
+  return writeIfChanged(configPath, generateConfigSource(config, matrix));
 }
-function compactCategoryAssignments(category, assignments, catalog) {
-  const compacted = assignments.map(compactAssignment);
-  if (!isExclusiveCategory(catalog, category)) return compacted;
-  if (compacted.length > 1) {
-    throw new Error(
-      `Category '${category}' is exclusive but holds ${compacted.length} skills: ${JSON.stringify(compacted)}`
-    );
-  }
-  return compacted[0];
-}
-function compactCategories(categories, catalog) {
-  return Object.fromEntries(
-    Object.entries(categories).filter(
-      ([, assignments]) => Array.isArray(assignments) && assignments.length > 0
-    ).map(([category, assignments]) => [
-      category,
-      compactCategoryAssignments(category, assignments, catalog)
-    ])
+async function writeGlobalTypesHalf(config, configPath, matrix2, agents, extras) {
+  return writeIfChanged(
+    typesPathFor(configPath),
+    renderStandaloneTypes(config, matrix2, agents, extras)
   );
 }
-function compactStackAssignments(stack, catalog) {
-  return Object.fromEntries(
-    Object.entries(stack).map(
-      ([agent, categories]) => [agent, compactCategories(categories, catalog)]
-    ).filter(([, categories]) => Object.keys(categories).length > 0)
+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;
 }
-function generateBlankGlobalConfigSource() {
-  return `import type { ProjectConfig } from ${quoteText(CONFIG_TYPES_SPECIFIER)}
-
-export default {
-  name: ${quoteText(GLOBAL_CONFIG_NAME)},
-  skills: [],
-  agents: [],
-  selectedDomains: [],
-} satisfies ProjectConfig
-`;
+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;
 }
 
 // src/cli/lib/config-gate/propagate.ts
-async function writeConfigFile(config, configPath, options) {
-  const source = generateConfigSource(config, matrix, options);
-  await writeFile(configPath, source);
-}
+import fs from "fs";
+import { isDeepEqual as isDeepEqual3, unique } from "remeda";
+
+// ../compile/src/global-config.ts
+import { isDeepEqual as isDeepEqual2 } from "remeda";
 function additiveMergeStack(existing, incoming) {
   const merged = existing ? structuredClone(existing) : {};
   if (!incoming) return { stack: merged, changed: false };
   let changed = false;
-  for (const [agentName, incomingAgentStack] of typedEntries(
-    incoming
-  )) {
+  for (const [agentName, incomingAgentStack] of typedEntries2(incoming)) {
     if (!incomingAgentStack) continue;
     const existingAgentStack = merged[agentName];
     if (!existingAgentStack) {
@@ -592,9 +323,7 @@ function additiveMergeStack(existing, incoming) {
 }
 function mergeAgentCategories(existingAgentStack, incomingAgentStack) {
   let changed = false;
-  for (const [category, incomingAssignments] of typedEntries(
-    incomingAgentStack
-  )) {
+  for (const [category, incomingAssignments] of typedEntries2(incomingAgentStack)) {
     if (!incomingAssignments) continue;
     const existingAssignments = existingAgentStack[category];
     if (!existingAssignments) {
@@ -602,24 +331,34 @@ function mergeAgentCategories(existingAgentStack, incomingAgentStack) {
       changed = true;
       continue;
     }
-    const existingIds = new Set(existingAssignments.map((a) => a.id));
-    for (const assignment of incomingAssignments) {
-      if (!existingIds.has(assignment.id)) {
-        existingAssignments.push({ ...assignment });
-        existingIds.add(assignment.id);
-        changed = true;
-      }
+    if (appendMissingAssignments(existingAssignments, incomingAssignments)) {
+      changed = true;
     }
   }
   return changed;
 }
+function appendMissingAssignments(existingAssignments, incomingAssignments) {
+  const existingIds = new Set(existingAssignments.map((a) => a.id));
+  let changed = false;
+  for (const assignment of incomingAssignments) {
+    if (existingIds.has(assignment.id)) continue;
+    existingAssignments.push({ ...assignment });
+    existingIds.add(assignment.id);
+    changed = true;
+  }
+  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 newAgents = incomingActiveAgents.filter((a) => !existingAgentNames.has(a.name));
+  const newSkills = incomingActiveSkills.filter(
+    (s) => !existingSkillIds.has(s.id)
+  );
+  const newAgents = incomingActiveAgents.filter(
+    (a) => !existingAgentNames.has(a.name)
+  );
   const mergedSkills = [...existing.skills, ...newSkills];
   const mergedAgents = [...existing.agents, ...newAgents];
   const { stack: mergedStack, changed: stackChanged } = additiveMergeStack(
@@ -627,11 +366,13 @@ function mergeGlobalConfigs(existing, incoming) {
     incoming.stack
   );
   const mergedSelectedDomains = [
-    .../* @__PURE__ */ new Set([...existing.selectedDomains ?? [], ...incoming.selectedDomains ?? []])
+    .../* @__PURE__ */ new Set([
+      ...existing.selectedDomains ?? [],
+      ...incoming.selectedDomains ?? []
+    ])
   ];
-  const mergedMarketplaceName = existing.marketplaceName ?? incoming.marketplaceName;
-  const mergedMarketplace = existing.marketplace ?? incoming.marketplace;
-  const changed = newSkills.length > 0 || newAgents.length > 0 || stackChanged || !isDeepEqual(existing.selectedDomains ?? [], mergedSelectedDomains) || mergedMarketplaceName !== existing.marketplaceName || mergedMarketplace !== existing.marketplace;
+  const addsEntries = newSkills.length > 0 || newAgents.length > 0;
+  const changed = addsEntries || stackChanged || !isDeepEqual2(existing.selectedDomains ?? [], mergedSelectedDomains);
   return {
     config: {
       ...existing,
@@ -639,12 +380,59 @@ function mergeGlobalConfigs(existing, incoming) {
       agents: mergedAgents,
       stack: mergedStack,
       selectedDomains: mergedSelectedDomains,
-      ...mergedMarketplaceName !== void 0 && { marketplaceName: mergedMarketplaceName },
-      ...mergedMarketplace !== void 0 && { marketplace: mergedMarketplace }
+      ...marketplaceIdentityFilledFrom(existing, addsEntries ? incoming : null)
     },
     changed
   };
 }
+function marketplaceIdentityFilledFrom(existing, arriving) {
+  const marketplaceName = existing.marketplaceName ?? arriving?.marketplaceName;
+  const marketplace = existing.marketplace ?? arriving?.marketplace;
+  return {
+    ...marketplaceName !== void 0 && { marketplaceName },
+    ...marketplace !== void 0 && { marketplace }
+  };
+}
+function addSessionToGlobal(globalSplit, existingGlobalConfig, catalog) {
+  const hasGlobalItems = globalSplit.skills.length > 0 || globalSplit.agents.length > 0;
+  if (!hasGlobalItems) {
+    return {
+      config: existingGlobalConfig ?? {
+        name: GLOBAL_CONFIG_NAME,
+        skills: [],
+        agents: []
+      },
+      changed: false
+    };
+  }
+  const arriving = withTheDomainsItAdds(
+    globalSplit,
+    existingGlobalConfig,
+    catalog
+  );
+  if (!existingGlobalConfig) return { config: arriving, changed: true };
+  return mergeGlobalConfigs(existingGlobalConfig, arriving);
+}
+function withTheDomainsItAdds(globalSplit, existingGlobalConfig, catalog) {
+  const installed = new Set(
+    existingGlobalConfig?.skills.map((skill) => skill.id)
+  );
+  const arrivingDomains = new Set(
+    globalSplit.skills.filter((skill) => !skill.excluded && !installed.has(skill.id)).map((skill) => skillDomain(catalog, skill.id))
+  );
+  return {
+    ...globalSplit,
+    selectedDomains: (globalSplit.selectedDomains ?? []).filter(
+      (domain) => arrivingDomains.has(domain)
+    )
+  };
+}
+
+// src/cli/lib/config-gate/propagate.ts
+async function writeConfigFile(config, configPath, options) {
+  const source = generateConfigSource(config, matrix, options);
+  await writeFile(configPath, source);
+}
 function normalizeProjectPath(projectDir) {
   return fs.realpathSync(projectDir);
 }
@@ -654,7 +442,7 @@ async function registerProjectPath(globalConfig, projectDir) {
   const staleChecks = await Promise.all(
     existing.map(async (p) => ({
       path: p,
-      hasConfig: await fileExists(getProjectConfigPath(p))
+      hasConfig: await fileExists(getInstalledConfigPath(p))
     }))
   );
   const valid = staleChecks.filter((c) => c.hasConfig).map((c) => c.path);
@@ -688,7 +476,7 @@ function categoryOfSkill(id, matrix2) {
   if (category === void 0 || category === LOCAL_PSEUDO_CATEGORY) return void 0;
   return category;
 }
-function isExclusiveCategory2(category, matrix2) {
+function isExclusiveCategory(category, matrix2) {
   return matrix2.categories[category]?.exclusive === true;
 }
 function activeProjectCategories(projectOwnedSkills, matrix2) {
@@ -702,7 +490,7 @@ function buildProjectCollisionTest(projectOwnedSkills, matrix2) {
   );
   const occupiedExclusiveCategories = new Set(
     [...activeProjectCategories(projectOwnedSkills, matrix2)].filter(
-      (category) => isExclusiveCategory2(category, matrix2)
+      (category) => isExclusiveCategory(category, matrix2)
     )
   );
   return (id) => {
@@ -765,20 +553,25 @@ function retainReconciledStack(stack, removedGlobalSkillIds) {
   if (!stack || removedGlobalSkillIds.size === 0) return stack;
   const reconciled = {};
   for (const [agent, agentStack] of Object.entries(stack)) {
-    const reconciledAgentStack = {};
-    for (const [category, assignments] of typedEntries(agentStack)) {
-      if (!assignments) continue;
-      const kept = assignments.filter((assignment) => !removedGlobalSkillIds.has(assignment.id));
-      if (kept.length > 0) reconciledAgentStack[category] = kept;
-    }
+    const reconciledAgentStack = withoutRemovedAssignments(agentStack, removedGlobalSkillIds);
     if (typedKeys(reconciledAgentStack).length > 0) {
       reconciled[agent] = reconciledAgentStack;
     }
   }
   return reconciled;
 }
-async function writeProjectConfigPair(projectDir, reconciledSplit, effectiveGlobal, matrix2, agents, options = {}) {
-  await writeConfigFile(reconciledSplit, getProjectConfigPath(projectDir), {
+function withoutRemovedAssignments(agentStack, removedGlobalSkillIds) {
+  const reconciledAgentStack = {};
+  for (const [category, assignments] of typedEntries(agentStack)) {
+    if (!assignments) continue;
+    const kept = assignments.filter((assignment) => !removedGlobalSkillIds.has(assignment.id));
+    if (kept.length > 0) reconciledAgentStack[category] = kept;
+  }
+  return reconciledAgentStack;
+}
+async function writeProjectConfigPair(projectDir, provider, reconciledSplit, effectiveGlobal, matrix2, agents, options = {}) {
+  const configPath = refuseAWriteOutsideTheInstallation(projectDir, provider);
+  await writeConfigFile(reconciledSplit, configPath, {
     isProjectConfig: true,
     globalConfig: effectiveGlobal
   });
@@ -815,55 +608,103 @@ function reconcileAgainstGlobal(onDisk, globalConfig, matrix2) {
     matrix2
   );
 }
-async function propagateToProject(projectPath, globalConfig, agents, options) {
+function refuseAWriteOutsideTheInstallation(projectDir, provider) {
+  const installed = providerInUse(projectDir);
+  const configPath = getProjectConfigPath(projectDir, provider);
+  if (installed !== provider) {
+    throw new Error(
+      `Refusing to write ${configPath}: ${projectDir} holds the ${installed} installation at ${sourceFolderInUse(projectDir, installed).dir}, not a ${provider} one.`
+    );
+  }
+  return configPath;
+}
+async function propagateToProject(projectPath, provider, globalConfig, agents, options) {
+  const existingProject = await loadInstalledConfig(projectPath);
+  if (!existingProject?.config) return false;
   return withCatalogueSeatedFor(projectPath, async (catalogue) => {
-    const existingProject = await loadProjectConfigFromDir(projectPath);
-    if (!existingProject?.config) return false;
     const projectSplit = reconcileAgainstGlobal(existingProject.config, globalConfig, catalogue);
-    await writeProjectConfigPair(projectPath, projectSplit, globalConfig, catalogue, agents, {
-      regenerateTypes: options.regenerateTypes ?? true
-    });
+    await writeProjectConfigPair(
+      projectPath,
+      provider,
+      projectSplit,
+      globalConfig,
+      catalogue,
+      agents,
+      { regenerateTypes: options.regenerateTypes ?? true }
+    );
     return true;
   });
 }
-async function propagateGlobalChangesToProjects(globalConfig, agents, currentProjectDir, options = {}) {
+async function propagateGlobalChangesToProjects(globalConfig, agents, provider, currentProjectDir, options = {}) {
   const projects = globalConfig.projects ?? [];
-  if (projects.length === 0) return { updated: [], skipped: [] };
+  const result = {
+    updated: [],
+    unreadable: [],
+    gone: [],
+    notOurs: [],
+    failed: []
+  };
+  if (projects.length === 0) return result;
   const currentNormalized = currentProjectDir ? normalizeProjectPath(currentProjectDir) : null;
-  const updated = [];
-  const skipped = [];
   for (const projectPath of projects) {
     if (currentNormalized && projectPath === currentNormalized) continue;
-    const projectConfigPath = getProjectConfigPath(projectPath);
-    if (!await fileExists(projectConfigPath)) {
-      skipped.push(projectPath);
-      verbose(`Skipped propagation to ${projectPath} (config not found)`);
-      continue;
-    }
-    try {
-      if (await propagateToProject(projectPath, globalConfig, agents, options)) {
-        updated.push(projectPath);
-        verbose(`Propagated global changes to ${projectPath}`);
-      } else {
-        skipped.push(projectPath);
-      }
-    } catch (error) {
-      skipped.push(projectPath);
-      verbose(`Failed to propagate to ${projectPath}: ${getErrorMessage(error)}`);
+    const outcome = await propagateToRegisteredProject(
+      projectPath,
+      provider,
+      globalConfig,
+      agents,
+      options
+    );
+    result[outcome].push(projectPath);
+  }
+  return result;
+}
+async function propagateToRegisteredProject(projectPath, provider, globalConfig, agents, options) {
+  if (!await holdsAnInstallation(projectPath)) {
+    verbose(`Skipped propagation to ${projectPath} (nothing installed there)`);
+    return "gone";
+  }
+  const notOurs = await whyThisProjectIsNotOurs(projectPath, provider);
+  if (notOurs !== null) {
+    verbose(`Skipped propagation to ${projectPath} (${notOurs})`);
+    return "notOurs";
+  }
+  try {
+    if (!await propagateToProject(projectPath, provider, globalConfig, agents, options)) {
+      return "gone";
     }
+    verbose(`Propagated global changes to ${projectPath}`);
+    return "updated";
+  } catch (error) {
+    verbose(`Failed to propagate to ${projectPath}: ${getErrorMessage(error)}`);
+    return error instanceof ConfigLoadError ? "unreadable" : "failed";
+  }
+}
+async function holdsAnInstallation(projectPath) {
+  const configs = await Promise.all(
+    PROVIDERS.map((installed) => fileExists(getProjectConfigPath(projectPath, installed)))
+  );
+  return configs.includes(true);
+}
+async function whyThisProjectIsNotOurs(projectPath, provider) {
+  const notOurs = `not a ${provider} installation`;
+  try {
+    if (providerInUse(projectPath) !== provider) return notOurs;
+  } catch (error) {
+    return getErrorMessage(error);
   }
-  return { updated, skipped };
+  return await fileExists(getProjectConfigPath(projectPath, provider)) ? null : notOurs;
 }
-async function pruneGlobalEntriesFromRegisteredProjects(globalConfig, agents) {
+async function pruneGlobalEntriesFromRegisteredProjects(globalConfig, agents, provider) {
   const emptiedGlobal = {
     ...globalConfig,
     skills: [],
     agents: []
   };
-  return propagateGlobalChangesToProjects(emptiedGlobal, agents);
+  return propagateGlobalChangesToProjects(emptiedGlobal, agents, provider);
 }
 async function resolveEffectiveGlobalConfig(globalSplit, existingGlobalConfig, projectDir, authority) {
-  const merged = authority === "all" ? matchGlobalToSession(globalSplit, existingGlobalConfig) : addSessionToGlobal(globalSplit, existingGlobalConfig);
+  const merged = authority === "all" ? matchGlobalToSession(globalSplit, existingGlobalConfig) : addSessionToGlobal(globalSplit, existingGlobalConfig, matrix);
   const registration = await registerProjectPath(merged.config, projectDir);
   return {
     config: registration.config,
@@ -871,21 +712,10 @@ async function resolveEffectiveGlobalConfig(globalSplit, existingGlobalConfig, p
     changed: merged.changed || registration.changed
   };
 }
-function addSessionToGlobal(globalSplit, existingGlobalConfig) {
-  const hasGlobalItems = globalSplit.skills.length > 0 || globalSplit.agents.length > 0;
-  if (!hasGlobalItems) {
-    return {
-      config: existingGlobalConfig ?? { name: GLOBAL_CONFIG_NAME, skills: [], agents: [] },
-      changed: false
-    };
-  }
-  if (!existingGlobalConfig) return { config: globalSplit, changed: true };
-  return mergeGlobalConfigs(existingGlobalConfig, globalSplit);
-}
 function matchGlobalToSession(globalSplit, existingGlobalConfig) {
   if (!existingGlobalConfig) return { config: globalSplit, changed: true };
   const config = mergeConfigs(globalSplit, existingGlobalConfig, { authoritativeScope: "all" });
-  return { config, changed: !isDeepEqual(config, existingGlobalConfig) };
+  return { config, changed: !isDeepEqual3(config, existingGlobalConfig) };
 }
 function stackCategories(stack) {
   return Object.values(stack ?? {}).flatMap((agentStack) => typedKeys(agentStack ?? {}));
@@ -906,185 +736,6 @@ function buildProjectTypesExtras(finalConfig, matrix2) {
   return { extraSkillIds, extraAgentNames, extraDomains, extraCategories };
 }
 
-// src/cli/lib/config-gate/index.ts
-import os2 from "os";
-import path2 from "path";
-
-// src/cli/lib/config-gate/classify.ts
-import { isDeepEqual as isDeepEqual2 } from "remeda";
-var NO_CHANGES = {
-  skills: { added: [], removed: [], sourceChanged: [], otherChanged: [] },
-  agents: { added: [], removed: [], changed: [] },
-  stackChanged: false,
-  selectedDomainsChanged: false,
-  scalarsChanged: [],
-  projectsChanged: false
-};
-var EXTRACTED_FIELDS2 = /* @__PURE__ */ new Set(["skills", "agents", "stack", "selectedDomains"]);
-var REGISTRATION_FIELD = "projects";
-function normalize(config) {
-  return JSON.parse(JSON.stringify(config));
-}
-function field(config, key) {
-  return config[key];
-}
-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_FIELDS2.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 || isDeepEqual2(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 && !isDeepEqual2(beforeEntry, after.get(name));
-    })
-  };
-}
-function classifyGlobalChange(prev, next) {
-  const before = prev ? normalize(prev) : {};
-  const after = normalize(next);
-  return {
-    skills: diffSkills(before, after),
-    agents: diffAgents(before, after),
-    stackChanged: !isDeepEqual2(field(before, "stack"), field(after, "stack")),
-    selectedDomainsChanged: !isDeepEqual2(
-      field(before, "selectedDomains"),
-      field(after, "selectedDomains")
-    ),
-    scalarsChanged: scalarKeys(before, after).filter(
-      (key) => !isDeepEqual2(field(before, key), field(after, key))
-    ),
-    projectsChanged: !isDeepEqual2(
-      field(before, REGISTRATION_FIELD),
-      field(after, 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 path from "path";
-function globalPairPaths() {
-  const dir = path.join(os.homedir(), CLAUDE_SRC_DIR);
-  return {
-    configPath: path.join(dir, STANDARD_FILES.CONFIG_TS),
-    typesPath: path.join(dir, STANDARD_FILES.CONFIG_TYPES_TS)
-  };
-}
-function typesPathFor(configPath) {
-  return path.join(path.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() {
-  const { configPath, typesPath } = globalPairPaths();
-  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;
-}
-
 // src/cli/lib/config-gate/recompile.ts
 var NOTHING_RECOMPILED = {
   rewrittenCount: 0,
@@ -1094,16 +745,25 @@ var NOTHING_RECOMPILED = {
 };
 async function recompilePropagated(projectDirs) {
   if (projectDirs.length === 0) return NOTHING_RECOMPILED;
-  const { recompilePropagatedProjectAgents: recompilePropagatedProjectAgents2 } = await import("./recompile-project-agents-VR4NLGOU.js");
+  const { recompilePropagatedProjectAgents: recompilePropagatedProjectAgents2 } = await import("./recompile-project-agents-DGNBCU3N.js");
   return recompilePropagatedProjectAgents2(projectDirs);
 }
 
 // src/cli/lib/config-gate/index.ts
-var NOTHING_PROPAGATED = { updated: [], skipped: [] };
+var NOTHING_PROPAGATED = {
+  updated: [],
+  unreadable: [],
+  gone: [],
+  notOurs: [],
+  failed: []
+};
+function movedGlobalAgentInputs(written) {
+  return tierRegeneratesTypes(consequenceTier(written.changes));
+}
 function report(globalWritten, changes, propagated = NOTHING_PROPAGATED, recompile = NOTHING_RECOMPILED) {
   return { globalWritten, changes, propagated, recompile };
 }
-async function applyConsequences(globalConfig, changes, deps, currentProjectDir) {
+async function applyConsequences(globalConfig, changes, deps, provider, currentProjectDir) {
   const tier = consequenceTier(changes);
   if (!tierPropagates(tier) || !globalConfig.projects?.length) {
     return { propagated: NOTHING_PROPAGATED, recompile: NOTHING_RECOMPILED };
@@ -1111,6 +771,7 @@ async function applyConsequences(globalConfig, changes, deps, currentProjectDir)
   const propagated = await propagateGlobalChangesToProjects(
     globalConfig,
     deps.agents,
+    provider,
     currentProjectDir,
     { regenerateTypes: tierRegeneratesTypes(tier) }
   );
@@ -1123,7 +784,7 @@ async function applyConsequences(globalConfig, changes, deps, currentProjectDir)
 function lazyGateDeps(projectDir) {
   return {
     loadMatrix: async () => {
-      const { loadSkillsMatrixFromSource: loadSkillsMatrixFromSource2 } = await import("./source-loader-GRBVNRAW.js");
+      const { loadSkillsMatrixFromSource: loadSkillsMatrixFromSource2 } = await import("./source-loader-7KZ3MD5O.js");
       const { matrix: matrix2 } = await loadSkillsMatrixFromSource2({
         projectDir,
         skipExtraSources: true,
@@ -1132,7 +793,7 @@ function lazyGateDeps(projectDir) {
       return matrix2;
     },
     loadAgents: async () => {
-      const { loadAgentDefs: loadAgentDefs2 } = await import("./load-agent-defs-7IM3GBEQ.js");
+      const { loadAgentDefs: loadAgentDefs2 } = await import("./load-agent-defs-3C27ENC7.js");
       return (await loadAgentDefs2()).agents;
     }
   };
@@ -1145,18 +806,20 @@ async function writeScopedFromWizard(args) {
     if (!isHomeDirectory(projectDir)) {
       return writeFromProjectContext(args, homeDir, deps);
     }
-    const priorGlobal = await loadProjectConfigFromDir(homeDir);
+    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);
+    const { propagated, recompile } = await applyConsequences(finalConfig, changes, deps, provider);
     return report(globalWritten, changes, propagated, recompile);
   });
 }
 async function writeFromProjectContext(args, homeDir, deps) {
-  const { finalConfig, matrix: matrix2, agents, projectDir, projectConfigPath } = args;
+  const { finalConfig, projectDir } = args;
   const { global: globalConfig, project: projectSplitConfig } = splitConfigByScope(finalConfig);
-  const globalConfigPath = getProjectConfigPath(homeDir);
-  const existingGlobal = await loadProjectConfigFromDir(homeDir);
+  const provider = providerInUse(projectDir);
+  const globalConfigPath = getProjectConfigPath(homeDir, provider);
+  const existingGlobal = await loadProjectConfigFromDir(homeDir, provider);
   const effective = await resolveEffectiveGlobalConfig(
     globalConfig,
     existingGlobal?.config,
@@ -1165,49 +828,70 @@ async function writeFromProjectContext(args, homeDir, deps) {
   );
   const effectiveGlobalConfig = effective.config;
   const changes = classifyGlobalChange(existingGlobal?.config, effectiveGlobalConfig);
-  let globalWritten = false;
-  if (effective.changed) {
-    await ensureDir(path2.dirname(globalConfigPath));
-    globalWritten = await writeGlobalPair(effectiveGlobalConfig, globalConfigPath, matrix2, agents);
-    verbose(`Updated global config at ${globalConfigPath}`);
-  } else {
-    verbose("Global config unchanged, skipping write");
-  }
+  const globalWritten = await writeGlobalPairWhenChanged(effective, globalConfigPath, deps);
   const { propagated, recompile } = await applyConsequences(
     effectiveGlobalConfig,
     changes,
     deps,
+    provider,
     projectDir
   );
   const reconciledProjectConfig = reconcileProjectSplitAgainstGlobal(
     projectSplitConfig,
     effectiveGlobalConfig,
-    matrix2
+    deps.matrix
   );
-  const hasProjectItems = reconciledProjectConfig.skills.length > 0 || reconciledProjectConfig.agents.length > 0;
-  if (args.projectInstallationExists || hasProjectItems) {
-    await ensureDir(path2.dirname(projectConfigPath));
-    await writeProjectConfigPair(
-      projectDir,
-      reconciledProjectConfig,
-      effectiveGlobalConfig,
-      matrix2,
-      agents
-    );
-    verbose(`Updated project config at ${projectConfigPath}`);
-  } else {
+  await writeProjectPairWhenOwed(
+    args,
+    provider,
+    reconciledProjectConfig,
+    effectiveGlobalConfig,
+    deps
+  );
+  return report(globalWritten, changes, propagated, recompile);
+}
+async function writeGlobalPairWhenChanged(effective, globalConfigPath, deps) {
+  if (!effective.changed) {
+    verbose("Global config unchanged, skipping write");
+    return false;
+  }
+  await ensureDir(path2.dirname(globalConfigPath));
+  const written = await writeGlobalPair(
+    effective.config,
+    globalConfigPath,
+    deps.matrix,
+    deps.agents
+  );
+  verbose(`Updated global config at ${globalConfigPath}`);
+  return written;
+}
+async function writeProjectPairWhenOwed(project, provider, reconciledProjectConfig, effectiveGlobalConfig, deps) {
+  if (!project.projectInstallationExists && !holdsAnythingOfItsOwn(reconciledProjectConfig)) {
     verbose(
       "Skipped project config \u2014 no existing project installation and no project-scoped items"
     );
+    return;
   }
-  return report(globalWritten, changes, propagated, recompile);
+  await ensureDir(path2.dirname(project.projectConfigPath));
+  await writeProjectConfigPair(
+    project.projectDir,
+    provider,
+    reconciledProjectConfig,
+    effectiveGlobalConfig,
+    deps.matrix,
+    deps.agents
+  );
+  verbose(`Updated project config at ${project.projectConfigPath}`);
+}
+function holdsAnythingOfItsOwn(projectConfig) {
+  return projectConfig.skills.length > 0 || projectConfig.agents.length > 0;
 }
 async function writeScopeConfigTypes(projectDir, config, deps, extras) {
   return withGateToken(async () => {
     if (isHomeDirectory(projectDir)) {
       return writeGlobalTypesHalf(
         config,
-        getProjectConfigPath(projectDir),
+        getInstalledConfigPath(projectDir),
         deps.matrix,
         deps.agents,
         extras
@@ -1230,6 +914,7 @@ async function reconcileTypesFromDisk(projectDir, config, deps, options) {
     const propagated = await propagateGlobalChangesToProjects(
       config,
       deps.agents,
+      providerInUse(projectDir),
       options?.currentProjectDir
     );
     if (propagated.updated.length > 0) {
@@ -1288,7 +973,8 @@ function fallbackNameFor(mutation) {
 async function mutateGlobal(mutation, deps) {
   return withGateToken(async () => {
     const homeDir = os2.homedir();
-    const loadedGlobal = await loadProjectConfigFromDir(homeDir);
+    const provider = providerInUse(homeDir);
+    const loadedGlobal = await loadProjectConfigFromDir(homeDir, provider);
     if (!loadedGlobal) return report(false, NO_CHANGES);
     const current = loadedGlobal.config;
     const mutated = applyMutation(mutation, current);
@@ -1296,15 +982,18 @@ async function mutateGlobal(mutation, deps) {
     const prior = fillRequiredFields(current, fallbackNameFor(mutation));
     const next = fillRequiredFields(mutated, fallbackNameFor(mutation));
     const changes = classifyGlobalChange(prior, next);
-    const globalWritten = await writeGlobalConfigHalf(next, getProjectConfigPath(homeDir));
+    const globalWritten = await writeGlobalConfigHalf(
+      next,
+      getProjectConfigPath(homeDir, provider)
+    );
     if (!next.projects?.length) return report(globalWritten, changes);
     const loaded = await resolveGateDeps(deps, consequenceTier(changes));
     if (!loaded) return report(globalWritten, changes);
-    const { propagated, recompile } = await applyConsequences(next, changes, loaded);
+    const { propagated, recompile } = await applyConsequences(next, changes, loaded, provider);
     return report(globalWritten, changes, propagated, recompile);
   });
 }
-async function propagateGlobalRemoval(preRemovalGlobalConfig, deps) {
+async function propagateGlobalRemoval(preRemovalGlobalConfig, deps, provider) {
   return withGateToken(async () => {
     const changes = classifyGlobalChange(preRemovalGlobalConfig, {
       ...preRemovalGlobalConfig,
@@ -1313,14 +1002,15 @@ async function propagateGlobalRemoval(preRemovalGlobalConfig, deps) {
     });
     const propagated = await pruneGlobalEntriesFromRegisteredProjects(
       preRemovalGlobalConfig,
-      deps.agents
+      deps.agents,
+      provider
     );
     const recompile = await recompilePropagated(propagated.updated);
     return report(false, changes, propagated, recompile);
   });
 }
-async function ensureBlankPair2() {
-  return withGateToken(() => ensureBlankPair());
+async function ensureBlankPair2(provider) {
+  return withGateToken(() => ensureBlankPair(provider));
 }
 function withNormalizedStack(partial) {
   if (!partial.stack) return partial;
@@ -1328,10 +1018,10 @@ function withNormalizedStack(partial) {
 }
 async function writeProjectPartial(projectDir, partial, options = {}) {
   if (isHomeDirectory(projectDir)) {
-    throw new GlobalPairWriteViolation(getProjectConfigPath(projectDir));
+    throw new GlobalPairWriteViolation(getInstalledConfigPath(projectDir));
   }
-  const configPath = getProjectConfigPath(projectDir);
-  await ensureDir(path2.join(projectDir, CLAUDE_SRC_DIR));
+  const configPath = getInstalledConfigPath(projectDir);
+  await ensureDir(path2.dirname(configPath));
   await writeFile(
     configPath,
     generateConfigSource(
@@ -1358,7 +1048,7 @@ async function writeProjectConfig(options) {
   const finalConfig = mergeResult.config;
   const isProjectContext = !isHomeDirectory(projectDir);
   if (isProjectContext) {
-    await ensureBlankPair2();
+    await ensureBlankPair2(providerInUse(projectDir));
   }
   const propagation = await writeScopedFromWizard({
     finalConfig,
@@ -1381,7 +1071,6 @@ async function writeProjectConfig(options) {
     ...mergeResult.existingConfigPath !== void 0 && {
       existingConfigPath: mergeResult.existingConfigPath
     },
-    filesWritten: isProjectContext ? 4 : 2,
     propagation
   };
 }
@@ -1404,13 +1093,19 @@ async function compileAgentsAllScopes(options) {
     outputDir: resolveInstallPaths(os3.homedir(), "global").agentsDir,
     scopeFilter: "global"
   });
-  const projectResult = await compileAgents({
-    ...base,
+  const projectResult = await compileProjectScope(options);
+  return mergeCompilationResults(globalResult, projectResult);
+}
+async function compileProjectScope(options) {
+  const { projectDir, sourcePath, skills, agentScopeMap } = options;
+  return compileAgents({
+    sourcePath,
+    skills,
+    agentScopeMap,
     projectDir,
     outputDir: resolveInstallPaths(projectDir, "project").agentsDir,
     scopeFilter: "project"
   });
-  return mergeCompilationResults(globalResult, projectResult);
 }
 function mergeCompilationResults(...results) {
   return {
@@ -1423,9 +1118,10 @@ function mergeCompilationResults(...results) {
 
 export {
   loadSource,
+  sayCapturedWarnings,
   detectProject,
   detectBothInstallations,
-  normalizeProjectPath,
+  movedGlobalAgentInputs,
   lazyGateDeps,
   reconcileTypesFromDisk,
   applyMigratedGlobalSources,
@@ -1434,6 +1130,7 @@ export {
   ensureBlankPair2 as ensureBlankPair,
   writeProjectPartial,
   writeProjectConfig,
-  compileAgentsAllScopes
+  compileAgentsAllScopes,
+  compileProjectScope
 };
-//# sourceMappingURL=chunk-X37UYIE3.js.map
+//# sourceMappingURL=chunk-G6UREQ4V.js.map