agents-inc 0.168.0 → 0.170.1

package/dist/chunk-WNLF5EDZ.js

@@ -1,1170 +0,0 @@
-#!/usr/bin/env node
-import {
-  deriveInstallMode,
-  disableBuffering,
-  drainBuffer,
-  enableBuffering,
-  getAvailableSkills,
-  getCellState,
-  getUnmetRequiredBy,
-  isLocalOnlySkill,
-  warn
-} from "./chunk-C2UISKIM.js";
-import {
-  getCategoryDomain,
-  getSkillById,
-  matrix,
-  typedEntries,
-  typedFromEntries,
-  typedKeys,
-  typedValues
-} from "./chunk-NU2K5G54.js";
-import {
-  CLI_INVOKE_COMMAND,
-  DEFAULT_PUBLIC_SOURCE_NAME,
-  DEFAULT_SCRATCH_DOMAINS,
-  EJECT_SOURCE,
-  FALLBACK_DOMAIN,
-  INSTALL_MODES,
-  SKILL_CATEGORIES_PATH,
-  isActiveAt,
-  isGlobalTombstone,
-  isProjectOwned,
-  orderDomains
-} from "./chunk-AG3ZVM3B.js";
-
-// src/cli/stores/wizard-store.ts
-import { create } from "zustand";
-
-// src/cli/lib/wizard/build-step-logic.ts
-import { sortBy } from "remeda";
-
-// src/cli/lib/wizard/scope-diff.ts
-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.origin])
-  ) : 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 = activeSkillBaseline.filter(
-    (s) => !currentSkills.some((c) => c.id === s.id && c.scope === s.scope)
-  );
-  const removedAgents = activeAgentBaseline.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" && !inheritedSkillIdSet.has(s.id));
-  const removedProjectSkills = removedSkills.filter((s) => s.scope === "project");
-  const removedGlobalAgents = isInitMode ? [] : removedAgents.filter((a) => a.scope === "global" && !inheritedAgentNameSet.has(a.name));
-  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 modeChanged = !isNew && prevSource != null && prevSource !== skill.origin;
-  if (modeChanged) {
-    return { id: skill.id, source: skill.origin, status: "mode-changed" };
-  }
-  return { id: skill.id, source: skill.origin, 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.origin, status: "removed" };
-}
-function toRemovedAgentRow(agent) {
-  return { name: agent.name, status: "removed" };
-}
-
-// src/cli/lib/wizard/build-step-logic.ts
-function buildCategoriesForDomain(domain, allSelections, installedSkillIds, skillConfigs) {
-  const categories = sortBy(
-    typedValues(matrix.categories).filter((cat) => cat.domain === domain),
-    (cat) => cat.order
-  );
-  const categoryRows = categories.map((cat) => {
-    const skillOptions = getAvailableSkills(cat.id, allSelections);
-    const sortedOptions = sortBy(
-      skillOptions,
-      (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);
-      const local = getSkillById(skill.id).local;
-      const requiredBy = skill.selected ? void 0 : getUnmetRequiredBy(skill.id, allSelections);
-      return {
-        id: skill.id,
-        // The cell verdict, not the raw advisory: inside a pick-one category
-        // the shared semantics forgive what the swap resolves.
-        state: getCellState(skill.id, allSelections),
-        selected: skill.selected,
-        ...local !== void 0 && { local },
-        installed: installedSkillIds?.includes(skill.id) || false,
-        ...activeConfig?.scope !== void 0 && { scope: activeConfig.scope },
-        ...secondaryScope !== void 0 && { secondaryScope },
-        ...activeConfig?.origin !== void 0 && { source: activeConfig.origin },
-        hasUnmetRequirements: skill.hasUnmetRequirements,
-        ...skill.unmetRequirementsReason !== void 0 && {
-          unmetRequirementsReason: skill.unmetRequirementsReason
-        },
-        ...requiredBy !== void 0 && { requiredBy }
-      };
-    });
-    return {
-      id: cat.id,
-      displayName: cat.displayName,
-      exclusive: cat.exclusive,
-      options
-    };
-  });
-  return categoryRows.filter((row) => row.options.length > 0);
-}
-
-// src/cli/lib/wizard/agent-roster.ts
-var BUILT_IN_AGENT_GROUPS = [
-  {
-    label: "Web",
-    items: [
-      {
-        id: "web-developer",
-        label: "Web Developer",
-        description: "Frontend features, components, TypeScript"
-      },
-      { id: "web-researcher", label: "Web Researcher", description: "Frontend pattern discovery" },
-      {
-        id: "web-tester",
-        label: "Web Tester",
-        description: "Frontend tests, E2E, component tests"
-      }
-    ]
-  },
-  {
-    label: "API",
-    items: [
-      {
-        id: "api-developer",
-        label: "API Developer",
-        description: "Backend routes, database, middleware"
-      },
-      { id: "api-researcher", label: "API Researcher", description: "Backend pattern discovery" },
-      {
-        id: "api-tester",
-        label: "API Tester",
-        description: "Endpoint, database, and auth flow tests"
-      }
-    ]
-  },
-  {
-    label: "AI",
-    items: [
-      {
-        id: "ai-developer",
-        label: "AI Developer",
-        description: "RAG pipelines, agent loops, tool calling"
-      },
-      {
-        id: "ai-researcher",
-        label: "AI Researcher",
-        description: "Prompt, model, and RAG pipeline discovery"
-      },
-      {
-        id: "ai-tester",
-        label: "AI Tester",
-        description: "LLM mocking, prompt regression, eval harnesses"
-      }
-    ]
-  },
-  {
-    label: "CLI",
-    items: [
-      {
-        id: "cli-developer",
-        label: "CLI Developer",
-        description: "CLI commands, interactive prompts"
-      },
-      { id: "cli-tester", label: "CLI Tester", description: "CLI application tests" },
-      {
-        id: "cli-researcher",
-        label: "CLI Researcher",
-        description: "CLI command and config pattern discovery"
-      }
-    ]
-  },
-  {
-    label: "Meta",
-    items: [
-      {
-        id: "pm",
-        label: "PM",
-        description: "Cross-domain implementation specs; domain frameworks via skills"
-      },
-      {
-        id: "reviewer",
-        label: "Reviewer",
-        description: "Cross-domain code review; domain knowledge via skills"
-      },
-      { id: "agent-summoner", label: "Agent Summoner", description: "Create and improve agents" },
-      {
-        id: "skill-summoner",
-        label: "Skill Summoner",
-        description: "Create technology-specific skills"
-      },
-      { id: "codex-keeper", label: "Codex Keeper", description: "AI-focused documentation" }
-    ]
-  }
-];
-var BUILT_IN_AGENT_IDS = new Set(
-  BUILT_IN_AGENT_GROUPS.flatMap((group) => group.items.map((agent) => agent.id))
-);
-function firstFocusableAgent() {
-  const first = BUILT_IN_AGENT_GROUPS[0]?.items[0];
-  if (first === void 0) throw new Error("The built-in agent roster is empty");
-  return first.id;
-}
-
-// src/cli/stores/wizard-store.ts
-var LOCAL_ONLY_INSTALL_MODES = ["eject"];
-var TOAST_MESSAGES = {
-  GLOBAL_SKILLS_LOCKED: "Global skills cannot be changed from project scope",
-  ALREADY_EJECTED_AT_GLOBAL: "Already exists as ejected skill at global scope",
-  GLOBAL_AGENTS_LOCKED: "Global agents cannot be changed from project scope"
-};
-function skillsLeftOutToast(count) {
-  return count === 1 ? "1 skill was left out \u2014 this source cannot place it" : `${count} skills were left out \u2014 this source cannot place them`;
-}
-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 marketplaceSourceName(skill) {
-  return skill?.availableSources?.find((source) => source.type !== "local")?.name;
-}
-function defaultOriginFor(skill) {
-  if (isLocalOnlySkill(skill)) return EJECT_SOURCE;
-  return primarySourceName(skill) ?? DEFAULT_PUBLIC_SOURCE_NAME;
-}
-function createDefaultSkillConfig(id) {
-  return { id, scope: "global", origin: defaultOriginFor(matrix.skills[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);
-}
-function blocksExclusiveSwap(installed, liveConfigs, id) {
-  return isGloballyLockedSkill(installed, liveConfigs, id) || isDualScopePair(liveConfigs, id);
-}
-function wouldOverwriteGlobalEject(config, liveConfigs, installedSkillConfigs) {
-  if (config.scope !== "project" || config.origin !== EJECT_SOURCE) return false;
-  const globalEjectInstalled = installedSkillConfigs?.some(
-    (sc) => sc.id === config.id && sc.scope === "global" && sc.origin === EJECT_SOURCE && !sc.excluded
-  );
-  if (!globalEjectInstalled) return false;
-  return !liveConfigs.some((sc) => sc.id === config.id && sc.excluded);
-}
-function isInheritedGlobalSlot(installed, id, scope) {
-  if (installed === null) return false;
-  return scope === "global" && (hasGlobalActive(installed, id) || hasGlobalTombstone(installed, id));
-}
-function withActiveEntryOrigin(configs, id, scope, origin) {
-  return configs.map(
-    (sc) => sc.id === id && !sc.excluded && sc.scope === scope ? { ...sc, origin } : 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",
-    origin: configs.find((sc) => sc.id === id && sc.scope === "global")?.origin ?? 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 origin = globalEntry?.origin ?? DEFAULT_PUBLIC_SOURCE_NAME;
-      result = [
-        ...result.filter((sc) => sc.id !== id),
-        { id, scope: "project", origin },
-        { id, scope: "global", excluded: true, origin }
-      ];
-      continue;
-    }
-    const existingExcluded = result.find((sc) => sc.id === id && sc.excluded);
-    if (existingExcluded) {
-      result = result.map((sc) => {
-        if (sc.id !== id || !sc.excluded) return sc;
-        const { excluded: _excluded, ...active } = sc;
-        return active;
-      });
-    } 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 && isActiveAt(ac, "project"));
-}
-function agentHasGlobalActive(configs, name) {
-  return configs.some((ac) => ac.name === name && isActiveAt(ac, "global"));
-}
-function agentHasGlobalTombstone(configs, name) {
-  return configs.some((ac) => ac.name === name && isGlobalTombstone(ac));
-}
-function isDualScopeAgentPair(configs, name) {
-  return agentHasProjectActive(configs, name) && agentHasGlobalTombstone(configs, name);
-}
-function collectTombstones(configs) {
-  return configs.filter((entry) => entry.excluded);
-}
-function filledAgentSlots(configs) {
-  return new Set(configs.map((ac) => agentSlotKey(ac.name, ac.scope)));
-}
-function agentTombstonesOutsideRebuild(saved, rebuilt) {
-  const filled = filledAgentSlots(rebuilt);
-  return collectTombstones(saved).filter((ac) => !filled.has(agentSlotKey(ac.name, ac.scope)));
-}
-function skillTombstonesOutsideRebuild(saved, rebuilt) {
-  const filled = new Set(rebuilt.map((sc) => skillSlotKey(sc.id, sc.scope)));
-  return collectTombstones(saved).filter((sc) => !filled.has(skillSlotKey(sc.id, sc.scope)));
-}
-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) => {
-      if (ac.name !== agent || !ac.excluded) return ac;
-      const { excluded: _excluded, ...active } = ac;
-      return active;
-    });
-  }
-  return [...configs, { name: agent, scope: "global" }];
-}
-function survivesRosterRebuild(agentConfig, roster, rebuiltSlots) {
-  if (agentConfig.excluded) {
-    return !rebuiltSlots.has(agentSlotKey(agentConfig.name, agentConfig.scope));
-  }
-  return !isProjectOwned(agentConfig) && !roster.has(agentConfig.name);
-}
-function tuningOf(agentConfig) {
-  return {
-    ...agentConfig?.model !== void 0 && { model: agentConfig.model },
-    ...agentConfig?.codexModel !== void 0 && { codexModel: agentConfig.codexModel },
-    ...agentConfig?.effort !== void 0 && { effort: agentConfig.effort }
-  };
-}
-function tunedEntryFor(agentConfigs, agent) {
-  return agentConfigs?.find((ac) => ac.name === agent && !ac.excluded && ac.scope === "project") ?? agentConfigs?.find((ac) => ac.name === agent && !ac.excluded);
-}
-function restoreDualScopeAgent(selectedAgents, agentConfigs, agent) {
-  const tuning = tuningOf(tunedEntryFor(agentConfigs, agent));
-  return {
-    selectedAgents: [...selectedAgents, agent],
-    agentConfigs: [
-      ...agentConfigs.filter((ac) => ac.name !== agent),
-      { name: agent, scope: "project", ...tuning },
-      { name: agent, scope: "global", ...tuning, 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);
-  return {
-    id,
-    scope: saved?.scope ?? "global",
-    origin: saved?.origin ?? defaultOriginFor(matrix.skills[id])
-  };
-}
-function buildAgentConfigForName(name, savedConfigs) {
-  const saved = tunedEntryFor(savedConfigs, name);
-  return {
-    name,
-    scope: saved?.scope ?? "global",
-    ...tuningOf(saved)
-  };
-}
-function restoreSkillConfigs(existingConfigs, restoredIds) {
-  const restoredSet = new Set(restoredIds);
-  const existingIds = new Set(existingConfigs.map((sc) => sc.id));
-  const updated = existingConfigs.map((sc) => {
-    if (!restoredSet.has(sc.id) || !sc.excluded) return sc;
-    const { excluded: _excluded, ...active } = sc;
-    return active;
-  });
-  const newConfigs = restoredIds.filter((id) => !existingIds.has(id)).map(createDefaultSkillConfig);
-  return [...updated, ...newConfigs];
-}
-var DOMAIN_AGENTS = {
-  web: ["web-developer", "web-researcher", "web-tester", "pm", "reviewer"],
-  api: ["api-developer", "api-researcher", "api-tester", "pm", "reviewer"],
-  cli: ["cli-developer", "cli-tester", "cli-researcher", "pm", "reviewer"],
-  ai: ["ai-developer", "ai-researcher", "ai-tester", "pm", "reviewer"]
-};
-function absentFromSourceWarning(skillId) {
-  return `Installed skill '${skillId}' is not present in the loaded source \u2014 it may have been removed or renamed. It is left out of this session's selection. Run '${CLI_INVOKE_COMMAND} update' to refresh the marketplace if you expect it to still be carried there.`;
-}
-function unplaceableCategoryWarning(skillId, category) {
-  return `Installed skill '${skillId}' has unknown category '${category}' \u2014 skipping. No domain in this source claims that category, so the wizard has no screen to place the skill on. Declare it with a 'domain' in the source's '${SKILL_CATEGORIES_PATH}', or run '${CLI_INVOKE_COMMAND} update' to refresh the marketplace.`;
-}
-function resolveSkillForPopulation(skillId) {
-  const { skills } = matrix;
-  const skill = skills[skillId];
-  if (!skill?.category) {
-    warn(absentFromSourceWarning(skillId));
-    return null;
-  }
-  const domain = getCategoryDomain(skill.category);
-  if (!domain) {
-    warn(unplaceableCategoryWarning(skillId, skill.category));
-    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 sourceForInstallMode(skill, mode) {
-  if (mode === "eject") return EJECT_SOURCE;
-  return marketplaceSourceName(skill) ?? DEFAULT_PUBLIC_SOURCE_NAME;
-}
-function installModeOfSource(origin) {
-  return origin === EJECT_SOURCE ? "eject" : "plugin";
-}
-function buildInstallModeOptions(skill, selectedMode) {
-  const modes = isLocalOnlySkill(skill) ? LOCAL_ONLY_INSTALL_MODES : INSTALL_MODES;
-  return modes.map((mode) => ({ mode, selected: mode === selectedMode }));
-}
-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)) && // Hydration already moved it to unresolvableSkillIds, and getSkillById would throw on it.
-    !!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 withSelectedMode(options, source) {
-  const mode = installModeOfSource(source);
-  return options.map((option) => ({ ...option, selected: option.mode === mode }));
-}
-function resolveSkillRowInputs(id, skillConfigs) {
-  const skill = getSkillById(id);
-  const configEntry = skillConfigs.find((sc) => sc.id === skill.id);
-  const selectedSource = resolveEffectiveSource(
-    configEntry?.origin,
-    skill.activeSource?.name,
-    primarySourceName(skill)
-  );
-  return {
-    skillId: skill.id,
-    configEntry,
-    options: buildInstallModeOptions(skill, installModeOfSource(selectedSource))
-  };
-}
-function toPendingRemovalRow(skillId, options, removedInstalledEntry) {
-  return {
-    skillId,
-    options: withSelectedMode(options, removedInstalledEntry.origin),
-    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: withSelectedMode(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?.origin ?? configEntry.origin,
-        installedSkillSlots
-      )
-    ];
-  }
-  if (!isEditingFromGlobalScope && installedGlobalConfig && configEntry?.scope === "project") {
-    return [
-      toLockedGlobalRow(skillId, options, installedGlobalConfig.origin, installedSkillSlots),
-      {
-        skillId,
-        options,
-        scope: "project",
-        ...addedSlotFlag(installedSkillSlots, skillId, "project")
-      }
-    ];
-  }
-  const readOnly = !isEditingFromGlobalScope && (!!installedGlobalConfig || isInheritedGlobalSlot(installedSkillConfigs, skillId, configEntry?.scope));
-  return [
-    {
-      skillId,
-      options,
-      ...configEntry?.scope !== void 0 && { 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"
-];
-function offersStacks() {
-  return matrix.suggestedStacks.length > 0;
-}
-function getActiveStepFlow() {
-  if (offersStacks()) return [...WIZARD_STEP_ORDER];
-  return WIZARD_STEP_ORDER.filter((step) => step !== "stack");
-}
-function stepsBefore(flow, step) {
-  const index = flow.indexOf(step);
-  return index < 0 ? [] : flow.slice(0, index);
-}
-var createInitialState = (overrides) => ({
-  step: "stack",
-  approach: null,
-  selectedStackId: null,
-  stackAction: null,
-  selectedDomains: [],
-  currentDomainIndex: 0,
-  domainSelections: {},
-  _stackDomainSelections: null,
-  showLabels: false,
-  skillConfigs: [],
-  focusedSkillId: null,
-  unresolvableSkillIds: [],
-  foldedSkillIds: [],
-  setupMarketplace: null,
-  showInfo: false,
-  selectedAgents: [],
-  agentConfigs: [],
-  focusedAgentId: null,
-  installedSkillConfigs: null,
-  installedAgentConfigs: null,
-  isInitMode: false,
-  isEditingFromGlobalScope: false,
-  toastMessage: null,
-  globalPreselections: null,
-  globalAgentPreselections: null,
-  history: [],
-  ...overrides
-});
-function seedFocusForStep(step, actions) {
-  if (step === "build") actions.seedFocusedSkillForActiveDomain();
-  if (step === "agents") actions.seedFocusedAgent();
-}
-var useWizardStore = create((set, get) => ({
-  ...createInitialState(),
-  setStep: (step) => {
-    set((state) => ({
-      step,
-      history: [...state.history, state.step]
-    }));
-    seedFocusForStep(step, get());
-  },
-  setApproach: (approach) => set({ approach }),
-  selectStack: (stackId) => set({
-    selectedStackId: stackId,
-    domainSelections: {},
-    _stackDomainSelections: null,
-    selectedDomains: [],
-    skillConfigs: [],
-    selectedAgents: [],
-    agentConfigs: [],
-    currentDomainIndex: 0,
-    stackAction: null
-  }),
-  setStackAction: (action) => set({ stackAction: action }),
-  startFromScratch: () => {
-    get().selectStack(null);
-    get().setApproach("scratch");
-    const { globalAgentPreselections, globalPreselections } = get();
-    if (globalAgentPreselections) {
-      set({
-        selectedAgents: globalAgentPreselections.agents,
-        agentConfigs: globalAgentPreselections.configs
-      });
-    }
-    if (globalPreselections?.length) {
-      get().populateFromSkillIds(
-        globalPreselections.map((skill) => skill.id),
-        globalPreselections
-      );
-    }
-    for (const domain of DEFAULT_SCRATCH_DOMAINS) {
-      if (!get().selectedDomains.includes(domain)) get().toggleDomain(domain);
-    }
-  },
-  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);
-      }
-    }
-    const selectedDomains = orderDomains(typedKeys(domainSelections));
-    const skillConfigs = resolvedSkillIds.map(
-      (id) => buildSkillConfigForId(id, savedConfigs)
-    );
-    const excludedConfigs = skillTombstonesOutsideRebuild(savedConfigs ?? [], skillConfigs);
-    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: deselecting a domain uninstalls its skills instead of tombstoning.
-        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 (exclusive && !isSelected) {
-      const wouldDropLockedSkill = currentSelections.some(
-        (selectedId) => blocksExclusiveSwap(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 })),
-  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, origin: config.origin }
-        ] : rescoped,
-        foldedSkillIds: state.foldedSkillIds.filter((id) => id !== skillId)
-      };
-    }
-    return {
-      skillConfigs: rescoped.filter((sc) => !(sc.id === skillId && sc.excluded)),
-      foldedSkillIds: isDualScopePair(state.skillConfigs, skillId) ? [...state.foldedSkillIds, skillId] : state.foldedSkillIds
-    };
-  }),
-  setFocusedSkillId: (id) => set({ focusedSkillId: id }),
-  seedFocusedSkillForActiveDomain: () => {
-    const state = get();
-    const domain = state.getCurrentDomain() ?? FALLBACK_DOMAIN;
-    const categories = buildCategoriesForDomain(
-      domain,
-      state.getAllSelectedTechnologies(),
-      void 0,
-      state.skillConfigs
-    );
-    set({ focusedSkillId: categories[0]?.options[0]?.id ?? null });
-  },
-  setInstallMode: (skillId, mode, scope) => set((state) => {
-    if (!skillId) {
-      warn("Ignoring setInstallMode call with empty skillId");
-      return state;
-    }
-    if (isInheritedGlobalSlot(state.installedSkillConfigs, skillId, scope) && !state.isEditingFromGlobalScope) {
-      return state;
-    }
-    const origin = sourceForInstallMode(getSkillById(skillId), mode);
-    return {
-      skillConfigs: withActiveEntryOrigin(state.skillConfigs, skillId, scope, origin)
-    };
-  }),
-  toggleInfo: () => set((state) => ({ showInfo: !state.showInfo })),
-  setToastMessage: (message) => set({ toastMessage: message }),
-  goBack: () => {
-    const previousStep = get().history.at(-1);
-    if (previousStep === void 0) return;
-    set((state) => ({ step: previousStep, history: state.history.slice(0, -1) }));
-    seedFocusForStep(previousStep, get());
-  },
-  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 }),
-  seedFocusedAgent: () => {
-    if (get().focusedAgentId !== null) return;
-    set({ focusedAgentId: firstFocusableAgent() });
-  },
-  preselectAgentsFromDomains: () => set((state) => {
-    if (state.selectedStackId) return state;
-    const sorted = [
-      ...new Set(state.selectedDomains.flatMap((domain) => DOMAIN_AGENTS[domain] ?? []))
-    ].sort();
-    const roster = new Set(sorted);
-    const merged = sorted.map((name) => buildAgentConfigForName(name, state.agentConfigs));
-    const rebuiltSlots = filledAgentSlots(merged);
-    const retained = state.agentConfigs.filter(
-      (ac) => survivesRosterRebuild(ac, roster, rebuiltSlots)
-    );
-    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 = agentTombstonesOutsideRebuild(savedConfigs, merged);
-    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 = stepsBefore(getActiveStepFlow(), 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;
-  },
-  buildSourceRows: () => {
-    const state = get();
-    const selectedTechnologies = get().getAllSelectedTechnologies();
-    const { skillConfigs } = 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);
-    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 showWarningsAsToast(change) {
-  enableBuffering();
-  try {
-    change();
-    const warnings = drainBuffer();
-    if (warnings.length > 0) {
-      useWizardStore.getState().setToastMessage(skillsLeftOutToast(warnings.length));
-    }
-  } finally {
-    disableBuffering();
-  }
-}
-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,
-    setupMarketplace
-  } = options;
-  if (installedSkillIds?.length) {
-    useWizardStore.getState().populateFromSkillIds(installedSkillIds, installedSkillConfigs);
-  }
-  useWizardStore.setState({
-    isInitMode: false,
-    step: initialStep,
-    history: [],
-    approach: "scratch",
-    ...initialDomains?.length ? { selectedDomains: initialDomains, currentDomainIndex: 0 } : {},
-    ...initialAgents?.length ? { selectedAgents: initialAgents } : {},
-    ...initialAgents?.length && installedAgentConfigs?.length ? { agentConfigs: installedAgentConfigs } : {},
-    ...installedSkillConfigs?.length || installedAgentConfigs?.length ? {
-      installedSkillConfigs: installedSkillConfigs ?? null,
-      installedAgentConfigs: installedAgentConfigs ?? null
-    } : {},
-    ...isEditingFromGlobalScope ? { isEditingFromGlobalScope: true } : {},
-    ...setupMarketplace !== void 0 && { setupMarketplace }
-  });
-  useWizardStore.getState().seedFocusedSkillForActiveDomain();
-}
-var FIRST_STEP_WITHOUT_STACKS = "domains";
-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 } : {},
-    ...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 ?? []
-      }
-    } : {}
-  });
-  if (!offersStacks()) {
-    useWizardStore.getState().startFromScratch();
-    useWizardStore.setState({ step: FIRST_STEP_WITHOUT_STACKS, history: [] });
-  }
-  useWizardStore.getState().seedFocusedSkillForActiveDomain();
-}
-
-export {
-  computeScopeDiff,
-  formatScopeTag,
-  deriveScopeBadges,
-  buildCategoriesForDomain,
-  BUILT_IN_AGENT_GROUPS,
-  BUILT_IN_AGENT_IDS,
-  DOMAIN_AGENTS,
-  WIZARD_STEP_ORDER,
-  getActiveStepFlow,
-  createInitialState,
-  useWizardStore,
-  showWarningsAsToast,
-  hydrateWizardStore
-};
-//# sourceMappingURL=chunk-WNLF5EDZ.js.map