@cat-factory/app 0.164.0 → 0.166.0

package/app/components/board/AddTaskModal.vue

@@ -27,7 +27,7 @@ import type { AppSlots, ResultViewContribution } from '~/modular/slots'
 import ContextDocumentPicker from '~/components/documents/ContextDocumentPicker.vue'
 import ContextIssuePicker from '~/components/tasks/ContextIssuePicker.vue'
 import FragmentSelector from '~/components/fragments/FragmentSelector.vue'
-import { riskPolicyOptionLabel, riskPolicySummary } from '~/utils/riskPolicy'
+import RiskPolicyPicker from '~/components/riskPolicy/RiskPolicyPicker.vue'
 import { parseConflict } from '~/composables/usePipelineErrorToast'
 import { pipelineAllowedForManualStart } from '~/utils/pipeline'
 
@@ -334,33 +334,13 @@ const riskPolicyId = ref('')
 const modelPresetId = ref('')
 const pipelineId = ref('')
 
+// The "pick nothing" row names the default policy it resolves to; the picker's detail pane
+// explains what that policy does, so the row itself stays a bare name.
 const defaultPresetLabel = computed(() =>
   riskPolicies.defaultPreset
-    ? t('board.addTask.defaultPreset', {
-        name: riskPolicies.defaultPreset.name,
-        thresholds: riskPolicySummary(riskPolicies.defaultPreset),
-      })
+    ? t('board.addTask.defaultPreset', { name: riskPolicies.defaultPreset.name })
     : t('board.addTask.workspaceDefault'),
 )
