@cat-factory/app 0.164.0 → 0.166.0

package/app/components/riskPolicy/RiskPolicyPicker.logic.spec.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest'
+import type { RiskPolicy } from '~/types/merge'
+import { resolveRiskPolicyPicker } from '~/components/riskPolicy/RiskPolicyPicker.logic'
+
+// The resolver reads ids only, so the fixture carries just enough to be identifiable.
+const policy = (id: string, name: string) => ({ id, name }) as unknown as RiskPolicy
+
+const balanced = policy('mp_balanced', 'Balanced')
+const strict = policy('mp_strict', 'Strict')
+const options = [balanced, strict]
+
+describe('resolveRiskPolicyPicker', () => {
+  it('previews the active row over the selection', () => {
+    const state = resolveRiskPolicyPicker({
+      options,
+      defaultPolicy: balanced,
+      modelValue: 'mp_balanced',
+      activeId: 'mp_strict',
+    })
+    expect(state).toEqual({ policy: strict, viaWorkspaceDefault: false })
+  })
+
+  it('falls back to the selection when no row is active', () => {
+    const state = resolveRiskPolicyPicker({
+      options,
+      defaultPolicy: balanced,
+      modelValue: 'mp_strict',
+      activeId: undefined,
+    })
+    expect(state).toEqual({ policy: strict, viaWorkspaceDefault: false })
+  })
+
+  it('previews the workspace default for the "pick nothing" row, captioned', () => {
+    const state = resolveRiskPolicyPicker({
+      options,
+      defaultPolicy: balanced,
+      modelValue: 'mp_strict',
+      activeId: '',
+    })
+    expect(state).toEqual({ policy: balanced, viaWorkspaceDefault: true })
+  })
+
+  it('previews the workspace default when nothing is selected at all', () => {
+    const state = resolveRiskPolicyPicker({
+      options,
+      defaultPolicy: balanced,
+      modelValue: '',
+      activeId: undefined,
+    })
+    expect(state).toEqual({ policy: balanced, viaWorkspaceDefault: true })
+  })
+
+  it('resolves a DELETED policy to the workspace default, as the run engine does', () => {
+    // A task can hold a riskPolicyId whose policy was since removed from the library. The
+    // store's resolve() hands that task the default, so the pane must not claim there is no
+    // policy — that would describe the run wrongly on the one surface explaining it.
+    const state = resolveRiskPolicyPicker({
+      options,
+      defaultPolicy: balanced,
+      modelValue: 'mp_deleted',
+      activeId: undefined,
+    })
+    expect(state).toEqual({ policy: balanced, viaWorkspaceDefault: true })
+  })
+
+  it('reports nothing to preview only when the workspace has no default at all', () => {
+    const state = resolveRiskPolicyPicker({
+      options: [],
+      defaultPolicy: null,
+      modelValue: '',
+      activeId: '',
+    })
+    expect(state).toEqual({ policy: null, viaWorkspaceDefault: false })
+  })
+})

package/app/components/riskPolicy/RiskPolicyPicker.logic.ts

