@cat-factory/app 0.266.0 → 0.267.0

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">

package/app/components/testing/TestReportWindow.vue

@@ -20,6 +20,7 @@ import StepContainerStatus from '~/components/panels/StepContainerStatus.vue'
 import AttemptEntryHeader from '~/components/panels/AttemptEntryHeader.vue'
 import EnvironmentStatusPanel from '~/components/environments/EnvironmentStatusPanel.vue'
 import ProvisioningLogsDrawer from '~/components/provisioning/ProvisioningLogsDrawer.vue'
+import MarkdownProse from '~/components/common/MarkdownProse.vue'
 
 const board = useBoardStore()
 const execution = useExecutionStore()
@@ -489,9 +490,11 @@ const GROUP_STATUS_META: Record<ScenarioGroup['status'], { icon: string; text: s
                 :icon="a.outcome === 'completed' ? 'i-lucide-wrench' : 'i-lucide-circle-x'"
                 :icon-class="a.outcome === 'completed' ? 'text-amber-300' : 'text-rose-400'"
               />
-              <p v-if="a.summary" class="mt-1 max-w-3xl text-[12px] leading-snug text-slate-400">
-                {{ a.summary }}
-              </p>
+              <MarkdownProse
+                v-if="a.summary"
+                :text="a.summary"
+                class="mt-1 max-w-3xl text-[12px] leading-snug text-slate-400"
+              />
               <div v-if="a.concerns && a.concerns.length" class="mt-1.5">
                 <p class="text-[11px] text-slate-500">
                   {{ t('testing.fixerTimeline.addressed') }}
@@ -575,9 +578,11 @@ const GROUP_STATUS_META: Record<ScenarioGroup['status'], { icon: string; text: s
                   d(new Date(vd.at), 'short')
                 }}</span>
               </div>
-              <p v-if="vd.feedback" class="mt-1 text-[12px] leading-snug text-slate-400">
-                {{ vd.feedback }}
-              </p>
+              <MarkdownProse
+                v-if="vd.feedback"
+                :text="vd.feedback"
+                class="mt-1 text-[12px] leading-snug text-slate-400"
+              />
               <div v-if="vd.gaps.length" class="mt-1.5">
                 <p class="text-[11px] text-slate-500">{{ t('testing.quality.gaps') }}</p>
                 <ul class="mt-1 space-y-0.5">