-const presetMenu = computed(() => [
-  [
-    {
-      label: defaultPresetLabel.value,
-      icon: 'i-lucide-rotate-ccw',
-      onSelect: () => (riskPolicyId.value = ''),
-    },
-    ...riskPolicies.presets.map((p) => ({
-      label: riskPolicyOptionLabel(p),
-      icon: 'i-lucide-git-merge',
-      onSelect: () => (riskPolicyId.value = p.id),
-    })),
-  ],
-])
-const selectedPresetLabel = computed(() => {
-  if (!riskPolicyId.value) return defaultPresetLabel.value
-  const picked = riskPolicies.presets.find((p) => p.id === riskPolicyId.value)
-  return picked ? riskPolicyOptionLabel(picked) : t('board.addTask.workspaceDefault')
-})
 
 // Model preset: which model each agent runs on. Empty = workspace default preset.
 const defaultModelPresetLabel = computed(() =>
@@ -1146,18 +1126,14 @@ function openReviewFrictionDialog(conflict: NonNullable<ReturnType<typeof parseC
 
             <!-- A review task merges nothing, so its risk (merge) policy is meaningless — omit it. -->
             <UFormField v-if="!isReview" :label="t('board.addTask.mergePolicy')">
-              <UDropdownMenu :items="presetMenu" class="w-full">
-                <UButton
-                  color="neutral"
-                  variant="subtle"
-                  size="sm"
-                  icon="i-lucide-git-merge"
-                  trailing-icon="i-lucide-chevron-down"
-                  class="w-full justify-between"
-                >
-                  {{ selectedPresetLabel }}
-                </UButton>
-              </UDropdownMenu>
+              <RiskPolicyPicker
+                :model-value="riskPolicyId"
+                :options="riskPolicies.presets"
+                :default-policy="riskPolicies.defaultPreset"
+                :none-label="defaultPresetLabel"
+                trigger-class="w-full justify-between"
+                @update:model-value="riskPolicyId = $event"
+              />
             </UFormField>
 
             <UFormField :label="t('board.addTask.modelPreset')">

package/app/components/panels/inspector/TaskRunSettings.vue

@@ -3,9 +3,9 @@ import { computed, onMounted } from 'vue'
 import { connectionNeighborIds } from '@cat-factory/contracts'
 import type { Block } from '~/types/domain'
 import type { WritebackOverride } from '~/types/tracker'
-import { riskPolicyOptionLabel, riskPolicySummary } from '~/utils/riskPolicy'
 import { pipelineAllowedForManualStart } from '~/utils/pipeline'
 import InspectorSection from '~/components/panels/inspector/InspectorSection.vue'
+import RiskPolicyPicker from '~/components/riskPolicy/RiskPolicyPicker.vue'
 import TaskAprioriBranches from '~/components/panels/inspector/TaskAprioriBranches.vue'
 
 const props = defineProps<{ block: Block }>()
@@ -67,25 +67,13 @@ function setAutoStartDependents(value: boolean) {
 // budget. None selected → the workspace default preset. (The old confidence-based
 // auto-merge threshold is gone; the `merger` step gates on this policy instead.)
 const selectedPreset = computed(() => riskPolicies.resolve(props.block.riskPolicyId))
-const presetMenu = computed(() => [
-  [
-    {
-      label: riskPolicies.defaultPreset
-        ? t('inspector.runSettings.defaultPresetThresholds', {
-            name: riskPolicies.defaultPreset.name,
-            thresholds: riskPolicySummary(riskPolicies.defaultPreset),
-          })
-        : t('inspector.runSettings.workspaceDefault'),
-      icon: 'i-lucide-rotate-ccw',
-      onSelect: () => setPreset(''),
-    },
-    ...riskPolicies.presets.map((p) => ({
-      label: riskPolicyOptionLabel(p),
-      icon: 'i-lucide-git-merge',
-      onSelect: () => setPreset(p.id),
-    })),
-  ],
-])
+// The "pick nothing" row names the default policy it resolves to; the picker's detail pane
+// explains what that policy does, so the row itself stays a bare name.
+const defaultPresetLabel = computed(() =>
+  riskPolicies.defaultPreset
+    ? t('inspector.runSettings.defaultRiskPolicy', { name: riskPolicies.defaultPreset.name })
+    : t('inspector.runSettings.workspaceDefault'),
+)
 function setPreset(id: string) {
   board.updateBlock(props.block.id, { riskPolicyId: id })
 }
@@ -111,7 +99,7 @@ const modelPresetMenu = computed(() => [
   [
     {
       label: modelPresets.defaultPreset
-        ? t('inspector.runSettings.defaultPreset', { name: modelPresets.defaultPreset.name })
+        ? t('inspector.runSettings.defaultModelPreset', { name: modelPresets.defaultPreset.name })
         : t('inspector.runSettings.workspaceDefault'),
       icon: 'i-lucide-rotate-ccw',
       onSelect: () => setModelPreset(''),
@@ -308,24 +296,44 @@ const technicalLabel = computed(() => {
         <span class="text-[11px] font-semibold uppercase tracking-wide text-slate-400">
           {{ t('inspector.runSettings.mergePolicy') }}
         </span>
-        <UDropdownMenu :items="presetMenu">
-          <UButton
-            size="xs"
-            variant="ghost"
-            color="neutral"
-            icon="i-lucide-git-merge"
-            trailing-icon="i-lucide-chevron-down"
-          />
-        </UDropdownMenu>
+        <RiskPolicyPicker
+          :model-value="block.riskPolicyId ?? ''"
+          :options="riskPolicies.presets"
+          :default-policy="riskPolicies.defaultPreset"
+          :none-label="defaultPresetLabel"
+          @update:model-value="setPreset"
+        >
+          <template #trigger>
+            <UButton
+              size="xs"
+              variant="ghost"
+              color="neutral"
+              icon="i-lucide-git-merge"
+              trailing-icon="i-lucide-chevron-down"
+            />
+          </template>
+        </RiskPolicyPicker>
       </div>
       <div v-if="selectedPreset" class="text-[11px] text-slate-400">
-        <i18n-t keypath="inspector.runSettings.riskPolicyDetail" tag="span" scope="global">
+        <i18n-t
+          v-if="selectedPreset.autoMergeEnabled"
+          keypath="inspector.runSettings.riskPolicyDetail"
+          tag="span"
+          scope="global"
+        >
           <template #name>
             <span class="text-slate-300">{{ selectedPreset.name }}</span>
           </template>
-          <template #complexity>{{ n(selectedPreset.maxComplexity, { key: 'percent' }) }}</template>
           <template #risk>{{ n(selectedPreset.maxRisk, { key: 'percent' }) }}</template>
           <template #impact>{{ n(selectedPreset.maxImpact, { key: 'percent' }) }}</template>
+          <template #complexity>{{ n(selectedPreset.maxComplexity, { key: 'percent' }) }}</template>
+          <template #attempts>{{ selectedPreset.ciMaxAttempts }}</template>
+        </i18n-t>
+        <!-- Auto-merge off: the ceilings never apply, so quoting them would misdescribe it. -->
+        <i18n-t v-else keypath="inspector.runSettings.riskPolicyManual" tag="span" scope="global">
+          <template #name>
+            <span class="text-slate-300">{{ selectedPreset.name }}</span>
+          </template>
           <template #attempts>{{ selectedPreset.ciMaxAttempts }}</template>
         </i18n-t>
         <span v-if="!block.riskPolicyId" class="text-slate-500">{{

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

@@ -0,0 +1,145 @@
+import { describe, it, expect } from 'vitest'
+import {
+  findingAttention,
+  orderFindings,
+  reconcileFindingOrder,
+  type FindingRecommendationState,
+  type OrderedFinding,
+} from './RequirementsReviewWindow.logic'
+import type { RequirementReviewItem } from '~/types/requirements'
+
+/**
+ * The findings list's floating order. The point of the feature is that a human working a long
+ * review never has to hunt for what is still on them, so these pin the bucketing (including the
+ * cases where the recommendation state disagrees with the finding's own status), the tie-breaking
+ * that keeps the sort stable, and the pinning rule that stops the list re-sorting under a cursor
+ * without ever letting a stale pin hide a newly-raised finding.
+ */
+const NO_REC: FindingRecommendationState = { pending: false, ready: false }
+
+const item = (
+  id: string,
+  status: RequirementReviewItem['status'],
+  severity: RequirementReviewItem['severity'] = 'medium',
+): RequirementReviewItem => ({
+  id,
+  category: 'question',
+  severity,
+  title: id,
+  detail: `detail for ${id}`,
+  status,
+  reply: null,
+  createdAt: 0,
+  updatedAt: 0,
+})
+
+const order = (
+  items: RequirementReviewItem[],
+  recs: Record<string, FindingRecommendationState> = {},
+) => orderFindings(items, (i) => recs[i.id] ?? NO_REC)
+
+describe('findingAttention', () => {
+  it('puts an unanswered finding on the human', () => {
+    expect(findingAttention(item('a', 'open'), NO_REC)).toBe('action')
+  })
+
+  it('settles a finding the human already reacted to', () => {
+    expect(findingAttention(item('a', 'answered'), NO_REC)).toBe('settled')
+    expect(findingAttention(item('a', 'dismissed'), NO_REC)).toBe('settled')
+    expect(findingAttention(item('a', 'resolved'), NO_REC)).toBe('settled')
+  })
+
+  it('parks a finding whose suggestion is still being generated', () => {
+    expect(
+      findingAttention(item('a', 'recommend_requested'), { pending: true, ready: false }),
+    ).toBe('waiting')
+    // Even one the human never settled: there is nothing to react to until the Writer lands.
+    expect(findingAttention(item('a', 'open'), { pending: true, ready: false })).toBe('waiting')
+  })
+
+  it('returns a finding to the human the moment its suggestion is ready to accept or reject', () => {
+    expect(
+      findingAttention(item('a', 'recommend_requested'), { pending: false, ready: true }),
+    ).toBe('action')
+    // A ready suggestion outranks even an answer already recorded — accept/reject is still owed.
+    expect(findingAttention(item('a', 'answered'), { pending: false, ready: true })).toBe('action')
+  })
+
+  it('returns a recommend-requested finding with nothing in flight to the human', () => {
+    // The suggestion was rejected / never landed: nothing more is coming, so it is back on them.
+    expect(findingAttention(item('a', 'recommend_requested'), NO_REC)).toBe('action')
+  })
+})
+
+describe('orderFindings', () => {
+  it('floats what needs a reaction above what is waiting, above what is handled', () => {
+    const items = [
+      item('handled', 'answered'),
+      item('waiting', 'recommend_requested'),
+      item('needs-me', 'open'),
+    ]
+    expect(
+      order(items, { waiting: { pending: true, ready: false } }).map((entry) => entry.id),
+    ).toEqual(['needs-me', 'waiting', 'handled'])
+  })
+
+  it('keeps severity as the order within a bucket', () => {
+    const items = [item('low', 'open', 'low'), item('high', 'open', 'high'), item('mid', 'open')]
+    expect(order(items).map((entry) => entry.id)).toEqual(['high', 'mid', 'low'])
+  })
+
+  it('breaks ties on the reviewer ordering, so the sort is stable', () => {
+    const items = [item('first', 'open'), item('second', 'open'), item('third', 'open')]
+    expect(order(items).map((entry) => entry.id)).toEqual(['first', 'second', 'third'])
+  })
+
+  it('outranks severity by attention, so a low open finding beats a high handled one', () => {
+    const items = [item('high-handled', 'dismissed', 'high'), item('low-open', 'open', 'low')]
+    expect(order(items).map((entry) => entry.id)).toEqual(['low-open', 'high-handled'])
+  })
+
+  it('tags each entry with the bucket its position came from', () => {
+    const items = [item('a', 'open'), item('b', 'dismissed')]
+    expect(order(items)).toEqual([
+      { id: 'a', attention: 'action' },
+      { id: 'b', attention: 'settled' },
+    ])
+  })
+
+  it('handles an empty review', () => {
+    expect(order([])).toEqual([])
+  })
+})
+
+describe('reconcileFindingOrder', () => {
+  const desired: OrderedFinding[] = [
+    { id: 'a', attention: 'action' },
+    { id: 'b', attention: 'settled' },
+  ]
+
+  it('falls back to the computed order when nothing is pinned', () => {
+    expect(reconcileFindingOrder(desired, null)).toEqual(desired)
+  })
+
+  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' },
+    ]
+    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' }]
+    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' },
+    ]
+    expect(reconcileFindingOrder(desired, pinned)).toEqual(desired)
+  })
+})

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

@@ -0,0 +1,105 @@
+// Pure ordering for the requirements-review window's findings list.
+//
+// A reviewer pass raises its findings in whatever order it produced them, and the human then
+// works down the list answering, dismissing or handing findings to the Requirement Writer. A
+// finding they have dealt with keeps its slot, so on a long review (and on every re-review, which
+// re-raises what is still unresolved alongside what is new) the ones still waiting on a reaction
+// end up scattered between settled ones. This floats what still needs the human to the top and
+// sinks what is already handled, so "what is left for me?" is answered by looking at the top of
+// the list instead of scrolling it end to end.
+//
+// Kept out of the SFC so the bucketing, the comparator and the pinning rule are unit-testable
+// without mounting Nuxt.
+import type { RequirementReviewItem, ReviewItemSeverity } from '~/types/requirements'
+
+/**
+ * How much of the human's attention a finding still wants.
+ * - `action` — the ball is in THEIR court: an unanswered finding, or a Writer suggestion sitting
+ *   there awaiting accept/reject.
+ * - `waiting` — the ball is in the MACHINE's court: the Requirement Writer is still producing a
+ *   suggestion for this finding, so there is nothing to react to yet.
+ * - `settled` — answered, dismissed or resolved; nothing further is owed per-finding (the review
+ *   as a whole still needs the incorporate/proceed decision, which lives in the action rail).
+ */
+export type FindingAttention = 'action' | 'waiting' | 'settled'
+
+/** What the review's recommendation collection currently holds for one finding. */
+export interface FindingRecommendationState {
+  /** A requested suggestion is still being generated by the Writer. */
+  pending: boolean
+  /** A generated suggestion is waiting on the human's accept/reject. */
+  ready: boolean
+}
+
+/** One finding in the rendered order, tagged with the bucket its position came from. */
+export interface OrderedFinding {
+  id: string
+  attention: FindingAttention
+}
+
+const ATTENTION_RANK: Record<FindingAttention, number> = { action: 0, waiting: 1, settled: 2 }
+const SEVERITY_RANK: Record<ReviewItemSeverity, number> = { high: 0, medium: 1, low: 2 }
+
+/**
+ * Which bucket a finding belongs in. The recommendation state OUTRANKS the finding's own status,
+ * because that is where the actionability actually moved: a finding parked in
+ * `recommend_requested` is the human's problem again the moment a suggestion lands (accept or
+ * reject), and is nobody's problem while the Writer is still thinking. A `recommend_requested`
+ * finding with NEITHER a pending nor a ready suggestion has had its recommendation declined or
+ * lost, so nothing more is coming and it is back on the human — the opposite of what its status
+ * alone would suggest.
+ */
+export function findingAttention(
+  item: Pick<RequirementReviewItem, 'status'>,
+  recommendation: FindingRecommendationState,
+): FindingAttention {
+  if (recommendation.ready) return 'action'
+  if (recommendation.pending) return 'waiting'
+  if (item.status === 'open' || item.status === 'recommend_requested') return 'action'
+  return 'settled'
+}
+
+/**
+ * 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.
+ */
+export function orderFindings(
+  items: readonly RequirementReviewItem[],
+  recommendationFor: (item: RequirementReviewItem) => FindingRecommendationState,
+): OrderedFinding[] {
+  return items
+    .map((item, index) => ({
+      id: item.id,
+      attention: findingAttention(item, recommendationFor(item)),
+      severity: item.severity,
+      index,
+    }))
+    .sort(
+      (a, b) =>
+        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 }))
+}
+
+/**
+ * Which order to actually render: the PINNED one while it still covers exactly the same findings,
+ * otherwise the freshly computed one.
+ *
+ * The window pins the order while the human is typing in a finding's box and re-pins once they
+ * leave it, because an answer auto-saves on blur: re-sorting at that exact moment would slide the
+ * card they just clicked into out from under the cursor. Pinning is only ever allowed to hold a
+ * position STALE, never to hide a finding — a reviewer pass that adds or drops findings therefore
+ * invalidates the pin outright rather than rendering a list missing the new ones.
+ */
+export function reconcileFindingOrder(
+  desired: readonly OrderedFinding[],
+  pinned: readonly OrderedFinding[] | null,
+): readonly OrderedFinding[] {
+  if (!pinned || pinned.length !== desired.length) return desired
+  const ids = new Set(desired.map((entry) => entry.id))
+  return pinned.every((entry) => ids.has(entry.id)) ? pinned : desired
+}