@cat-factory/app 0.266.1 → 0.267.0

package/app/components/board/AddTaskModal.vue

@@ -429,6 +429,9 @@ function defaultPipelineIdFor(type: TaskTypeChoice): string {
   const preset =
     custom?.defaultPipelineId ??
     DEFAULT_PIPELINE_FOR_TYPE[type] ??
+    // The workspace's own declared in-app default, ahead of the interface-mode rung, so this form
+    // and the task card's plain Start still cannot disagree (see `declaredDefaultId`).
+    pipelines.declaredDefaultId('interactive') ??
     defaultBuildPipelineId(uiMode.isAdvanced)
   return pipelines.pipelines.some((p) => p.id === preset) ? preset : ''
 }

package/app/components/board/nodes/TaskCard.vue

@@ -92,7 +92,13 @@ const defaultPipeline = computed<{ id: string; name: string } | undefined>(() =>
       }
     )
   }
-  return pipelines.getPipeline(defaultBuildPipelineId(uiMode.isAdvanced)) ?? pipelines.pipelines[0]
+  // No pin: the workspace's own DECLARED in-app default outranks the interface-mode rung, because
+  // an operator who named one said something a tier cannot overrule.
+  const declared = pipelines.declaredDefaultId('interactive')
+  return (
+    pipelines.getPipeline(declared ?? defaultBuildPipelineId(uiMode.isAdvanced)) ??
+    pipelines.pipelines[0]
+  )
 })
 
 /** The PR the implementer agent opened for this task, if any. */

package/app/components/pipeline/PipelineBuilder.vue

@@ -399,45 +399,10 @@ const library = computed(() =>
   }),
 )
 const visiblePipelines = computed(() => library.value.offered)
-async function toggleArchive(p: Pipeline) {
-  try {
-    if (p.archived) await pipelines.unarchive(p.id)
-    else await pipelines.archive(p.id)
-  } catch {
-    toast.add({ title: t('pipeline.builder.toast.updateFailed'), color: 'error' })
-  }
-}
-
-/** Load a custom pipeline into the draft for in-place editing. */
-function edit(p: Pipeline) {
-  pipelines.loadForEdit(p)
-}
-
-const { confirm } = useConfirm()
-async function removePipeline(p: Pipeline) {
-  const ok = await confirm({
-    title: t('pipeline.builder.confirmDeletePipeline.title'),
-    description: t('pipeline.builder.confirmDeletePipeline.body', { name: p.name }),
-    variant: 'destructive',
-    confirmLabel: t('common.delete'),
-    icon: 'i-lucide-trash-2',
-  })
-  if (ok) void pipelines.removePipeline(p.id)
-}
-
-/** Clone any pipeline (incl. a read-only built-in) into an editable copy, then edit it. */
-async function clone(p: Pipeline) {
-  try {
-    const copy = await pipelines.clonePipeline(p.id)
-    toast.add({
-      title: t('pipeline.builder.toast.cloned', { name: p.name, copy: copy.name }),
-      color: 'success',
-      icon: 'i-lucide-copy',
-    })
-  } catch {
-    toast.add({ title: t('pipeline.builder.toast.cloneFailed'), color: 'error' })
-  }
-}
+// The library ROW's actions (archive, the two scope defaults, edit, clone, delete) — one cohesive
+// group, extracted so this component stays inside its size budget. See
+// `usePipelineLibraryActions` for why they belong together.
+const { toggleArchive, toggleDefault, edit, removePipeline, clone } = usePipelineLibraryActions()
 </script>
 
 <template>