@@ -610,12 +615,11 @@ const GROUP_STATUS_META: Record<ScenarioGroup['status'], { icon: string; text: s
           <!-- Summary — the tester's own prose, so it takes the reading measure the shell's `full`
                width obliges (see the `width` prop). The scenario rows and log tails below keep the
                full span. -->
-          <p
+          <MarkdownProse
             v-if="report.summary"
+            :text="report.summary"
             class="mb-4 max-w-3xl text-[13px] leading-relaxed text-slate-300"
-          >
-            {{ report.summary }}
-          </p>
+          />
 
           <h3 class="mb-2 text-[11px] font-semibold uppercase tracking-wide text-slate-500">
             {{ t('testing.scenariosOutcomes') }}
@@ -680,9 +684,11 @@ const GROUP_STATUS_META: Record<ScenarioGroup['status'], { icon: string; text: s
                   />
                   <div class="min-w-0">
                     <span class="text-[13px] text-slate-200">{{ o.name }}</span>
-                    <p v-if="o.detail" class="max-w-3xl text-[12px] leading-snug text-slate-400">
-                      {{ o.detail }}
-                    </p>
+                    <MarkdownProse
+                      v-if="o.detail"
+                      :text="o.detail"
+                      class="max-w-3xl text-[12px] leading-snug text-slate-400"
+                    />
                   </div>
                 </div>
                 <p v-if="!g.outcomes.length" class="py-0.5 text-[12px] italic text-slate-500">
@@ -710,9 +716,11 @@ const GROUP_STATUS_META: Record<ScenarioGroup['status'], { icon: string; text: s
                         {{ SEVERITY_LABELS[c.severity] }}
                       </span>
                     </div>
-                    <p v-if="c.detail" class="max-w-3xl text-[12px] leading-snug text-slate-400">
-                      {{ c.detail }}
-                    </p>
+                    <MarkdownProse
+                      v-if="c.detail"
+                      :text="c.detail"
+                      class="max-w-3xl text-[12px] leading-snug text-slate-400"
+                    />
                   </div>
                 </div>
 

package/app/composables/usePipelineLibraryActions.ts

@@ -0,0 +1,82 @@
+import type { RunDefaultScope } from '@cat-factory/contracts'
+import type { Pipeline } from '~/types/domain'
+import { usePipelinesStore } from '~/stores/pipelines'
+import { usePipelineErrorToast } from '~/composables/usePipelineErrorToast'
+
+/**
+ * The actions a row of the saved-pipeline LIBRARY offers: archive, promote to a scope default,
+ * edit, clone, delete.
+ *
+ * Extracted from `PipelineBuilder.vue` so that component stays inside its (shrink-only) size
+ * budget. A cohesive seam rather than an arbitrary cut: every one of these takes a library row and
+ * nothing else, none of them touches the DRAFT chain the rest of the builder is about, and each
+ * reports its own failure — which is what makes them the same kind of thing.
+ */
+export function usePipelineLibraryActions() {
+  const pipelines = usePipelinesStore()
+  const toast = useToast()
+  const { t } = useI18n()
+  const { present } = usePipelineErrorToast()
+  const { confirm } = useConfirm()
+
+  /** Archive / unarchive: organize the library without deleting. Works on built-ins too. */
+  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' })
+    }
+  }
+
+  /**
+   * Claim (or release) a pipeline as the workspace's default for one resolution scope.
+   *
+   * Both scopes are ADVANCED-tier controls in the builder, and the reason is the interface-mode rule
+   * rather than the feeling of the setting: a workspace that names neither runs exactly what it runs
+   * today (the interface-mode rung in the app, the seeded unattended rung headlessly), so hiding the
+   * control leaves the same default a basic-tier user would have had. What is NOT hidden is the
+   * resulting badge — a default somebody set has to be visible in the library at both tiers, or the
+   * hidden control becomes a hidden decision.
+   */
+  async function toggleDefault(p: Pipeline, scope: RunDefaultScope) {
+    const held = scope === 'unattended' ? p.isUnattendedDefault : p.isDefault
+    try {
+      await pipelines.setDefault(p.id, scope, !held)
+    } catch (error) {
+      present(error, 'pipeline.builder.toast.updateFailed')
+    }
+  }
+
+  /** Load a custom pipeline into the draft for in-place editing. */
+  function edit(p: Pipeline) {
+    pipelines.loadForEdit(p)
+  }
+
+  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. */
+  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' })
+    }
+  }
+
+  return { toggleArchive, toggleDefault, edit, removePipeline, clone }
+}

package/app/stores/pipelines/persistence.ts

@@ -112,16 +112,45 @@ export function createPipelinePersistence(
     return updated
   }
 
-  /** Set a pipeline's organizational metadata (labels / archive). Works on built-ins too. */
-  async function organize(id: string, body: { labels?: string[]; archived?: boolean }) {
+  /**
+   * Set a pipeline's organizational metadata (labels / archive / the two default claims). Works on
+   * built-ins too, which is the whole reason the default claims live on this call: the rungs a
+   * workspace most wants as its defaults are built-in, and a built-in refuses a structural edit.
+   *
+   * Promoting one row DEMOTES another, and the response names only the winner. So the incumbent is
+   * released LOCALLY before the winner is upserted: a targeted edit of the two rows that changed,
+   * rather than a full re-read (which this store has no door for — it hydrates from the workspace
+   * snapshot) and rather than upserting the winner alone, which would leave two rows claiming the
+   * same default on screen until the next snapshot.
+   */
+  async function organize(
+    id: string,
+    body: {
+      labels?: string[]
+      archived?: boolean
+      isDefault?: boolean
+      isUnattendedDefault?: boolean
+    },
+  ) {
     const updated = await api.organizePipeline(useWorkspaceStore().requireId(), id, body)
+    if (body.isDefault !== undefined) releaseOtherClaims(id, 'isDefault')
+    if (body.isUnattendedDefault !== undefined) releaseOtherClaims(id, 'isUnattendedDefault')
     upsertPipeline(updated)
     return updated
   }
 
+  /** Drop `field` from every row but `id`, mirroring what the store just did server-side. */
+  function releaseOtherClaims(id: string, field: 'isDefault' | 'isUnattendedDefault') {
+    ctx.pipelines.value = ctx.pipelines.value.map((pipeline) =>
+      pipeline.id === id || pipeline[field] !== true ? pipeline : { ...pipeline, [field]: false },
+    )
+  }
+
   const archive = (id: string) => organize(id, { archived: true })
   const unarchive = (id: string) => organize(id, { archived: false })
   const setLabels = (id: string, labels: string[]) => organize(id, { labels })
+  const setDefault = (id: string, scope: 'interactive' | 'unattended', claimed: boolean) =>
+    organize(id, scope === 'unattended' ? { isUnattendedDefault: claimed } : { isDefault: claimed })
 
   return {
     saveDraft,
@@ -132,5 +161,6 @@ export function createPipelinePersistence(
     archive,
     unarchive,
     setLabels,
+    setDefault,
   }
 }

package/app/stores/pipelines.ts

@@ -1,7 +1,13 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
 import type { Pipeline } from '~/types/domain'
-import type { GateConfigForm, PipelinePurpose, RetiredPipelineWire } from '@cat-factory/contracts'
+import type {
+  GateConfigForm,
+  PipelinePurpose,
+  RetiredPipelineWire,
+  RunDefaultScope,
+} from '@cat-factory/contracts'
+import { declaredDefaultPipelineId } from '@cat-factory/contracts'
 import { useUpsertList } from '~/composables/useUpsertList'
 import { createDraftStepState, type PipelinesContext } from '~/stores/pipelines/context'
 import { createPipelineDraftActions } from '~/stores/pipelines/draftActions'
@@ -124,6 +130,23 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     return pipelines.value.find((p) => p.id === id)
   }
 
