agents-inc 0.149.2 → 0.150.0

package/dist/chunk-MC5DUZ3V.js

@@ -0,0 +1,1135 @@
+#!/usr/bin/env node
+import {
+  deriveInstallMode,
+  getAvailableSkills,
+  getUnmetRequiredBy,
+  isActiveAt,
+  isCompatibleWithSelections,
+  isGlobalTombstone,
+  isProjectOwned
+} from "./chunk-KH7MOIM5.js";
+import {
+  warn
+} from "./chunk-3LIU2ZEF.js";
+import {
+  getCategoryDomain,
+  getSkillById,
+  matrix
+} from "./chunk-DJAZE4PD.js";
+import {
+  typedEntries,
+  typedFromEntries,
+  typedKeys,
+  typedValues
+} from "./chunk-VEP23B5W.js";
+import {
+  BUILT_IN_DOMAIN_ORDER,
+  DEFAULT_PUBLIC_SOURCE_NAME,
+  EJECT_SOURCE,
+  FALLBACK_DOMAIN
+} from "./chunk-O5ASLZ2K.js";
+import {
+  init_esm_shims
+} from "./chunk-P56WJ5FA.js";
+
+// src/cli/stores/wizard-store.ts
+init_esm_shims();
+import { flatMap } from "remeda";
+import { create } from "zustand";
+
+// src/cli/lib/wizard/index.ts
+init_esm_shims();
+
+// src/cli/lib/wizard/build-step-logic.ts
+init_esm_shims();
+import { sortBy } from "remeda";
+
+// src/cli/lib/wizard/scope-diff.ts
+init_esm_shims();
+function computeScopeDiff(input) {
+  const { currentSkills, currentAgents, installedSkillConfigs, installedAgentConfigs, isInitMode } = input;
+  const projectSkills = currentSkills.filter((s) => s.scope === "project" && !s.excluded);
+  const globalSkills = currentSkills.filter((s) => s.scope === "global" && !s.excluded);
+  const projectAgents = currentAgents.filter((a) => a.scope === "project" && !a.excluded);
+  const globalAgents = currentAgents.filter((a) => a.scope === "global" && !a.excluded);
+  const excludedGlobalSkills = currentSkills.filter((s) => s.scope === "global" && !!s.excluded);
+  const excludedGlobalAgents = currentAgents.filter((a) => a.scope === "global" && !!a.excluded);
+  const prevSkillKeySet = installedSkillConfigs ? new Set(installedSkillConfigs.map((s) => skillSlotKey(s.id, s.scope))) : null;
+  const prevSourceMap = installedSkillConfigs ? new Map(
+    installedSkillConfigs.filter((s) => !s.excluded).map((s) => [skillSlotKey(s.id, s.scope), s.source])
+  ) : null;
+  const prevAgentKeySet = installedAgentConfigs ? new Set(installedAgentConfigs.map((a) => agentSlotKey(a.name, a.scope))) : null;
+  const activeSkillBaseline = installedSkillConfigs ? installedSkillConfigs.filter((s) => !s.excluded) : [];
+  const activeAgentBaseline = installedAgentConfigs ? installedAgentConfigs.filter((a) => !a.excluded) : [];
+  const inheritedGlobalSkills = activeSkillBaseline.filter(
+    (s) => s.scope === "global" && !globalSkills.some((g) => g.id === s.id) && !excludedGlobalSkills.some((e) => e.id === s.id) && projectSkills.some((p) => p.id === s.id)
+  );
+  const inheritedGlobalAgents = activeAgentBaseline.filter(
+    (a) => a.scope === "global" && !globalAgents.some((g) => g.name === a.name) && !excludedGlobalAgents.some((e) => e.name === a.name) && projectAgents.some((p) => p.name === a.name)
+  );
+  const removedSkills = installedSkillConfigs ? installedSkillConfigs.filter(
+    (s) => !currentSkills.some((c) => c.id === s.id && c.scope === s.scope)
+  ) : [];
+  const removedAgents = installedAgentConfigs ? installedAgentConfigs.filter(
+    (a) => !currentAgents.some((c) => c.name === a.name && c.scope === a.scope)
+  ) : [];
+  const inheritedSkillIdSet = new Set(inheritedGlobalSkills.map((s) => s.id));
+  const uniqueExcludedGlobalSkills = excludedGlobalSkills.filter(
+    (s) => !inheritedSkillIdSet.has(s.id)
+  );
+  const allGlobalSkills = [
+    ...globalSkills,
+    ...inheritedGlobalSkills,
+    ...uniqueExcludedGlobalSkills
+  ];
+  const inheritedAgentNameSet = new Set(inheritedGlobalAgents.map((a) => a.name));
+  const uniqueExcludedGlobalAgents = excludedGlobalAgents.filter(
+    (a) => !inheritedAgentNameSet.has(a.name)
+  );
+  const allGlobalAgents = [
+    ...globalAgents,
+    ...inheritedGlobalAgents,
+    ...uniqueExcludedGlobalAgents
+  ];
+  const removedGlobalSkills = isInitMode ? [] : removedSkills.filter((s) => s.scope === "global");
+  const removedProjectSkills = removedSkills.filter((s) => s.scope === "project");
+  const removedGlobalAgents = isInitMode ? [] : removedAgents.filter((a) => a.scope === "global");
+  const removedProjectAgents = removedAgents.filter((a) => a.scope === "project");
+  const projectSkillRows = [
+    ...projectSkills.map((s) => classifyDiffRow(s, prevSkillKeySet, prevSourceMap)),
+    ...removedProjectSkills.map(toRemovedSkillRow)
+  ];
+  const globalSkillRows = [
+    ...allGlobalSkills.map((s) => classifyDiffRow(s, prevSkillKeySet, prevSourceMap)),
+    ...removedGlobalSkills.map(toRemovedSkillRow)
+  ];
+  const projectAgentRows = [
+    ...projectAgents.map((a) => classifyAgentDiffRow(a, prevAgentKeySet)),
+    ...removedProjectAgents.map(toRemovedAgentRow)
+  ];
+  const globalAgentRows = [
+    ...allGlobalAgents.map((a) => classifyAgentDiffRow(a, prevAgentKeySet)),
+    ...removedGlobalAgents.map(toRemovedAgentRow)
+  ];
+  const hasContent = projectSkillRows.length > 0 || globalSkillRows.length > 0 || projectAgentRows.length > 0 || globalAgentRows.length > 0;
+  return { projectSkillRows, globalSkillRows, projectAgentRows, globalAgentRows, hasContent };
+}
+function skillSlotKey(id, scope) {
+  return `${id}:${scope}`;
+}
+function agentSlotKey(name, scope) {
+  return `${name}:${scope}`;
+}
+function formatScopeTag(scope) {
+  return scope === "global" ? "[G]" : "[P]";
+}
+function deriveScopeBadges(activeConfig, excludedConfig) {
+  const secondaryScope = excludedConfig && activeConfig && excludedConfig.scope !== activeConfig.scope ? excludedConfig.scope : void 0;
+  return { scope: activeConfig?.scope, secondaryScope };
+}
+function classifyDiffRow(skill, prevKeySet, prevSourceMap) {
+  const key = skillSlotKey(skill.id, skill.scope);
+  const isNew = prevKeySet === null || !prevKeySet.has(key);
+  const prevSource = prevSourceMap?.get(key);
+  const sourceChanged = !isNew && prevSource != null && prevSource !== skill.source;
+  if (sourceChanged) {
+    return { id: skill.id, source: skill.source, status: "source-changed" };
+  }
+  return { id: skill.id, source: skill.source, status: isNew ? "added" : "unchanged" };
+}
+function classifyAgentDiffRow(agent, prevKeySet) {
+  const isNew = prevKeySet === null || !prevKeySet.has(agentSlotKey(agent.name, agent.scope));
+  return { name: agent.name, status: isNew ? "added" : "unchanged" };
+}
+function toRemovedSkillRow(skill) {
+  return { id: skill.id, source: skill.source, status: "removed" };
+}
+function toRemovedAgentRow(agent) {
+  return { name: agent.name, status: "removed" };
+}
+
+// src/cli/lib/wizard/build-step-logic.ts
+var FRAMEWORK_CATEGORY_ID = "web-framework";
+var WEB_DOMAIN_ID = "web";
+function validateBuildStep(categories, selections) {
+  const emptyRequired = categories.find(
+    (category) => category.required && !selections[category.id]?.length
+  );
+  return emptyRequired ? {
+    valid: true,
+    message: `No skills selected in ${emptyRequired.displayName} (required category)`
+  } : { valid: true };
+}
+function getSelectedFrameworks(selections) {
+  return (selections[FRAMEWORK_CATEGORY_ID] ?? []).map((alias) => getSkillById(alias).id);
+}
+function isCompatibleWithSelectedFrameworks(skillId, selectedFrameworkIds) {
+  return isCompatibleWithSelections(getSkillById(skillId), selectedFrameworkIds);
+}
+function buildCategoriesForDomain(domain, allSelections, selections, installedSkillIds, skillConfigs, filterIncompatible) {
+  const selectedFrameworkIds = getSelectedFrameworks(selections);
+  const shouldFilter = filterIncompatible && domain === WEB_DOMAIN_ID && selectedFrameworkIds.length > 0;
+  const categories = sortBy(
+    typedValues(matrix.categories).filter((cat) => cat.domain === domain),
+    (cat) => cat.order ?? 0
+  );
+  const categoryRows = categories.map((cat) => {
+    const skillOptions = getAvailableSkills(cat.id, allSelections);
+    const filteredOptions = shouldFilter && cat.id !== FRAMEWORK_CATEGORY_ID ? skillOptions.filter(
+      (skill) => isCompatibleWithSelectedFrameworks(skill.id, selectedFrameworkIds)
+    ) : skillOptions;
+    const isExclusive = cat.exclusive ?? true;
+    const sortedOptions = sortBy(
+      filteredOptions,
+      (skill) => getSkillById(skill.id).displayName.toLowerCase()
+    );
+    const options = sortedOptions.map((skill) => {
+      const activeConfig = skillConfigs?.find((sc) => sc.id === skill.id && !sc.excluded);
+      const excludedConfig = skillConfigs?.find((sc) => sc.id === skill.id && sc.excluded);
+      const { secondaryScope } = deriveScopeBadges(activeConfig, excludedConfig);
+      return {
+        id: skill.id,
+        state: isExclusive && skill.advisoryState.status === "incompatible" ? { status: "normal" } : skill.advisoryState,
+        selected: skill.selected,
+        local: getSkillById(skill.id).local,
+        installed: installedSkillIds?.includes(skill.id) || false,
+        scope: activeConfig?.scope,
+        secondaryScope,
+        source: activeConfig?.source,
+        hasUnmetRequirements: skill.hasUnmetRequirements,
+        unmetRequirementsReason: skill.unmetRequirementsReason,
+        requiredBy: skill.selected ? void 0 : getUnmetRequiredBy(skill.id, allSelections)
+      };
+    });
+    return {
+      id: cat.id,
+      displayName: cat.displayName,
+      required: cat.required ?? false,
+      exclusive: cat.exclusive ?? true,
+      options
+    };
+  });
+  return categoryRows.filter((row) => row.options.length > 0);
+}
+
+// src/cli/lib/wizard/domain-order.ts
+init_esm_shims();
+function orderDomains(domains) {
+  const builtInSet = new Set(BUILT_IN_DOMAIN_ORDER);
+  return [
+    ...domains.filter((d) => !builtInSet.has(d)).sort(),
+    ...BUILT_IN_DOMAIN_ORDER.filter((d) => domains.includes(d))
+  ];
+}
+
+// src/cli/stores/wizard-store.ts
+var TOAST_MESSAGES = {
+  GLOBAL_SKILLS_LOCKED: "Global skills cannot be changed from project scope",
+  ONLY_SKILL_IN_CATEGORY: "Cannot deselect the only skill in this category",
+  ALREADY_EJECTED_AT_GLOBAL: "Already exists as ejected skill at global scope",
+  GLOBAL_AGENTS_LOCKED: "Global agents cannot be changed from project scope"
+};
+function resolveEffectiveSource(...candidates) {
+  return candidates.find((source) => source !== void 0) ?? DEFAULT_PUBLIC_SOURCE_NAME;
+}
+function primarySourceName(skill) {
+  return skill?.availableSources?.find((s) => s.primary)?.name;
+}
+function createDefaultSkillConfig(id) {
+  const skill = matrix.skills[id];
+  const primarySource = primarySourceName(skill);
+  return { id, scope: "global", source: primarySource ?? DEFAULT_PUBLIC_SOURCE_NAME };
+}
+function findIncompatibleWebSkills(webSelections, skillConfigs) {
+  const frameworkSelections = webSelections[FRAMEWORK_CATEGORY_ID] ?? [];
+  if (frameworkSelections.length === 0) return /* @__PURE__ */ new Set();
+  const excludedIds = new Set(skillConfigs.filter((s) => s.excluded).map((s) => s.id));
+  const selectedFrameworkIds = frameworkSelections.map((alias) => getSkillById(alias).id);
+  return new Set(
+    flatMap(
+      typedEntries(webSelections),
+      ([cat, skills]) => cat === FRAMEWORK_CATEGORY_ID || !skills ? [] : skills.filter(
+        (id) => !excludedIds.has(id) && !isCompatibleWithSelectedFrameworks(id, selectedFrameworkIds)
+      )
+    )
+  );
+}
+function removeSkillsFromSelections(selections, toRemove) {
+  return typedFromEntries(
+    typedEntries(selections).map(([cat, skills]) => [
+      cat,
+      skills?.filter((id) => !toRemove.has(id)) ?? []
+    ])
+  );
+}
+function hasProjectActive(configs, id) {
+  return configs.some((sc) => sc.id === id && isActiveAt(sc, "project"));
+}
+function findGlobalActive(configs, id) {
+  return configs.find((sc) => sc.id === id && isActiveAt(sc, "global"));
+}
+function hasGlobalActive(configs, id) {
+  return findGlobalActive(configs, id) !== void 0;
+}
+function hasGlobalTombstone(configs, id) {
+  return configs.some((sc) => sc.id === id && isGlobalTombstone(sc));
+}
+function isDualScopePair(configs, id) {
+  return hasProjectActive(configs, id) && hasGlobalTombstone(configs, id);
+}
+function isGloballyLockedSkill(installed, liveConfigs, id) {
+  return hasGlobalActive(installed, id) || hasGlobalTombstone(installed, id) && hasGlobalActive(liveConfigs, id) || isDualScopePair(liveConfigs, id);
+}
+function wouldOverwriteGlobalEject(config, liveConfigs, installedSkillConfigs) {
+  if (config.scope !== "project" || config.source !== EJECT_SOURCE) return false;
+  const globalEjectInstalled = installedSkillConfigs?.some(
+    (sc) => sc.id === config.id && sc.scope === "global" && sc.source === EJECT_SOURCE && !sc.excluded
+  );
+  if (!globalEjectInstalled) return false;
+  return !liveConfigs.some((sc) => sc.id === config.id && sc.excluded);
+}
+function withActiveEntrySource(configs, id, scope, source) {
+  return configs.map(
+    (sc) => sc.id === id && !sc.excluded && sc.scope === scope ? { ...sc, source } : sc
+  );
+}
+function applySkillRemoval(configs, removedIds, installedSkillConfigs) {
+  const removed = removedIds instanceof Set ? removedIds : new Set(removedIds);
+  const installedIds = new Set((installedSkillConfigs ?? []).map((s) => s.id));
+  const survivesRemoval = (entry) => !isDualScopePair(configs, entry.id) && !isProjectOwned(entry) && installedIds.has(entry.id);
+  const retained = configs.filter((sc) => !removed.has(sc.id) || survivesRemoval(sc));
+  const resurfacedInheritedGlobals = [...removed].filter((id) => isDualScopePair(configs, id)).map((id) => ({
+    id,
+    scope: "global",
+    source: configs.find((sc) => sc.id === id && sc.scope === "global")?.source ?? DEFAULT_PUBLIC_SOURCE_NAME
+  }));
+  return [...retained, ...resurfacedInheritedGlobals];
+}
+function flattenCategorySelections(selections) {
+  return typedValues(selections).flat();
+}
+function collectSkillIdsFromSelections(selections) {
+  return new Set(flattenCategorySelections(selections));
+}
+function reconcileSkillConfigs(configs, added, removed, installedSkillConfigs, isEditingFromGlobalScope) {
+  const effectiveInstalled = isEditingFromGlobalScope ? null : installedSkillConfigs;
+  let result = applySkillRemoval(configs, removed, effectiveInstalled);
+  for (const id of added) {
+    if (!isEditingFromGlobalScope && hasGlobalTombstone(installedSkillConfigs ?? [], id) && !hasProjectActive(result, id)) {
+      const globalEntry = (installedSkillConfigs ?? []).find((sc) => sc.id === id && sc.scope === "global") ?? result.find((sc) => sc.id === id && sc.scope === "global");
+      const source = globalEntry?.source ?? DEFAULT_PUBLIC_SOURCE_NAME;
+      result = [
+        ...result.filter((sc) => sc.id !== id),
+        { id, scope: "project", source },
+        { id, scope: "global", excluded: true, source }
+      ];
+      continue;
+    }
+    const existingExcluded = result.find((sc) => sc.id === id && sc.excluded);
+    if (existingExcluded) {
+      result = result.map(
+        (sc) => sc.id === id && sc.excluded ? { ...sc, excluded: void 0 } : sc
+      );
+    } else if (!result.some((sc) => sc.id === id)) {
+      result = [...result, buildSkillConfigForId(id, installedSkillConfigs)];
+    }
+  }
+  return result;
+}
+function agentHasProjectActive(configs, name) {
+  return configs.some((ac) => ac.name === name && ac.scope === "project" && !ac.excluded);
+}
+function agentHasGlobalActive(configs, name) {
+  return configs.some((ac) => ac.name === name && ac.scope === "global" && !ac.excluded);
+}
+function agentHasGlobalTombstone(configs, name) {
+  return configs.some((ac) => ac.name === name && ac.scope === "global" && ac.excluded);
+}
+function isDualScopeAgentPair(configs, name) {
+  return agentHasProjectActive(configs, name) && agentHasGlobalTombstone(configs, name);
+}
+function collectTombstones(configs) {
+  return configs.filter((entry) => entry.excluded);
+}
+function applyAgentToggle(configs, agent, isSelected) {
+  if (isSelected) {
+    return configs.filter((ac) => ac.name !== agent);
+  }
+  const existingExcluded = configs.find((ac) => ac.name === agent && ac.excluded);
+  if (existingExcluded) {
+    return configs.map(
+      (ac) => ac.name === agent && ac.excluded ? { ...ac, excluded: void 0 } : ac
+    );
+  }
+  return [...configs, { name: agent, scope: "global" }];
+}
+function survivesRosterRebuild(agentConfig, roster) {
+  if (agentConfig.excluded) return true;
+  return !isProjectOwned(agentConfig) && !roster.has(agentConfig.name);
+}
+function restoreDualScopeAgent(selectedAgents, agentConfigs, agent) {
+  return {
+    selectedAgents: [...selectedAgents, agent],
+    agentConfigs: [
+      ...agentConfigs.filter((ac) => ac.name !== agent),
+      { name: agent, scope: "project" },
+      { name: agent, scope: "global", excluded: true }
+    ]
+  };
+}
+function nextSelectedAgents(selectedAgents, agent, flags) {
+  if (flags.isSelected) return selectedAgents.filter((a) => a !== agent);
+  if (flags.isInList) return selectedAgents;
+  return [...selectedAgents, agent];
+}
+function buildSkillConfigForId(id, savedConfigs) {
+  const saved = savedConfigs?.find((sc) => sc.id === id && !sc.excluded && sc.scope === "project") ?? savedConfigs?.find((sc) => sc.id === id && !sc.excluded);
+  const skill = matrix.skills[id];
+  const primarySource = primarySourceName(skill);
+  return {
+    id,
+    scope: saved?.scope ?? "global",
+    source: resolveEffectiveSource(saved?.source, primarySource)
+  };
+}
+function buildAgentConfigForName(name, savedConfigs) {
+  const saved = savedConfigs?.find((ac) => ac.name === name && !ac.excluded && ac.scope === "project") ?? savedConfigs?.find((ac) => ac.name === name && !ac.excluded);
+  return {
+    name,
+    scope: saved?.scope ?? "global",
+    // Model and effort are the user's deliberate choice, not something the roster re-derives —
+    // they survive the rebuild on the same terms as scope.
+    ...saved?.model !== void 0 && { model: saved.model },
+    ...saved?.effort !== void 0 && { effort: saved.effort }
+  };
+}
+function restoreSkillConfigs(existingConfigs, restoredIds) {
+  const restoredSet = new Set(restoredIds);
+  const existingIds = new Set(existingConfigs.map((sc) => sc.id));
+  const updated = existingConfigs.map(
+    (sc) => restoredSet.has(sc.id) && sc.excluded ? { ...sc, excluded: void 0 } : sc
+  );
+  const newConfigs = restoredIds.filter((id) => !existingIds.has(id)).map(createDefaultSkillConfig);
+  return [...updated, ...newConfigs];
+}
+var DOMAIN_AGENTS = {
+  web: [
+    "web-developer",
+    "web-reviewer",
+    "web-researcher",
+    "web-tester",
+    "web-pm",
+    "web-architecture"
+  ],
+  api: ["api-developer", "api-reviewer", "api-researcher"],
+  cli: ["cli-developer", "cli-tester", "cli-reviewer"]
+};
+var SOURCE_SORT_TIER_LOCAL = 1;
+var SOURCE_SORT_TIER_SCOPED = 2;
+var SOURCE_SORT_TIER_PUBLIC = 3;
+var SOURCE_SORT_TIER_THIRD_PARTY = 4;
+function getSourceSortTier(source) {
+  if (source.type === "local") return SOURCE_SORT_TIER_LOCAL;
+  if (source.primary) return SOURCE_SORT_TIER_SCOPED;
+  if (source.type === "public") return SOURCE_SORT_TIER_PUBLIC;
+  return SOURCE_SORT_TIER_THIRD_PARTY;
+}
+function resolveSkillForPopulation(skillId) {
+  const { skills } = matrix;
+  const skill = skills[skillId];
+  if (!skill?.category) {
+    warn(
+      `Installed skill '${skillId}' is missing from the marketplace \u2014 it may have been removed or renamed`
+    );
+    return null;
+  }
+  const domain = getCategoryDomain(skill.category);
+  if (!domain) {
+    warn(`Installed skill '${skillId}' has unknown category '${skill.category}' \u2014 skipping`);
+    return null;
+  }
+  const subcat = skill.category;
+  return { domain, subcat, techId: skillId };
+}
+function addToDomainSelections(selections, domain, category, skillId) {
+  const categorySelections = selections[domain] ??= {};
+  const skillList = categorySelections[category] ??= [];
+  if (skillList.includes(skillId)) return false;
+  skillList.push(skillId);
+  return true;
+}
+function buildBoundSkillOptions(boundSkills, alias, selectedSource) {
+  return boundSkills.filter((b) => b.boundTo === alias).map((bound) => ({
+    id: bound.sourceName,
+    selected: selectedSource === bound.sourceName,
+    installed: false
+  }));
+}
+function buildSkillSourceOptions(skill, selectedSource, boundSkills) {
+  const sortedSources = [...skill.availableSources || []].sort(
+    (a, b) => getSourceSortTier(a) - getSourceSortTier(b)
+  );
+  const baseOptions = sortedSources.length > 0 ? sortedSources.map((source) => ({
+    id: source.name,
+    selected: selectedSource === source.name,
+    installed: source.installed
+  })) : [
+    {
+      id: DEFAULT_PUBLIC_SOURCE_NAME,
+      selected: selectedSource === DEFAULT_PUBLIC_SOURCE_NAME,
+      installed: false
+    }
+  ];
+  const withEject = baseOptions.some((o) => o.id === EJECT_SOURCE) ? baseOptions : [
+    { id: EJECT_SOURCE, selected: selectedSource === EJECT_SOURCE, installed: false },
+    ...baseOptions
+  ];
+  return [...withEject, ...buildBoundSkillOptions(boundSkills, skill.slug, selectedSource)];
+}
+function collectRemovedInstalledEntries(installedSkillConfigs, skillConfigs) {
+  if (!installedSkillConfigs) return [];
+  const occupiedSlots = new Set(skillConfigs.map((sc) => skillSlotKey(sc.id, sc.scope)));
+  return installedSkillConfigs.filter(
+    (sc) => !sc.excluded && !occupiedSlots.has(skillSlotKey(sc.id, sc.scope)) && // A skill the marketplace no longer carries has nothing to render — hydration already
+    // skipped it into unresolvableSkillIds, and getSkillById would throw on it downstream.
+    !!matrix.skills[sc.id]
+  );
+}
+function collectInstalledSkillSlots(installedSkillConfigs) {
+  if (!installedSkillConfigs) return /* @__PURE__ */ new Set();
+  return new Set(installedSkillConfigs.map((sc) => skillSlotKey(sc.id, sc.scope)));
+}
+function addedSlotFlag(installedSkillSlots, id, scope) {
+  return installedSkillSlots.has(skillSlotKey(id, scope)) ? {} : { added: true };
+}
+function withSelectedSource(options, sourceId) {
+  return options.map((option) => ({ ...option, selected: option.id === sourceId }));
+}
+function resolveSkillRowInputs(id, skillConfigs, boundSkills) {
+  const skill = getSkillById(id);
+  const configEntry = skillConfigs.find((sc) => sc.id === skill.id);
+  const selectedSource = resolveEffectiveSource(
+    configEntry?.source,
+    skill.activeSource?.name,
+    primarySourceName(skill)
+  );
+  return {
+    skillId: skill.id,
+    configEntry,
+    options: buildSkillSourceOptions(skill, selectedSource, boundSkills)
+  };
+}
+function toPendingRemovalRow(skillId, options, removedInstalledEntry) {
+  return {
+    skillId,
+    options: withSelectedSource(options, removedInstalledEntry.source),
+    scope: removedInstalledEntry.scope,
+    disabled: true
+  };
+}
+function isSlotAlreadyRendered(rows, removedInstalledEntry) {
+  const slot = skillSlotKey(removedInstalledEntry.id, removedInstalledEntry.scope);
+  return rows.some((row) => skillSlotKey(row.skillId, row.scope) === slot);
+}
+function toLockedGlobalRow(skillId, options, installedSource, installedSkillSlots) {
+  return {
+    skillId,
+    options: withSelectedSource(options, installedSource),
+    scope: "global",
+    readOnly: true,
+    ...addedSlotFlag(installedSkillSlots, skillId, "global")
+  };
+}
+function classifySkillSourceRows(skillId, options, context) {
+  const { configEntry, installedSkillConfigs, isEditingFromGlobalScope, installedSkillSlots } = context;
+  const installedGlobalConfig = findGlobalActive(installedSkillConfigs ?? [], skillId);
+  const isExcludedGlobal = configEntry?.excluded && configEntry.scope === "global";
+  if (isExcludedGlobal && !isEditingFromGlobalScope) {
+    return [
+      toLockedGlobalRow(
+        skillId,
+        options,
+        installedGlobalConfig?.source ?? configEntry.source,
+        installedSkillSlots
+      )
+    ];
+  }
+  if (!isEditingFromGlobalScope && installedGlobalConfig && configEntry?.scope === "project") {
+    return [
+      toLockedGlobalRow(skillId, options, installedGlobalConfig.source, installedSkillSlots),
+      {
+        skillId,
+        options,
+        scope: "project",
+        ...addedSlotFlag(installedSkillSlots, skillId, "project")
+      }
+    ];
+  }
+  const readOnly = !isEditingFromGlobalScope && !!installedGlobalConfig;
+  return [
+    {
+      skillId,
+      options,
+      scope: configEntry?.scope,
+      ...readOnly ? { readOnly: true } : {},
+      ...addedSlotFlag(installedSkillSlots, skillId, configEntry?.scope)
+    }
+  ];
+}
+function sourceRowSortTier(row) {
+  if (row.scope === "global" && row.readOnly) return 0;
+  if (row.scope === "global") return 1;
+  return 2;
+}
+var WIZARD_STEP_ORDER = [
+  "stack",
+  "domains",
+  "build",
+  "sources",
+  "agents",
+  "confirm"
+];
+var createInitialState = (overrides) => ({
+  step: "stack",
+  approach: null,
+  selectedStackId: null,
+  stackAction: null,
+  selectedDomains: [],
+  currentDomainIndex: 0,
+  domainSelections: {},
+  /** Snapshot of domainSelections from populateFromSkillIds, used to restore on domain re-toggle */
+  _stackDomainSelections: null,
+  showLabels: false,
+  filterIncompatible: false,
+  skillConfigs: [],
+  focusedSkillId: null,
+  unresolvableSkillIds: [],
+  customizeSources: false,
+  showSettings: false,
+  showInfo: false,
+  selectedAgents: [],
+  agentConfigs: [],
+  focusedAgentId: null,
+  boundSkills: [],
+  installedSkillConfigs: null,
+  installedAgentConfigs: null,
+  isInitMode: false,
+  isEditingFromGlobalScope: false,
+  toastMessage: null,
+  globalPreselections: null,
+  globalAgentPreselections: null,
+  history: [],
+  ...overrides
+});
+var useWizardStore = create((set, get) => ({
+  ...createInitialState(),
+  setStep: (step) => {
+    set((state) => ({
+      step,
+      history: [...state.history, state.step]
+    }));
+    if (step === "build") get().seedFocusedSkillForActiveDomain();
+  },
+  setApproach: (approach) => set({ approach }),
+  selectStack: (stackId) => set({
+    selectedStackId: stackId,
+    domainSelections: {},
+    _stackDomainSelections: null,
+    selectedDomains: [],
+    skillConfigs: [],
+    selectedAgents: [],
+    agentConfigs: [],
+    boundSkills: [],
+    currentDomainIndex: 0,
+    stackAction: null
+  }),
+  setStackAction: (action) => set({ stackAction: action }),
+  populateFromSkillIds: (skillIds, savedConfigs) => set(() => {
+    const domainSelections = {};
+    const resolvedSkillIds = [];
+    const unresolvableSkillIds = [];
+    for (const skillId of skillIds) {
+      const resolved = resolveSkillForPopulation(skillId);
+      if (!resolved) {
+        unresolvableSkillIds.push(skillId);
+        continue;
+      }
+      const { domain, subcat, techId } = resolved;
+      if (addToDomainSelections(domainSelections, domain, subcat, techId)) {
+        resolvedSkillIds.push(techId);
+      }
+    }
+    if (unresolvableSkillIds.length > 0) {
+      warn(
+        `${unresolvableSkillIds.length} installed skill(s) could not be resolved and were skipped`
+      );
+    }
+    const selectedDomains = orderDomains(typedKeys(domainSelections));
+    const skillConfigs = resolvedSkillIds.map(
+      (id) => buildSkillConfigForId(id, savedConfigs)
+    );
+    const excludedConfigs = collectTombstones(savedConfigs ?? []);
+    return {
+      domainSelections,
+      _stackDomainSelections: structuredClone(domainSelections),
+      selectedDomains,
+      skillConfigs: [...skillConfigs, ...excludedConfigs],
+      unresolvableSkillIds
+    };
+  }),
+  toggleDomain: (domain) => set((state) => {
+    const isSelected = state.selectedDomains.includes(domain);
+    if (isSelected) {
+      const { [domain]: _removed, ...remainingSelections } = state.domainSelections;
+      const removedSkillIds = _removed ? collectSkillIdsFromSelections(_removed) : /* @__PURE__ */ new Set();
+      return {
+        selectedDomains: state.selectedDomains.filter((d) => d !== domain),
+        domainSelections: remainingSelections,
+        // Global-scope edit: no overlay, so deselecting a domain uninstalls its skills cleanly
+        // rather than tombstoning them in the global config (D-233 Scenario C).
+        skillConfigs: applySkillRemoval(
+          state.skillConfigs,
+          removedSkillIds,
+          state.isEditingFromGlobalScope ? null : state.installedSkillConfigs
+        )
+      };
+    }
+    const stackSelections = state._stackDomainSelections?.[domain];
+    if (stackSelections) {
+      const restoredSkillIds = [...collectSkillIdsFromSelections(stackSelections)];
+      return {
+        selectedDomains: orderDomains([...state.selectedDomains, domain]),
+        domainSelections: {
+          ...state.domainSelections,
+          [domain]: structuredClone(stackSelections)
+        },
+        skillConfigs: restoreSkillConfigs(state.skillConfigs, restoredSkillIds)
+      };
+    }
+    return {
+      selectedDomains: orderDomains([...state.selectedDomains, domain])
+    };
+  }),
+  toggleTechnology: (domain, category, technology, exclusive) => set((state) => {
+    const installed = state.installedSkillConfigs ?? [];
+    const currentSelections = state.domainSelections[domain]?.[category] || [];
+    const isSelected = currentSelections.includes(technology);
+    const isGlobalLocked = isSelected ? isGloballyLockedSkill(installed, state.skillConfigs, technology) : hasGlobalActive(installed, technology);
+    if (isGlobalLocked && !state.isEditingFromGlobalScope) {
+      return { toastMessage: TOAST_MESSAGES.GLOBAL_SKILLS_LOCKED };
+    }
+    if (isSelected) {
+      const categoryDef = matrix.categories[category];
+      if (categoryDef?.exclusive && categoryDef?.required) {
+        const categorySkillCount = typedValues(matrix.skills).filter(
+          (s) => s.category === category
+        ).length;
+        if (categorySkillCount <= 1) {
+          return { toastMessage: TOAST_MESSAGES.ONLY_SKILL_IN_CATEGORY };
+        }
+      }
+    }
+    if (exclusive && !isSelected) {
+      const wouldDropLockedSkill = currentSelections.some(
+        (selectedId) => isGloballyLockedSkill(installed, state.skillConfigs, selectedId)
+      );
+      if (wouldDropLockedSkill && !state.isEditingFromGlobalScope) {
+        return { toastMessage: TOAST_MESSAGES.GLOBAL_SKILLS_LOCKED };
+      }
+    }
+    let newSelections;
+    if (exclusive) {
+      newSelections = isSelected ? [] : [technology];
+    } else {
+      newSelections = isSelected ? currentSelections.filter((t) => t !== technology) : [...currentSelections, technology];
+    }
+    const removed = currentSelections.filter((id) => !newSelections.includes(id));
+    const added = newSelections.filter((id) => !currentSelections.includes(id));
+    const skillConfigs = reconcileSkillConfigs(
+      state.skillConfigs,
+      added,
+      removed,
+      state.installedSkillConfigs,
+      state.isEditingFromGlobalScope
+    );
+    const stillActiveAfterRemoval = isSelected && !newSelections.includes(technology) && (hasProjectActive(skillConfigs, technology) || hasGlobalActive(skillConfigs, technology));
+    const resolvedSelections = stillActiveAfterRemoval ? [...newSelections, technology] : newSelections;
+    return {
+      skillConfigs,
+      domainSelections: {
+        ...state.domainSelections,
+        [domain]: {
+          ...state.domainSelections[domain],
+          [category]: resolvedSelections
+        }
+      }
+    };
+  }),
+  nextDomain: () => {
+    const state = get();
+    if (state.currentDomainIndex < state.selectedDomains.length - 1) {
+      set({
+        currentDomainIndex: state.currentDomainIndex + 1
+      });
+      get().seedFocusedSkillForActiveDomain();
+      return true;
+    }
+    return false;
+  },
+  prevDomain: () => {
+    const state = get();
+    if (state.currentDomainIndex > 0) {
+      set({
+        currentDomainIndex: state.currentDomainIndex - 1
+      });
+      get().seedFocusedSkillForActiveDomain();
+      return true;
+    }
+    return false;
+  },
+  setCurrentDomainIndex: (index) => {
+    const state = get();
+    if (index >= 0 && index < state.selectedDomains.length) {
+      set({ currentDomainIndex: index });
+      get().seedFocusedSkillForActiveDomain();
+    }
+  },
+  toggleShowLabels: () => set((state) => ({ showLabels: !state.showLabels })),
+  toggleFilterIncompatible: () => set((state) => {
+    if (state.filterIncompatible) return { filterIncompatible: false };
+    const webSelections = state.domainSelections.web;
+    if (!webSelections) return { filterIncompatible: true };
+    const removed = findIncompatibleWebSkills(webSelections, state.skillConfigs);
+    if (removed.size === 0) return { filterIncompatible: true };
+    const installed = state.installedSkillConfigs ?? [];
+    const removesLockedGlobal = [...removed].some(
+      (id) => hasGlobalActive(installed, id) || hasGlobalTombstone(installed, id) && hasGlobalActive(state.skillConfigs, id)
+    );
+    if (removesLockedGlobal && !state.isEditingFromGlobalScope) {
+      return { toastMessage: TOAST_MESSAGES.GLOBAL_SKILLS_LOCKED };
+    }
+    return {
+      filterIncompatible: true,
+      domainSelections: {
+        ...state.domainSelections,
+        web: removeSkillsFromSelections(webSelections, removed)
+      },
+      // Global-scope edit: clean uninstall, no tombstone (D-233 Scenario C).
+      skillConfigs: applySkillRemoval(
+        state.skillConfigs,
+        removed,
+        state.isEditingFromGlobalScope ? null : state.installedSkillConfigs
+      )
+    };
+  }),
+  deriveInstallMode: () => {
+    const { skillConfigs } = get();
+    return deriveInstallMode(skillConfigs);
+  },
+  toggleSkillScope: (skillId) => set((state) => {
+    if (state.isEditingFromGlobalScope) return state;
+    const config = state.skillConfigs.find((sc) => sc.id === skillId && !sc.excluded);
+    if (!config) return state;
+    if (wouldOverwriteGlobalEject(config, state.skillConfigs, state.installedSkillConfigs)) {
+      return { toastMessage: TOAST_MESSAGES.ALREADY_EJECTED_AT_GLOBAL };
+    }
+    const wasInstalledGlobally = state.installedSkillConfigs?.some((sc) => sc.id === skillId && sc.scope === "global") ?? false;
+    const newScope = config.scope === "project" ? "global" : "project";
+    const rescoped = state.skillConfigs.map(
+      (sc) => sc.id === skillId && !sc.excluded ? { ...sc, scope: newScope } : sc
+    );
+    if (newScope === "project") {
+      const needsTombstone = wasInstalledGlobally && !rescoped.some((sc) => sc.id === skillId && sc.excluded);
+      return {
+        skillConfigs: needsTombstone ? [
+          ...rescoped,
+          { id: skillId, scope: "global", excluded: true, source: config.source }
+        ] : rescoped
+      };
+    }
+    return { skillConfigs: rescoped.filter((sc) => !(sc.id === skillId && sc.excluded)) };
+  }),
+  setFocusedSkillId: (id) => set({ focusedSkillId: id }),
+  seedFocusedSkillForActiveDomain: () => {
+    const state = get();
+    const domain = state.getCurrentDomain() ?? FALLBACK_DOMAIN;
+    const categories = buildCategoriesForDomain(
+      domain,
+      state.getAllSelectedTechnologies(),
+      state.domainSelections[domain] ?? {},
+      void 0,
+      state.skillConfigs,
+      state.filterIncompatible
+    );
+    set({ focusedSkillId: categories[0]?.options[0]?.id ?? null });
+  },
+  setSourceSelection: (skillId, sourceId, scope) => set((state) => {
+    if (!skillId) {
+      warn("Ignoring setSourceSelection call with empty skillId");
+      return state;
+    }
+    if (!sourceId) {
+      warn(`Ignoring setSourceSelection call with empty sourceId for skill '${skillId}'`);
+      return state;
+    }
+    return {
+      skillConfigs: withActiveEntrySource(state.skillConfigs, skillId, scope, sourceId)
+    };
+  }),
+  setCustomizeSources: (customize) => set({ customizeSources: customize }),
+  toggleSettings: () => set((state) => ({ showSettings: !state.showSettings })),
+  toggleInfo: () => set((state) => ({ showInfo: !state.showInfo })),
+  setToastMessage: (message) => set({ toastMessage: message }),
+  bindSkill: (skill) => set((state) => {
+    const exists = state.boundSkills.some(
+      (b) => b.id === skill.id && b.sourceUrl === skill.sourceUrl
+    );
+    if (exists) {
+      warn(`Skill '${skill.id}' from '${skill.sourceUrl}' is already bound \u2014 skipping duplicate`);
+      return state;
+    }
+    return { boundSkills: [...state.boundSkills, skill] };
+  }),
+  goBack: () => set((state) => {
+    if (state.history.length === 0) return state;
+    const history = [...state.history];
+    const previousStep = history.pop();
+    return {
+      step: previousStep,
+      history
+    };
+  }),
+  toggleAgent: (agent) => set((state) => {
+    const installed = state.installedAgentConfigs ?? [];
+    const isDualScopePairRow = !state.isEditingFromGlobalScope && isDualScopeAgentPair(state.agentConfigs, agent);
+    if (isDualScopePairRow) {
+      return { toastMessage: TOAST_MESSAGES.GLOBAL_AGENTS_LOCKED };
+    }
+    const isInheritedGlobalReselect = !state.isEditingFromGlobalScope && agentHasGlobalActive(state.agentConfigs, agent) && !agentHasProjectActive(state.agentConfigs, agent) && !state.selectedAgents.includes(agent) && agentHasGlobalTombstone(installed, agent);
+    if (isInheritedGlobalReselect) {
+      return restoreDualScopeAgent(state.selectedAgents, state.agentConfigs, agent);
+    }
+    const isActiveGlobal = agentHasGlobalActive(installed, agent) || agentHasGlobalTombstone(installed, agent) && agentHasGlobalActive(state.agentConfigs, agent);
+    if (isActiveGlobal && !state.isEditingFromGlobalScope) {
+      return { toastMessage: TOAST_MESSAGES.GLOBAL_AGENTS_LOCKED };
+    }
+    const isInList = state.selectedAgents.includes(agent);
+    const hasExcludedTombstone = state.agentConfigs.some(
+      (ac) => ac.name === agent && ac.excluded
+    );
+    const isSelected = isInList && !hasExcludedTombstone;
+    return {
+      selectedAgents: nextSelectedAgents(state.selectedAgents, agent, { isSelected, isInList }),
+      agentConfigs: applyAgentToggle(state.agentConfigs, agent, isSelected)
+    };
+  }),
+  toggleAgentScope: (agentName) => set((state) => {
+    if (state.isEditingFromGlobalScope) return state;
+    const config = state.agentConfigs.find((ac) => ac.name === agentName && !ac.excluded);
+    if (!config) return state;
+    const wasInstalledGlobally = state.installedAgentConfigs?.some((ac) => ac.name === agentName && ac.scope === "global") ?? false;
+    const newScope = config.scope === "project" ? "global" : "project";
+    const rescoped = state.agentConfigs.map(
+      (ac) => ac.name === agentName && !ac.excluded ? { ...ac, scope: newScope } : ac
+    );
+    if (newScope === "project") {
+      const needsTombstone = wasInstalledGlobally && !rescoped.some((ac) => ac.name === agentName && ac.excluded);
+      return {
+        agentConfigs: needsTombstone ? [...rescoped, { name: agentName, scope: "global", excluded: true }] : rescoped
+      };
+    }
+    return { agentConfigs: rescoped.filter((ac) => !(ac.name === agentName && ac.excluded)) };
+  }),
+  setFocusedAgentId: (id) => set({ focusedAgentId: id }),
+  preselectAgentsFromDomains: () => set((state) => {
+    const sorted = state.selectedDomains.flatMap((domain) => DOMAIN_AGENTS[domain] ?? []).sort();
+    const roster = new Set(sorted);
+    const merged = sorted.map((name) => buildAgentConfigForName(name, state.agentConfigs));
+    const retained = state.agentConfigs.filter((ac) => survivesRosterRebuild(ac, roster));
+    return {
+      selectedAgents: sorted,
+      agentConfigs: [...merged, ...retained]
+    };
+  }),
+  preselectAgentsFromStack: (stackAgents) => set((state) => {
+    const savedConfigs = state.globalAgentPreselections?.configs ?? [];
+    const globalAgents = state.globalAgentPreselections?.agents ?? [];
+    const mergedAgents = [.../* @__PURE__ */ new Set([...stackAgents, ...globalAgents])].sort();
+    const merged = mergedAgents.map((name) => buildAgentConfigForName(name, savedConfigs));
+    const excludedConfigs = collectTombstones(savedConfigs);
+    return {
+      selectedAgents: mergedAgents,
+      agentConfigs: [...merged, ...excludedConfigs]
+    };
+  }),
+  reset: () => set(createInitialState()),
+  getAllSelectedTechnologies: () => {
+    return typedValues(get().domainSelections).flatMap(flattenCategorySelections);
+  },
+  getSelectedTechnologiesPerDomain: () => {
+    const entries = typedEntries(get().domainSelections).map(([domain, domainSel]) => [domain, flattenCategorySelections(domainSel)]).filter(([, techs]) => techs.length > 0);
+    return typedFromEntries(entries);
+  },
+  getCurrentDomain: () => {
+    const state = get();
+    return state.selectedDomains[state.currentDomainIndex] || null;
+  },
+  getTechnologyCount: () => {
+    return get().getAllSelectedTechnologies().length;
+  },
+  getStepProgress: () => {
+    const state = get();
+    const isStackDefaults = state.approach === "stack" && !!state.selectedStackId && state.stackAction === "defaults";
+    const skippedSteps = isStackDefaults ? ["build", "sources", "agents"] : [];
+    const precedingSteps = WIZARD_STEP_ORDER.slice(0, WIZARD_STEP_ORDER.indexOf(state.step));
+    const completedSteps = precedingSteps.filter((step) => !skippedSteps.includes(step));
+    return { completedSteps, skippedSteps };
+  },
+  canGoToNextDomain: () => {
+    const state = get();
+    return state.currentDomainIndex < state.selectedDomains.length - 1;
+  },
+  canGoToPreviousDomain: () => {
+    const state = get();
+    return state.currentDomainIndex > 0;
+  },
+  setAllSourcesEject: () => {
+    set((state) => ({
+      // Never touch tombstones — a dual-scope skill's excluded global tombstone keeps describing
+      // the masked global install. The bulk set-all applies only to active entries, mirroring the
+      // D-262 per-skill setSkillSource/setSourceSelection guard (D-265).
+      skillConfigs: state.skillConfigs.map(
+        (sc) => sc.excluded ? sc : { ...sc, source: EJECT_SOURCE }
+      )
+    }));
+  },
+  setAllSourcesPlugin: () => {
+    set((state) => ({
+      // Never touch tombstones (see setAllSourcesEject) — the excluded global tombstone keeps its
+      // marketplace source describing the masked global install (D-265).
+      skillConfigs: state.skillConfigs.map((sc) => {
+        if (sc.excluded) return sc;
+        const marketplaceSource = getSkillById(sc.id).availableSources?.find(
+          (source) => source.type !== "local"
+        );
+        return marketplaceSource ? { ...sc, source: marketplaceSource.name } : sc;
+      })
+    }));
+  },
+  buildSourceRows: () => {
+    const state = get();
+    const selectedTechnologies = get().getAllSelectedTechnologies();
+    const { skillConfigs, boundSkills } = state;
+    const selectedSet = new Set(selectedTechnologies);
+    const inheritedSkillIds = skillConfigs.filter((sc) => !sc.excluded && !selectedSet.has(sc.id)).map((sc) => sc.id);
+    const allActiveIds = /* @__PURE__ */ new Set([...inheritedSkillIds, ...selectedTechnologies]);
+    const excludedGlobalIds = skillConfigs.filter((sc) => isGlobalTombstone(sc) && !allActiveIds.has(sc.id)).map((sc) => sc.id);
+    const liveSkillIds = [...inheritedSkillIds, ...selectedTechnologies, ...excludedGlobalIds];
+    const installedSkillSlots = collectInstalledSkillSlots(state.installedSkillConfigs);
+    const resolveRowInputs = (id) => resolveSkillRowInputs(id, skillConfigs, boundSkills);
+    const liveRows = liveSkillIds.flatMap((id) => {
+      const { skillId, configEntry, options } = resolveRowInputs(id);
+      return classifySkillSourceRows(skillId, options, {
+        configEntry,
+        installedSkillConfigs: state.installedSkillConfigs,
+        isEditingFromGlobalScope: state.isEditingFromGlobalScope,
+        installedSkillSlots
+      });
+    });
+    const pendingRemovalRows = collectRemovedInstalledEntries(
+      state.installedSkillConfigs,
+      skillConfigs
+    ).filter((entry) => !isSlotAlreadyRendered(liveRows, entry)).map((entry) => {
+      const { skillId, options } = resolveRowInputs(entry.id);
+      return toPendingRemovalRow(skillId, options, entry);
+    });
+    const rows = [...liveRows, ...pendingRemovalRows];
+    rows.sort((a, b) => sourceRowSortTier(a) - sourceRowSortTier(b));
+    return rows;
+  }
+}));
+function hydrateWizardStore(options) {
+  useWizardStore.setState(createInitialState());
+  const { initialStep } = options;
+  const isEditFlow = initialStep !== void 0;
+  if (isEditFlow) {
+    hydrateForEdit(initialStep, options);
+  } else {
+    hydrateForInit(options);
+  }
+}
+function hydrateForEdit(initialStep, options) {
+  const {
+    initialDomains,
+    initialAgents,
+    installedSkillIds,
+    installedSkillConfigs,
+    installedAgentConfigs,
+    isEditingFromGlobalScope
+  } = options;
+  if (installedSkillIds?.length) {
+    useWizardStore.getState().populateFromSkillIds(installedSkillIds, installedSkillConfigs);
+  }
+  useWizardStore.setState({
+    isInitMode: false,
+    // Jump directly to initialStep with empty history. The user is starting
+    // fresh at this step — no prior steps to navigate back through.
+    step: initialStep,
+    history: [],
+    approach: "scratch",
+    // Saved domains/agents from config override what populateFromSkillIds derived.
+    ...initialDomains?.length ? { selectedDomains: initialDomains, currentDomainIndex: 0 } : {},
+    ...initialAgents?.length ? { selectedAgents: initialAgents } : {},
+    ...initialAgents?.length && installedAgentConfigs?.length ? { agentConfigs: installedAgentConfigs } : {},
+    // Snapshot installed configs for diff rendering in SkillAgentSummary
+    ...installedSkillConfigs?.length || installedAgentConfigs?.length ? {
+      installedSkillConfigs: installedSkillConfigs ?? null,
+      installedAgentConfigs: installedAgentConfigs ?? null
+    } : {},
+    ...isEditingFromGlobalScope ? { isEditingFromGlobalScope: true } : {}
+  });
+  useWizardStore.getState().seedFocusedSkillForActiveDomain();
+}
+function hydrateForInit(options) {
+  const {
+    initialDomains,
+    initialAgents,
+    installedSkillConfigs,
+    installedAgentConfigs,
+    isEditingFromGlobalScope
+  } = options;
+  useWizardStore.setState({
+    isInitMode: true,
+    ...initialDomains?.length ? { selectedDomains: initialDomains, currentDomainIndex: 0 } : {},
+    ...initialAgents?.length ? { selectedAgents: initialAgents } : {},
+    ...initialAgents?.length && installedAgentConfigs?.length ? { agentConfigs: installedAgentConfigs } : {},
+    // Snapshot installed configs for diff rendering in SkillAgentSummary
+    ...installedSkillConfigs?.length || installedAgentConfigs?.length ? {
+      installedSkillConfigs: installedSkillConfigs ?? null,
+      installedAgentConfigs: installedAgentConfigs ?? null
+    } : {},
+    ...isEditingFromGlobalScope ? { isEditingFromGlobalScope: true } : {},
+    ...installedSkillConfigs?.length ? { globalPreselections: installedSkillConfigs } : {},
+    ...initialAgents?.length || installedAgentConfigs?.length ? {
+      globalAgentPreselections: {
+        agents: initialAgents ?? [],
+        configs: installedAgentConfigs ?? []
+      }
+    } : {}
+  });
+  useWizardStore.getState().seedFocusedSkillForActiveDomain();
+}
+
+export {
+  computeScopeDiff,
+  formatScopeTag,
+  deriveScopeBadges,
+  validateBuildStep,
+  buildCategoriesForDomain,
+  orderDomains,
+  WIZARD_STEP_ORDER,
+  createInitialState,
+  useWizardStore,
+  hydrateWizardStore
+};
+//# sourceMappingURL=chunk-MC5DUZ3V.js.map