agents-inc 0.152.1 → 0.154.0

package/dist/{chunk-5UWKOOIS.js → chunk-QQTYMW7N.js}

@@ -1,21 +1,22 @@
 #!/usr/bin/env node
 import {
+  DOMAIN_ORDER,
   deriveInstallMode,
   getAvailableSkills,
+  getCellState,
   getUnmetRequiredBy,
   isActiveAt,
-  isCompatibleWithSelections,
   isGlobalTombstone,
   isProjectOwned
-} from "./chunk-EEPELKOM.js";
+} from "./chunk-CBF4ZYV3.js";
 import {
   warn
-} from "./chunk-PMM2MYMA.js";
+} from "./chunk-4VCWL2IG.js";
 import {
   getCategoryDomain,
   getSkillById,
   matrix
-} from "./chunk-WKTHWQKM.js";
+} from "./chunk-IPJOMAWC.js";
 import {
   typedEntries,
   typedFromEntries,
@@ -23,14 +24,14 @@ import {
   typedValues
 } from "./chunk-VASLW636.js";
 import {
-  BUILT_IN_DOMAIN_ORDER,
   DEFAULT_PUBLIC_SOURCE_NAME,
+  DEFAULT_SCRATCH_DOMAINS,
   EJECT_SOURCE,
-  FALLBACK_DOMAIN
-} from "./chunk-76ADG7LQ.js";
+  FALLBACK_DOMAIN,
+  INSTALL_MODES
+} from "./chunk-R54KIGN2.js";
 
 // src/cli/stores/wizard-store.ts
-import { flatMap } from "remeda";
 import { create } from "zustand";
 
 // src/cli/lib/wizard/build-step-logic.ts
@@ -122,9 +123,9 @@ 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" };
+  const modeChanged = !isNew && prevSource != null && prevSource !== skill.source;
+  if (modeChanged) {
+    return { id: skill.id, source: skill.source, status: "mode-changed" };
   }
   return { id: skill.id, source: skill.source, status: isNew ? "added" : "unchanged" };
 }
@@ -140,53 +141,48 @@ function toRemovedAgentRow(agent) {
 }
 
 // src/cli/lib/wizard/build-step-logic.ts
-var FRAMEWORK_CATEGORY_ID = "web-framework";
-var WEB_DOMAIN_ID = "web";
-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;
+function buildCategoriesForDomain(domain, allSelections, installedSkillIds, skillConfigs) {
   const categories = sortBy(
     typedValues(matrix.categories).filter((cat) => cat.domain === domain),
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- CategoryDefinition declares this required, but an auto-synthesized category for a custom skill can arrive without it — the type is stricter than the data
     (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,
+      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,
-        state: isExclusive && skill.advisoryState.status === "incompatible" ? { status: "normal" } : skill.advisoryState,
+        // 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: getSkillById(skill.id).local,
+        ...local !== void 0 && { local },
         installed: installedSkillIds?.includes(skill.id) || false,
-        scope: activeConfig?.scope,
-        secondaryScope,
-        source: activeConfig?.source,
+        ...activeConfig?.scope !== void 0 && { scope: activeConfig.scope },
+        ...secondaryScope !== void 0 && { secondaryScope },
+        ...activeConfig?.source !== void 0 && { source: activeConfig.source },
         hasUnmetRequirements: skill.hasUnmetRequirements,
-        unmetRequirementsReason: skill.unmetRequirementsReason,
-        requiredBy: skill.selected ? void 0 : getUnmetRequiredBy(skill.id, allSelections)
+        ...skill.unmetRequirementsReason !== void 0 && {
+          unmetRequirementsReason: skill.unmetRequirementsReason
+        },
+        ...requiredBy !== void 0 && { requiredBy }
       };
     });
     return {
       id: cat.id,
       displayName: cat.displayName,
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- CategoryDefinition declares this required, but an auto-synthesized category for a custom skill can arrive without it — the type is stricter than the data
       required: cat.required ?? false,
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- CategoryDefinition declares this required, but an auto-synthesized category for a custom skill can arrive without it — the type is stricter than the data
       exclusive: cat.exclusive ?? true,
       options
     };
@@ -196,10 +192,10 @@ function buildCategoriesForDomain(domain, allSelections, selections, installedSk
 
 // src/cli/lib/wizard/domain-order.ts
 function orderDomains(domains) {
-  const builtInSet = new Set(BUILT_IN_DOMAIN_ORDER);
+  const builtInSet = new Set(DOMAIN_ORDER);
   return [
     ...domains.filter((d) => !builtInSet.has(d)).sort(),
-    ...BUILT_IN_DOMAIN_ORDER.filter((d) => domains.includes(d))
+    ...DOMAIN_ORDER.filter((d) => domains.includes(d))
   ];
 }
 
@@ -221,28 +217,6 @@ function createDefaultSkillConfig(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"));
 }
@@ -259,7 +233,10 @@ 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);
+  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.source !== EJECT_SOURCE) return false;
@@ -269,6 +246,10 @@ function wouldOverwriteGlobalEject(config, liveConfigs, installedSkillConfigs) {
   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);