@@ -0,0 +1,47 @@
+// Pure resolution behind <RiskPolicyPicker>'s detail pane.
+//
+// Kept out of the SFC because the interesting case is not the happy path: a task can hold a
+// `riskPolicyId` naming a policy that has since been DELETED from the workspace library, and
+// what the pane shows then has to agree with what the run engine would actually do. The
+// riskPolicies store's `resolve()` falls back to the workspace default for both an empty id
+// and a dangling one; this mirrors that, so the picker can never tell the user "no risk policy
+// configured" about a task the default is quietly governing.
+import type { RiskPolicy } from '~/types/merge'
+
+export interface RiskPolicyPickerState {
+  /** The policy the detail pane renders, or `null` when the workspace has none at all. */
+  policy: RiskPolicy | null
+  /**
+   * True when `policy` is the workspace default standing in for a row that names no live
+   * policy of its own — the pane captions it, so the user knows why they are looking at a
+   * policy they did not point at.
+   */
+  viaWorkspaceDefault: boolean
+}
+
+export interface RiskPolicyPickerInput {
+  /** The policies offered (the workspace's library). */
+  options: readonly RiskPolicy[]
+  /** The workspace default, resolved by the caller. `null` when the workspace has none. */
+  defaultPolicy: RiskPolicy | null
+  /** The selected policy id, or `''` for the "workspace default" row. */
+  modelValue: string
+  /**
+   * The row the pointer or keyboard focus is on: an id, `''` for the "workspace default"
+   * row, or `undefined` when neither is on a row (fall back to the selection).
+   */
+  activeId: string | undefined
+}
+
+/**
+ * Resolve what the detail pane shows: the active row's policy, else the selected one, else
+ * the workspace default. An id that resolves to nothing — empty (the explicit "workspace
+ * default" row) or dangling (a deleted policy) — takes the default, since that is the policy
+ * the task is governed by either way.
+ */
+export function resolveRiskPolicyPicker(input: RiskPolicyPickerInput): RiskPolicyPickerState {
+  const id = input.activeId ?? input.modelValue
+  const named = id ? input.options.find((p) => p.id === id) : undefined
+  if (named) return { policy: named, viaWorkspaceDefault: false }
+  return { policy: input.defaultPolicy, viaWorkspaceDefault: !!input.defaultPolicy }
+}

package/app/components/riskPolicy/RiskPolicyPicker.vue

