@cat-factory/app 0.266.0 → 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/judge/JudgeResultView.vue

@@ -12,6 +12,7 @@ import { agentKindMeta } from '~/utils/catalog'
 import type { JudgeFinding, JudgeStepState } from '~/types/execution'
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
 import CopyButton from '~/components/common/CopyButton.vue'
+import MarkdownProse from '~/components/common/MarkdownProse.vue'
 
 const board = useBoardStore()
 const execution = useExecutionStore()
@@ -190,11 +191,14 @@ async function act(choice: 'proceed' | 'bounce' | 'stop') {
           {{ judge.note }}
         </p>
 
+        <!-- The verdict a human reads. Markdown, because the judge prompt asks for a verdict
+             line plus grouped bullets rather than one paragraph. -->
         <div v-if="verdict?.summary" class="relative mt-3">
           <CopyButton :text="verdict.summary" class="absolute end-1 top-1" />
-          <p class="whitespace-pre-wrap pe-8 text-[13px] leading-relaxed text-slate-200">
-            {{ verdict.summary }}
-          </p>
+          <MarkdownProse
+            :text="verdict.summary"
+            class="pe-8 text-[13px] leading-relaxed text-slate-200"
+          />
         </div>
 
         <section v-if="findings.length" class="mt-4">
@@ -220,12 +224,11 @@ async function act(choice: 'proceed' | 'bounce' | 'stop') {
                   finding.where
                 }}</code>
               </div>
-              <p
+              <MarkdownProse
                 v-if="finding.detail"
-                class="mt-1 whitespace-pre-wrap text-[12px] leading-relaxed text-slate-400"
-              >
-                {{ finding.detail }}
-              </p>
+                :text="finding.detail"
+                class="mt-1 text-[12px] leading-relaxed text-slate-400"
+              />
             </li>
           </ul>
         </section>

package/app/components/panels/StepFragmentAdherence.vue

@@ -6,6 +6,7 @@
 // reviewer reported at least one standard; when none were reachable the reviewer says so in its
 // summary instead (so there is nothing to show here).
 import type { FragmentAdherence } from '~/types/execution'
+import MarkdownProse from '~/components/common/MarkdownProse.vue'
 
 const props = defineProps<{ items: FragmentAdherence }>()
 const { t } = useI18n()
