@cat-factory/app 0.187.0 → 0.189.0

package/app/stores/pipelines/draftStepConfig.ts

@@ -0,0 +1,157 @@
+import type { StepOptions } from '@cat-factory/contracts'
+import type { ConsensusStepConfig } from '~/types/consensus'
+import { defaultConsensusConfig, type PipelinesContext } from './context'
+
+/**
+ * The pipeline-builder draft's PER-STEP CONFIG toggles: consensus (inline panel and the workspace
+ * consensus-GROUP tier set), the human approval gate, the estimate gate on a companion step, the
+ * follow-up and test-QC companions, the per-step enable flag, and the `StepOptions` bag
+ * (requirements auto-recommendation, the picked skill).
+ *
+ * Split out of `./draftActions`, which owns the draft's STRUCTURE (insert / remove / reorder /
+ * units). Every function here reads and writes one of the parallel per-step arrays at an index and
+ * touches nothing else, which is what makes the two independent; both are spread into the store,
+ * so the store's API is unchanged.
+ */
+export function createPipelineStepConfigActions(ctx: PipelinesContext) {
+  const {
+    draftGates,
+    draftEnabled,
+    draftConsensus,
+    draftGating,
+    draftFollowUps,
+    draftTesterQuality,
+    draftStepOptions,
+  } = ctx
+
+  /** 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' }
+  }
+
+  /** 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
+  }
+
+  /**
+   * Add/remove a workspace consensus GROUP from the draft step's tier set. The array is a SET,
+   * not a precedence list — the engine ranks candidates by the bar each group sets — so this
+   * appends without ceremony.
+   *
+   * An empty tier set falls back to the step's inline participants; a non-empty one takes over,
+   * which is why the builder shows only one of the two editors at a time.
+   */
+  function toggleDraftConsensusGroup(index: number, groupId: string) {
+    const config = draftConsensus.value[index]
+    if (!config) return
+    const current = config.groupIds ?? []
+    const next = current.includes(groupId)
+      ? current.filter((id) => id !== groupId)
+      : [...current, groupId]
+    // Drop the key entirely when the set empties, so a step that never used tiers persists the
+    // same shape it always did rather than an empty array that reads as "tiered, but none".
+    if (next.length) config.groupIds = next
+    else delete config.groupIds
+  }
+
+  /** 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
+  }
+
+  return {
+    toggleDraftGating,
+    toggleDraftConsensus,
+    setDraftConsensus,
+    toggleDraftConsensusGroup,
+    toggleDraftGate,
+    toggleDraftFollowUps,
+    toggleDraftTesterQuality,
+    toggleDraftTesterQualityGating,
+    toggleDraftEnabled,
+    draftAutoRecommendEnabled,
+    toggleDraftAutoRecommend,
+    draftSkillId,
+    setDraftSkillId,
+  }
+}

package/app/stores/pipelines.ts

@@ -1,7 +1,7 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
 import type { Pipeline } from '~/types/domain'
-import type { PipelinePurpose } from '@cat-factory/contracts'
+import type { PipelinePurpose, RetiredPipelineWire } from '@cat-factory/contracts'
 import { useUpsertList } from '~/composables/useUpsertList'
 import { createDraftStepState, type PipelinesContext } from '~/stores/pipelines/context'
 import { createPipelineDraftActions } from '~/stores/pipelines/draftActions'
@@ -32,6 +32,13 @@ export const usePipelinesStore = defineStore('pipelines', () => {
    * a newer definition available (see `usePipelineHealth`).
    */
   const catalogVersions = ref<Record<string, number>>({})
+  /**
+   * Built-in pipelines WITHDRAWN from the catalog (`retiredPipelines()`), from the workspace
+   * snapshot. A stored pipeline whose id appears here is no longer relevant and can be REMOVED —
+   * the opposite of a reseed, and the only case where deleting a built-in is allowed (see
+   * `usePipelineHealth`). Disjoint from {@link catalogVersions} by construction.
+   */
+  const retiredPipelines = ref<RetiredPipelineWire[]>([])
 
   // The per-step, index-aligned draft arrays (kept in lockstep — see `createDraftStepState`).
   const {
@@ -60,10 +67,20 @@ export const usePipelinesStore = defineStore('pipelines', () => {
   /** The id of the pipeline being edited, or null when assembling a brand-new one. */
   const editingId = ref<string | null>(null)
 
-  /** Replace the cached pipelines (and the current built-in catalog versions) from a snapshot. */
-  function hydrate(next: Pipeline[], versions?: Record<string, number>) {
+  /**
+   * Replace the cached pipelines (and the current built-in catalog versions + retirements) from a
+   * snapshot. `retired` is applied even when EMPTY, unlike `versions`: an absent list means the
+   * facade shipped no retirements, and carrying the previous board's forward would offer a delete
+   * for a pipeline this deployment still ships.
+   */
+  function hydrate(
+    next: Pipeline[],
+    versions?: Record<string, number>,
+    retired?: RetiredPipelineWire[],
+  ) {
     pipelines.value = next
     if (versions) catalogVersions.value = versions
+    retiredPipelines.value = retired ?? []
   }
 
   function getPipeline(id: string) {
@@ -99,6 +116,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
   return {
     pipelines,
     catalogVersions,
+    retiredPipelines,
     draft,
     draftGates,
     draftEnabled,

package/app/stores/workspace/hydrate.ts

@@ -12,6 +12,7 @@ import { useFragmentsStore } from '~/stores/fragments'
 import { useGitHubStore } from '~/stores/github'
 import { useInitiativesStore } from '~/stores/initiative'
 import { useModelPresetsStore } from '~/stores/modelPresets'
+import { useConsensusGroupsStore } from '~/stores/consensusGroups'
 import { useNotificationsStore } from '~/stores/notifications'
 import { usePipelinesStore } from '~/stores/pipelines'
 import { useProviderConnectionsStore } from '~/stores/providerConnections'
@@ -61,7 +62,11 @@ export function applySnapshotToStores(snapshot: WorkspaceSnapshot, boardSince?:
   useUserSettingsStore().hydrate(snapshot.userSettings ?? null)
   useBoardStore().hydrate(snapshot.blocks, boardSince)
   useBoardStore().hydrateArchived(snapshot.archivedServices ?? [])
-  usePipelinesStore().hydrate(snapshot.pipelines, snapshot.pipelineCatalogVersions)
+  usePipelinesStore().hydrate(
+    snapshot.pipelines,
+    snapshot.pipelineCatalogVersions,
+    snapshot.retiredPipelines,
+  )
   useExecutionStore().hydrate(snapshot.executions, snapshot.workspace.id)
   useAgentRunsStore().hydrate(snapshot.bootstrapJobs ?? [], snapshot.workspace.id)
   useAgentRunsStore().hydrateEnvConfigRepair(snapshot.envConfigRepairJobs ?? [])
@@ -72,6 +77,7 @@ export function applySnapshotToStores(snapshot: WorkspaceSnapshot, boardSince?:
   useWorkspaceSettingsStore().hydrate(snapshot.settings)
   useAgentConfigStore().hydrate(snapshot.agentConfigCatalog ?? [])
   useModelPresetsStore().hydrate(snapshot.modelPresets ?? [], snapshot.modelPresetCatalogVersions)
+  useConsensusGroupsStore().hydrate(snapshot.consensusGroups ?? [])
   useServiceFragmentDefaultsStore().hydrate(snapshot.serviceFragmentDefaults?.fragmentIds)
   useRecurringPipelinesStore().hydrate(snapshot.recurringPipelines ?? [])
   useInitiativesStore().hydrate(snapshot.initiatives)

package/app/types/consensus.ts

@@ -15,4 +15,7 @@ export type {
   ConsensusRound,
   ConsensusSessionStatus,
   ConsensusSession,
+  ConsensusGroup,
+  CreateConsensusGroupInput,
+  UpdateConsensusGroupInput,
 } from '@cat-factory/contracts'

package/app/types/domain.ts

@@ -60,6 +60,7 @@ export type {
   TestScreenshot,
   AgentKind,
   AgentCategory,
+  AgentTier,
   CustomAgentKind,
   CustomTaskType,
   TaskTypePresentation,
@@ -96,7 +97,7 @@ export type {
   PreviewStatus,
 } from '@cat-factory/contracts'
 
-import type { AgentCategory, AgentKind } from '@cat-factory/contracts'
+import type { AgentCategory, AgentKind, AgentTier } from '@cat-factory/contracts'
 
 // The document-kind list + the per-kind field descriptors are runtime values (used to render
 // the picker and the conditional per-kind inputs), so they are re-exported as values — the
@@ -114,6 +115,12 @@ export interface AgentArchetype {
   description: string
   /** Palette category this archetype is grouped under. Absent ⇒ ungrouped/system kind. */
   category?: AgentCategory
+  /**
+   * How specialist this kind is — the tier the palette / model-preset override list filter on
+   * (`basic` shows only basic kinds, `intermediate` adds those, `advanced` shows everything).
+   * Absent ⇒ `DEFAULT_AGENT_TIER`, which is how an unclassified deployment kind behaves.
+   */
+  tier?: AgentTier
   /**
    * Optional id of a DEDICATED result window this agent's step opens instead of the
    * generic prose step-detail panel. Resolved through the modular `resultViews` slot

package/app/utils/agentTier.spec.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest'
+import type { AgentArchetype } from '~/types/domain'
+import { filterByAgentTier, filterByAgentTierKeeping, isAgentTier } from '~/utils/agentTier'
+
+const archetype = (kind: string, tier?: AgentArchetype['tier']): AgentArchetype => ({
+  kind: kind as AgentArchetype['kind'],
+  label: kind,
+  icon: 'i-lucide-bot',
+  color: '#fff',
+  description: kind,
+  ...(tier ? { tier } : {}),
+})
+
+const CATALOG: AgentArchetype[] = [
+  archetype('coder', 'basic'),
+  archetype('researcher', 'intermediate'),
+  archetype('mocker', 'advanced'),
+  // A deployment-registered kind that declared no tier.
+  archetype('acme-auditor'),
+]
+
+describe('filterByAgentTier', () => {
+  it('shows only the basic kinds at the default level', () => {
+    expect(filterByAgentTier(CATALOG, 'basic').map((a) => a.kind)).toEqual(['coder'])
+  })
+
+  it('accumulates the levels, with advanced showing the whole catalog', () => {
+    expect(filterByAgentTier(CATALOG, 'intermediate').map((a) => a.kind)).toEqual([
+      'coder',
+      'researcher',
+      // An undeclared tier defaults to intermediate, so it appears here.
+      'acme-auditor',
+    ])
+    expect(filterByAgentTier(CATALOG, 'advanced')).toHaveLength(CATALOG.length)
+  })
+})
+
+describe('filterByAgentTierKeeping', () => {
+  it('keeps a pinned kind the tier would otherwise hide, in catalog order', () => {
+    const kept = filterByAgentTierKeeping(CATALOG, 'basic', (a) => a.kind === 'mocker')
+    expect(kept.map((a) => a.kind)).toEqual(['coder', 'mocker'])
+  })
+
+  it('does not duplicate a pinned kind the tier already shows', () => {
+    const kept = filterByAgentTierKeeping(CATALOG, 'advanced', () => true)
+    expect(kept.map((a) => a.kind)).toEqual(CATALOG.map((a) => a.kind))
+  })
+})
+
+describe('isAgentTier', () => {
+  it('accepts the known tiers and rejects anything else', () => {
+    expect(isAgentTier('basic')).toBe(true)
+    expect(isAgentTier('advanced')).toBe(true)
+    // A persisted blob from an older build, or a hand-edited one.
+    expect(isAgentTier('expert')).toBe(false)
+    expect(isAgentTier(undefined)).toBe(false)
+    expect(isAgentTier(2)).toBe(false)
+  })
+})

package/app/utils/agentTier.ts

@@ -0,0 +1,49 @@
+import { AGENT_TIERS, agentTierVisibleAt, type AgentTier } from '@cat-factory/contracts'
+import type { AgentArchetype } from '~/types/domain'
+
+/**
+ * Agent-tier filtering for the two catalog surfaces — the pipeline builder's palette and the
+ * model preset's per-agent override list.
+ *
+ * The tier vocabulary, the default and the cumulative predicate live in `@cat-factory/contracts`
+ * (beside `purposeAllowsAgentCategory`) so a deployment-registered kind's declared tier and the
+ * SPA's own built-ins are read by ONE rule. This module holds only the frontend-shaped helpers
+ * built on it.
+ *
+ * Deliberately NOT the interface mode (`utils/uiMode.ts`). That tier says which SURFACES the
+ * whole SPA offers; this one says how deep into the agent catalog a given surface reaches. They
+ * are independent axes — an advanced-mode user still starts on the basic agent tier — and the
+ * control for this one is visible in both interface modes, since it is the only way to reach
+ * the kinds it hides.
+ */
+
+/** The default agent tier a surface opens on: the everyday delivery loop, nothing else. */
+export const DEFAULT_AGENT_TIER_LEVEL: AgentTier = 'basic'
+
+/** Whether an untrusted (persisted / hand-edited) value is one of the known tiers. */
+export function isAgentTier(value: unknown): value is AgentTier {
+  return typeof value === 'string' && (AGENT_TIERS as readonly string[]).includes(value)
+}
+
+/** Keep only the archetypes visible at `level` (cumulative — see `agentTierVisibleAt`). */
+export function filterByAgentTier<T extends Pick<AgentArchetype, 'tier'>>(
+  archetypes: readonly T[],
+  level: AgentTier,
+): T[] {
+  return archetypes.filter((a) => agentTierVisibleAt(a.tier, level))
+}
+
+/**
+ * Keep the archetypes visible at `level`, PLUS any the caller marks as pinned — the model
+ * preset editor's kinds that already carry an override. An entity can hold a setting written
+ * by a teammate, by the API, or by this user at a wider tier; hiding the row would leave them
+ * unable to see or clear it, which is the same failure the interface mode's `showOverrideField`
+ * exists to prevent. Order follows the input, so a pinned kind stays where the catalog puts it.
+ */
+export function filterByAgentTierKeeping<T extends Pick<AgentArchetype, 'tier' | 'kind'>>(
+  archetypes: readonly T[],
+  level: AgentTier,
+  isPinned: (archetype: T) => boolean,
+): T[] {
+  return archetypes.filter((a) => agentTierVisibleAt(a.tier, level) || isPinned(a))
+}

package/app/utils/catalog.spec.ts

@@ -67,6 +67,18 @@ describe('catalog', () => {
     }
   })
 
+  it('classifies every built-in kind into a tier', () => {
+    // The palette / model-preset surfaces open on `basic`, so a built-in that forgot its tier
+    // would silently fall to the DEFAULT (intermediate) and vanish from the default view for
+    // no stated reason. Only a deployment-registered kind may leave it to the default.
+    for (const a of [...AGENT_ARCHETYPES, ...Object.values(SYSTEM_AGENT_META)]) {
+      expect(a.tier, `${a.kind} declares no tier`).toBeDefined()
+    }
+    // And the everyday delivery loop has to be assemblable without touching the control.
+    const basic = AGENT_ARCHETYPES.filter((a) => a.tier === 'basic').map((a) => a.kind)
+    expect(basic).toEqual(expect.arrayContaining(['architect', 'coder', 'tester-api']))
+  })
+
   it('resolves usable metadata for every kind via agentKindMeta', () => {
     // Palette archetypes resolve to their own entry.
     for (const a of AGENT_ARCHETYPES) {