+  /**
+   * The pipeline id this workspace has DECLARED as its default for a resolution scope, or undefined
+   * when no row claims it.
+   *
+   * The rule itself is `declaredDefaultPipelineId` in `@cat-factory/contracts`, shared with the
+   * engine: the SPA pre-selects on its start controls what the backend falls back to when a headless
+   * caller names none, and two readings of "the default" is how a Start button comes to run
+   * something other than what the board said it would.
+   *
+   * Undefined is a real answer, not a lookup failure, and each caller composes its own fallback with
+   * it: the start controls `defaultBuildPipelineId` (the interface-mode rung), the backend catalog
+   * order.
+   */
+  function declaredDefaultId(scope: RunDefaultScope): string | undefined {
+    return declaredDefaultPipelineId(pipelines.value, scope)
+  }
+
   // The draft manipulation + persistence operations, split into cohesive factories sharing the
   // state above (a size-only extraction — behaviour is identical to the former in-closure
   // functions). Persistence drives the draft-lifecycle helpers (`clearDraft`/`loadForEdit`).
@@ -173,6 +196,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     hydrate,
     hydrateGateConfigForms,
     getPipeline,
+    declaredDefaultId,
     ...draftActions,
     ...persistence,
   }

package/i18n/locales/de.json

@@ -611,6 +611,10 @@
         "label": "Unbeaufsichtigte Läufe ohne Wartezeit auf eine Person abschließen",
         "unattendedHint": "Wenn eine automatische Schleife aufgibt (ein Companion an seinem Überarbeitungslimit, eine Prüfung an ihrem Durchlauflimit, unbearbeitete Folgepunkte), läuft der Durchlauf nachvollziehbar weiter statt anzuhalten. Von der Pipeline angeforderte Gates wie manuelles Testen, Review und Freigabe halten den Durchlauf weiterhin an.",
         "attendedHint": "Wenn eine automatische Schleife aufgibt, hält der Durchlauf an und wartet auf eine Entscheidung. Richtig für ein Board, das jemand beobachtet; ein über die API gestarteter Durchlauf wartet unbegrenzt."