@@ -1260,6 +1225,32 @@ async function clone(p: Pipeline) {
                   >
                     {{ t('pipeline.builder.defaultBadge') }}
                   </UBadge>
+                  <!-- Which scope this rung is the default for. Shown at BOTH interface tiers even
+                       though the controls below are advanced-only: the control is an override, the
+                       resulting default is a decision, and a decision nobody can see is the
+                       concealed-setting failure. -->
+                  <UBadge
+                    v-if="p.isDefault"
+                    color="primary"
+                    variant="subtle"
+                    size="xs"
+                    class="shrink-0"
+                    :title="t('pipeline.builder.scopeDefault.interactiveHint')"
+                    data-testid="pipeline-interactive-default"
+                  >
+                    {{ t('pipeline.builder.scopeDefault.interactive') }}
+                  </UBadge>
+                  <UBadge
+                    v-if="p.isUnattendedDefault"
+                    color="info"
+                    variant="subtle"
+                    size="xs"
+                    class="shrink-0"
+                    :title="t('pipeline.builder.scopeDefault.unattendedHint')"
+                    data-testid="pipeline-unattended-default"
+                  >
+                    {{ t('pipeline.builder.scopeDefault.unattended') }}
+                  </UBadge>
                   <span class="shrink-0 text-[10px] text-slate-500">
                     {{
                       t(
@@ -1273,6 +1264,38 @@ async function clone(p: Pipeline) {
                 <div
                   class="flex shrink-0 items-center opacity-0 transition group-hover:opacity-100"
                 >
+                  <!-- The two DEFAULT claims, advanced-tier (see `toggleDefault`). An archived
+                         pipeline is not offered either: the backend refuses a hidden row as a
+                         default, and a control that can only fail is worse than no control. Safe
+                         to hide rather than a way to strand a claim, because the same rule refuses
+                         ARCHIVING a row that still holds one: a hidden row never holds a default,
+                         so there is never one here to release. -->
+                  <template v-if="uiMode.isAdvanced && !p.archived && !p.internal">
+                    <UButton
+                      :icon="p.isDefault ? 'i-lucide-star' : 'i-lucide-star-off'"
+                      :color="p.isDefault ? 'primary' : 'neutral'"
+                      variant="ghost"
+                      size="xs"
+                      :title="
+                        p.isDefault
+                          ? t('pipeline.builder.scopeDefault.releaseInteractive')
+                          : t('pipeline.builder.scopeDefault.claimInteractive')
+                      "
+                      @click="toggleDefault(p, 'interactive')"
+                    />
+                    <UButton
+                      :icon="p.isUnattendedDefault ? 'i-lucide-bot' : 'i-lucide-bot-off'"
+                      :color="p.isUnattendedDefault ? 'info' : 'neutral'"
+                      variant="ghost"
+                      size="xs"
+                      :title="
+                        p.isUnattendedDefault
+                          ? t('pipeline.builder.scopeDefault.releaseUnattended')
+                          : t('pipeline.builder.scopeDefault.claimUnattended')
+                      "
+                      @click="toggleDefault(p, 'unattended')"
+                    />
+                  </template>
                   <!-- Archive/unarchive: organize the library without deleting. Works on
                          built-ins too (view metadata, not structure). -->
                   <UButton

package/app/components/requirements/RequirementsReviewWindow.logic.spec.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from 'vitest'
 import {
   findingAttention,
+  findingClass,
   orderFindings,
   reconcileFindingOrder,
   type FindingRecommendationState,
@@ -21,6 +22,7 @@ const item = (
   id: string,
   status: RequirementReviewItem['status'],
   severity: RequirementReviewItem['severity'] = 'medium',
+  autoAnswerable?: boolean,
 ): RequirementReviewItem => ({
   id,
   category: 'question',
@@ -29,6 +31,7 @@ const item = (
   detail: `detail for ${id}`,
   status,
   reply: null,
+  ...(autoAnswerable === undefined ? {} : { autoAnswerable }),
   createdAt: 0,
   updatedAt: 0,
 })
@@ -98,11 +101,37 @@ describe('orderFindings', () => {
     expect(order(items).map((entry) => entry.id)).toEqual(['low-open', 'high-handled'])
   })
 
-  it('tags each entry with the bucket its position came from', () => {
+  it('tags each entry with the buckets its position came from', () => {
     const items = [item('a', 'open'), item('b', 'dismissed')]
     expect(order(items)).toEqual([
-      { id: 'a', attention: 'action' },
-      { id: 'b', attention: 'settled' },
+      { id: 'a', attention: 'action', group: 'judgement' },
+      { id: 'b', attention: 'settled', group: 'judgement' },
+    ])
+  })
+
+  // The GROUP is the primary key, ahead of attention: the two groups have different audiences, so
+  // each is its own list ordered by what is left in it, rather than one list interleaving work the
+  // reader owns with work the platform may already have answered.
+  it('puts the judgement group ahead of the practice group, settled or not', () => {
+    const items = [
+      item('practice-open', 'open', 'high', true),
+      item('judgement-settled', 'answered', 'low', false),
+    ]
+    expect(order(items).map((entry) => entry.id)).toEqual(['judgement-settled', 'practice-open'])
+  })
+
+  it('keeps attention ordering INSIDE each group', () => {
+    const items = [
+      item('practice-settled', 'answered', 'high', true),
+      item('practice-open', 'open', 'low', true),
+      item('judgement-settled', 'answered', 'high', false),
+      item('judgement-open', 'open', 'low', false),
+    ]
+    expect(order(items).map((entry) => entry.id)).toEqual([
+      'judgement-open',
+      'judgement-settled',
+      'practice-open',
+      'practice-settled',
     ])
   })
 
@@ -111,10 +140,23 @@ describe('orderFindings', () => {
   })
 })
 
+describe('findingClass', () => {
+  it('reads the reviewer classification', () => {
+    expect(findingClass({ autoAnswerable: true })).toBe('practice')
+    expect(findingClass({ autoAnswerable: false })).toBe('judgement')
+  })
+
+  // An unclassified finding (a reviewer pass predating the flag, or a garbled reply) lands in the
+  // group that asks a person, matching how the contract and the engine both read it.
+  it('reads an unclassified finding as needing a person', () => {
+    expect(findingClass({})).toBe('judgement')
+  })
+})
+
 describe('reconcileFindingOrder', () => {
   const desired: OrderedFinding[] = [
-    { id: 'a', attention: 'action' },
-    { id: 'b', attention: 'settled' },
+    { id: 'a', attention: 'action', group: 'judgement' },
+    { id: 'b', attention: 'settled', group: 'judgement' },
   ]
 
   it('falls back to the computed order when nothing is pinned', () => {
@@ -124,21 +166,21 @@ describe('reconcileFindingOrder', () => {
   it('holds the pinned order while it covers the same findings', () => {
     // `b` has since been answered and would now sink, but the pin keeps the list still.
     const pinned: OrderedFinding[] = [
-      { id: 'b', attention: 'action' },
-      { id: 'a', attention: 'action' },
+      { id: 'b', attention: 'action', group: 'judgement' },
+      { id: 'a', attention: 'action', group: 'judgement' },
     ]
     expect(reconcileFindingOrder(desired, pinned)).toBe(pinned)
   })
 
   it('drops a pin that no longer covers every finding, so a new one can never be hidden', () => {
-    const pinned: OrderedFinding[] = [{ id: 'a', attention: 'action' }]
+    const pinned: OrderedFinding[] = [{ id: 'a', attention: 'action', group: 'judgement' }]
     expect(reconcileFindingOrder(desired, pinned)).toEqual(desired)
   })
 
   it('drops a pin naming a finding the review no longer has', () => {
     const pinned: OrderedFinding[] = [
-      { id: 'a', attention: 'action' },
-      { id: 'gone', attention: 'action' },
+      { id: 'a', attention: 'action', group: 'judgement' },
+      { id: 'gone', attention: 'action', group: 'judgement' },
     ]
     expect(reconcileFindingOrder(desired, pinned)).toEqual(desired)
   })

package/app/components/requirements/RequirementsReviewWindow.logic.ts

@@ -23,6 +23,32 @@ import type { RequirementReviewItem, ReviewItemSeverity } from '~/types/requirem
  */
 export type FindingAttention = 'action' | 'waiting' | 'settled'
 
+/**
+ * WHO can answer a finding, which is the reviewer's own `autoAnswerable` judgement read as the two
+ * groups it sorts findings into.
+ *
+ * - `judgement` — it takes a business / product / domain decision, or information the reviewer was
+ *   not given. Only a person can settle it, and a run nobody is watching parks on it.
+ * - `practice` — a confident answer follows from universal best practice, from the idiomatic
+ *   approach of a stack the work already uses, or from the context already provided. The
+ *   Requirement Writer pre-answers these, and an unattended run may adopt a sufficiently confident
+ *   suggestion without waiting (see `reviewSettledForUnattended`).
+ *
+ * The two are the PRIMARY grouping in the window, ahead of how much attention a finding wants,
+ * because they are answered by different people rather than at different times: the value of
+ * seeing them apart is knowing which of them is yours.
+ */
+export type FindingClass = 'judgement' | 'practice'
+
+/**
+ * Which group a finding is in. ABSENT `autoAnswerable` reads as `judgement`, matching the contract's
+ * own reading of an unclassified finding (a pass that predates the flag, or a garbled reply): the
+ * safe direction is the one that asks a person.
+ */
+export function findingClass(item: Pick<RequirementReviewItem, 'autoAnswerable'>): FindingClass {
+  return item.autoAnswerable === true ? 'practice' : 'judgement'
+}
+
 /** What the review's recommendation collection currently holds for one finding. */
 export interface FindingRecommendationState {
   /** A requested suggestion is still being generated by the Writer. */
@@ -31,13 +57,17 @@ export interface FindingRecommendationState {
   ready: boolean
 }
 
-/** One finding in the rendered order, tagged with the bucket its position came from. */
+/** One finding in the rendered order, tagged with the buckets its position came from. */
 export interface OrderedFinding {
   id: string
   attention: FindingAttention
+  group: FindingClass
 }
 
 const ATTENTION_RANK: Record<FindingAttention, number> = { action: 0, waiting: 1, settled: 2 }
+// `judgement` first: it is the group that always needs the person reading this, whatever state its
+// findings are in, and the practice group is the one the platform may have already answered.
+const CLASS_RANK: Record<FindingClass, number> = { judgement: 0, practice: 1 }
 const SEVERITY_RANK: Record<ReviewItemSeverity, number> = { high: 0, medium: 1, low: 2 }
 
 /**
@@ -60,10 +90,16 @@ export function findingAttention(
 }
 
 /**
- * The findings in the order the window should render them: unreacted-to first, then whatever the
- * Writer is still working on, then everything already handled. Severity stays the secondary key
- * (the order the window has always used within a bucket), and the reviewer's own ordering breaks
- * the remaining ties so the sort is total and stable.
+ * The findings in the order the window should render them: the two GROUPS first (the ones only a
+ * person can decide, then the ones practice can answer), and within each of them unreacted-to
+ * first, then whatever the Writer is still working on, then everything already handled. Severity
+ * stays the next key (the order the window has always used within a bucket), and the reviewer's own
+ * ordering breaks the remaining ties so the sort is total and stable.
+ *
+ * Group ahead of attention, which is a change of primary key rather than an extra tiebreak: a
+ * settled judgement finding now sorts above an open practice one. That is the intended reading —
+ * the groups are two lists with different audiences, and each is internally ordered by what is
+ * left to do in it, rather than one list interleaving work the reader owns with work they do not.
  */
 export function orderFindings(
   items: readonly RequirementReviewItem[],
@@ -73,16 +109,18 @@ export function orderFindings(
     .map((item, index) => ({
       id: item.id,
       attention: findingAttention(item, recommendationFor(item)),
+      group: findingClass(item),
       severity: item.severity,
       index,
     }))
     .sort(
       (a, b) =>
+        CLASS_RANK[a.group] - CLASS_RANK[b.group] ||
         ATTENTION_RANK[a.attention] - ATTENTION_RANK[b.attention] ||
         SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity] ||
         a.index - b.index,
     )
-    .map(({ id, attention }) => ({ id, attention }))
+    .map(({ id, attention, group }) => ({ id, attention, group }))
 }
 
 /**

package/app/components/requirements/RequirementsReviewWindow.vue

@@ -14,8 +14,11 @@ import {
   orderFindings,
   reconcileFindingOrder,
   type FindingAttention,
+  type FindingClass,
   type OrderedFinding,
 } from './RequirementsReviewWindow.logic'
+import { recommendationConfidenceBand } from '@cat-factory/contracts'
+import type { RecommendationConfidenceBand } from '@cat-factory/contracts'
 import type {
   RecommendationSource,
   RequirementRecommendation,
@@ -191,6 +194,49 @@ const STATUS_LABELS = computed<Record<ReviewItemStatus, string>>(() => ({
   recommend_requested: t('requirements.itemStatus.recommend_requested'),
 }))
 
+// The two GROUPS the reviewer sorts its findings into, which is the window's top-level structure:
+// what only this person can decide, and what practice can answer. Each section says what its group
+// IS rather than only naming it, because the distinction is what tells the reader which half of the
+// list is theirs — and, on an unwatched run, which half the platform may answer without them.
+const CLASS_LABELS = computed<Record<FindingClass, string>>(() => ({
+  judgement: t('requirements.findingClass.judgement'),
+  practice: t('requirements.findingClass.practice'),
+}))
+const CLASS_HINTS = computed<Record<FindingClass, string>>(() => ({
+  judgement: t('requirements.findingClass.judgementHint'),
+  practice: t('requirements.findingClass.practiceHint'),
+}))
+const CLASS_LABEL_COLOR = {
+  judgement: 'text-amber-300',
+  practice: 'text-sky-300',
+} as const satisfies Record<FindingClass, string>
+
+// How sure the Writer says it is. Shown on every suggestion, because the confidence is what an
+// unattended run compares against its policy floor: a reader deciding whether to keep a
+// pre-filled answer is looking at the same number the platform used to decide not to ask them.
+// A suggestion the Writer did not grade renders NO badge rather than a "low" one — unreported and
+// unsure are different facts (see `recommendationConfidenceBand`).
+const CONFIDENCE_COLOR = {
+  high: 'success',
+  medium: 'warning',
+  low: 'error',
+} as const satisfies Record<RecommendationConfidenceBand, string>
+const CONFIDENCE_LABELS = computed<Record<RecommendationConfidenceBand, string>>(() => ({
+  high: t('requirements.confidence.high'),
+  medium: t('requirements.confidence.medium'),
+  low: t('requirements.confidence.low'),
+}))
+/** The band a recommendation's grade falls in, or null when it reported none. */
+function confidenceBandOf(
+  rec: RequirementRecommendation | undefined,
+): RecommendationConfidenceBand | null {
+  return rec ? recommendationConfidenceBand(rec.confidence) : null
+}
+/** The grade as a percentage for the badge's tooltip, or null when ungraded. */
+function confidencePercent(rec: RequirementRecommendation | undefined): string | null {
+  return rec?.confidence == null ? null : `${Math.round(rec.confidence * 100)}%`
+}
+
 // Answers auto-save: there is no explicit "save" button. The textarea is pre-seeded with
 // the recorded reply (see the watch below); editing and blurring persists it. Persist only
 // when the trimmed draft actually differs from what's already recorded, so blurring an
@@ -365,24 +411,37 @@ watch(
   },
   { immediate: true },
 )
-const orderedFindings = computed<{ item: RequirementReviewItem; attention: FindingAttention }[]>(
-  () => {
-    const byId = new Map((review.value?.items ?? []).map((item) => [item.id, item]))
-    return reconcileFindingOrder(desiredOrder.value, pinnedOrder.value).flatMap((entry) => {
-      const item = byId.get(entry.id)
-      return item ? [{ item, attention: entry.attention }] : []
-    })
-  },
-)
-// Label the buckets only once the list actually spans more than one — on a fresh review every
-// finding is outstanding, and a lone "Needs your reaction" heading over all of them is noise.
-const attentionGroupsShown = computed(
-  () => new Set(orderedFindings.value.map((entry) => entry.attention)).size > 1,
-)
+const orderedFindings = computed<
+  { item: RequirementReviewItem; attention: FindingAttention; group: FindingClass }[]
+>(() => {
+  const byId = new Map((review.value?.items ?? []).map((item) => [item.id, item]))
+  return reconcileFindingOrder(desiredOrder.value, pinnedOrder.value).flatMap((entry) => {
+    const item = byId.get(entry.id)
+    return item ? [{ item, attention: entry.attention, group: entry.group }] : []
+  })
+})
+// The GROUP heading is shown whenever the list spans both groups, which is the point of the split:
+// a reader has to be able to see where "yours to decide" ends. A review entirely in one group needs
+// no heading, because then the whole list is that group.
+function startsFindingGroup(index: number): boolean {
+  const entries = orderedFindings.value
+  if (new Set(entries.map((entry) => entry.group)).size < 2) return false
+  return index === 0 || entries[index - 1]?.group !== entries[index]?.group
+}
+// The attention sub-heading is shown only inside a group that spans more than one bucket, so the
+// two levels of heading cannot both appear on a review where they would say the same thing (a fresh
+// review is all outstanding; a pre-answered practice group is all settled).
 function startsAttentionGroup(index: number): boolean {
-  if (!attentionGroupsShown.value) return false
   const entries = orderedFindings.value
-  return index === 0 || entries[index - 1]?.attention !== entries[index]?.attention
+  const here = entries[index]
+  if (!here) return false
+  if (entries.filter((entry) => entry.group === here.group).length < 2) return false
+  const spansBuckets =
+    new Set(entries.filter((entry) => entry.group === here.group).map((entry) => entry.attention))
+      .size > 1
+  if (!spansBuckets) return false
+  const previous = entries[index - 1]
+  return !previous || previous.group !== here.group || previous.attention !== here.attention
 }
 const ATTENTION_LABELS = computed<Record<FindingAttention, string>>(() => ({
   action: t('requirements.group.action'),
@@ -740,7 +799,20 @@ async function resolveExceeded(choice: 'extra-round' | 'proceed' | 'stop-reset')
             @focusin="onFindingFocusIn"
             @focusout="onFindingFocusOut"
           >
-            <template v-for="({ item, attention }, index) in orderedFindings" :key="item.id">
+            <template v-for="({ item, attention, group }, index) in orderedFindings" :key="item.id">
+              <div v-if="startsFindingGroup(index)" class="pt-2" data-testid="requirements-group">
+                <div class="flex items-center gap-2">
+                  <span
+                    class="text-xs font-semibold uppercase tracking-wide"
+                    :class="CLASS_LABEL_COLOR[group]"
+                    :data-finding-group="group"
+                  >
+                    {{ CLASS_LABELS[group] }}
+                  </span>
+                  <span class="h-px flex-1 bg-slate-700" />
+                </div>
+                <p class="mt-0.5 text-[11px] text-slate-500">{{ CLASS_HINTS[group] }}</p>
+              </div>
               <div v-if="startsAttentionGroup(index)" class="flex items-center gap-2 pt-1">
                 <span
                   class="text-[11px] font-semibold uppercase tracking-wide"
@@ -869,6 +941,20 @@ async function resolveExceeded(choice: 'extra-round' | 'proceed' | 'stop-reset')
                           >
                             {{ GROUNDING_LABELS[autoDefaults.get(item.id)!.groundedIn!] }}
                           </UBadge>
+                          <!-- The Writer's own grade, which is a different question from where the
+                                 answer came from: it is what an unwatched run compares against its
+                                 policy floor, so it is also what tells a reader how hard this
+                                 pre-filled answer was to be sure of. -->
+                          <UBadge
+                            v-if="confidenceBandOf(autoDefaults.get(item.id))"
+                            size="xs"
+                            variant="outline"
+                            :color="CONFIDENCE_COLOR[confidenceBandOf(autoDefaults.get(item.id))!]"
+                            :title="confidencePercent(autoDefaults.get(item.id)) ?? undefined"
+                            data-testid="requirements-confidence"
+                          >
+                            {{ CONFIDENCE_LABELS[confidenceBandOf(autoDefaults.get(item.id))!] }}
+                          </UBadge>
                         </div>
                         <UTextarea
                           v-model="drafts[item.id]"
@@ -927,6 +1013,17 @@ async function resolveExceeded(choice: 'extra-round' | 'proceed' | 'stop-reset')
                             >
                               {{ GROUNDING_LABELS[rec.groundedIn] }}
                             </UBadge>
+                            <UBadge
+                              v-if="confidenceBandOf(rec)"
+                              size="xs"
+                              variant="outline"
+                              class="ms-1.5"
+                              :color="CONFIDENCE_COLOR[confidenceBandOf(rec)!]"
+                              :title="confidencePercent(rec) ?? undefined"
+                              data-testid="requirements-confidence"
+                            >
+                              {{ CONFIDENCE_LABELS[confidenceBandOf(rec)!] }}
+                            </UBadge>
                             <!-- The Writer's suggested answer — agent prose, so it takes the
                                  measure like the finding's own question above it. -->
                             <p class="mt-1 max-w-3xl whitespace-pre-line text-sm text-slate-300">

package/app/components/settings/RiskPolicyPanel.vue

@@ -88,6 +88,10 @@ interface Draft {
   // up, rather than stopping for a person. Edited as a switch because the vocabulary is two-valued
   // and the OFF state is the historical behaviour.
   unattended: boolean
+  // The confidence floor an unattended run's auto-answered requirements finding must clear, as a
+  // PERCENT (the numbers above are edited the same way). Only read while `unattended` is on, which
+  // is why the field is rendered inside that block rather than beside the other budgets.
+  minAutoAnswerConfidence: number
   // Per-change-class auto-merge rules. An OMITTED class means "use the score ceilings above",
   // so `{}` is the identity — the editor stores `thresholds` as an omission for that reason.
   classRules: MergeClassRules
@@ -136,6 +140,7 @@ function toDraft(p: RiskPolicy): Draft {
     maxRequirementConcernAllowed: p.maxRequirementConcernAllowed,
     autoMergeEnabled: p.autoMergeEnabled,
     unattended: p.autonomy === 'unattended',
+    minAutoAnswerConfidence: Math.round(p.minAutoAnswerConfidence * 100),
     classRules: { ...p.classRules },
     classRulesByRole: { ...p.classRulesByRole },
     dryRunRoles: [...p.dryRunRoles],
@@ -196,6 +201,7 @@ async function save(p: RiskPolicy) {
       maxRequirementConcernAllowed: d.maxRequirementConcernAllowed,
       autoMergeEnabled: d.autoMergeEnabled,
       autonomy: d.unattended ? 'unattended' : 'attended',
+      minAutoAnswerConfidence: d.minAutoAnswerConfidence / 100,
       classRules: d.classRules,
       classRulesByRole: d.classRulesByRole,
       dryRunRoles: d.dryRunRoles,
@@ -277,6 +283,7 @@ const draft = reactive<Draft>({
   // A new policy parks on its own caps, matching every built-in but the unattended default: a
   // licence to answer them is a posture somebody grants, never one a blank form assumes.
   unattended: false,
+  minAutoAnswerConfidence: 80,
   // The create row authors the numbers only. Class and role rules start at their identity and
   // are edited on the saved preset, where each rule can be shown beside the base rule (and the
   // track record) it narrows — neither reads as anything on a policy that does not exist yet.
@@ -305,6 +312,7 @@ async function create() {
       maxRequirementConcernAllowed: draft.maxRequirementConcernAllowed,
       autoMergeEnabled: draft.autoMergeEnabled,
       autonomy: draft.unattended ? 'unattended' : 'attended',
+      minAutoAnswerConfidence: draft.minAutoAnswerConfidence / 100,
       classRules: draft.classRules,
       forkDecision: forkGating(draft),
     })
@@ -520,6 +528,25 @@ async function create() {
               : t('settings.riskPolicy.autonomy.attendedHint')
           "
         />
+        <!-- Shown only while the posture is on, because that is the only state that reads it: a
+             floor on an attended policy would be a control over a decision this policy never makes.
+             It is not hidden as an "advanced override" — it is inert, which is a different thing. -->
+        <label v-if="drafts[p.id]!.unattended" class="mt-3 block">
+          <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
+            {{ t('settings.riskPolicy.autoAnswer.label') }}
+          </span>
+          <UInput
+            v-model.number="drafts[p.id]!.minAutoAnswerConfidence"
+            type="number"
+            min="0"
+            max="100"
+            size="sm"
+            data-testid="risk-policy-auto-answer-floor"
+          />
+          <span class="mt-1 block text-[11px] text-slate-500">
+            {{ t('settings.riskPolicy.autoAnswer.hint') }}
+          </span>
+        </label>
       </div>
 
       <div class="mt-3 flex items-center justify-between gap-3">