@@ -0,0 +1,159 @@
+<script setup lang="ts">
+// The rich risk-policy picker used wherever a task's merge policy is chosen (add-task modal,
+// inspector run settings). A master-detail popover mirroring <PipelinePicker>: the left column
+// lists the policies by NAME ONLY (plus a "workspace default" row), and hovering a row reveals
+// that policy's ceilings and what they mean in the right column. Cramming the thresholds into
+// the option line itself made every row an unreadable run of abbreviated percentages; the
+// detail pane is where they belong. The trigger is customizable via the `#trigger` slot (the
+// inspector uses a bare icon button; the modal a full-width labelled one).
+//
+// The detail pane follows FOCUS as well as the pointer. Moving the numbers off the option
+// line would otherwise put them out of reach of anyone driving the list from the keyboard,
+// who never fires a `mouseenter` — the thresholds are the whole point of the pane, so they
+// cannot be pointer-only.
+import { computed, ref } from 'vue'
+import type { RiskPolicy } from '~/types/merge'
+import RiskPolicyPreview from '~/components/riskPolicy/RiskPolicyPreview.vue'
+import { resolveRiskPolicyPicker } from '~/components/riskPolicy/RiskPolicyPicker.logic'
+
+const props = withDefaults(
+  defineProps<{
+    /** Selected policy id, or '' for the "workspace default" option. */
+    modelValue: string
+    /** The policies offered (the workspace's library). */
+    options: RiskPolicy[]
+    /**
+     * The workspace default a task picking nothing is governed by, resolved by the consumer
+     * (which already reads it off the store to build `noneLabel`) so the two can't disagree.
+     */
+    defaultPolicy: RiskPolicy | null
+    /** Label for the "workspace default" row (the consumer names the resolved default). */
+    noneLabel: string
+    /** Extra classes for the default trigger button (e.g. full-width in the modal). */
+    triggerClass?: string
+  }>(),
+  { triggerClass: '' },
+)
+
+const emit = defineEmits<{ 'update:modelValue': [string] }>()
+const { t } = useI18n()
+
+const open = ref(false)
+// The row the pointer or the keyboard is currently on, driving the right-column preview.
+// `undefined` ⇒ fall back to the selected policy; the sentinel '' means the "workspace
+// default" row is active.
+const activeId = ref<string | undefined>(undefined)
+
+const selected = computed(() => props.options.find((p) => p.id === props.modelValue))
+const triggerLabel = computed(() => selected.value?.name ?? props.noneLabel)
+
+const preview = computed(() =>
+  resolveRiskPolicyPicker({
+    options: props.options,
+    defaultPolicy: props.defaultPolicy,
+    modelValue: props.modelValue,
+    activeId: activeId.value,
+  }),
+)
+
+/**
+ * Tabbing BETWEEN two rows fires `focusout` on the one being left, so only focus leaving the
+ * panel altogether may drop the preview back to the selection.
+ */
+function onPanelFocusOut(event: FocusEvent) {
+  const panel = event.currentTarget
+  const next = event.relatedTarget
+  if (panel instanceof Node && next instanceof Node && panel.contains(next)) return
+  activeId.value = undefined
+}
+
+function choose(id: string) {
+  emit('update:modelValue', id)
+  open.value = false
+}
+</script>
+
+<template>
+  <UPopover v-model:open="open" :content="{ align: 'start' }">
+    <slot name="trigger" :label="triggerLabel">
+      <UButton
+        color="neutral"
+        variant="subtle"
+        size="sm"
+        icon="i-lucide-git-merge"
+        trailing-icon="i-lucide-chevron-down"
+        :class="triggerClass"
+        data-testid="risk-policy-picker-trigger"
+      >
+        {{ triggerLabel }}
+      </UButton>
+    </slot>
+
+    <template #content>
+      <div
+        class="flex max-h-[24rem] w-[min(40rem,94vw)]"
+        data-testid="risk-policy-picker-panel"
+        @mouseleave="activeId = undefined"
+        @focusout="onPanelFocusOut"
+      >
+        <!-- left: selectable options, NAME ONLY -->
+        <ul class="w-1/2 shrink-0 overflow-y-auto border-e border-slate-800 p-1">
+          <li>
+            <button
+              type="button"
+              class="flex w-full items-center gap-2 rounded px-2 py-1.5 text-start text-sm hover:bg-slate-800/60"
+              :class="modelValue ? 'text-slate-300' : 'text-slate-100'"
+              data-testid="risk-policy-option-none"
+              @mouseenter="activeId = ''"
+              @focus="activeId = ''"
+              @click="choose('')"
+            >
+              <UIcon name="i-lucide-rotate-ccw" class="h-4 w-4 shrink-0 text-slate-400" />
+              <span class="flex-1 truncate">{{ noneLabel }}</span>
+              <UIcon
+                v-if="!modelValue"
+                name="i-lucide-check"
+                class="h-4 w-4 shrink-0 text-primary-400"
+              />
+            </button>
+          </li>
+          <li v-for="p in options" :key="p.id">
+            <button
+              type="button"
+              class="flex w-full items-center gap-2 rounded px-2 py-1.5 text-start text-sm hover:bg-slate-800/60"
+              :class="modelValue === p.id ? 'text-slate-100' : 'text-slate-300'"
+              :data-testid="`risk-policy-option-${p.id}`"
+              @mouseenter="activeId = p.id"
+              @focus="activeId = p.id"
+              @click="choose(p.id)"
+            >
+              <UIcon name="i-lucide-git-merge" class="h-4 w-4 shrink-0 text-slate-400" />
+              <span class="flex-1 truncate">{{ p.name }}</span>
+              <UIcon
+                v-if="modelValue === p.id"
+                name="i-lucide-check"
+                class="h-4 w-4 shrink-0 text-primary-400"
+              />
+            </button>
+          </li>
+        </ul>
+
+        <!-- right: what the active (or selected) policy actually does -->
+        <div class="w-1/2 overflow-y-auto p-3">
+          <template v-if="preview.policy">
+            <p
+              v-if="preview.viaWorkspaceDefault"
+              class="mb-2 text-[11px] leading-snug text-slate-500"
+            >
+              {{ t('riskPolicy.picker.workspaceDefaultCaption') }}
+            </p>
+            <RiskPolicyPreview :policy="preview.policy" />
+          </template>
+          <div v-else class="text-[12px] leading-snug text-slate-500">
+            {{ t('riskPolicy.picker.noneHint') }}
+          </div>
+        </div>
+      </div>
+    </template>
+  </UPopover>
+</template>