+      },
+      "autoAnswer": {
+        "label": "Mindestzuversicht für Auto-Antworten (%)",
+        "hint": "Wie sicher der Requirement Writer sein muss, damit ein unbeobachteter Lauf seinen Vorschlag übernimmt statt auf eine Person zu warten. Infrage kommen nur Befunde, die der Reviewer ohne Product Owner für beantwortbar hielt."
       }
     },
     "observabilityConnection": {
@@ -4509,7 +4513,17 @@
       "binaryComparison": "Kandidaten vor der Lieferung vergleichen",
       "binaryPerGenerator": "Kandidaten pro Integration",
       "binaryMultiSelect": "Mehrere behalten erlauben",
-      "binaryComparisonUnreachable": "Dieser Schritt kann nur einen Kandidaten pro Motiv erzeugen, es gäbe also nichts zu vergleichen und der einzige würde ungefragt behalten. Wähle eine zweite Integration oder erhöhe die Anzahl der Kandidaten pro Integration."
+      "binaryComparisonUnreachable": "Dieser Schritt kann nur einen Kandidaten pro Motiv erzeugen, es gäbe also nichts zu vergleichen und der einzige würde ungefragt behalten. Wähle eine zweite Integration oder erhöhe die Anzahl der Kandidaten pro Integration.",
+      "scopeDefault": {
+        "interactive": "Standard in der App",
+        "interactiveHint": "Was eine vom Board gestartete Aufgabe ausführt, wenn sie keine eigene Pipeline festlegt.",
+        "unattended": "Standard ohne Aufsicht",
+        "unattendedHint": "Was ein Lauf ohne Beobachter ausführt (API, Ticket, Zeitplan), wenn die Aufgabe keine Pipeline festlegt.",
+        "claimInteractive": "Als Standard in der App festlegen",
+        "releaseInteractive": "Nicht mehr Standard in der App",
+        "claimUnattended": "Als Standard ohne Aufsicht festlegen",
+        "releaseUnattended": "Nicht mehr Standard ohne Aufsicht"
+      }
     },
     "progress": {
       "status": {
@@ -4794,6 +4808,17 @@
       "reReview": "Die Anforderungen konnten nicht erneut geprüft werden",
       "proceed": "Es konnte nicht fortgefahren werden",
       "resolveReview": "Die Prüfung konnte nicht abgeschlossen werden"
+    },
+    "findingClass": {
+      "judgement": "Ihre Entscheidung nötig",
+      "judgementHint": "Eine Geschäfts-, Produkt- oder Domänenentscheidung oder etwas, das dem Reviewer nicht mitgeteilt wurde. Nur Sie können das klären.",
+      "practice": "Aus der Praxis beantwortbar",
+      "practiceHint": "Durch etablierte Praxis, den bereits genutzten Stack oder den vorliegenden Kontext geklärt. Vorbefüllt zum Übernehmen oder Ändern."
+    },
+    "confidence": {
+      "high": "Hohe Zuversicht",
+      "medium": "Mittlere Zuversicht",
+      "low": "Geringe Zuversicht"
     }
   },
   "bootstrap": {

package/i18n/locales/en.json

@@ -3347,6 +3347,10 @@
         "label": "Finish unattended runs without waiting for a person",
         "unattendedHint": "When an automatic loop gives up (a companion at its rework cap, a review at its pass cap, untriaged follow-ups), the run proceeds on the record instead of parking. Gates the pipeline asks for, such as human testing, review and approval, still stop the run.",
         "attendedHint": "When an automatic loop gives up, the run parks and waits for someone to choose. Right for a board somebody is watching; a run started over the API waits indefinitely."
+      },
+      "autoAnswer": {
+        "label": "Auto-answer confidence floor (%)",
+        "hint": "How sure the Requirement Writer must be for an unwatched run to keep its suggested answer instead of stopping for a person. Only findings the reviewer judged answerable without a product owner are eligible."
       }
     },
     "observabilityConnection": {
@@ -5117,7 +5121,17 @@
       "binaryComparison": "Compare candidates before delivering",
       "binaryPerGenerator": "Candidates per integration",
       "binaryMultiSelect": "Allow keeping more than one",
-      "binaryComparisonUnreachable": "This step can only produce one candidate per subject, so nothing would be compared and the only one would be kept without asking. Select a second integration, or raise the candidates-per-integration count."
+      "binaryComparisonUnreachable": "This step can only produce one candidate per subject, so nothing would be compared and the only one would be kept without asking. Select a second integration, or raise the candidates-per-integration count.",
+      "scopeDefault": {
+        "interactive": "In-app default",
+        "interactiveHint": "What a task started from the board runs when it pins no pipeline of its own.",
+        "unattended": "Unattended default",
+        "unattendedHint": "What a run nobody is watching runs (the API, a ticket, a schedule) when the task pins no pipeline.",
+        "claimInteractive": "Make the in-app default",
+        "releaseInteractive": "Stop being the in-app default",
+        "claimUnattended": "Make the unattended default",
+        "releaseUnattended": "Stop being the unattended default"
+      }
     },
     "progress": {
       "status": {
@@ -5654,6 +5668,17 @@
       "reReview": "Could not re-review the requirements",
       "proceed": "Could not proceed",
       "resolveReview": "Could not resolve the review"
+    },
+    "findingClass": {
+      "judgement": "Needs your decision",
+      "judgementHint": "A business, product or domain call, or something the reviewer was not told. Only you can settle these.",
+      "practice": "Answerable from practice",
+      "practiceHint": "Settled by established practice, the stack already in use, or the context provided. Pre-filled for you to keep or change."
+    },
+    "confidence": {
+      "high": "High confidence",
+      "medium": "Medium confidence",
+      "low": "Low confidence"
     }
   },
   "clarity": {