@@ -63,12 +64,11 @@ function label(item: FragmentAdherence[number]): string {
             {{ t('panels.stepDetail.adherence.outOfTen', { value: item.rating }) }}
           </span>
         </div>
-        <p
+        <MarkdownProse
           v-if="item.assessment"
-          class="mt-1 whitespace-pre-wrap text-[12px] leading-relaxed text-slate-300"
-        >
-          {{ item.assessment }}
-        </p>
+          :text="item.assessment"
+          class="mt-1 text-[12px] leading-relaxed text-slate-300"
+        />
         <div v-if="item.relatedFindings.length" class="mt-1.5">
           <p class="text-[10px] font-semibold uppercase tracking-wide text-slate-500">
             {{ t('panels.stepDetail.adherence.relatedFindings') }}

package/app/components/panels/StepMetadataCard.vue

@@ -4,6 +4,8 @@ import type { AgentState, PipelineStep, CompanionVerdict, StepApproval } from '~
 import { subtaskIconClass } from '~/utils/pipelineRender'
 import StepModelActivity from '~/components/observability/StepModelActivity.vue'
 import StepContainerStatus from '~/components/panels/StepContainerStatus.vue'
+import CopyButton from '~/components/common/CopyButton.vue'
+import MarkdownProse from '~/components/common/MarkdownProse.vue'
 
 // The step's metadata card body: state/timing/model/run id, the container cold-boot
 // phase, the live subtask breakdown, the LLM observability rollup, the applied
@@ -281,22 +283,35 @@ async function copyRunId() {
           {{ latestVerdict?.passed ? '≥' : '<' }} {{ pctOf(latestVerdict!.threshold) }}
         </UBadge>
       </div>
-      <ol class="mt-2 space-y-1.5">
-        <li v-for="(v, i) in companionVerdicts" :key="i" class="flex items-start gap-2 text-[12px]">
-          <span
-            class="mt-px inline-flex h-4 shrink-0 items-center rounded px-1 font-mono text-[11px] tabular-nums"
-            :class="
-              v.passed ? 'bg-emerald-500/15 text-emerald-300' : 'bg-amber-500/15 text-amber-300'
-            "
-          >
-            {{ i + 1 }}
-          </span>
-          <div class="min-w-0">
+      <!-- One card per correction round: the score on its own line, then the reviewer's
+           challenge as rendered markdown. The feedback used to trail the score inside the same
+           line, which turned a multi-point review into one unreadable run of text. -->
+      <ol class="mt-2 space-y-2">
+        <li
+          v-for="(v, i) in companionVerdicts"
+          :key="i"
+          data-testid="companion-verdict"
+          class="relative rounded-lg border border-slate-800 bg-slate-900/60 px-3 py-2"
+        >
+          <CopyButton v-if="v.feedback" :text="v.feedback" class="absolute end-1 top-1" />
+          <div class="flex items-center gap-2 text-[12px]">
+            <span
+              class="inline-flex h-4 shrink-0 items-center rounded px-1 font-mono text-[11px] tabular-nums"
+              :class="
+                v.passed ? 'bg-emerald-500/15 text-emerald-300' : 'bg-amber-500/15 text-amber-300'
+              "
+            >
+              {{ i + 1 }}
+            </span>
             <span :class="v.passed ? 'text-emerald-300' : 'text-amber-300'">
               {{ pctOf(v.rating) }} {{ v.passed ? '≥' : '<' }} {{ pctOf(v.threshold) }}
             </span>
-            <span v-if="v.feedback" class="ms-1 text-slate-400">— {{ v.feedback }}</span>
           </div>
+          <MarkdownProse
+            v-if="v.feedback"
+            :text="v.feedback"
+            class="mt-1.5 pe-6 text-[12px] leading-relaxed text-slate-300"
+          />
         </li>
       </ol>
       <p v-if="companionVerdicts.length > 1" class="mt-1 text-[11px] text-slate-500">

package/app/components/panels/StepTestReport.vue

@@ -2,6 +2,7 @@
 import type { RequirementVerdictStatus, TestReport } from '~/types/domain'
 import type { TesterStepState } from '~/types/execution'
 import { resolveVerdictMeta, type VerdictMeta } from './StepTestReport.logic'
+import MarkdownProse from '~/components/common/MarkdownProse.vue'
 
 // A tester step's latest structured report (what was tested, the per-area outcomes,
 // the concerns it raised and the greenlight verdict) plus the fixer-loop phase.
@@ -57,9 +58,11 @@ function verdictMeta(status: RequirementVerdictStatus): VerdictMeta {
         }}<span v-if="phase.phase === 'fixing'"> {{ t('panels.testReport.fixing') }}</span>
       </span>
     </div>
-    <p v-if="report.summary" class="mb-3 text-[13px] leading-relaxed text-slate-300">
-      {{ report.summary }}
-    </p>
+    <MarkdownProse
+      v-if="report.summary"
+      :text="report.summary"
+      class="mb-3 text-[13px] leading-relaxed text-slate-300"
+    />
 
     <div v-if="report.tested.length" class="mb-3">
       <div class="mb-1 text-[11px] text-slate-500">{{ t('panels.testReport.tested') }}</div>
@@ -123,7 +126,7 @@ function verdictMeta(status: RequirementVerdictStatus): VerdictMeta {
           >
           <span class="font-medium text-slate-200">{{ c.title }}</span>
         </div>
-        <p v-if="c.detail" class="mt-1 text-slate-400">{{ c.detail }}</p>
+        <MarkdownProse v-if="c.detail" :text="c.detail" class="mt-1 text-slate-400" />
       </div>
     </div>
   </section>

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/prReview/PrReviewWindow.vue

@@ -29,6 +29,7 @@ import { activeChunkLabels, chunkReviewPercent, hasNoSlicePlan } from '~/utils/p
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
 import StepRunMeta from '~/components/panels/StepRunMeta.vue'
 import StepFragmentAdherence from '~/components/panels/StepFragmentAdherence.vue'
+import MarkdownProse from '~/components/common/MarkdownProse.vue'
 
 const execution = useExecutionStore()
 const board = useBoardStore()
@@ -527,13 +528,13 @@ async function onDismiss(id: string): Promise<void> {
 
           <!-- The reviewer's overall assessment. Prose, so it takes the reading measure (see the
                shell's `width` prop) — this window is `full`-width. -->
-          <p
+          <div
             v-if="state?.summary"
             class="mb-3 max-w-3xl rounded-md bg-slate-800/50 px-3 py-2 text-[12px] text-slate-300"
           >
-            <span class="text-slate-500">{{ t('prReview.summaryLabel') }}</span>
-            {{ state.summary }}
-          </p>
+            <span class="mb-1 block text-slate-500">{{ t('prReview.summaryLabel') }}</span>
+            <MarkdownProse :text="state.summary" />
+          </div>
 
           <!-- Best-practice adherence: per standard folded into the reviewer's prompt, a 1..10
                rating of how well the PR adheres + the issues that standard surfaced. -->
@@ -680,12 +681,17 @@ async function onDismiss(id: string): Promise<void> {
                          bucket to `full`, so these are the three paragraphs the width would
                          otherwise have stretched furthest; the path/line row, the badges and the
                          per-finding actions are what it is actually for. -->
-                    <p
-                      class="mt-1 max-w-3xl whitespace-pre-wrap text-[12px] text-slate-300"
+                    <MarkdownProse
+                      v-if="f.detail"
+                      :text="f.detail"
+                      class="mt-1 max-w-3xl text-[12px] text-slate-300"
                       :class="isRetracted(f) ? 'line-through' : ''"
-                    >
-                      {{ f.detail }}
-                    </p>
+                    />
+                    <!-- The suggested fix is a VALUE a human copies (a patch line, a command, a
+                         path), not prose, so it stays preformatted: markdown would emphasise the
+                         `__dunder__` in an identifier, curl the quotes in a command, and drop the
+                         indentation of anything longer than a line. Same reason the CI gate's
+                         failure summary is left alone. -->
                     <p
                       v-if="f.suggestedFix"
                       class="mt-1 max-w-3xl whitespace-pre-wrap rounded-md bg-slate-800/50 px-2 py-1 text-[11px] text-slate-300"
@@ -696,10 +702,10 @@ async function onDismiss(id: string): Promise<void> {
 
                     <!-- The investigator's justification (why the finding holds up / was retracted),
                        or the reason the challenge investigation failed. -->
-                    <p
+                    <div
                       v-if="f.challenge?.justification"
                       data-testid="pr-review-finding-justification"
-                      class="mt-1.5 max-w-3xl whitespace-pre-wrap rounded-md px-2 py-1 text-[11px]"
+                      class="mt-1.5 max-w-3xl rounded-md px-2 py-1 text-[11px]"
                       :class="
                         isRetracted(f)
                           ? 'bg-rose-500/10 text-rose-200'
@@ -708,13 +714,16 @@ async function onDismiss(id: string): Promise<void> {
                             : 'bg-sky-500/10 text-sky-200'
                       "
                     >
-                      <span class="font-medium">{{
+                      <!-- A label that used to prefix its value inline now heads the block the
+                           rendered prose became, so it needs to READ as a heading line rather than
+                           as a stray word above a paragraph. -->
+                      <span class="mb-1 block font-medium">{{
                         isChallengeFailed(f)
                           ? t('prReview.challenge.failedLabel')
                           : t('prReview.challenge.verdictLabel')
                       }}</span>
-                      {{ f.challenge.justification }}
-                    </p>
+                      <MarkdownProse :text="f.challenge.justification" />
+                    </div>
 
                     <!-- Per-finding actions: Challenge + Dismiss (only while awaiting a selection). -->
                     <div

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 }))
 }
 
 /**