package/app/components/riskPolicy/RiskPolicyPreview.vue

@@ -0,0 +1,83 @@
+<script setup lang="ts">
+// A compact, read-only summary of a risk policy: the three auto-merge ceilings grouped
+// together, plus prose saying what clearing them actually DOES (the pull request merges
+// without waiting for a human review). Shared by the risk-policy picker's hover preview so
+// "what this policy means" is explained the same way everywhere — the <PipelinePreview>
+// counterpart for merge policy.
+//
+// A policy with auto-merge off has no thresholds to explain (the master switch wins before
+// any score is compared), so it says so instead of listing ceilings that never apply.
+import { computed } from 'vue'
+import type { RiskPolicy } from '~/types/merge'
+import { riskPolicyCeilings, type RiskPolicyAxis } from '~/utils/riskPolicy'
+
+const props = defineProps<{ policy: RiskPolicy }>()
+const { t, n } = useI18n()
+
+// Exhaustive over the axis union with LITERAL keys, so both i18n drift guards apply: the
+// typed-key check catches a renamed key, and the Record catches a new axis.
+const AXIS_LABEL: Record<RiskPolicyAxis, () => string> = {
+  risk: () => t('riskPolicy.preview.axis.risk'),
+  impact: () => t('riskPolicy.preview.axis.impact'),
+  complexity: () => t('riskPolicy.preview.axis.complexity'),
+}
+
+const ceilings = computed(() =>
+  riskPolicyCeilings(props.policy).map((c) => ({ ...c, label: AXIS_LABEL[c.axis]() })),
+)
+</script>
+
+<template>
+  <div class="space-y-3" data-testid="risk-policy-preview">
+    <div class="flex items-center gap-1.5">
+      <span class="text-sm font-semibold text-slate-100">{{ policy.name }}</span>
+      <UBadge v-if="policy.isDefault" size="sm" variant="soft" color="neutral">
+        {{ t('riskPolicy.preview.defaultBadge') }}
+      </UBadge>
+    </div>
+
+    <!-- the three ceilings, grouped under one heading that names what they are -->
+    <div v-if="policy.autoMergeEnabled">
+      <div class="mb-1 flex items-center gap-1 text-[10px] uppercase tracking-wide text-slate-500">
+        <UIcon name="i-lucide-git-merge" class="h-3 w-3" />
+        {{ t('riskPolicy.preview.autoMergeHeading') }}
+      </div>
+      <dl class="space-y-1">
+        <div
+          v-for="c in ceilings"
+          :key="c.axis"
+          class="flex items-baseline justify-between gap-3 rounded bg-slate-800/70 px-1.5 py-0.5 text-[12px]"
+        >
+          <dt class="text-slate-300">{{ c.label }}</dt>
+          <dd class="tabular-nums text-slate-100">
+            {{ t('riskPolicy.preview.ceiling', { value: n(c.max, { key: 'percent' }) }) }}
+          </dd>
+        </div>
+      </dl>
+      <p class="mt-1.5 text-[12px] leading-snug text-slate-400">
+        {{ t('riskPolicy.preview.autoMergeExplainer') }}
+      </p>
+    </div>
+    <div v-else>
+      <div class="mb-1 flex items-center gap-1 text-[10px] uppercase tracking-wide text-slate-500">
+        <UIcon name="i-lucide-user-check" class="h-3 w-3" />
+        {{ t('riskPolicy.preview.manualHeading') }}
+      </div>
+      <p class="text-[12px] leading-snug text-slate-400">
+        {{ t('riskPolicy.preview.manualExplainer') }}
+      </p>
+    </div>
+
+    <div>
+      <div class="mb-1 flex items-center gap-1 text-[10px] uppercase tracking-wide text-slate-500">
+        <UIcon name="i-lucide-wrench" class="h-3 w-3" />
+        {{ t('riskPolicy.preview.ciHeading') }}
+      </div>
+      <p class="text-[12px] leading-snug text-slate-400">
+        {{
+          t('riskPolicy.preview.ciAttempts', { count: policy.ciMaxAttempts }, policy.ciMaxAttempts)
+        }}
+      </p>
+    </div>
+  </div>
+</template>

