agents-inc 0.155.0 → 0.157.0

package/dist/chunk-Z3H2K5PK.js

@@ -0,0 +1,1352 @@
+#!/usr/bin/env node
+import {
+  compileAgents
+} from "./chunk-ZAQ6WMJV.js";
+import {
+  loadAgentDefs
+} from "./chunk-4KHUHPX4.js";
+import {
+  ConfigLoadError,
+  GlobalPairWriteViolation,
+  STACK_AGENT_CONFIG_LOOSE_LINE,
+  activeProjectAgentNames,
+  assembleConfigTypesSource,
+  assertGateToken,
+  buildAndMergeConfig,
+  buildConfigTypesBackgroundData,
+  deriveCategories,
+  deriveDomains,
+  detectGlobalInstallation,
+  detectInstallation,
+  detectProjectInstallation,
+  disableBuffering,
+  drainBuffer,
+  enableBuffering,
+  ensureDir,
+  fileExists,
+  generateConfigTypesSource,
+  getErrorMessage,
+  getProjectConfigPath,
+  isActiveAt,
+  isGlobalTombstone,
+  isHomeDirectory,
+  isSkillAssignment,
+  loadProjectConfig,
+  loadProjectConfigFromDir,
+  loadSkillsMatrixFromSource,
+  mergeConfigs,
+  normalizeStackRecord,
+  readFile,
+  regenerateConfigTypes,
+  resolveInstallPaths,
+  splitConfigByScope,
+  verbose,
+  withGateToken,
+  writeFile
+} from "./chunk-RVXI5VQU.js";
+import {
+  byCategoryDeclarationOrder,
+  matrix,
+  typedEntries,
+  typedKeys
+} from "./chunk-IGOFZG3S.js";
+import {
+  CLAUDE_SRC_DIR,
+  CLI_INVOKE_COMMAND,
+  DEFAULT_PLUGIN_NAME,
+  GLOBAL_CONFIG_NAME,
+  LOCAL_PSEUDO_CATEGORY,
+  STANDARD_FILES
+} from "./chunk-G6G2FT2G.js";
+
+// src/cli/lib/operations/source/load-source.ts
+async function loadSource(options) {
+  const { caller, sourceFlag, projectDir, captureStartupMessages } = options;
+  if (captureStartupMessages) {
+    enableBuffering();
+  }
+  let sourceResult;
+  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();
+    disableBuffering();
+  }
+  return { sourceResult, startupMessages };
+}
+
+// src/cli/lib/operations/project/detect-project.ts
+async function detectProject(projectDir) {
+  const resolvedDir = projectDir ?? process.cwd();
+  let installation;
+  try {
+    installation = await detectInstallation(resolvedDir);
+  } catch (error) {
+    if (error instanceof ConfigLoadError) return null;
+    throw error;
+  }
+  if (!installation) {
+    return null;
+  }
+  const loaded = await loadProjectConfig(installation.projectDir);
+  return {
+    installation,
+    config: loaded?.config ?? null,
+    configPath: loaded?.configPath ?? null
+  };
+}
+
+// src/cli/lib/operations/project/detect-both-installations.ts
+async function detectBothInstallations(projectDir) {
+  const global = await detectGlobalInstallation();
+  const project = isHomeDirectory(projectDir) ? null : await detectProjectInstallation(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/configuration/config-writer.ts
+import os from "os";
+import path from "path";
+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_FIELDS = new Set(CANONICAL_FIELD_ORDER);
+function canonicalizeFieldOrder(cleaned) {
+  const inSchemaOrder = CANONICAL_FIELD_ORDER.filter(
+    (key) => key in cleaned
+  ).map((key) => [key, cleaned[key]]);
+  const passthrough = Object.entries(cleaned).filter(([key]) => !CANONICAL_FIELDS.has(key));
+  return Object.fromEntries([...inSchemaOrder, ...passthrough]);
+}
+function withKeysOrderedBy(record, compareKeys) {
+  return Object.fromEntries(Object.entries(record).sort(([a], [b]) => compareKeys(a, b)));
+}
+function compareNamesInCodeUnitOrder(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+function canonicalizeStackOrder(stack) {
+  const byDeclaration = byCategoryDeclarationOrder();
+  const withCategoriesInOrder = Object.entries(stack).map(
+    ([agent, categories]) => [agent, withKeysOrderedBy(categories, byDeclaration)]
+  );
+  return withKeysOrderedBy(Object.fromEntries(withCategoriesInOrder), compareNamesInCodeUnitOrder);
+}
+function renderEntryLine(entry) {
+  return `  ${JSON.stringify(entry)},`;
+}
+function renderScalarField(key, value) {
+  return `  ${JSON.stringify(key)}: ${JSON.stringify(value)},`;
+}
+function extractConfigArrays(cleaned) {
+  return {
+    skills: cleaned.skills ?? [],
+    agents: cleaned.agents ?? [],
+    stack: cleaned.stack,
+    selectedDomains: cleaned.selectedDomains ?? []
+  };
+}
+function cleanForEmission(config, options) {
+  const cleaned = JSON.parse(JSON.stringify(config));
+  if (options.dropProjects) {
+    delete cleaned.projects;
+  }
+  if (cleaned.stack) {
+    const compacted = compactStackAssignments(
+      cleaned.stack
+    );
+    cleaned.stack = canonicalizeStackOrder(compacted);
+  }
+  return canonicalizeFieldOrder(cleaned);
+}
+function generateConfigSource(config, options) {
+  if (options?.isProjectConfig && options.globalConfig) {
+    return generateProjectConfigWithInlinedGlobal(
+      cleanForEmission(config, { dropProjects: true }),
+      cleanForEmission(options.globalConfig, { dropProjects: true })
+    );
+  }
+  if (options?.isProjectConfig) {
+    return generateProjectConfigWithGlobalImport(
+      cleanForEmission(config, { dropProjects: true }),
+      getGlobalConfigImportPath()
+    );
+  }
+  return generateStandaloneConfig(cleanForEmission(config, { dropProjects: false }));
+}
+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 = [`import type { ${typeImports} } from "./config-types";`];
+  if (hasSkills) {
+    lines.push(``);
+    lines.push(`const skills: SkillConfig[] = [`);
+    lines.push(skills.map(renderEntryLine).join("\n"));
+    lines.push(`];`);
+  }
+  if (hasAgents) {
+    lines.push(``);
+    lines.push(`const agents: AgentScopeConfig[] = [`);
+    lines.push(agents.map(renderEntryLine).join("\n"));
+    lines.push(`];`);
+  }
+  if (hasStack) {
+    lines.push(``);
+    const stackBody = JSON.stringify(stack, null, 2);
+    lines.push(`const stack: Partial<Record<ProjectAgentName, StackAgentConfig>> = ${stackBody};`);
+  }
+  if (hasSelectedDomains) {
+    lines.push(``);
+    const items = selectedDomains.map((d) => JSON.stringify(d)).join(", ");
+    lines.push(`const selectedDomains: Domain[] = [${items}];`);
+  }
+  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)).join(", ");
+}
+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({
+    hasSkills: true,
+    // Always present (spread from global)
+    hasAgents: true,
+    // Always present (spread from global)
+    hasStack,
+    hasSelectedDomains: hasProjectDomains
+  });
+  const lines = [
+    `import globalConfig from "${importPath}";`,
+    `import type { ${typeImports} } from "./config-types";`
+  ];
+  lines.push(``);
+  const skillItems = skills.map(renderEntryLine).join("\n");
+  lines.push(`const skills: SkillConfig[] = [`);
+  lines.push(`  ...globalConfig.skills,`);
+  if (skillItems) lines.push(skillItems);
+  lines.push(`];`);
+  lines.push(``);
+  const agentItems = agents.map(renderEntryLine).join("\n");
+  lines.push(`const agents: AgentScopeConfig[] = [`);
+  lines.push(`  ...globalConfig.agents,`);
+  if (agentItems) lines.push(agentItems);
+  lines.push(`];`);
+  if (hasStack) {
+    lines.push(``);
+    const stackBody = JSON.stringify(stack, null, 2);
+    lines.push(`const stack: Partial<Record<ProjectAgentName, StackAgentConfig>> = ${stackBody};`);
+  }
+  if (hasProjectDomains) {
+    lines.push(``);
+    const domainItems = selectedDomains.map(renderEntryLine).join("\n");
+    lines.push(`const selectedDomains: Domain[] = [`);
+    lines.push(`  ...(globalConfig.selectedDomains ?? []),`);
+    if (domainItems) lines.push(domainItems);
+    lines.push(`];`);
+  }
+  const scalarFields = Object.entries(cleaned).filter(([key]) => !EXTRACTED_FIELDS.has(key) && key !== "name").map(([key, value]) => renderScalarField(key, value)).join("\n");
+  const exportFields = [
+    `  ...globalConfig,`,
+    `  name: ${JSON.stringify(resolveProjectName(cleaned))},`,
+    `  skills,`,
+    `  agents,`,
+    ...hasStack ? [`  stack,`] : [],
+    ...hasProjectDomains ? [`  selectedDomains,`] : [],
+    ...scalarFields ? [scalarFields] : []
+  ];
+  lines.push(``);
+  lines.push(`export default {`);
+  lines.push(...exportFields);
+  lines.push(`} satisfies ProjectConfig;`);
+  lines.push(``);
+  return lines.join("\n");
+}
+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;
+  return {
+    globalSkills,
+    globalAgents,
+    projectSkills,
+    projectAgents,
+    filteredStack,
+    selectedDomains: [.../* @__PURE__ */ new Set([...global.selectedDomains, ...project.selectedDomains])]
+  };
+}
+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 = [`import type { ${typeImports} } from "./config-types";`];
+  if (hasSkills) {
+    lines.push(``);
+    lines.push(`const skills: SkillConfig[] = [`);
+    lines.push(
+      ...hasGlobalSkills ? [`  // global`, ...globalSkills.map(renderEntryLine)] : [],
+      ...hasProjectSkills ? [`  // project`, ...projectSkills.map(renderEntryLine)] : []
+    );
+    lines.push(`];`);
+  }
+  if (hasAgents) {
+    lines.push(``);
+    lines.push(`const agents: AgentScopeConfig[] = [`);
+    lines.push(
+      ...hasGlobalAgents ? [`  // global`, ...globalAgents.map(renderEntryLine)] : [],
+      ...hasProjectAgents ? [`  // project`, ...projectAgents.map(renderEntryLine)] : []
+    );
+    lines.push(`];`);
+  }
+  if (hasStack) {
+    lines.push(``);
+    const stackBody = JSON.stringify(filteredStack, null, 2);
+    lines.push(`const stack: Partial<Record<ProjectAgentName, StackAgentConfig>> = ${stackBody};`);
+  }
+  if (hasSelectedDomains) {
+    lines.push(``);
+    const items = partition.selectedDomains.map((d) => JSON.stringify(d)).join(", ");
+    lines.push(`const selectedDomains: Domain[] = [${items}];`);
+  }
+  const scalarFields = mergeInlinedScalarFields(cleaned, cleanedGlobal);
+  const exportFields = [
+    `  name: ${JSON.stringify(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 carriesFlags(assignment) {
+  return Boolean(assignment.preloaded || assignment.local || assignment.path);
+}
+function compactAssignment(assignment) {
+  if (isSkillAssignment(assignment) && !carriesFlags(assignment)) return assignment.id;
+  return assignment;
+}
+function isExclusiveCategory(category) {
+  return matrix.categories[category]?.exclusive === true;
+}
+function compactCategoryAssignments(category, assignments) {
+  const compacted = assignments.map(compactAssignment);
+  if (!isExclusiveCategory(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) {
+  return Object.fromEntries(
+    Object.entries(categories).filter(([, assignments]) => Array.isArray(assignments) && assignments.length > 0).map(([category, assignments]) => [
+      category,
+      compactCategoryAssignments(category, assignments)
+    ])
+  );
+}
+function compactStackAssignments(stack) {
+  return Object.fromEntries(
+    Object.entries(stack).map(([agent, categories]) => [agent, compactCategories(categories)]).filter(([, categories]) => Object.keys(categories).length > 0)
+  );
+}
+function getGlobalConfigImportPath() {
+  return path.join(os.homedir(), CLAUDE_SRC_DIR);
+}
+function generateBlankGlobalConfigSource() {
+  return `import type { ProjectConfig } from "./config-types";
+
+export default {
+  "name": "${GLOBAL_CONFIG_NAME}",
+  "skills": [],
+  "agents": [],
+  "selectedDomains": []
+} satisfies ProjectConfig;
+`;
+}
+function generateBlankGlobalConfigTypesSource() {
+  return assembleConfigTypesSource({
+    skillId: "never",
+    agentName: "never",
+    selectedAgentName: "never",
+    projectAgentName: "SelectedAgentName",
+    domain: "never",
+    category: "never",
+    stackAgentConfig: STACK_AGENT_CONFIG_LOOSE_LINE
+  });
+}
+
+// src/cli/lib/config-gate/propagate.ts
+async function writeConfigFile(config, configPath, options) {
+  const source = generateConfigSource(config, options);
+  await writeFile(configPath, source);
+}
+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
+  )) {
+    if (!incomingAgentStack) continue;
+    const existingAgentStack = merged[agentName];
+    if (!existingAgentStack) {
+      merged[agentName] = structuredClone(incomingAgentStack);
+      changed = true;
+      continue;
+    }
+    if (mergeAgentCategories(existingAgentStack, incomingAgentStack)) {
+      changed = true;
+    }
+  }
+  return { stack: merged, changed };
+}
+function mergeAgentCategories(existingAgentStack, incomingAgentStack) {
+  let changed = false;
+  for (const [category, incomingAssignments] of typedEntries(
+    incomingAgentStack
+  )) {
+    if (!incomingAssignments) continue;
+    const existingAssignments = existingAgentStack[category];
+    if (!existingAssignments) {
+      existingAgentStack[category] = incomingAssignments.map((a) => ({ ...a }));
+      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;
+      }
+    }
+  }
+  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 mergedSkills = [...existing.skills, ...newSkills];
+  const mergedAgents = [...existing.agents, ...newAgents];
+  const { stack: mergedStack, changed: stackChanged } = additiveMergeStack(
+    existing.stack,
+    incoming.stack
+  );
+  const mergedSelectedDomains = [
+    .../* @__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;
+  return {
+    config: {
+      ...existing,
+      skills: mergedSkills,
+      agents: mergedAgents,
+      stack: mergedStack,
+      selectedDomains: mergedSelectedDomains,
+      ...mergedMarketplaceName !== void 0 && { marketplaceName: mergedMarketplaceName },
+      ...mergedMarketplace !== void 0 && { marketplace: mergedMarketplace }
+    },
+    changed
+  };
+}
+function normalizeProjectPath(projectDir) {
+  return fs.realpathSync(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(getProjectConfigPath(p))
+    }))
+  );
+  const valid = staleChecks.filter((c) => c.hasConfig).map((c) => c.path);
+  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";
+}
+function globalHasActiveSkill(globalConfig, id) {
+  return globalConfig.skills.some((s) => s.id === id && isActiveAt(s, "global"));
+}
+function globalHasActiveAgent(globalConfig, name) {
+  return globalConfig.agents.some((a) => a.name === name && isActiveAt(a, "global"));
+}
+function retainProjectOwnedSkills(skills, globalConfig) {
+  return skills.filter(
+    (entry) => isProjectScopedEntry(entry) || isGlobalTombstone(entry) && globalHasActiveSkill(globalConfig, entry.id)
+  );
+}
+function retainProjectOwnedAgents(agents, globalConfig) {
+  return agents.filter(
+    (entry) => isProjectScopedEntry(entry) || isGlobalTombstone(entry) && globalHasActiveAgent(globalConfig, entry.name)
+  );
+}
+function categoryOfSkill(id, matrix2) {
+  const category = matrix2.skills[id]?.category;
+  if (category === void 0 || category === LOCAL_PSEUDO_CATEGORY) return void 0;
+  return category;
+}
+function isExclusiveCategory2(category, matrix2) {
+  return matrix2.categories[category]?.exclusive === true;
+}
+function activeProjectCategories(projectOwnedSkills, matrix2) {
+  return new Set(
+    projectOwnedSkills.filter((s) => isActiveAt(s, "project")).map((s) => categoryOfSkill(s.id, matrix2)).filter((category) => category !== void 0)
+  );
+}
+function buildProjectCollisionTest(projectOwnedSkills, matrix2) {
+  const ownedIds = new Set(
+    projectOwnedSkills.filter((s) => isActiveAt(s, "project")).map((s) => s.id)
+  );
+  const occupiedExclusiveCategories = new Set(
+    [...activeProjectCategories(projectOwnedSkills, matrix2)].filter(
+      (category) => isExclusiveCategory2(category, matrix2)
+    )
+  );
+  return (id) => {
+    if (ownedIds.has(id)) return true;
+    const category = categoryOfSkill(id, matrix2);
+    return category !== void 0 && occupiedExclusiveCategories.has(category);
+  };
+}
+function dropOrphanedDerivedMasks(projectOwnedSkills, matrix2) {
+  const collidesWithProjectOwnership = buildProjectCollisionTest(projectOwnedSkills, matrix2);
+  return projectOwnedSkills.filter(
+    (entry) => !isGlobalTombstone(entry) || collidesWithProjectOwnership(entry.id)
+  );
+}
+function dropOrphanedDerivedAgentMasks(projectOwnedAgents) {
+  const ownedNames = new Set(activeProjectAgentNames(projectOwnedAgents));
+  return projectOwnedAgents.filter(
+    (entry) => !isGlobalTombstone(entry) || ownedNames.has(entry.name)
+  );
+}
+function maskCollidingGlobalSkills(projectOwnedSkills, globalConfig, matrix2) {
+  const collidesWithProjectOwnership = buildProjectCollisionTest(projectOwnedSkills, matrix2);
+  const alreadyTombstoned = new Set(projectOwnedSkills.filter(isGlobalTombstone).map((s) => s.id));
+  return globalConfig.skills.filter(
+    (globalEntry) => isActiveAt(globalEntry, "global") && collidesWithProjectOwnership(globalEntry.id) && !alreadyTombstoned.has(globalEntry.id)
+  ).map((globalEntry) => ({ ...globalEntry, excluded: true }));
+}
+function maskCollidingGlobalAgents(projectOwnedAgents, globalConfig) {
+  const ownedNames = new Set(activeProjectAgentNames(projectOwnedAgents));
+  const alreadyTombstoned = new Set(
+    projectOwnedAgents.filter(isGlobalTombstone).map((a) => a.name)
+  );
+  return globalConfig.agents.filter(
+    (globalEntry) => isActiveAt(globalEntry, "global") && ownedNames.has(globalEntry.name) && !alreadyTombstoned.has(globalEntry.name)
+  ).map((globalEntry) => ({ ...globalEntry, excluded: true }));
+}
+function reconcileProjectSplitAgainstGlobal(projectSplit, globalConfig, matrix2) {
+  const healedSkills = dropOrphanedDerivedMasks(projectSplit.skills, matrix2);
+  const healedAgents = dropOrphanedDerivedAgentMasks(projectSplit.agents);
+  return {
+    ...projectSplit,
+    skills: [...healedSkills, ...maskCollidingGlobalSkills(healedSkills, globalConfig, matrix2)],
+    agents: [...healedAgents, ...maskCollidingGlobalAgents(healedAgents, globalConfig)]
+  };
+}
+function computeRemovedGlobalSkillIds(priorProjectSkills, globalConfig) {
+  const activeGlobalIds = new Set(
+    globalConfig.skills.filter((s) => isActiveAt(s, "global")).map((s) => s.id)
+  );
+  const projectOwnedIds = new Set(
+    priorProjectSkills.filter((s) => isActiveAt(s, "project")).map((s) => s.id)
+  );
+  return new Set(
+    priorProjectSkills.filter(
+      (s) => s.scope === "global" && !s.excluded && !activeGlobalIds.has(s.id) && !projectOwnedIds.has(s.id)
+    ).map((s) => s.id)
+  );
+}
+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;
+    }
+    if (typedKeys(reconciledAgentStack).length > 0) {
+      reconciled[agent] = reconciledAgentStack;
+    }
+  }
+  return reconciled;
+}
+async function writeProjectConfigPair(projectDir, reconciledSplit, effectiveGlobal, matrix2, agents, options = {}) {
+  await writeConfigFile(reconciledSplit, getProjectConfigPath(projectDir), {
+    isProjectConfig: true,
+    globalConfig: effectiveGlobal
+  });
+  if (options.regenerateTypes === false) return;
+  await regenerateConfigTypes(
+    projectDir,
+    Promise.resolve(buildConfigTypesBackgroundData(matrix2, agents)),
+    buildProjectTypesExtras(inlinedProjectView(reconciledSplit, effectiveGlobal), matrix2)
+  );
+}
+function inlinedProjectView(reconciledSplit, effectiveGlobal) {
+  return {
+    ...reconciledSplit,
+    skills: [...effectiveGlobal.skills, ...reconciledSplit.skills],
+    agents: [...effectiveGlobal.agents, ...reconciledSplit.agents],
+    selectedDomains: unique([
+      ...effectiveGlobal.selectedDomains ?? [],
+      ...reconciledSplit.selectedDomains ?? []
+    ]),
+    stack: { ...effectiveGlobal.stack ?? {}, ...reconciledSplit.stack ?? {} }
+  };
+}
+async function propagateGlobalChangesToProjects(globalConfig, matrix2, agents, currentProjectDir, options = {}) {
+  const projects = globalConfig.projects ?? [];
+  if (projects.length === 0) return { updated: [], skipped: [] };
+  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 {
+      const existingProject = await loadProjectConfigFromDir(projectPath);
+      if (!existingProject?.config) {
+        skipped.push(projectPath);
+        continue;
+      }
+      const projectConfig = existingProject.config;
+      const removedGlobalSkillIds = computeRemovedGlobalSkillIds(
+        projectConfig.skills,
+        globalConfig
+      );
+      const retained = retainReconciledStack(projectConfig.stack, removedGlobalSkillIds);
+      const reconciledStack = retained === void 0 ? {} : { stack: retained };
+      const projectSplit = reconcileProjectSplitAgainstGlobal(
+        {
+          ...projectConfig,
+          skills: retainProjectOwnedSkills(projectConfig.skills, globalConfig),
+          agents: retainProjectOwnedAgents(projectConfig.agents, globalConfig),
+          ...reconciledStack
+        },
+        globalConfig,
+        matrix2
+      );
+      await writeProjectConfigPair(projectPath, projectSplit, globalConfig, matrix2, agents, {
+        regenerateTypes: options.regenerateTypes ?? true
+      });
+      updated.push(projectPath);
+      verbose(`Propagated global changes to ${projectPath}`);
+    } catch (error) {
+      skipped.push(projectPath);
+      verbose(`Failed to propagate to ${projectPath}: ${getErrorMessage(error)}`);
+    }
+  }
+  return { updated, skipped };
+}
+async function pruneGlobalEntriesFromRegisteredProjects(globalConfig, matrix2, agents) {
+  const emptiedGlobal = {
+    ...globalConfig,
+    skills: [],
+    agents: []
+  };
+  return propagateGlobalChangesToProjects(emptiedGlobal, matrix2, agents);
+}
+async function resolveEffectiveGlobalConfig(globalSplit, existingGlobalConfig, projectDir, authority) {
+  const merged = authority === "all" ? matchGlobalToSession(globalSplit, existingGlobalConfig) : addSessionToGlobal(globalSplit, existingGlobalConfig);
+  const registration = await registerProjectPath(merged.config, projectDir);
+  return {
+    config: registration.config,
+    globalDataChanged: merged.changed,
+    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) };
+}
+function stackCategories(stack) {
+  return Object.values(stack ?? {}).flatMap((agentStack) => typedKeys(agentStack ?? {}));
+}
+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([
+    ...deriveCategories(extraSkillIds, matrix2),
+    ...stackCategories(finalConfig.stack)
+  ]);
+  const extraDomains = unique([
+    ...deriveDomains(extraCategories, matrix2),
+    ...finalConfig.selectedDomains ?? []
+  ]);
+  return { extraSkillIds, extraAgentNames, extraDomains, extraCategories };
+}
+
+// src/cli/lib/config-gate/index.ts
+import os3 from "os";
+import path3 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 os2 from "os";
+import path2 from "path";
+function globalPairPaths() {
+  const dir = path2.join(os2.homedir(), CLAUDE_SRC_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));
+}
+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));
+  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(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,
+  unchangedCount: 0,
+  failedCount: 0,
+  warnings: []
+};
+async function recompilePropagated(projectDirs) {
+  if (projectDirs.length === 0) return NOTHING_RECOMPILED;
+  const { recompilePropagatedProjectAgents: recompilePropagatedProjectAgents2 } = await import("./recompile-project-agents-G7ZM25PC.js");
+  return recompilePropagatedProjectAgents2(projectDirs);
+}
+
+// src/cli/lib/config-gate/index.ts
+var NOTHING_PROPAGATED = { updated: [], skipped: [] };
+function report(globalWritten, changes, propagated = NOTHING_PROPAGATED, recompile = NOTHING_RECOMPILED) {
+  return { globalWritten, changes, propagated, recompile };
+}
+async function applyConsequences(globalConfig, changes, deps, currentProjectDir) {
+  const tier = consequenceTier(changes);
+  if (!tierPropagates(tier) || !globalConfig.projects?.length) {
+    return { propagated: NOTHING_PROPAGATED, recompile: NOTHING_RECOMPILED };
+  }
+  const propagated = await propagateGlobalChangesToProjects(
+    globalConfig,
+    deps.matrix,
+    deps.agents,
+    currentProjectDir,
+    { regenerateTypes: tierRegeneratesTypes(tier) }
+  );
+  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 };
+}
+function lazyGateDeps(projectDir) {
+  return {
+    loadMatrix: async () => {
+      const { loadSkillsMatrixFromSource: loadSkillsMatrixFromSource2 } = await import("./source-loader-BIAEDR5R.js");
+      const { matrix: matrix2 } = await loadSkillsMatrixFromSource2({
+        projectDir,
+        skipExtraSources: true,
+        matrixOnly: true
+      });
+      return matrix2;
+    },
+    loadAgents: async () => {
+      const { loadAgentDefs: loadAgentDefs2 } = await import("./load-agent-defs-M6LRVISN.js");
+      return (await loadAgentDefs2()).agents;
+    }
+  };
+}
+async function writeScopedFromWizard(args) {
+  return withGateToken(async () => {
+    const { finalConfig, matrix: matrix2, agents, projectDir, projectConfigPath } = args;
+    const homeDir = os3.homedir();
+    const deps = { matrix: matrix2, agents };
+    if (!isHomeDirectory(projectDir)) {
+      return writeFromProjectContext(args, homeDir, deps);
+    }
+    const priorGlobal = await loadProjectConfigFromDir(homeDir);
+    const changes = classifyGlobalChange(priorGlobal?.config, finalConfig);
+    const globalWritten = await writeGlobalPair(finalConfig, projectConfigPath, matrix2, agents);
+    const { propagated, recompile } = await applyConsequences(finalConfig, changes, deps);
+    return report(globalWritten, changes, propagated, recompile);
+  });
+}
+async function writeFromProjectContext(args, homeDir, deps) {
+  const { finalConfig, matrix: matrix2, agents, projectDir, projectConfigPath } = args;
+  const { global: globalConfig, project: projectSplitConfig } = splitConfigByScope(finalConfig);
+  const globalConfigPath = getProjectConfigPath(homeDir);
+  const existingGlobal = await loadProjectConfigFromDir(homeDir);
+  const effective = await resolveEffectiveGlobalConfig(
+    globalConfig,
+    existingGlobal?.config,
+    projectDir,
+    args.authoritativeScope
+  );
+  const effectiveGlobalConfig = effective.config;
+  const changes = classifyGlobalChange(existingGlobal?.config, effectiveGlobalConfig);
+  let globalWritten = false;
+  if (effective.changed) {
+    await ensureDir(path3.dirname(globalConfigPath));
+    globalWritten = await writeGlobalPair(effectiveGlobalConfig, globalConfigPath, matrix2, agents);
+    verbose(`Updated global config at ${globalConfigPath}`);
+  } else {
+    verbose("Global config unchanged, skipping write");
+  }
+  const { propagated, recompile } = await applyConsequences(
+    effectiveGlobalConfig,
+    changes,
+    deps,
+    projectDir
+  );
+  const reconciledProjectConfig = reconcileProjectSplitAgainstGlobal(
+    projectSplitConfig,
+    effectiveGlobalConfig,
+    matrix2
+  );
+  const hasProjectItems = reconciledProjectConfig.skills.length > 0 || reconciledProjectConfig.agents.length > 0;
+  if (args.projectInstallationExists || hasProjectItems) {
+    await ensureDir(path3.dirname(projectConfigPath));
+    await writeProjectConfigPair(
+      projectDir,
+      reconciledProjectConfig,
+      effectiveGlobalConfig,
+      matrix2,
+      agents
+    );
+    verbose(`Updated project config at ${projectConfigPath}`);
+  } else {
+    verbose(
+      "Skipped project config \u2014 no existing project installation and no project-scoped items"
+    );
+  }
+  return report(globalWritten, changes, propagated, recompile);
+}
+async function writeScopeConfigTypes(projectDir, config, deps, extras) {
+  return withGateToken(async () => {
+    if (isHomeDirectory(projectDir)) {
+      return writeGlobalTypesHalf(
+        config,
+        getProjectConfigPath(projectDir),
+        deps.matrix,
+        deps.agents,
+        extras
+      );
+    }
+    await regenerateConfigTypes(
+      projectDir,
+      Promise.resolve(buildConfigTypesBackgroundData(deps.matrix, deps.agents)),
+      extras ?? buildProjectTypesExtras(config, deps.matrix)
+    );
+    return false;
+  });
+}
+async function reconcileTypesFromDisk(projectDir, config, deps, options) {
+  return withGateToken(async () => {
+    const changes = classifyGlobalChange(void 0, config);
+    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.matrix,
+      deps.agents,
+      options?.currentProjectDir
+    );
+    if (propagated.updated.length > 0) {
+      verbose(`Propagated global changes to ${propagated.updated.length} project(s)`);
+    }
+    const recompile = await recompilePropagated(propagated.updated);
+    return report(globalWritten, changes, propagated, recompile);
+  });
+}
+function withMigratedSource(skill, migratedSources) {
+  if (!isActiveAt(skill, "global")) return skill;
+  const origin = migratedSources.get(skill.id);
+  if (origin === void 0 || origin === skill.origin) return skill;
+  return { ...skill, origin };
+}
+function applyMigratedGlobalSources(globalSkills, migratedSources) {
+  const skills = globalSkills.map((skill) => withMigratedSource(skill, migratedSources));
+  return { skills, changed: skills.some((skill, index) => skill !== globalSkills[index]) };
+}
+function fillRequiredFields(partial, fallbackName) {
+  const name = partial.name ?? fallbackName;
+  if (!name) {
+    throw new Error(
+      `Cannot write config: no project config found. Run \`${CLI_INVOKE_COMMAND} init\` first.`
+    );
+  }
+  return { ...partial, name, skills: partial.skills ?? [], agents: partial.agents ?? [] };
+}
+function applyMutation(mutation, current) {
+  switch (mutation.kind) {
+    case "migrate-skill-sources": {
+      const { skills, changed } = applyMigratedGlobalSources(
+        current.skills ?? [],
+        mutation.sources
+      );
+      return changed ? { ...current, skills } : null;
+    }
+    case "deregister-project": {
+      const projects = current.projects ?? [];
+      if (projects.length === 0) return null;
+      const normalized = normalizeProjectPath(mutation.projectDir);
+      const filtered = projects.filter((p) => p !== normalized);
+      return filtered.length === projects.length ? null : { ...current, projects: filtered };
+    }
+    case "set-source":
+      return { ...current, marketplace: mutation.source };
+    default: {
+      const _exhaustive = mutation;
+      return _exhaustive;
+    }
+  }
+}
+function fallbackNameFor(mutation) {
+  return mutation.kind === "set-source" ? mutation.fallbackName : void 0;
+}
+async function mutateGlobal(mutation, deps) {
+  return withGateToken(async () => {
+    const homeDir = os3.homedir();
+    const loadedGlobal = await loadProjectConfigFromDir(homeDir);
+    if (!loadedGlobal) return report(false, NO_CHANGES);
+    const current = loadedGlobal.config;
+    const mutated = applyMutation(mutation, current);
+    if (!mutated) return report(false, NO_CHANGES);
+    const prior = fillRequiredFields(current, fallbackNameFor(mutation));
+    const next = fillRequiredFields(mutated, fallbackNameFor(mutation));
+    const changes = classifyGlobalChange(prior, next);
+    const globalWritten = await writeGlobalConfigHalf(next, getProjectConfigPath(homeDir));
+    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);
+    return report(globalWritten, changes, propagated, recompile);
+  });
+}
+async function propagateGlobalRemoval(preRemovalGlobalConfig, deps) {
+  return withGateToken(async () => {
+    const changes = classifyGlobalChange(preRemovalGlobalConfig, {
+      ...preRemovalGlobalConfig,
+      skills: [],
+      agents: []
+    });
+    const propagated = await pruneGlobalEntriesFromRegisteredProjects(
+      preRemovalGlobalConfig,
+      deps.matrix,
+      deps.agents
+    );
+    const recompile = await recompilePropagated(propagated.updated);
+    return report(false, changes, propagated, recompile);
+  });
+}
+async function ensureBlankPair2() {
+  return withGateToken(() => ensureBlankPair());
+}
+function withNormalizedStack(partial) {
+  if (!partial.stack) return partial;
+  return { ...partial, stack: normalizeStackRecord(partial.stack) };
+}
+async function writeProjectPartial(projectDir, partial, options = {}) {
+  if (isHomeDirectory(projectDir)) {
+    throw new GlobalPairWriteViolation(getProjectConfigPath(projectDir));
+  }
+  const configPath = getProjectConfigPath(projectDir);
+  await ensureDir(path3.join(projectDir, CLAUDE_SRC_DIR));
+  await writeFile(
+    configPath,
+    generateConfigSource(fillRequiredFields(withNormalizedStack(partial), options.fallbackName))
+  );
+}
+
+// src/cli/lib/operations/project/write-project-config.ts
+import path4 from "path";
+async function writeProjectConfig(options) {
+  const { wizardResult, sourceResult, projectDir, sourceFlag } = options;
+  const projectPaths = resolveInstallPaths(projectDir, "project");
+  await ensureDir(path4.dirname(projectPaths.configPath));
+  const { agents } = options.agentDefs ?? await loadAgentDefs();
+  const mergeResult = await buildAndMergeConfig(
+    wizardResult,
+    sourceResult,
+    projectDir,
+    sourceFlag,
+    options.authoritativeScope
+  );
+  const finalConfig = mergeResult.config;
+  const isProjectContext = !isHomeDirectory(projectDir);
+  if (isProjectContext) {
+    await ensureBlankPair2();
+  }
+  const propagation = await writeScopedFromWizard({
+    finalConfig,
+    matrix: sourceResult.matrix,
+    agents,
+    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.
+    ...options.authoritativeScope !== void 0 && {
+      authoritativeScope: options.authoritativeScope
+    }
+  });
+  return {
+    config: finalConfig,
+    configPath: projectPaths.configPath,
+    wasMerged: mergeResult.merged,
+    ...mergeResult.existingConfigPath !== void 0 && {
+      existingConfigPath: mergeResult.existingConfigPath
+    },
+    filesWritten: isProjectContext ? 4 : 2,
+    propagation
+  };
+}
+
+// src/cli/lib/operations/project/compile-agents-all-scopes.ts
+import os4 from "os";
+async function compileAgentsAllScopes(options) {
+  const { projectDir, sourcePath, skills, agentScopeMap } = options;
+  const base = { sourcePath, skills, agentScopeMap };
+  if (isHomeDirectory(projectDir)) {
+    return compileAgents({
+      ...base,
+      projectDir,
+      outputDir: resolveInstallPaths(projectDir, "project").agentsDir
+    });
+  }
+  const globalResult = await compileAgents({
+    ...base,
+    projectDir: os4.homedir(),
+    outputDir: resolveInstallPaths(os4.homedir(), "global").agentsDir,
+    scopeFilter: "global"
+  });
+  const projectResult = await compileAgents({
+    ...base,
+    projectDir,
+    outputDir: resolveInstallPaths(projectDir, "project").agentsDir,
+    scopeFilter: "project"
+  });
+  return mergeCompilationResults(globalResult, projectResult);
+}
+function mergeCompilationResults(...results) {
+  return {
+    compiled: results.flatMap((r) => r.compiled),
+    rewritten: results.flatMap((r) => r.rewritten),
+    failed: results.flatMap((r) => r.failed),
+    warnings: results.flatMap((r) => r.warnings)
+  };
+}
+
+export {
+  loadSource,
+  detectProject,
+  detectBothInstallations,
+  normalizeProjectPath,
+  lazyGateDeps,
+  reconcileTypesFromDisk,
+  applyMigratedGlobalSources,
+  mutateGlobal,
+  propagateGlobalRemoval,
+  ensureBlankPair2 as ensureBlankPair,
+  writeProjectPartial,
+  writeProjectConfig,
+  compileAgentsAllScopes
+};
+//# sourceMappingURL=chunk-Z3H2K5PK.js.map