@cat-factory/app 0.186.0 → 0.188.0

package/app/components/settings/ConsensusGroupsSection.vue

@@ -0,0 +1,498 @@
+<script setup lang="ts">
+// The workspace's CONSENSUS-GROUP library, rendered as a section of the Model Configuration
+// screen. A group is a reusable review panel — participants (role + perspective framing +
+// model), the strategy that runs them, a synthesizer — plus the ESTIMATE BAR a task must clear
+// to earn it. A pipeline step names a SET of groups and the engine runs the most demanding tier
+// the task clears, so the library is where "which models review our risky work" is decided once
+// instead of per pipeline.
+//
+// It lives beside the model presets rather than in its own destination because it answers the
+// same question those do — which models do the work — and splitting them is what sends people
+// hunting through Integrations for a model setting.
+import { computed, ref } from 'vue'
+import type { ConsensusGroup, ConsensusStrategy } from '~/types/consensus'
+import { isSelectable } from '~/stores/models'
+
+const { t } = useI18n()
+const groups = useConsensusGroupsStore()
+const models = useModelsStore()
+const creds = useVendorCredentialsStore()
+const uiMode = useUiModeStore()
+const toast = useToast()
+const { confirm } = useConfirm()
+
+/**
+ * Advanced-tier authoring that REVEALS itself once the workspace has a library. Hiding a
+ * populated library in basic mode would leave a basic-mode user looking at tier chips in the
+ * pipeline builder with no way to find out what they contain — the same failure the override
+ * rules exist to prevent.
+ */
+const visible = computed(() => uiMode.isAdvanced || groups.hasGroups)
+
+const STRATEGIES = computed<{ value: ConsensusStrategy; label: string }[]>(() => [
+  { value: 'specialist-panel', label: t('pipeline.builder.strategyOption.specialist-panel') },
+  { value: 'debate', label: t('pipeline.builder.strategyOption.debate') },
+  { value: 'ranked-voting', label: t('pipeline.builder.strategyOption.ranked-voting') },
+])
+
+interface EditorState {
+  id?: string
+  name: string
+  description: string
+  strategy: ConsensusStrategy
+  participants: { id: string; role: string; systemFraming?: string; modelId?: string }[]
+  synthesizerModelId: string
+  rounds: number | null
+  gated: boolean
+  minComplexity: number | null
+  minRisk: number | null
+  minImpact: number | null
+}
+
+const editor = ref<EditorState | null>(null)
+const busy = ref(false)
+
+function uid(prefix: string) {
+  return `${prefix}_${Math.random().toString(36).slice(2, 9)}`
+}
+
+/** A fresh group starts as a gated two-model panel — the shape the feature is for. */
+function startCreate() {
+  editor.value = {
+    name: '',
+    description: '',
+    strategy: 'specialist-panel',
+    participants: [
+      { id: uid('cnp'), role: 'Pragmatist', systemFraming: 'Favour the simplest viable approach.' },
+      {
+        id: uid('cnp'),
+        role: 'Skeptic',
+        systemFraming: 'Probe risks, edge cases and failure modes.',
+      },
+    ],
+    synthesizerModelId: '',
+    rounds: null,
+    gated: true,
+    minComplexity: null,
+    minRisk: 0.7,
+    minImpact: null,
+  }
+}
+
+function startEdit(group: ConsensusGroup) {
+  editor.value = {
+    id: group.id,
+    name: group.name,
+    description: group.description ?? '',
+    strategy: group.strategy,
+    participants: group.participants.map((p) => ({ ...p })),
+    synthesizerModelId: group.synthesizerModelId ?? '',
+    rounds: group.rounds ?? null,
+    gated: group.gating.enabled,
+    minComplexity: group.gating.minComplexity ?? null,
+    minRisk: group.gating.minRisk ?? null,
+    minImpact: group.gating.minImpact ?? null,
+  }
+}
+
+function addParticipant() {
+  editor.value?.participants.push({ id: uid('cnp'), role: '' })
+}
+
+function removeParticipant(index: number) {
+  editor.value?.participants.splice(index, 1)
+}
+
+/** The bar a stored group sets, for the list rows. */
+function barLabel(group: ConsensusGroup): string {
+  const bar = groups.barFor(group)
+  return bar === null
+    ? t('settings.consensusGroups.list.always')
+    : t('settings.consensusGroups.list.bar', { bar })
+}
+
+const selectableModelIds = computed(() => {
+  const configured = creds.configuredVendors
+  return models.models
+    .filter((m) => isSelectable(m, configured))
+    .map((m) => ({ id: m.id, label: m.label }))
+})
+
+/**
+ * A threshold field's value as the contract wants it, or undefined when the author left it blank.
+ *
+ * `v-model.number` does NOT yield null for an emptied input: Vue's coercion returns the RAW value
+ * when it cannot parse a number, so clearing a box a user had typed in leaves `''` behind. Read
+ * back with a `!== null` test that empty string passes every guard, reaches the wire as
+ * `minRisk: ''`, and comes back a 422 behind a generic "could not save" toast. Anything that is
+ * not a finite number is therefore treated as absent, at the one place the value crosses out of
+ * the editor.
+ */
+function threshold(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+/** The thresholds the author actually set, in contract shape. */
+function thresholds(e: EditorState) {
+  return {
+    ...(threshold(e.minComplexity) !== undefined
+      ? { minComplexity: threshold(e.minComplexity) }
+      : {}),
+    ...(threshold(e.minRisk) !== undefined ? { minRisk: threshold(e.minRisk) } : {}),
+    ...(threshold(e.minImpact) !== undefined ? { minImpact: threshold(e.minImpact) } : {}),
+  }
+}
+
+/**
+ * The gating payload. A gated group with no threshold is refused by the backend (it could never
+ * be selected), so surface that here rather than as a save failure.
+ */
+function gatingPayload(e: EditorState) {
+  if (!e.gated) return { enabled: false as const, onMissingEstimate: 'consensus' as const }
+  return {
+    enabled: true as const,
+    ...thresholds(e),
+    onMissingEstimate: 'consensus' as const,
+  }
+}
+
+const gatingIncomplete = computed(
+  () => !!editor.value?.gated && Object.keys(thresholds(editor.value)).length === 0,
+)
+
+async function save() {
+  const e = editor.value
+  if (!e) return
+  if (!e.name.trim() || gatingIncomplete.value) return
+  const body = {
+    name: e.name.trim(),
+    ...(e.description.trim() ? { description: e.description.trim() } : {}),
+    strategy: e.strategy,
+    participants: e.participants.map((p) => ({
+      id: p.id,
+      role: p.role.trim() || t('settings.consensusGroups.editor.unnamedRole'),
+      ...(p.systemFraming?.trim() ? { systemFraming: p.systemFraming.trim() } : {}),
+      ...(p.modelId?.trim() ? { modelId: p.modelId.trim() } : {}),
+    })),
+    ...(e.synthesizerModelId.trim() ? { synthesizerModelId: e.synthesizerModelId.trim() } : {}),
+    ...(e.rounds !== null ? { rounds: e.rounds } : {}),
+    gating: gatingPayload(e),
+  }
+  busy.value = true
+  try {
+    if (e.id) await groups.update(e.id, body)
+    else await groups.create(body)
+    editor.value = null
+  } catch (err) {
+    fail(t('settings.consensusGroups.toast.saveFailed'), err)
+  } finally {
+    busy.value = false
+  }
+}
+
+async function remove(group: ConsensusGroup) {
+  const ok = await confirm({
+    title: t('settings.consensusGroups.confirmDelete.title'),
+    description: t('settings.consensusGroups.confirmDelete.body', { name: group.name }),
+    variant: 'destructive',
+    confirmLabel: t('common.delete'),
+    icon: 'i-lucide-trash-2',
+  })
+  if (!ok) return
+  busy.value = true
+  try {
+    await groups.remove(group.id)
+  } catch (err) {
+    fail(t('settings.consensusGroups.toast.deleteFailed'), err)
+  } finally {
+    busy.value = false
+  }
+}
+
+function fail(title: string, e: unknown) {
+  toast.add({
+    title,
+    description: e instanceof Error ? e.message : String(e),
+    icon: 'i-lucide-triangle-alert',
+    color: 'error',
+  })
+}
+</script>
+
+<template>
+  <section v-if="visible" class="space-y-3 border-t border-slate-800 pt-5">
+    <div class="flex items-start justify-between gap-3">
+      <div class="min-w-0">
+        <h2 class="text-sm font-semibold text-slate-100">
+          {{ t('settings.consensusGroups.title') }}
+        </h2>
+        <p class="mt-1 text-xs leading-relaxed text-slate-500">
+          {{ t('settings.consensusGroups.intro') }}
+        </p>
+      </div>
+      <UButton
+        v-if="!editor"
+        icon="i-lucide-plus"
+        color="neutral"
+        variant="soft"
+        size="sm"
+        class="shrink-0"
+        data-testid="consensus-group-new"
+        @click="startCreate"
+      >
+        {{ t('settings.consensusGroups.new') }}
+      </UButton>
+    </div>
+
+    <!-- ===== list ===== -->
+    <template v-if="!editor">
+      <div v-if="groups.groups.length" class="space-y-2">
+        <div
+          v-for="g in groups.groups"
+          :key="g.id"
+          class="rounded-xl border border-slate-800 bg-slate-900/50 p-3"
+          data-testid="consensus-group-row"
+        >
+          <div class="flex items-center gap-2">
+            <span class="truncate text-sm font-semibold text-slate-100">{{ g.name }}</span>
+            <UBadge color="neutral" variant="subtle" size="xs">{{ barLabel(g) }}</UBadge>
+            <div class="ms-auto flex items-center gap-1">
+              <UButton
+                size="xs"
+                variant="ghost"
+                color="neutral"
+                icon="i-lucide-pencil"
+                :title="t('settings.consensusGroups.list.editTitle')"
+                @click="startEdit(g)"
+              />
+              <UButton
+                size="xs"
+                variant="ghost"
+                color="error"
+                icon="i-lucide-trash-2"
+                :loading="busy"
+                :title="t('settings.consensusGroups.list.deleteTitle')"
+                @click="remove(g)"
+              />
+            </div>
+          </div>
+          <p v-if="g.description" class="mt-1 text-[11px] text-slate-400">{{ g.description }}</p>
+          <div class="mt-1.5 text-[11px] text-slate-400">
+            {{ t(`pipeline.builder.strategyOption.${g.strategy}`) }}
+            ·
+            {{
+              t(
+                'settings.consensusGroups.list.participantCount',
+                { count: g.participants.length },
+                g.participants.length,
+              )
+            }}
+          </div>
+        </div>
+      </div>
+      <p v-else class="py-4 text-center text-sm text-slate-500">
+        {{ t('settings.consensusGroups.list.empty') }}
+      </p>
+    </template>
+
+    <!-- ===== editor ===== -->
+    <div v-else class="space-y-4 rounded-xl border border-slate-800 bg-slate-900/50 p-4">
+      <div class="grid gap-3 sm:grid-cols-2">
+        <div>
+          <label
+            class="mb-1 block text-[11px] font-semibold uppercase tracking-wide text-slate-400"
+          >
+            {{ t('settings.consensusGroups.editor.nameLabel') }}
+          </label>
+          <UInput
+            v-model="editor.name"
+            size="sm"
+            class="w-full"
+            :placeholder="t('settings.consensusGroups.editor.namePlaceholder')"
+          />
+        </div>
+        <div>
+          <label
+            class="mb-1 block text-[11px] font-semibold uppercase tracking-wide text-slate-400"
+          >
+            {{ t('settings.consensusGroups.editor.strategyLabel') }}
+          </label>
+          <select
+            v-model="editor.strategy"
+            class="w-full rounded border border-slate-700 bg-slate-900 px-2 py-1.5 text-sm text-slate-100"
+          >
+            <option v-for="s in STRATEGIES" :key="s.value" :value="s.value">{{ s.label }}</option>
+          </select>
+        </div>
+      </div>
+
+      <div>
+        <label class="mb-1 block text-[11px] font-semibold uppercase tracking-wide text-slate-400">
+          {{ t('settings.consensusGroups.editor.descriptionLabel') }}
+        </label>
+        <UInput
+          v-model="editor.description"
+          size="sm"
+          class="w-full"
+          :placeholder="t('settings.consensusGroups.editor.descriptionPlaceholder')"
+        />
+      </div>
+
+      <!-- participants -->
+      <div class="space-y-2">
+        <div class="flex items-center justify-between">
+          <span class="text-[11px] font-semibold uppercase tracking-wide text-slate-400">
+            {{ t('settings.consensusGroups.editor.participantsLabel') }}
+          </span>
+          <UButton
+            icon="i-lucide-plus"
+            color="neutral"
+            variant="ghost"
+            size="xs"
+            :label="t('settings.consensusGroups.editor.addParticipant')"
+            @click="addParticipant"
+          />
+        </div>
+        <p class="text-[11px] text-slate-500">
+          {{ t('settings.consensusGroups.editor.participantsHint') }}
+        </p>
+        <div
+          v-for="(p, index) in editor.participants"
+          :key="p.id"
+          class="flex flex-wrap items-center gap-1.5"
+        >
+          <UInput
+            v-model="p.role"
+            size="xs"
+            class="w-32"
+            :placeholder="t('pipeline.builder.rolePlaceholder')"
+          />
+          <UInput
+            v-model="p.systemFraming"
+            size="xs"
+            class="min-w-40 flex-1"
+            :placeholder="t('settings.consensusGroups.editor.framingPlaceholder')"
+          />
+          <select
+            v-model="p.modelId"
+            class="w-44 rounded border border-slate-700 bg-slate-900 px-1.5 py-1 text-xs text-slate-300"
+          >
+            <option :value="undefined">{{ t('settings.consensusGroups.editor.stepModel') }}</option>
+            <option v-for="m in selectableModelIds" :key="m.id" :value="m.id">{{ m.label }}</option>
+          </select>
+          <UButton
+            icon="i-lucide-x"
+            color="error"
+            variant="ghost"
+            size="xs"
+            :disabled="editor.participants.length <= 2"
+            :title="t('pipeline.builder.removeParticipant')"
+            @click="removeParticipant(index)"
+          />
+        </div>
+      </div>
+
+      <div class="grid gap-3 sm:grid-cols-2">
+        <div>
+          <label
+            class="mb-1 block text-[11px] font-semibold uppercase tracking-wide text-slate-400"
+          >
+            {{ t('settings.consensusGroups.editor.synthesizerLabel') }}
+          </label>
+          <select
+            v-model="editor.synthesizerModelId"
+            class="w-full rounded border border-slate-700 bg-slate-900 px-2 py-1.5 text-sm text-slate-100"
+          >
+            <option value="">{{ t('settings.consensusGroups.editor.stepModel') }}</option>
+            <option v-for="m in selectableModelIds" :key="m.id" :value="m.id">{{ m.label }}</option>
+          </select>
+        </div>
+        <div v-if="editor.strategy === 'debate'">
+          <label
+            class="mb-1 block text-[11px] font-semibold uppercase tracking-wide text-slate-400"
+          >
+            {{ t('pipeline.builder.rounds') }}
+          </label>
+          <UInput v-model.number="editor.rounds" type="number" min="1" max="5" size="sm" />
+        </div>
+      </div>
+
+      <!-- the estimate bar -->
+      <div class="space-y-2 rounded-lg border border-slate-800 bg-slate-950/40 p-3">
+        <label class="flex items-center gap-2 text-xs text-slate-300">
+          <input v-model="editor.gated" type="checkbox" class="accent-emerald-500" />
+          {{ t('settings.consensusGroups.editor.gatedLabel') }}
+        </label>
+        <p class="text-[11px] text-slate-500">
+          {{ t('settings.consensusGroups.editor.gatedHint') }}
+        </p>
+        <div v-if="editor.gated" class="flex flex-wrap items-center gap-3 text-xs">
+          <label class="flex items-center gap-1.5 text-slate-400">
+            {{ t('pipeline.builder.riskThreshold') }}
+            <UInput
+              v-model.number="editor.minRisk"
+              type="number"
+              min="0"
+              max="1"
+              step="0.1"
+              size="xs"
+              class="w-20"
+            />
+          </label>
+          <label class="flex items-center gap-1.5 text-slate-400">
+            {{ t('pipeline.builder.impactThreshold') }}
+            <UInput
+              v-model.number="editor.minImpact"
+              type="number"
+              min="0"
+              max="1"
+              step="0.1"
+              size="xs"
+              class="w-20"
+            />
+          </label>
+          <label class="flex items-center gap-1.5 text-slate-400">
+            {{ t('settings.consensusGroups.editor.complexityThreshold') }}
+            <UInput
+              v-model.number="editor.minComplexity"
+              type="number"
+              min="0"
+              max="1"
+              step="0.1"
+              size="xs"
+              class="w-20"
+            />
+          </label>
+        </div>
+        <p v-if="gatingIncomplete" class="text-[11px] text-amber-400">
+          {{ t('settings.consensusGroups.editor.gatingIncomplete') }}
+        </p>
+      </div>
+
+      <div class="flex items-center justify-end gap-2">
+        <UButton
+          color="neutral"
+          variant="ghost"
+          size="sm"
+          @click="
+            () => {
+              editor = null
+            }
+          "
+        >
+          {{ t('settings.consensusGroups.editor.cancel') }}
+        </UButton>
+        <UButton
+          color="primary"
+          size="sm"
+          :loading="busy"
+          :disabled="!editor.name.trim() || gatingIncomplete"
+          data-testid="consensus-group-save"
+          @click="save"
+        >
+          {{ t('settings.consensusGroups.editor.save') }}
+        </UButton>
+      </div>
+    </div>
+  </section>
+</template>

package/app/components/settings/ModelConfigurationPanel.vue

@@ -14,14 +14,18 @@ import { computed, ref, watch } from 'vue'
 import { onKeyStroke } from '@vueuse/core'
 import type { AgentKind } from '~/types/domain'
 import type { ModelPreset } from '~/types/model-presets'
+import AgentTierSelect from '~/components/palettes/AgentTierSelect.vue'
+import { filterByAgentTierKeeping } from '~/utils/agentTier'
 import { MODEL_CONFIGURABLE_SYSTEM_KINDS } from '~/utils/catalog'
 import { cachingLabel, contextLabel, costLabel, displayFlavor, isSelectable } from '~/stores/models'
+import ConsensusGroupsSection from '~/components/settings/ConsensusGroupsSection.vue'
 
 const { t } = useI18n()
 const ui = useUiStore()
 const models = useModelsStore()
 const presets = useModelPresetsStore()
 const agents = useAgentsStore()
+const agentTier = useAgentTierStore()
 const creds = useVendorCredentialsStore()
 const workspace = useWorkspaceStore()
 const toast = useToast()
@@ -49,14 +53,36 @@ const filter = ref('')
 // (spec-writer, merger, the fixers/resolver). The pure gates run no model, so they
 // stay out — exactly the set the per-agent override list should cover.
 const configurableKinds = computed(() => [...agents.archetypes, ...MODEL_CONFIGURABLE_SYSTEM_KINDS])
+
+// Narrowed to the selected agent tier, EXCEPT that a kind the preset being edited already
+// pins a model for is always kept: that override may have been written by a teammate, by the
+// API, or by this user at a wider tier, and a row hidden here is one they can neither read
+// nor clear. Same rule the interface mode's `showOverrideField` states for a single field.
+const tieredKinds = computed(() =>
+  filterByAgentTierKeeping(
+    configurableKinds.value,
+    agentTier.tier,
+    (a) => editor.value?.overrides[a.kind] !== undefined,
+  ),
+)
+
 const filteredKinds = computed(() => {
   const q = filter.value.trim().toLowerCase()
-  if (!q) return configurableKinds.value
+  if (!q) return tieredKinds.value
+  // A typed query searches the WHOLE catalog, not the tiered slice: naming an agent is a
+  // stronger statement of intent than the tier default, and "No agents match" for a kind the
+  // user can spell would read as "this deployment doesn't have it".
   return configurableKinds.value.filter(
     (a) => a.label.toLowerCase().includes(q) || String(a.kind).toLowerCase().includes(q),
   )
 })
 
+// Nothing is being held back while a search is running (it spans every kind), so the hint
+// reports 0 rather than a count the visible list contradicts.
+const hiddenByTier = computed(() =>
+  filter.value.trim() ? 0 : configurableKinds.value.length - tieredKinds.value.length,
+)
+
 watch(
   open,
   (isOpen) => {
@@ -405,6 +431,11 @@ function fail(title: string, e: unknown) {
                   {{ t('settings.modelConfiguration.list.empty') }}
                 </p>
               </div>
+
+              <!-- The consensus-GROUP library: which model PANELS review the workspace's heavier
+                   tasks, and at what estimate bar. Beside the presets because both answer "which
+                   models do the work"; its own component so this screen keeps its size budget. -->
+              <ConsensusGroupsSection />
             </template>
 
             <!-- ===== editor view ===== -->
@@ -453,10 +484,11 @@ function fail(title: string, e: unknown) {
               </div>
 
               <div>
-                <div class="mb-1 flex items-center justify-between">
+                <div class="mb-1 flex items-start justify-between gap-3">
                   <span class="text-[11px] font-semibold uppercase tracking-wide text-slate-400">
                     {{ t('settings.modelConfiguration.editor.perAgentOverrides') }}
                   </span>
+                  <AgentTierSelect class="w-56 shrink-0" :hidden-count="hiddenByTier" />
                 </div>
                 <UInput
                   v-model="filter"

package/app/composables/api/presets.ts

@@ -2,6 +2,10 @@ import {
   createRiskPolicyContract,
   listMergeClassRollupsContract,
   tagMergeReviewEffortContract,
+  createConsensusGroupContract,
+  deleteConsensusGroupContract,
+  listConsensusGroupsContract,
+  updateConsensusGroupContract,
   createModelPresetContract,
   deleteRiskPolicyContract,
   deleteModelPresetContract,
@@ -14,6 +18,7 @@ import {
 } from '@cat-factory/contracts'
 import type { ReviewEffort, UpdateRiskPolicyInput } from '~/types/merge'
 import type { CreateModelPresetInput, UpdateModelPresetInput } from '~/types/model-presets'
+import type { CreateConsensusGroupInput, UpdateConsensusGroupInput } from '~/types/consensus'
 import type { SendParams } from './client'
 import type { ApiContext } from './context'
 
@@ -86,5 +91,22 @@ export function presetsApi({ send, ws }: ApiContext) {
     // a drifted one, or materialise a new built-in that appeared). Custom presets reject this.
     reseedModelPreset: (workspaceId: string, presetId: string) =>
       send(reseedModelPresetContract, { pathPrefix: ws(workspaceId), pathParams: { presetId } }),
+
+    // ---- consensus groups (the estimate-gated review panels a step escalates to) ----
+    listConsensusGroups: (workspaceId: string) =>
+      send(listConsensusGroupsContract, { pathPrefix: ws(workspaceId) }),
+
+    createConsensusGroup: (workspaceId: string, body: CreateConsensusGroupInput) =>
+      send(createConsensusGroupContract, { pathPrefix: ws(workspaceId), body }),
+
+    updateConsensusGroup: (workspaceId: string, groupId: string, body: UpdateConsensusGroupInput) =>
+      send(updateConsensusGroupContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { groupId },
+        body,
+      }),
+
+    deleteConsensusGroup: (workspaceId: string, groupId: string) =>
+      send(deleteConsensusGroupContract, { pathPrefix: ws(workspaceId), pathParams: { groupId } }),
   }
 }

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')
+  })
+})