package/app/components/settings/RiskPolicyPanel.vue

@@ -7,9 +7,40 @@
 import { computed, reactive, ref, watch } from 'vue'
 import type { MergeClassRules, RiskPolicy, RequirementConcernLevel } from '~/types/merge'
 import type { StepGating } from '@cat-factory/contracts'
+import {
+  RISK_POLICY_AXES,
+  RISK_POLICY_CEILING_FIELD,
+  type RiskPolicyAxis,
+} from '~/utils/riskPolicy'
 
 const { t } = useI18n()
 
+// Both axis groups below iterate the SHARED presentation order rather than hard-coding one,
+// so this editor can't drift from the order the picker's preview and the inspector's summary
+// line use (it used to read complexity-first while they read risk-first).
+const CEILING_LABEL_KEYS: Record<RiskPolicyAxis, string> = {
+  risk: 'settings.riskPolicy.field.maxRisk',
+  impact: 'settings.riskPolicy.field.maxImpact',
+  complexity: 'settings.riskPolicy.field.maxComplexity',
+}
+
+// The fork-decision group is the same three axes read as FLOORS (how big an estimate has to
+// be before the coder stops to propose implementations), so it shares the order but not the
+// fields.
+const FORK_FLOOR_FIELD: Record<
+  RiskPolicyAxis,
+  'forkMinRisk' | 'forkMinImpact' | 'forkMinComplexity'
+> = {
+  risk: 'forkMinRisk',
+  impact: 'forkMinImpact',
+  complexity: 'forkMinComplexity',
+}
+const FORK_FLOOR_LABEL_KEYS: Record<RiskPolicyAxis, string> = {
+  risk: 'settings.riskPolicy.forkDecision.minRisk',
+  impact: 'settings.riskPolicy.forkDecision.minImpact',
+  complexity: 'settings.riskPolicy.forkDecision.minComplexity',
+}
+
 // Per-concern-level label. An exhaustive Record keyed off the union (a missing member fails
 // the typecheck); each value is a LITERAL catalog key so the typed-message-keys check sees
 // it. Leaf keys mirror the enum value verbatim.