+}
 function withActiveEntrySource(configs, id, scope, source) {
   return configs.map(
     (sc) => sc.id === id && !sc.excluded && sc.scope === scope ? { ...sc, source } : sc
@@ -308,9 +289,11 @@ function reconcileSkillConfigs(configs, added, removed, installedSkillConfigs, i
     }
     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
-      );
+      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)];
     }
@@ -338,9 +321,11 @@ function applyAgentToggle(configs, agent, isSelected) {
   }
   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.map((ac) => {
+      if (ac.name !== agent || !ac.excluded) return ac;
+      const { excluded: _excluded, ...active } = ac;
+      return active;
+    });
   }
   return [...configs, { name: agent, scope: "global" }];
 }
@@ -387,40 +372,26 @@ function buildAgentConfigForName(name, savedConfigs) {
 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 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-reviewer",
-    "web-researcher",
-    "web-tester",
-    "web-pm",
-    "web-architecture"
-  ],
-  api: ["api-developer", "api-reviewer", "api-researcher"],
-  cli: ["cli-developer", "cli-tester", "cli-reviewer"]
+  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"]
 };
-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`
+      `Installed skill '${skillId}' is not present in the loaded source \u2014 it may have been removed or renamed`
     );
     return null;
   }
@@ -439,33 +410,17 @@ function addToDomainSelections(selections, domain, category, skillId) {
   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 marketplaceSourceName(skill) {
+  return skill.availableSources?.find((source) => source.type !== "local")?.name ?? DEFAULT_PUBLIC_SOURCE_NAME;
 }
-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 sourceForInstallMode(skill, mode) {
+  return mode === "eject" ? EJECT_SOURCE : marketplaceSourceName(skill);
+}
+function installModeOfSource(source) {
+  return source === EJECT_SOURCE ? "eject" : "plugin";
+}
+function buildInstallModeOptions(selectedMode) {
+  return INSTALL_MODES.map((mode) => ({ mode, selected: mode === selectedMode }));
 }
 function collectRemovedInstalledEntries(installedSkillConfigs, skillConfigs) {
   if (!installedSkillConfigs) return [];
@@ -483,10 +438,11 @@ function collectInstalledSkillSlots(installedSkillConfigs) {
 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 withSelectedMode(options, source) {
+  const mode = installModeOfSource(source);
+  return options.map((option) => ({ ...option, selected: option.mode === mode }));
 }
-function resolveSkillRowInputs(id, skillConfigs, boundSkills) {
+function resolveSkillRowInputs(id, skillConfigs) {
   const skill = getSkillById(id);
   const configEntry = skillConfigs.find((sc) => sc.id === skill.id);
   const selectedSource = resolveEffectiveSource(
@@ -497,13 +453,13 @@ function resolveSkillRowInputs(id, skillConfigs, boundSkills) {
   return {
     skillId: skill.id,
     configEntry,
-    options: buildSkillSourceOptions(skill, selectedSource, boundSkills)
+    options: buildInstallModeOptions(installModeOfSource(selectedSource))
   };
 }
 function toPendingRemovalRow(skillId, options, removedInstalledEntry) {
   return {
     skillId,
-    options: withSelectedSource(options, removedInstalledEntry.source),
+    options: withSelectedMode(options, removedInstalledEntry.source),
     scope: removedInstalledEntry.scope,
     disabled: true
   };
@@ -515,7 +471,7 @@ function isSlotAlreadyRendered(rows, removedInstalledEntry) {
 function toLockedGlobalRow(skillId, options, installedSource, installedSkillSlots) {
   return {
     skillId,
-    options: withSelectedSource(options, installedSource),
+    options: withSelectedMode(options, installedSource),
     scope: "global",
     readOnly: true,
     ...addedSlotFlag(installedSkillSlots, skillId, "global")
@@ -551,7 +507,7 @@ function classifySkillSourceRows(skillId, options, context) {
     {
       skillId,
       options,
-      scope: configEntry?.scope,
+      ...configEntry?.scope !== void 0 && { scope: configEntry.scope },
       ...readOnly ? { readOnly: true } : {},
       ...addedSlotFlag(installedSkillSlots, skillId, configEntry?.scope)
     }
@@ -570,6 +526,17 @@ var WIZARD_STEP_ORDER = [
   "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,
@@ -581,17 +548,13 @@ var createInitialState = (overrides) => ({
   /** 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,
@@ -620,11 +583,30 @@ var useWizardStore = create((set, get) => ({
     skillConfigs: [],
     selectedAgents: [],
     agentConfigs: [],
-    boundSkills: [],
     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 = [];
@@ -640,11 +622,6 @@ var useWizardStore = create((set, get) => ({
         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)
@@ -701,7 +678,7 @@ var useWizardStore = create((set, get) => ({
     }
     if (isSelected) {
       const categoryDef = matrix.categories[category];
-      if (categoryDef?.exclusive && categoryDef?.required) {
+      if (categoryDef?.exclusive && categoryDef.required) {
         const categorySkillCount = typedValues(matrix.skills).filter(
           (s) => s.category === category
         ).length;
@@ -712,7 +689,7 @@ var useWizardStore = create((set, get) => ({
     }
     if (exclusive && !isSelected) {
       const wouldDropLockedSkill = currentSelections.some(
-        (selectedId) => isGloballyLockedSkill(installed, state.skillConfigs, selectedId)
+        (selectedId) => blocksExclusiveSwap(installed, state.skillConfigs, selectedId)
       );
       if (wouldDropLockedSkill && !state.isEditingFromGlobalScope) {
         return { toastMessage: TOAST_MESSAGES.GLOBAL_SKILLS_LOCKED };
@@ -776,33 +753,6 @@ var useWizardStore = create((set, get) => ({
     }
   },
   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);
@@ -837,40 +787,26 @@ var useWizardStore = create((set, get) => ({
     const categories = buildCategoriesForDomain(
       domain,
       state.getAllSelectedTechnologies(),
-      state.domainSelections[domain] ?? {},
       void 0,
-      state.skillConfigs,
-      state.filterIncompatible
+      state.skillConfigs
     );
     set({ focusedSkillId: categories[0]?.options[0]?.id ?? null });
   },
-  setSourceSelection: (skillId, sourceId, scope) => set((state) => {
+  setInstallMode: (skillId, mode, scope) => set((state) => {
     if (!skillId) {
-      warn("Ignoring setSourceSelection call with empty skillId");
+      warn("Ignoring setInstallMode call with empty skillId");
       return state;
     }
-    if (!sourceId) {
-      warn(`Ignoring setSourceSelection call with empty sourceId for skill '${skillId}'`);
+    if (isInheritedGlobalSlot(state.installedSkillConfigs, skillId, scope) && !state.isEditingFromGlobalScope) {
       return state;
     }
+    const source = sourceForInstallMode(getSkillById(skillId), mode);
     return {
-      skillConfigs: withActiveEntrySource(state.skillConfigs, skillId, scope, sourceId)
+      skillConfigs: withActiveEntrySource(state.skillConfigs, skillId, scope, source)
     };
   }),
-  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];
@@ -923,7 +859,10 @@ var useWizardStore = create((set, get) => ({
   }),
   setFocusedAgentId: (id) => set({ focusedAgentId: id }),
   preselectAgentsFromDomains: () => set((state) => {
-    const sorted = state.selectedDomains.flatMap((domain) => DOMAIN_AGENTS[domain] ?? []).sort();
+    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 retained = state.agentConfigs.filter((ac) => survivesRosterRebuild(ac, roster));
@@ -962,7 +901,7 @@ var useWizardStore = create((set, get) => ({
     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 precedingSteps = stepsBefore(getActiveStepFlow(), state.step);
     const completedSteps = precedingSteps.filter((step) => !skippedSteps.includes(step));
     return { completedSteps, skippedSteps };
   },
@@ -974,40 +913,17 @@ var useWizardStore = create((set, get) => ({
     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 { 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, boundSkills);
+    const resolveRowInputs = (id) => resolveSkillRowInputs(id, skillConfigs);
     const liveRows = liveSkillIds.flatMap((id) => {
       const { skillId, configEntry, options } = resolveRowInputs(id);
       return classifySkillSourceRows(skillId, options, {
@@ -1071,6 +987,7 @@ function hydrateForEdit(initialStep, options) {
   });
   useWizardStore.getState().seedFocusedSkillForActiveDomain();
 }
+var FIRST_STEP_WITHOUT_STACKS = "domains";
 function hydrateForInit(options) {
   const {
     initialDomains,
@@ -1098,6 +1015,10 @@ function hydrateForInit(options) {
       }
     } : {}
   });
+  if (!offersStacks()) {
+    useWizardStore.getState().startFromScratch();
+    useWizardStore.setState({ step: FIRST_STEP_WITHOUT_STACKS, history: [] });
+  }
   useWizardStore.getState().seedFocusedSkillForActiveDomain();
 }
 
@@ -1108,8 +1029,9 @@ export {
   buildCategoriesForDomain,
   orderDomains,
   WIZARD_STEP_ORDER,
+  getActiveStepFlow,
   createInitialState,
   useWizardStore,
   hydrateWizardStore
 };
-//# sourceMappingURL=chunk-5UWKOOIS.js.map
+//# sourceMappingURL=chunk-QQTYMW7N.js.map