@cat-factory/app 0.187.0 → 0.189.0

package/app/composables/usePipelineHealth.spec.ts

@@ -27,14 +27,26 @@ function builtin(agentKinds: string[], over: Partial<Pipeline> = {}): Pipeline {
   }
 }
 
-/** Seed the store with pipelines + their current catalog versions, then scan. */
-function scan(pipelines: Pipeline[], versions: Record<string, number> = {}) {
+/**
+ * Seed the store with pipelines + their current catalog versions (and any RETIREMENTS), then scan.
+ * A retired id is dropped from the derived catalog versions, mirroring the backend where the two
+ * sets are disjoint by construction — a test that seeded both would assert against a snapshot the
+ * facade cannot produce.
+ */
+function scan(
+  pipelines: Pipeline[],
+  versions: Record<string, number> = {},
+  retired: { id: string; replacedBy?: string }[] = [],
+) {
   const store = usePipelinesStore()
-  const catalogVersions = {
-    ...Object.fromEntries(pipelines.filter((p) => p.builtin).map((p) => [p.id, p.version ?? 0])),
-    ...versions,
-  }
-  store.hydrate(pipelines, catalogVersions)
+  const retiredIds = new Set(retired.map((r) => r.id))
+  const catalogVersions = Object.fromEntries(
+    Object.entries({
+      ...Object.fromEntries(pipelines.filter((p) => p.builtin).map((p) => [p.id, p.version ?? 0])),
+      ...versions,
+    }).filter(([id]) => !retiredIds.has(id)),
+  )
+  store.hydrate(pipelines, catalogVersions, retired)
   return usePipelineHealth()
 }
 
@@ -164,4 +176,64 @@ describe('usePipelineHealth', () => {
     expect(newPipelines.value).toHaveLength(0)
     expect(hasIssues.value).toBe(false)
   })
+  it('reports a stored built-in the catalog retired, with no reseed offer', () => {
+    const stale = builtin(['coder', 'reviewer'], { id: 'pl_gone', name: 'Old flow', version: 1 })
+    const { retired, invalid, outdated, newPipelines, hasIssues } = scan([stale], {}, [
+      { id: 'pl_gone' },
+    ])
+    expect(retired.value).toHaveLength(1)
+    expect(retired.value[0]!.pipeline.id).toBe('pl_gone')
+    expect(retired.value[0]!.replacement).toBeUndefined()
+    expect(hasIssues.value).toBe(true)
+    // Retirement is answered by a REMOVAL, so the pipeline must appear in no reseed-shaped list.
+    expect(invalid.value).toHaveLength(0)
+    expect(outdated.value).toHaveLength(0)
+    expect(newPipelines.value).toHaveLength(0)
+  })
+
+  it('resolves a retirement replacement to the stored pipeline it names', () => {
+    const stale = builtin(['coder'], { id: 'pl_gone', name: 'Old flow', version: 1 })
+    const live = builtin(['coder', 'reviewer'], { id: 'pl_simple', name: 'Simple', version: 1 })
+    const { retired } = scan([stale, live], {}, [{ id: 'pl_gone', replacedBy: 'pl_simple' }])
+    expect(retired.value[0]!.replacement).toEqual({ id: 'pl_simple', name: 'Simple' })
+  })
+
+  it('names a replacement that is in the catalog but NOT yet stored on this board', () => {
+    // The canonical retirement: an old flow superseded by a NEWLY SHIPPED built-in. The replacement
+    // is in `catalogVersions` with no row until someone adds it — it is simultaneously a
+    // `newPipelines` entry — so resolving only against stored pipelines silently dropped the
+    // "Use X instead" sentence in exactly the case `replacedBy` exists to serve.
+    const stale = builtin(['coder'], { id: 'pl_gone', name: 'Old flow', version: 1 })
+    const { retired, newPipelines } = scan([stale], { pl_bug_triage: 1 }, [
+      { id: 'pl_gone', replacedBy: 'pl_bug_triage' },
+    ])
+    expect(newPipelines.value.map((p) => p.id)).toContain('pl_bug_triage')
+    expect(retired.value[0]!.replacement).toEqual({ id: 'pl_bug_triage', name: 'bug triage' })
+  })
+
+  it('leaves the replacement unnamed when the id resolves nowhere', () => {
+    // A SPA running against a newer backend can be handed a `replacedBy` it knows nothing about.
+    // The advisory falls back to the un-named copy rather than inventing a name for it.
+    const stale = builtin(['coder'], { id: 'pl_gone', name: 'Old flow', version: 1 })
+    const { retired } = scan([stale], {}, [{ id: 'pl_gone', replacedBy: 'pl_from_the_future' }])
+    expect(retired.value[0]!.replacement).toBeUndefined()
+  })
+
+  it('keeps an INVALID retired built-in out of the invalid list (its Reseed could only fail)', () => {
+    // The regression this pins: a retired pipeline that also references an unknown kind used to
+    // land in `invalid` with a built-in Reseed button, and reseed 422s for an id the catalog no
+    // longer defines — an advisory offering a fix that cannot work.
+    const broken = builtin(['coder', 'bogus-kind'], { id: 'pl_gone', version: 1 })
+    const { invalid, retired } = scan([broken], {}, [{ id: 'pl_gone' }])
+    expect(invalid.value).toHaveLength(0)
+    expect(retired.value).toHaveLength(1)
+  })
+
+  it('ignores a retirement for a pipeline this workspace never stored', () => {
+    // Nothing to clean up: the board was created after the withdrawal, so it was never seeded.
+    const stored = builtin(['coder', 'reviewer'], { id: 'pl_full', version: 1 })
+    const { retired, hasIssues } = scan([stored], { pl_full: 1 }, [{ id: 'pl_gone' }])
+    expect(retired.value).toHaveLength(0)
+    expect(hasIssues.value).toBe(false)
+  })
 })