@@ -276,36 +307,12 @@ async function create() {
       </div>
 
       <div class="grid grid-cols-2 gap-3 sm:grid-cols-4">
-        <label class="block">
-          <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
-            {{ t('settings.riskPolicy.field.maxComplexity') }}
-          </span>
-          <UInput
-            v-model.number="drafts[p.id]!.maxComplexity"
-            type="number"
-            :min="0"
-            :max="100"
-            size="sm"
-          />
-        </label>
-        <label class="block">
+        <label v-for="axis in RISK_POLICY_AXES" :key="axis" class="block">
           <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
-            {{ t('settings.riskPolicy.field.maxRisk') }}
+            {{ t(CEILING_LABEL_KEYS[axis]) }}
           </span>
           <UInput
-            v-model.number="drafts[p.id]!.maxRisk"
-            type="number"
-            :min="0"
-            :max="100"
-            size="sm"
-          />
-        </label>
-        <label class="block">
-          <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
-            {{ t('settings.riskPolicy.field.maxImpact') }}
-          </span>
-          <UInput
-            v-model.number="drafts[p.id]!.maxImpact"
+            v-model.number="drafts[p.id]![RISK_POLICY_CEILING_FIELD[axis]]"
             type="number"
             :min="0"
             :max="100"
@@ -369,36 +376,12 @@ async function create() {
           :description="t('settings.riskPolicy.forkDecision.hint')"
         />
         <div v-if="drafts[p.id]!.forkEnabled" class="mt-3 grid grid-cols-2 gap-3 sm:grid-cols-4">
-          <label class="block">
-            <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
-              {{ t('settings.riskPolicy.forkDecision.minComplexity') }}
-            </span>
-            <UInput
-              v-model.number="drafts[p.id]!.forkMinComplexity"
-              type="number"
-              size="sm"
-              :min="0"
-              :max="100"
-            />
-          </label>
-          <label class="block">
-            <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
-              {{ t('settings.riskPolicy.forkDecision.minRisk') }}
-            </span>
-            <UInput
-              v-model.number="drafts[p.id]!.forkMinRisk"
-              type="number"
-              size="sm"
-              :min="0"
-              :max="100"
-            />
-          </label>
-          <label class="block">
+          <label v-for="axis in RISK_POLICY_AXES" :key="axis" class="block">
             <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
-              {{ t('settings.riskPolicy.forkDecision.minImpact') }}
+              {{ t(FORK_FLOOR_LABEL_KEYS[axis]) }}
             </span>
             <UInput
-              v-model.number="drafts[p.id]!.forkMinImpact"
+              v-model.number="drafts[p.id]![FORK_FLOOR_FIELD[axis]]"
               type="number"
               size="sm"
               :min="0"

package/app/utils/riskPolicy.spec.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import type { RiskPolicy } from '~/types/merge'
+import { RISK_POLICY_AXES, RISK_POLICY_CEILING_FIELD, riskPolicyCeilings } from '~/utils/riskPolicy'
+
+const policy = (over: Partial<RiskPolicy> = {}): RiskPolicy =>
+  ({
+    id: 'mp_balanced',
+    name: 'Balanced',
+    maxComplexity: 0.6,
+    maxRisk: 0.4,
+    maxImpact: 0.5,
+    ciMaxAttempts: 10,
+    maxRequirementIterations: 6,
+    maxRequirementConcernAllowed: 'none',
+    maxTesterQualityIterations: 3,
+    releaseWatchWindowMinutes: 30,
+    releaseMaxAttempts: 1,
+    humanReviewGraceMinutes: 10,
+    judgeMinScore: 0.7,
+    judgeMaxBounces: 2,
+    autoMergeEnabled: true,
+    classRules: {},
+    isDefault: true,
+    version: 1,
+    createdAt: 0,
+    updatedAt: 0,
+    ...over,
+  }) as RiskPolicy
+
+describe('riskPolicyCeilings', () => {
+  it('groups the three axes in presentation order', () => {
+    expect(riskPolicyCeilings(policy()).map((c) => c.axis)).toEqual([
+      'risk',
+      'impact',
+      'complexity',
+    ])
+  })
+
+  it('carries each axis ceiling as the stored 0..1 ratio', () => {
+    expect(riskPolicyCeilings(policy())).toEqual([
+      { axis: 'risk', max: 0.4 },
+      { axis: 'impact', max: 0.5 },
+      { axis: 'complexity', max: 0.6 },
+    ])
+  })
+
+  it('follows the shared axis order, which the settings editor iterates too', () => {
+    // The point of the exported order: the picker preview, the inspector summary and the
+    // settings editor all read it, so none of them can drift into its own sequence.
+    expect(riskPolicyCeilings(policy()).map((c) => c.axis)).toEqual([...RISK_POLICY_AXES])
+    expect(Object.keys(RISK_POLICY_CEILING_FIELD).sort()).toEqual([...RISK_POLICY_AXES].sort())
+  })
+})

package/app/utils/riskPolicy.ts

@@ -1,21 +1,42 @@
 import type { RiskPolicy } from '~/types/merge'
 
 /**
- * A compact one-line summary of a merge preset's auto-merge ceilings + CI-fix budget,
- * suitable for a dropdown option label so the user sees each preset's actual thresholds
- * (not just its name) while choosing one. Percentages are the stored 0..1 ratios
- * rendered as whole percents.
+ * The three axes a `merger` agent scores a pull request on. Presentation order is
+ * risk → impact → complexity: what the PR could break first, then how far it reaches, then
+ * how hard it was to write.
+ *
+ * This array IS the order — every surface that shows the three axes iterates it rather than
+ * hard-coding a sequence, so the picker's preview, the inspector's summary line and the
+ * settings editor cannot drift into three different orders (which is exactly what they had).
  */
-export function riskPolicySummary(p: RiskPolicy): string {
-  // Auto-merge disabled: the thresholds don't apply, every PR goes to human review.
-  if (!p.autoMergeEnabled) return `manual review only · ${p.ciMaxAttempts} CI fixes`
-  const pct = (n: number) => `${Math.round(n * 100)}%`
-  return `cx ≤${pct(p.maxComplexity)} · risk ≤${pct(p.maxRisk)} · impact ≤${pct(
-    p.maxImpact,
-  )} · ${p.ciMaxAttempts} CI fixes`
+export const RISK_POLICY_AXES = ['risk', 'impact', 'complexity'] as const
+
+export type RiskPolicyAxis = (typeof RISK_POLICY_AXES)[number]
+
+/**
+ * Which `RiskPolicy` field carries each axis's auto-merge ceiling. Exhaustive over the axis
+ * union, so adding an axis fails the typecheck here rather than silently rendering two.
+ */
+export const RISK_POLICY_CEILING_FIELD: Record<
+  RiskPolicyAxis,
+  'maxRisk' | 'maxImpact' | 'maxComplexity'
+> = {
+  risk: 'maxRisk',
+  impact: 'maxImpact',
+  complexity: 'maxComplexity',
 }
 
-/** The preset name followed by its thresholds, for a single-line dropdown option. */
-export function riskPolicyOptionLabel(p: RiskPolicy): string {
-  return `${p.name} — ${riskPolicySummary(p)}`
+/** One axis of a policy, with the ceiling a score must stay at or below to auto-merge. */
+export interface RiskPolicyCeiling {
+  axis: RiskPolicyAxis
+  /** The stored 0..1 ratio. Render it through the `percent` number format, never raw. */
+  max: number
+}
+
+/**
+ * A policy's auto-merge ceilings, one entry per axis in presentation order, so every
+ * surface that explains a policy groups the three axes the same way.
+ */
+export function riskPolicyCeilings(p: RiskPolicy): RiskPolicyCeiling[] {
+  return RISK_POLICY_AXES.map((axis) => ({ axis, max: p[RISK_POLICY_CEILING_FIELD[axis]] }))
 }

package/i18n/locales/de.json

@@ -1318,8 +1318,8 @@
       "unassigned": "Nicht zugewiesen",
       "workspaceDefault": "Workspace-Standard",
       "workspaceDefaultParen": "(Workspace-Standard)",
-      "defaultPresetThresholds": "Standard ({name}): {thresholds}",
-      "defaultPreset": "Standard ({name})",
+      "defaultRiskPolicy": "Standard ({name})",
+      "defaultModelPreset": "Standard ({name})",
       "noDefault": "Kein Standard",
       "inheritWorkspace": "Vom Workspace erben",
       "on": "An",
@@ -1335,7 +1335,8 @@
       "pipelineEmpty": "Kein Standard. Wähle eine Pipeline, wenn du diese Aufgabe ausführst.",
       "pipelineHint": "Die Pipeline, die der Run-Button standardmäßig startet: die Abfolge der Agent-Schritte (zum Beispiel Spec, Code, Test, Merge), die für diese Aufgabe ausgeführt werden.",
       "mergePolicy": "Risikorichtlinie",
-      "riskPolicyDetail": "{name}: automatisch mergen, wenn Komplexität ≤ {complexity}, Risiko ≤ {risk}, Wirkung ≤ {impact}; bis zu {attempts} CI-Fix-Versuche.",
+      "riskPolicyDetail": "{name}: mergt ohne menschliche Prüfung, wenn Risiko ≤ {risk}, Wirkung ≤ {impact} und Komplexität ≤ {complexity}; bis zu {attempts} CI-Fix-Versuche.",
+      "riskPolicyManual": "{name}: mergt nie von selbst, jeder Pull Request wartet also auf eine menschliche Prüfung; bis zu {attempts} CI-Fix-Versuche.",
       "riskPolicyEmpty": "Keine Risikorichtlinie konfiguriert. Der Merger löst für jeden PR eine Prüfbenachrichtigung aus.",
       "mergePolicyHint": "Entscheidet, wann ein fertiger Pull Request automatisch mergt, statt auf eine menschliche Prüfung zu warten, und wie viele CI-Fix-Versuche ein Lauf erhält.",
       "modelPreset": "Modell-Preset",
@@ -2304,7 +2305,7 @@
       "chooseAtRunTime": "Zur Laufzeit auswählen",
       "mergePolicy": "Risikorichtlinie",
       "workspaceDefault": "Workspace-Standard",
-      "defaultPreset": "Standard ({name}) — {thresholds}",
+      "defaultPreset": "Standard ({name})",
       "defaultModelPreset": "Standard ({name})",
       "modelPreset": "Modell-Preset",
       "bestPractices": "Best Practices",
@@ -3592,6 +3593,11 @@
     "recommendationRequested": "Empfehlung angefordert — prüfen Sie den Vorschlag unten.",
     "recommendedDefault": "Empfohlene Vorgabe: behalten, bearbeiten oder die Feststellung verwerfen.",
     "needsYourInput": "Benötigt Ihre Eingabe",
+    "group": {
+      "action": "Benötigt Ihre Reaktion",
+      "waiting": "Warten auf Vorschläge",
+      "settled": "Erledigt"
+    },
     "mode": {
       "answer": "Beantworten",
       "dismiss": "Verwerfen",
@@ -5131,6 +5137,25 @@
       "toast": {
         "reseedFailed": "Risikorichtlinie konnte nicht erneut geseedet werden"
       }
+    },
+    "picker": {
+      "workspaceDefaultCaption": "Gilt, weil diese Aufgabe keine eigene Richtlinie wählt.",
+      "noneHint": "Keine Risikorichtlinie konfiguriert. Jeder Pull Request wartet auf eine menschliche Prüfung."
+    },
+    "preview": {
+      "defaultBadge": "Standard",
+      "autoMergeHeading": "Schwellen für automatisches Mergen",
+      "axis": {
+        "risk": "Risiko",
+        "impact": "Wirkung",
+        "complexity": "Komplexität"
+      },
+      "ceiling": "höchstens {value}",
+      "autoMergeExplainer": "Sobald die CI grün ist, bewertet der Merger-Agent den Pull Request auf diesen drei Achsen. Bleibt jede Bewertung auf oder unter ihrer Obergrenze, mergt der Pull Request von selbst und überspringt die menschliche Prüfung; alles darüber geht an eine Person.",
+      "manualHeading": "Nur manuelle Prüfung",
+      "manualExplainer": "Diese Richtlinie mergt nie von selbst, jeder Pull Request wartet also unabhängig von den Bewertungen auf eine menschliche Prüfung.",
+      "ciHeading": "CI-Fixes",
+      "ciAttempts": "Der Lauf darf {count} Mal versuchen, eine rote CI grün zu bekommen, bevor er aufgibt. | Der Lauf darf {count} Mal versuchen, eine rote CI grün zu bekommen, bevor er aufgibt."
     }
   },
   "modelPreset": {