package/app/composables/usePipelineHealth.ts

@@ -7,7 +7,7 @@ import { usePipelinesStore } from '~/stores/pipelines'
 /** Estimate-gating consults a `task-estimator` step (mirrors the backend constant). */
 const TASK_ESTIMATOR_KIND = 'task-estimator'
 
-export type PipelineProblemType = 'unknown-kind' | 'shape' | 'outdated'
+export type PipelineProblemType = 'unknown-kind' | 'shape' | 'outdated' | 'retired'
 
 export interface PipelineProblem {
   type: PipelineProblemType
@@ -23,6 +23,30 @@ export interface PipelineHealth {
   outdated: boolean
 }
 
+/**
+ * A stored built-in that has been WITHDRAWN from the catalog — no longer relevant, and removable
+ * (the one case where deleting a built-in is allowed).
+ *
+ * It is a list of its own rather than a {@link PipelineProblem} on {@link PipelineHealth} because
+ * every problem there is answered by a RESEED, and a retired pipeline has no catalog definition
+ * left to reseed from. Keeping it separate is what guarantees the advisory can never offer both
+ * fixes for one row — a retired pipeline is skipped by the health scan entirely.
+ */
+export interface RetiredPipelineHealth {
+  pipeline: Pipeline
+  /**
+   * The live pipeline that supersedes it, when the catalog names one — resolved to a display name
+   * so the advisory can write "Use {name} instead".
+   *
+   * Deliberately NOT a {@link Pipeline}: the replacement usually is NOT one this workspace stores.
+   * The canonical retirement is "old flow superseded by a NEWLY SHIPPED built-in", and a new
+   * built-in lives in `catalogVersions` with no row until someone reseeds it — it is literally a
+   * {@link NewPipeline} at that moment. Typing this as a stored `Pipeline` made the replacement
+   * unresolvable in exactly the case `replacedBy` exists for, silently dropping the sentence.
+   */
+  replacement?: { id: string; name: string }
+}
+
 /** A brand-new built-in pipeline that appeared in the catalog but isn't in the workspace yet. */
 export interface NewPipeline {
   /** The catalog (built-in) id — what the reseed endpoint is keyed by (it creates the row). */
@@ -117,9 +141,18 @@ function shapeProblem(p: Pipeline): string | null {
 export function usePipelineHealth() {
   const store = usePipelinesStore()
 
+  /** Catalog ids the backend reports as withdrawn, indexed to their (optional) replacement id. */
+  const retiredIds = computed(
+    () => new Map(store.retiredPipelines.map((p) => [p.id, p.replacedBy])),
+  )
+
   const health = computed<PipelineHealth[]>(() => {
     const out: PipelineHealth[] = []
     for (const pipeline of store.pipelines) {
+      // A retired pipeline is reported by `retired` below, never here: every problem this scan
+      // raises is answered by a reseed, and there is no catalog definition left to reseed from.
+      // (An invalid retired pipeline would otherwise get a Reseed button that can only 422.)
+      if (retiredIds.value.has(pipeline.id)) continue
       const problems: PipelineProblem[] = []
 
       const unknown = [...new Set(pipeline.agentKinds.filter((k) => !isKnownAgentKind(k)))]
@@ -158,11 +191,45 @@ export function usePipelineHealth() {
       .map((id) => ({ id, name: builtinPipelineName(id) }))
   })
 
+  // Retired built-ins this workspace still stores: the ones seeded before the withdrawal. A
+  // retirement the board never had a row for is nothing to report — there is no cleanup to do.
+  const retired = computed<RetiredPipelineHealth[]>(() =>
+    store.pipelines
+      .filter((p) => retiredIds.value.has(p.id))
+      .map((pipeline) => {
+        const replacementId = retiredIds.value.get(pipeline.id)
+        const replacement = replacementId ? resolveReplacement(replacementId) : undefined
+        return { pipeline, ...(replacement ? { replacement } : {}) }
+      }),
+  )
+
+  /**
+   * Name the pipeline a retirement points at. Two sources, in order, because a replacement is a
+   * LIVE catalog id and a live catalog id may or may not have been seeded into this workspace yet:
+   * the stored row's authored name when there is one, else the catalog-derived name — the same
+   * `builtinPipelineName` fallback `newPipelines` uses for exactly this "in the catalog, no row
+   * yet" state. Reading only the store would blank the replacement on the most common retirement
+   * (superseded by a newly shipped built-in, which by definition has no row until it is added).
+   *
+   * An id in neither returns undefined and the advisory falls back to the un-named copy: the
+   * backend guards `replacedBy` against naming a non-existent pipeline, but a SPA running against
+   * a newer backend can still be handed one it doesn't know, and inventing a name for it would be
+   * worse than saying nothing.
+   */
+  function resolveReplacement(id: string): { id: string; name: string } | undefined {
+    const stored = store.getPipeline(id)
+    if (stored) return { id, name: stored.name }
+    if (id in store.catalogVersions) return { id, name: builtinPipelineName(id) }
+    return undefined
+  }
+
   // An invalid built-in is reseeded (not deleted) and that also clears any "outdated" flag, so
   // exclude it from the outdated list to avoid offering the same fix twice.
   const invalid = computed(() => health.value.filter((h) => h.invalid))
   const outdated = computed(() => health.value.filter((h) => h.outdated && !h.invalid))
-  const hasIssues = computed(() => health.value.length > 0 || newPipelines.value.length > 0)
+  const hasIssues = computed(
+    () => health.value.length > 0 || newPipelines.value.length > 0 || retired.value.length > 0,
+  )
 
-  return { health, invalid, outdated, newPipelines, hasIssues }
+  return { health, invalid, outdated, newPipelines, retired, hasIssues }
 }

package/app/modular/agent-kinds.spec.ts

@@ -28,15 +28,21 @@ describe('customKindToArchetype', () => {
     })
   })
 
-  it('carries category and resultView through when present', () => {
-    const a = customKindToArchetype(kind({ category: 'review', resultView: 'acme:audit' }))
+  it('carries category, tier and resultView through when present', () => {
+    const a = customKindToArchetype(
+      kind({ category: 'review', tier: 'basic', resultView: 'acme:audit' }),
+    )
     expect(a.category).toBe('review')
+    expect(a.tier).toBe('basic')
     expect(a.resultView).toBe('acme:audit')
   })
 
-  it('omits category/resultView when absent (no undefined keys)', () => {
+  it('omits category/tier/resultView when absent (no undefined keys)', () => {
     const a = customKindToArchetype(kind())
     expect('category' in a).toBe(false)
+    // Left UNSET rather than stamped with the default, so the fallback stays in one place
+    // (`agentTierVisibleAt`) instead of being forked into this projection.
+    expect('tier' in a).toBe(false)
     expect('resultView' in a).toBe(false)
   })
 })

package/app/modular/agent-kinds.ts

@@ -27,6 +27,10 @@ export function customKindToArchetype(kind: CustomAgentKind): AgentArchetype {
     color: p.color,
     description: p.description,
     ...(p.category ? { category: p.category } : {}),
+    // A kind that declares no tier is left WITHOUT one rather than stamped with the default
+    // here, so the single fallback stays in `agentTierVisibleAt` — filling it in at the
+    // projection would fork the rule the moment the default changes.
+    ...(p.tier ? { tier: p.tier } : {}),
     ...(p.resultView ? { resultView: p.resultView } : {}),
   }
 }

package/app/stores/agentTier.spec.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest'
+import type { AgentTier } from '~/types/domain'
+import { useAgentTierStore } from '~/stores/agentTier'
+
+describe('agentTier store', () => {
+  it('opens on the everyday-loop tier and records a widening', () => {
+    const store = useAgentTierStore()
+    expect(store.tier).toBe('basic')
+    expect(store.showsAll).toBe(false)
+
+    store.setTier('advanced')
+    expect(store.tier).toBe('advanced')
+    // The widest level is the "show everything" setting the surfaces advertise.
+    expect(store.showsAll).toBe(true)
+  })
+
+  it('falls back to the default when the persisted value is not a known tier', () => {
+    const store = useAgentTierStore()
+    // What a blob written by an older build (or hand-edited) looks like coming back in. A
+    // catalog filtered on an unknown level would list nothing at all, so this must not pass through.
+    store.storedTier = 'expert' as AgentTier
+    expect(store.tier).toBe('basic')
+  })
+})

package/app/stores/agentTier.ts

@@ -0,0 +1,42 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { AgentTier } from '~/types/domain'
+import { DEFAULT_AGENT_TIER_LEVEL, isAgentTier } from '~/utils/agentTier'
+
+/**
+ * How deep into the agent catalog the two catalog surfaces reach — the pipeline builder's
+ * palette and the model preset's per-agent override list.
+ *
+ * ONE persisted preference shared by both, not a per-surface one: the two are halves of the
+ * same job (pick the agents a pipeline runs, then pick what each of them runs on), so a user
+ * who widened the palette to reach a specialist kind expects to find that same kind when they
+ * go to pin its model. Persisted like the interface mode's own preference, so the choice
+ * survives a reload.
+ *
+ * Distinct from `uiMode` (the SPA-wide basic/advanced interface tier) on purpose — see
+ * `utils/agentTier.ts` for why the axes stay separate.
+ */
+export const useAgentTierStore = defineStore(
+  'agentTier',
+  () => {
+    /** The selected level, persisted. Seeded to the everyday-loop default. */
+    const storedTier = ref<AgentTier>(DEFAULT_AGENT_TIER_LEVEL)
+
+    // The restored value is untrusted input (a blob written by an older build, or hand-edited),
+    // and a catalog filtered on an unknown level would show nothing at all — so fall back
+    // rather than trust it, exactly as `uiMode` does with its persisted mode.
+    const tier = computed<AgentTier>(() =>
+      isAgentTier(storedTier.value) ? storedTier.value : DEFAULT_AGENT_TIER_LEVEL,
+    )
+
+    /** Whether the widest level is selected, i.e. the whole catalog is showing. */
+    const showsAll = computed(() => tier.value === 'advanced')
+
+    function setTier(next: AgentTier) {
+      storedTier.value = next
+    }
+
+    return { tier, showsAll, storedTier, setTier }
+  },
+  { persist: { pick: ['storedTier'] } },
+)

package/app/stores/consensusGroups.ts

@@ -0,0 +1,77 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  ConsensusGroup,
+  CreateConsensusGroupInput,
+  UpdateConsensusGroupInput,
+} from '~/types/consensus'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * The workspace's consensus-GROUP library: the reusable, estimate-gated review panels a pipeline
+ * step escalates to. Hydrated from the workspace snapshot (like the model presets) and managed
+ * from the Model Configuration settings screen; the pipeline builder reads it to offer a step's
+ * tier set.
+ *
+ * A workspace that has authored no group simply has nothing to escalate to, and every consensus
+ * step runs the inline participants written on it — so an empty library is a valid, quiet state,
+ * not an error.
+ */
+export const useConsensusGroupsStore = defineStore('consensusGroups', () => {
+  const api = useApi()
+
+  const groups = ref<ConsensusGroup[]>([])
+
+  function hydrate(list: ConsensusGroup[]) {
+    groups.value = [...list].sort((a, b) => a.createdAt - b.createdAt)
+  }
+
+  /** Whether the workspace has any tier to escalate to (drives the builder's empty state). */
+  const hasGroups = computed(() => groups.value.length > 0)
+
+  /** Resolve ids to groups, dropping any the library no longer holds. */
+  function resolve(ids: readonly string[] | undefined): ConsensusGroup[] {
+    if (!ids?.length) return []
+    return ids
+      .map((id) => groups.value.find((g) => g.id === id))
+      .filter((g): g is ConsensusGroup => !!g)
+  }
+
+  /**
+   * The estimate bar a group sets, as a display number: the highest threshold it names, or null
+   * when it is ungated (the unconditional floor tier). Mirrors kernel's `consensusGroupBar`,
+   * which returns -1 for the same case — the sentinel exists so an ungated group SORTS below
+   * every gated one, which is a ranking concern the UI doesn't share.
+   */
+  function barFor(group: ConsensusGroup): number | null {
+    if (!group.gating.enabled) return null
+    const thresholds = [
+      group.gating.minComplexity,
+      group.gating.minRisk,
+      group.gating.minImpact,
+    ].filter((t): t is number => t !== undefined)
+    return thresholds.length ? Math.max(...thresholds) : null
+  }
+
+  async function create(input: CreateConsensusGroupInput) {
+    const ws = useWorkspaceStore()
+    const created = await api.createConsensusGroup(ws.requireId(), input)
+    await ws.refresh()
+    return created
+  }
+
+  async function update(groupId: string, patch: UpdateConsensusGroupInput) {
+    const ws = useWorkspaceStore()
+    const updated = await api.updateConsensusGroup(ws.requireId(), groupId, patch)
+    await ws.refresh()
+    return updated
+  }
+
+  async function remove(groupId: string) {
+    const ws = useWorkspaceStore()
+    await api.deleteConsensusGroup(ws.requireId(), groupId)
+    await ws.refresh()
+  }
+
+  return { groups, hasGroups, hydrate, resolve, barFor, create, update, remove }
+})

package/app/stores/pipelines/draftActions.ts

@@ -1,15 +1,18 @@
 import { computed } from 'vue'
 import type { AgentKind, Pipeline } from '~/types/domain'
-import type { ConsensusStepConfig } from '~/types/consensus'
-import type { StepOptions } from '@cat-factory/contracts'
 import { companionForProducer } from '~/utils/catalog'
-import { defaultConsensusConfig, type PipelinesContext } from './context'
+import type { PipelinesContext } from './context'
+import { createPipelineStepConfigActions } from './draftStepConfig'
 
 /**
- * The pipeline-builder draft manipulation: inserting/removing/reordering steps and toggling each
- * step's per-step config, plus `clearDraft` / `loadForEdit`. Extracted from the store setup into a
- * factory closing over the shared {@link PipelinesContext} so behaviour is byte-identical to the
- * former in-closure functions — the split is purely to keep the setup within the size budget.
+ * The pipeline-builder draft's STRUCTURE: inserting/removing/reordering steps, the companion
+ * folding that turns the flat arrays into renderable units, and `clearDraft` / `loadForEdit`.
+ * Extracted from the store setup into a factory closing over the shared {@link PipelinesContext}.
+ *
+ * The per-step CONFIG toggles (consensus + its group tiers, gates, companions, step options) are
+ * the sibling factory in `./draftStepConfig` — a different concern on the same context, and the
+ * seam this file was split along when it outgrew the per-function budget. Both are spread into
+ * the store, so callers see one flat API exactly as before.
  */
 export function createPipelineDraftActions(ctx: PipelinesContext) {
   const {
@@ -97,13 +100,6 @@ export function createPipelineDraftActions(ctx: PipelinesContext) {
     else insertAt(index + 1, companion)
   }
 
-  /** Toggle estimate gating on/off for the (companion) step at `index`. */
-  function toggleDraftGating(index: number) {
-    draftGating.value[index] = draftGating.value[index]?.enabled
-      ? null
-      : { enabled: true, minRisk: 0.5, minImpact: 0.5, onMissingEstimate: 'run' }
-  }
-
   /**
    * The draft as a list of "units" for rendering: each step is one unit, EXCEPT a companion
    * that sits immediately after its producer — that companion is folded into the producer's
@@ -157,93 +153,6 @@ export function createPipelineDraftActions(ctx: PipelinesContext) {
     draftStepOptions.value = reorder(draftStepOptions.value)
   }
 
-  /** Toggle the consensus mechanism on the draft step at `index` (default config / off). */
-  function toggleDraftConsensus(index: number) {
-    draftConsensus.value[index] = draftConsensus.value[index] ? null : defaultConsensusConfig()
-  }
-
-  /** Replace the consensus config of the draft step at `index` (builder editor edits). */
-  function setDraftConsensus(index: number, config: ConsensusStepConfig | null) {
-    draftConsensus.value[index] = config
-  }
-
-  /** Toggle the approval gate on the draft step at `index`. */
-  function toggleDraftGate(index: number) {
-    draftGates.value[index] = !draftGates.value[index]
-  }
-
-  /** Toggle the Follow-up companion on the draft (coder) step at `index` (default on → off). */
-  function toggleDraftFollowUps(index: number) {
-    // Default (null/true) is enabled, so the first toggle disables it (false); toggle back to null.
-    draftFollowUps.value[index] = draftFollowUps.value[index] === false ? null : false
-  }
-
-  /**
-   * Toggle the test quality-control companion on the draft (Tester) step at `index`. The
-   * companion is enabled by default (a `null` entry), so the first toggle disables it
-   * (`{ enabled: false }`, dropping any gating) and the next restores the default.
-   */
-  function toggleDraftTesterQuality(index: number) {
-    draftTesterQuality.value[index] =
-      draftTesterQuality.value[index]?.enabled === false ? null : { enabled: false }
-  }
-
-  /**
-   * Toggle estimate gating on/off for the QC companion on the draft (Tester) step at `index`.
-   * A no-op while the companion is disabled (nothing to gate). Enabling gating pins the config
-   * to `{ enabled: true, gating }` so the thresholds are editable; disabling drops back to the
-   * default `null` (enabled, ungated).
-   */
-  function toggleDraftTesterQualityGating(index: number) {
-    const cur = draftTesterQuality.value[index]
-    if (cur?.enabled === false) return
-    draftTesterQuality.value[index] = cur?.gating?.enabled
-      ? null
-      : {
-          enabled: true,
-          gating: { enabled: true, minRisk: 0.5, minImpact: 0.5, onMissingEstimate: 'run' },
-        }
-  }
-
-  /** Enable/disable the draft step at `index` without removing it. */
-  function toggleDraftEnabled(index: number) {
-    draftEnabled.value[index] = draftEnabled.value[index] === false
-  }
-
-  /** Whether auto-recommendation is on for the draft (requirements-review) step at `index`. */
-  function draftAutoRecommendEnabled(index: number): boolean {
-    return draftStepOptions.value[index]?.autoRecommend !== false
-  }
-
-  /**
-   * Toggle the requirements-review auto-recommendation on the draft step at `index`. It is on by
-   * default, so we store ONLY the opt-out (`{ autoRecommend: false }`); toggling back drops the
-   * flag. Merges with any other future StepOptions fields rather than clobbering the whole bag.
-   */
-  function toggleDraftAutoRecommend(index: number) {
-    const next: StepOptions = { ...draftStepOptions.value[index] }
-    if (draftAutoRecommendEnabled(index)) next.autoRecommend = false
-    else delete next.autoRecommend
-    draftStepOptions.value[index] = Object.keys(next).length ? next : null
-  }
-
-  /** The skill picked for the draft `skill` step at `index` (its `stepOptions.skillId`). */
-  function draftSkillId(index: number): string | undefined {
-    return draftStepOptions.value[index]?.skillId
-  }
-
-  /**
-   * Set (or clear) the picked skill on the draft `skill` step at `index`. Merges into the
-   * step's `StepOptions` bag rather than clobbering it; clearing drops the field and, if the
-   * bag empties, the whole entry (so it normalizes away like the other options).
-   */
-  function setDraftSkillId(index: number, skillId: string | undefined) {
-    const next: StepOptions = { ...draftStepOptions.value[index] }
-    if (skillId) next.skillId = skillId
-    else delete next.skillId
-    draftStepOptions.value[index] = Object.keys(next).length ? next : null
-  }
-
   function clearDraft() {
     draft.value = []
     draftGates.value = []
@@ -282,25 +191,14 @@ export function createPipelineDraftActions(ctx: PipelinesContext) {
   }
 
   return {
+    ...createPipelineStepConfigActions(ctx),
     addToDraft,
     removeFromDraft,
     moveInDraft,
     hasCompanion,
     toggleCompanion,
-    toggleDraftGating,
     units,
     moveUnit,
-    toggleDraftConsensus,
-    setDraftConsensus,
-    toggleDraftGate,
-    toggleDraftFollowUps,
-    toggleDraftTesterQuality,
-    toggleDraftTesterQualityGating,
-    toggleDraftEnabled,
-    draftAutoRecommendEnabled,
-    toggleDraftAutoRecommend,
-    draftSkillId,
-    setDraftSkillId,
     clearDraft,
     loadForEdit,
   }