@cat-factory/app 0.270.3 → 0.271.0

package/app/components/panels/AgentStepDetail.vue

@@ -13,7 +13,7 @@ import StepFragmentAdherence from '~/components/panels/StepFragmentAdherence.vue
 import BinaryOutputReport from '~/components/binaryOutput/BinaryOutputReport.vue'
 import EnvironmentStatusPanel from '~/components/environments/EnvironmentStatusPanel.vue'
 import FrontendBindingsResolved from '~/components/panels/inspector/FrontendBindingsResolved.vue'
-import { UI_TESTER_AGENT_KIND } from '@cat-factory/contracts'
+import { UI_TESTER_AGENT_KIND, blockingReviewComments } from '@cat-factory/contracts'
 import type { GateApprovalRefusal } from '@cat-factory/contracts'
 import ProvisioningLogsDrawer from '~/components/provisioning/ProvisioningLogsDrawer.vue'
 import IterationCapPrompt from '~/components/pipeline/IterationCapPrompt.vue'
@@ -171,10 +171,31 @@ const proposalEditable = computed(() => step.value?.outputIsRendered !== true)
 // approve/request-changes/reject rail, it shows the shared iteration-cap prompt
 // (one more round / proceed / stop & reset), resolved through its own endpoint.
 const companionExceeded = computed(() => approvalPending.value && !!step.value?.companion?.exceeded)
+/**
+ * The must-fix findings the reviewer left open on its last round.
+ *
+ * They are why the cap prompts read differently, and the difference is not cosmetic: a cap
+ * reached on the rating alone is the loop reporting that this is as good as it got, while an open
+ * blocker is the reviewer saying the work must not go on as it stands. That second one is also the
+ * park no risk policy will answer, so the person reading it is the only route past it and should
+ * be told what they are being asked to overrule.
+ */
+const blockingFindings = computed(() => blockingReviewComments(latestVerdict.value?.comments))
 // The SAME park, reached for the opposite reason: the loop was abandoned with rounds still on the
 // budget because the producer handed back the work it was asked to change and the rating did not
 // move. The three choices are identical, so this only picks the wording — the cap copy states a
 // spent limit, which is a false claim about this park (`companion.stalled`).
+//
+// It can hold TOGETHER with `blockingFindings`, and that pair is what splits the wording across
+// the two slots rather than ranking them: the HEADING says how the loop ended (a stalled one did
+// not reach its limit, so only it may say so) and the DETAIL says what this person is being asked
+// to decide (an open blocker outranks a bar that went unmet, and its copy claims nothing about
+// rounds). Neither slot can then state something untrue of the park it is describing.
+//
+// Which is why the stalled heading claims nothing about the RATING either. Standing still is
+// unchanged output at an unmoved rating (`companionLoopStalled`), never a rating under the bar: a
+// round held by an open blocker fails at a rating that cleared it, and the copy said "the rating
+// held below the 80% bar" over a 95% one. What the number was is on the verdict card above.
 const companionStalled = computed(() => companionExceeded.value && !!step.value?.companion?.stalled)
 // A park a DEDICATED window owns (fork choice / follow-up triage): the generic approve
 // resolver refuses these server-side, so the rail is replaced by a redirect to that window.
@@ -492,10 +513,12 @@ async function copyOutput() {
                 :step-index="ctx?.stepIndex ?? null"
               />
 
-              <!-- companion rework budget spent, OR the loop abandoned early as unproductive:
-                   the shared iteration-cap decision (one more round / proceed with the current
-                   output / stop & reset). One prompt, two headings — the choices are the same but
-                   the reason is not, and the spent-limit wording is untrue of a stalled loop. -->
+              <!-- companion rework budget spent, OR the loop abandoned early as unproductive,
+                   with or without must-fix findings still open: the shared iteration-cap decision
+                   (one more round / proceed with the current output / stop & reset). One prompt,
+                   and the two slots are picked on different facts — the choices are the same but
+                   the reason is not, the spent-limit wording is untrue of a stalled loop, and an
+                   open blocker is what the person is actually being asked to overrule. -->
               <IterationCapPrompt
                 v-if="companionExceeded"
                 :heading="
@@ -504,18 +527,29 @@ async function copyOutput() {
                         agent: agent.label,
                         attempts: step.companion?.attempts,
                         maxAttempts: step.companion?.maxAttempts,
-                        threshold: pctOf(latestVerdict?.threshold ?? 0),
-                      })
-                    : t('panels.stepDetail.companionCapHeading', {
-                        agent: agent.label,
-                        attempts: step.companion?.maxAttempts,
-                        threshold: pctOf(latestVerdict?.threshold ?? 0),
                       })
+                    : blockingFindings.length
+                      ? t(
+                          'panels.stepDetail.companionCapBlockedHeading',
+                          {
+                            agent: agent.label,
+                            attempts: step.companion?.maxAttempts,
+                            count: blockingFindings.length,
+                          },
+                          blockingFindings.length,
+                        )
+                      : t('panels.stepDetail.companionCapHeading', {
+                          agent: agent.label,
+                          attempts: step.companion?.maxAttempts,
+                          threshold: pctOf(latestVerdict?.threshold ?? 0),
+                        })
                 "
                 :detail="
-                  companionStalled
-                    ? t('panels.stepDetail.companionStalledDetail')
-                    : t('panels.stepDetail.companionCapDetail')
+                  blockingFindings.length
+                    ? t('panels.stepDetail.companionCapBlockedDetail')
+                    : companionStalled
+                      ? t('panels.stepDetail.companionStalledDetail')
+                      : t('panels.stepDetail.companionCapDetail')
                 "
                 :loading="resolvingCap"
                 @resolve="resolveCompanionCap"

package/app/components/panels/StepMetadataCard.vue

@@ -1,6 +1,12 @@
 <script setup lang="ts">
 import { computed } from 'vue'
+import {
+  bySeverityWorstFirst,
+  isReviewCommentSeverity,
+  type ReviewCommentSeverity,
+} from '@cat-factory/contracts'
 import type { AgentState, PipelineStep, CompanionVerdict, StepApproval } from '~/types/execution'
+import type { BadgeColor } from '~/utils/badge'
 import { subtaskIconClass } from '~/utils/pipelineRender'
 import StepModelActivity from '~/components/observability/StepModelActivity.vue'
 import StepContainerStatus from '~/components/panels/StepContainerStatus.vue'
@@ -65,6 +71,71 @@ const ITEM_ICON: Record<string, string> = {
 
 const pctOf = (n: number) => `${Math.round(n * 100)}%`
 
+/**
+ * The colour each finding grade renders at. `ungraded` is its own member rather than a fallback
+ * arm: a person's comment carries no severity and neither does a verdict recorded before reviewers
+ * graded anything, and painting either of those `major` would put a level on the screen that
+ * nobody chose. `unrecognized` is the same argument for the other direction (see
+ * {@link findingGrade}). An exhaustive `Record` so a severity added to the contract fails to
+ * compile here, typed against the shared `BadgeColor` rather than a hand-picked subset of it.
+ */
+const SEVERITY_COLOR: Record<ReviewCommentSeverity | 'ungraded' | 'unrecognized', BadgeColor> = {
+  blocker: 'error',
+  major: 'warning',
+  minor: 'neutral',
+  ungraded: 'neutral',
+  unrecognized: 'neutral',
+}
+
+/**
+ * How one finding's grade renders: the level itself, or which of the two NON-levels it is.
+ *
+ * `unrecognized` is what a level this build has retired reads as. The severity vocabulary is closed
+ * but persisted, and a stored verdict is mapped onto the type rather than re-parsed, so the schema's
+ * `major` fallback never runs on this path (contracts' `isReviewCommentSeverity` states the rule).
+ * Left unnarrowed the value indexes both maps and comes back `undefined`, which renders an unstyled
+ * badge over a raw i18n key; guessed onto a current level it would show an urgency nobody graded, on
+ * the panel asking a person to act on it. So it is NAMED, and the copy carries the stored value.
+ */
+function findingGrade(severity: string | undefined): {
+  key: ReviewCommentSeverity | 'ungraded' | 'unrecognized'
+  level: string
+} {
+  if (severity === undefined) return { key: 'ungraded', level: '' }
+  if (isReviewCommentSeverity(severity)) return { key: severity, level: severity }
+  return { key: 'unrecognized', level: severity }
+}
+
+/**
+ * Each round paired with its findings, worst first (the order the reviewer's asks should be worked
+ * in) and each finding with its resolved grade.
+ *
+ * A `computed` rather than methods the template calls, because a run panel re-renders on every
+ * pushed instance update while the template needs the list twice per round (the `v-if` and the
+ * `v-for`) and the grade three times per finding: as methods that is a copy, a sort and a narrowing
+ * per reader per push, all off state that only changes when a verdict lands.
+ */
+const verdictRounds = computed(() =>
+  props.companionVerdicts.map((verdict) => ({
+    verdict,
+    findings: bySeverityWorstFirst(verdict.comments ?? []).map((finding) => ({
+      body: finding.body,
+      grade: findingGrade(finding.severity),
+    })),
+  })),
+)
+
+/**
+ * Whether this round's rating actually reached its bar.
+ *
+ * Distinct from the verdict's own `passed`, which is what the ENGINE decided and can be `false` at a
+ * rating well above the threshold: an open `blocker` holds the step whatever the number says. The
+ * two were one expression, so the panel printed a false inequality over the findings that explained
+ * it. `>=` matches kernel's `disposeCompanionVerdict`, where a threshold typed by an operator must be
+ * met exactly by a rating equal to it.
+ */
+const ratingMeetsBar = (verdict: CompanionVerdict) => verdict.rating >= verdict.threshold
+
 const APPROVAL_STATUS_KEYS: Record<StepApproval['status'], string> = {
   pending: 'panels.stepMeta.approvalStatus.pending',
   approved: 'panels.stepMeta.approvalStatus.approved',
@@ -278,17 +349,23 @@ async function copyRunId() {
         <span class="text-[11px] uppercase tracking-wide text-slate-500">
           {{ t('panels.stepMeta.companionReview') }}
         </span>
+        <!-- The COLOUR is the verdict (`passed`) and the GLYPH is the arithmetic, which are no
+             longer the same fact: a round holding an open `blocker` fails at a rating that cleared
+             its bar, and reading the inequality off `passed` printed "95% < 80%" over the findings
+             explaining why. -->
         <UBadge :color="latestVerdict?.passed ? 'success' : 'warning'" variant="subtle" size="sm">
           {{ pctOf(latestVerdict!.rating) }}
-          {{ latestVerdict?.passed ? '≥' : '<' }} {{ pctOf(latestVerdict!.threshold) }}
+          {{ ratingMeetsBar(latestVerdict!) ? '≥' : '<' }} {{ pctOf(latestVerdict!.threshold) }}
         </UBadge>
       </div>
-      <!-- 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. -->
+      <!-- One card per correction round: the score on its own line, then the reviewer's verdict
+           as rendered markdown, then its graded findings worst first. The feedback used to trail
+           the score inside the same line, which turned a multi-point review into one unreadable
+           run of text; the findings used not to be rendered at all, so a "must fix" holding the
+           run was invisible to the person being asked to resolve it. -->
       <ol class="mt-2 space-y-2">
         <li
-          v-for="(v, i) in companionVerdicts"
+          v-for="({ verdict: v, findings }, i) in verdictRounds"
           :key="i"
           data-testid="companion-verdict"
           class="relative rounded-lg border border-slate-800 bg-slate-900/60 px-3 py-2"
@@ -304,14 +381,36 @@ async function copyRunId() {
               {{ i + 1 }}
             </span>
             <span :class="v.passed ? 'text-emerald-300' : 'text-amber-300'">
-              {{ pctOf(v.rating) }} {{ v.passed ? '≥' : '<' }} {{ pctOf(v.threshold) }}
+              {{ pctOf(v.rating) }} {{ ratingMeetsBar(v) ? '≥' : '<' }} {{ pctOf(v.threshold) }}
             </span>
           </div>
           <MarkdownProse
             v-if="v.feedback"
             :text="v.feedback"
+            data-testid="companion-verdict-summary"
             class="mt-1.5 pe-6 text-[12px] leading-relaxed text-slate-300"
           />
+          <ul v-if="findings.length" class="mt-2 space-y-1.5">
+            <li
+              v-for="(finding, fi) in findings"
+              :key="fi"
+              data-testid="companion-finding"
+              class="flex gap-2"
+            >
+              <UBadge
+                :color="SEVERITY_COLOR[finding.grade.key]"
+                variant="subtle"
+                size="sm"
+                class="mt-px h-4 shrink-0"
+              >
+                {{ t(`panels.stepMeta.findingSeverity.${finding.grade.key}`, finding.grade) }}
+              </UBadge>
+              <MarkdownProse
+                :text="finding.body"
+                class="min-w-0 text-[12px] leading-relaxed text-slate-300"
+              />
+            </li>
+          </ul>
         </li>
       </ol>
       <p v-if="companionVerdicts.length > 1" class="mt-1 text-[11px] text-slate-500">

package/i18n/locales/de.json

@@ -2033,6 +2033,13 @@
       "awaitingChoice": "Wartet auf eine menschliche Wahl",
       "approvalGate": "Freigabe-Gate",
       "companionReview": "Begleiter-Prüfung",
+      "findingSeverity": {
+        "blocker": "Muss behoben werden",
+        "major": "Sollte behoben werden",
+        "minor": "Geringfügig",
+        "ungraded": "Kommentar",
+        "unrecognized": "Unbekannte Stufe ({level})"
+      },
       "correctionIterations": "{count} Korrekturiteration. | {count} Korrekturiterationen.",
       "state": {
         "pending": "Ausstehend",
@@ -2069,7 +2076,9 @@
       "closeEsc": "Schließen (Esc)",
       "companionCapHeading": "{agent} hat sein Überarbeitungslimit von {attempts} Versuchen erreicht, noch unter der {threshold}-Schwelle.",
       "companionCapDetail": "Führe eine weitere automatische Überarbeitungsrunde durch, fahre mit dem nächsten Schritt fort und akzeptiere die aktuelle Ausgabe, oder stoppe und setze die Aufgabe zurück, damit du die Eingaben bearbeiten und erneut einreichen kannst.",
-      "companionStalledHeading": "{agent} hat die Überarbeitungsschleife nach {attempts} von {maxAttempts} Runden gestoppt: Die letzte Überarbeitung kam unverändert zurück und die Bewertung blieb unter der {threshold}-Schwelle.",
+      "companionCapBlockedHeading": "{agent} hat sein Überarbeitungslimit von {attempts} Versuchen erreicht, {count} zwingender Befund ist weiterhin offen. | {agent} hat sein Überarbeitungslimit von {attempts} Versuchen erreicht, {count} zwingende Befunde sind weiterhin offen.",
+      "companionCapBlockedDetail": "Fortfahren akzeptiert die Arbeit mit diesen ungelösten Befunden, deshalb trifft die Risikorichtlinie dieses Laufs diese Wahl nie für dich. Führe eine weitere automatische Überarbeitungsrunde durch, fahre trotzdem mit der aktuellen Ausgabe fort, oder stoppe und setze die Aufgabe zurück, damit du die Eingaben bearbeiten und erneut einreichen kannst.",
+      "companionStalledHeading": "{agent} hat die Überarbeitungsschleife nach {attempts} von {maxAttempts} Runden gestoppt: Die letzte Überarbeitung kam unverändert zurück und die Bewertung hat sich nicht verändert.",
       "companionStalledDetail": "Die restlichen Runden bleiben ungenutzt, weil sie nur ein bereits abgegebenes Urteil wiederholen würden. Führe trotzdem eine weitere Runde durch, fahre mit dem nächsten Schritt fort und akzeptiere die aktuelle Ausgabe, oder stoppe und setze die Aufgabe zurück, damit du die Eingaben bearbeiten und erneut einreichen kannst.",
       "infraAttempts": "Infrastruktur-Versuche",
       "hideInfraAttempts": "Infrastruktur-Versuche ausblenden",

package/i18n/locales/en.json

@@ -1458,6 +1458,13 @@
       "awaitingChoice": "Awaiting a human choice",
       "approvalGate": "Approval gate",
       "companionReview": "Companion review",
+      "findingSeverity": {
+        "blocker": "Must fix",
+        "major": "Should fix",
+        "minor": "Minor",
+        "ungraded": "Comment",
+        "unrecognized": "Level not recognised ({level})"
+      },
       "correctionIterations": "{count} correction iteration. | {count} correction iterations.",
       "state": {
         "pending": "Pending",
@@ -1494,7 +1501,9 @@
       "closeEsc": "Close (Esc)",
       "companionCapHeading": "{agent} hit its {attempts}-attempt rework limit, still below the {threshold} bar.",
       "companionCapDetail": "Do one more automatic rework round, proceed to the next step accepting the current output, or stop and reset the task so you can edit the inputs and resubmit.",
-      "companionStalledHeading": "{agent} stopped the rework loop after {attempts} of {maxAttempts} rounds: the last revision came back unchanged and the rating held below the {threshold} bar.",
+      "companionCapBlockedHeading": "{agent} hit its {attempts}-attempt rework limit with {count} must-fix finding still open. | {agent} hit its {attempts}-attempt rework limit with {count} must-fix findings still open.",
+      "companionCapBlockedDetail": "Proceeding accepts the work with those findings unfixed, which is why this run’s risk policy will never take that choice for you. Do one more automatic rework round, proceed anyway on the current output, or stop and reset the task so you can edit the inputs and resubmit.",
+      "companionStalledHeading": "{agent} stopped the rework loop after {attempts} of {maxAttempts} rounds: the last revision came back unchanged and its rating did not move.",
       "companionStalledDetail": "The remaining rounds were left unspent because they would only repeat a verdict already given. Do one more round anyway, proceed to the next step accepting the current output, or stop and reset the task so you can edit the inputs and resubmit.",
       "infraAttempts": "Infrastructure attempts",
       "hideInfraAttempts": "Hide infrastructure attempts",

package/i18n/locales/es.json

@@ -1348,6 +1348,13 @@
       "awaitingChoice": "Esperando una elección humana",
       "approvalGate": "Verificación de aprobación",
       "companionReview": "Revisión del acompañante",
+      "findingSeverity": {
+        "blocker": "Debe corregirse",
+        "major": "Debería corregirse",
+        "minor": "Menor",
+        "ungraded": "Comentario",
+        "unrecognized": "Nivel no reconocido ({level})"
+      },
       "correctionIterations": "{count} iteración de corrección. | {count} iteraciones de corrección.",
       "state": {
         "pending": "Pendiente",
@@ -1403,7 +1410,9 @@
       "closeEsc": "Cerrar (Esc)",
       "companionCapHeading": "{agent} alcanzó su límite de {attempts} intentos de reelaboración, aún por debajo del umbral de {threshold}.",
       "companionCapDetail": "Haz una ronda más de reelaboración automática, avanza al siguiente paso aceptando la salida actual, o detén y restablece la tarea para que puedas editar las entradas y reenviarla.",
-      "companionStalledHeading": "{agent} detuvo el bucle de reelaboración tras {attempts} de {maxAttempts} rondas: la última revisión volvió sin cambios y la puntuación se mantuvo por debajo del umbral de {threshold}.",
+      "companionCapBlockedHeading": "{agent} alcanzó su límite de {attempts} intentos de reelaboración con {count} hallazgo obligatorio aún sin resolver. | {agent} alcanzó su límite de {attempts} intentos de reelaboración con {count} hallazgos obligatorios aún sin resolver.",
+      "companionCapBlockedDetail": "Continuar acepta el trabajo con esos hallazgos sin resolver, por eso la política de riesgo de esta ejecución nunca tomará esa decisión por ti. Haz una ronda más de reelaboración automática, continúa igualmente con la salida actual, o detén y restablece la tarea para que puedas editar las entradas y reenviarla.",
+      "companionStalledHeading": "{agent} detuvo el bucle de reelaboración tras {attempts} de {maxAttempts} rondas: la última revisión volvió sin cambios y la puntuación no se movió.",
       "companionStalledDetail": "Las rondas restantes quedaron sin usar porque solo repetirían un veredicto ya emitido. Haz una ronda más de todos modos, avanza al siguiente paso aceptando la salida actual, o detén y restablece la tarea para que puedas editar las entradas y reenviarla.",
       "infraAttempts": "Intentos de infraestructura",
       "hideInfraAttempts": "Ocultar intentos de infraestructura",

package/i18n/locales/fr.json

@@ -1348,6 +1348,13 @@
       "awaitingChoice": "En attente d'un choix humain",
       "approvalGate": "Gate d'approbation",
       "companionReview": "Revue du compagnon",
+      "findingSeverity": {
+        "blocker": "À corriger absolument",
+        "major": "À corriger",
+        "minor": "Mineur",
+        "ungraded": "Commentaire",
+        "unrecognized": "Niveau non reconnu ({level})"
+      },
       "correctionIterations": "{count} itération de correction. | {count} itérations de correction.",
       "state": {
         "pending": "En attente",
@@ -1403,7 +1410,9 @@
       "closeEsc": "Fermer (Esc)",
       "companionCapHeading": "{agent} a atteint sa limite de {attempts} tentatives de retravail, toujours en dessous du seuil {threshold}.",
       "companionCapDetail": "Effectuer un tour de retravail automatique supplémentaire, passer à l'étape suivante en acceptant la sortie actuelle, ou arrêter et réinitialiser la tâche pour modifier les entrées et la resoumettre.",
-      "companionStalledHeading": "{agent} a arrêté la boucle de retravail après {attempts} tours sur {maxAttempts} : la dernière révision est revenue inchangée et la note est restée sous le seuil {threshold}.",
+      "companionCapBlockedHeading": "{agent} a atteint sa limite de {attempts} tentatives de retravail avec {count} point bloquant encore ouvert. | {agent} a atteint sa limite de {attempts} tentatives de retravail avec {count} points bloquants encore ouverts.",
+      "companionCapBlockedDetail": "Poursuivre revient à accepter le travail avec ces points non corrigés, c’est pourquoi la politique de risque de cette exécution ne prendra jamais cette décision à votre place. Effectuer un tour de retravail automatique supplémentaire, poursuivre malgré tout avec la sortie actuelle, ou arrêter et réinitialiser la tâche pour modifier les entrées et la resoumettre.",
+      "companionStalledHeading": "{agent} a arrêté la boucle de retravail après {attempts} tours sur {maxAttempts} : la dernière révision est revenue inchangée et la note n'a pas bougé.",
       "companionStalledDetail": "Les tours restants n'ont pas été utilisés car ils ne feraient que répéter un verdict déjà rendu. Effectuer tout de même un tour supplémentaire, passer à l'étape suivante en acceptant la sortie actuelle, ou arrêter et réinitialiser la tâche pour modifier les entrées et la resoumettre.",
       "infraAttempts": "Tentatives d'infrastructure",
       "hideInfraAttempts": "Masquer les tentatives d'infrastructure",

package/i18n/locales/he.json

@@ -1367,6 +1367,13 @@
       "awaitingChoice": "ממתין לבחירה אנושית",
       "approvalGate": "שער אישור",
       "companionReview": "סקירת מלווה",
+      "findingSeverity": {
+        "blocker": "חובה לתקן",
+        "major": "כדאי לתקן",
+        "minor": "מינורי",
+        "ungraded": "הערה",
+        "unrecognized": "רמה לא מזוהה ({level})"
+      },
       "correctionIterations": "מחזור תיקון אחד. | שני מחזורי תיקון. | {count} מחזורי תיקון.",
       "state": {
         "pending": "ממתין",
@@ -1403,7 +1410,9 @@
       "closeEsc": "סגור (Esc)",
       "companionCapHeading": "{agent} הגיע למגבלת {attempts} ניסיונות עיבוד מחדש, ועדיין מתחת לרף {threshold}.",
       "companionCapDetail": "בצע סבב עיבוד אוטומטי נוסף, המשך לשלב הבא תוך קבלת הפלט הנוכחי, או עצור ואפס את המשימה כדי לערוך את הקלטים ולשלוח מחדש.",
-      "companionStalledHeading": "{agent} עצר את לופ העיבוד מחדש לאחר {attempts} מתוך {maxAttempts} סבבים: הגרסה האחרונה חזרה ללא שינוי והדירוג נשאר מתחת לרף {threshold}.",
+      "companionCapBlockedHeading": "{agent} הגיע למגבלת {attempts} ניסיונות עיבוד מחדש, וממצא חובה אחד עדיין פתוח. | {agent} הגיע למגבלת {attempts} ניסיונות עיבוד מחדש, ושני ממצאי חובה עדיין פתוחים. | {agent} הגיע למגבלת {attempts} ניסיונות עיבוד מחדש, ו-{count} ממצאי חובה עדיין פתוחים.",
+      "companionCapBlockedDetail": "המשך פירושו קבלת העבודה בלי שהממצאים האלה תוקנו, ולכן מדיניות הסיכון של הריצה הזו לעולם לא תבחר בכך במקומך. בצע סבב עיבוד אוטומטי נוסף, המשך בכל זאת עם הפלט הנוכחי, או עצור ואפס את המשימה כדי לערוך את הקלטים ולשלוח מחדש.",
+      "companionStalledHeading": "{agent} עצר את לופ העיבוד מחדש לאחר {attempts} מתוך {maxAttempts} סבבים: הגרסה האחרונה חזרה ללא שינוי והדירוג לא זז.",
       "companionStalledDetail": "הסבבים שנותרו לא נוצלו מפני שהם רק יחזרו על שיפוט שכבר ניתן. אפשר לבצע סבב נוסף בכל זאת, להמשיך לשלב הבא תוך קבלת הפלט הנוכחי, או לעצור ולאפס את המשימה כדי לערוך את הקלטים ולשלוח מחדש.",
       "infraAttempts": "ניסיונות תשתית",
       "hideInfraAttempts": "הסתר ניסיונות תשתית",

package/i18n/locales/it.json

@@ -2033,6 +2033,13 @@
       "awaitingChoice": "In attesa di una scelta umana",
       "approvalGate": "Gate di approvazione",
       "companionReview": "Revisione companion",
+      "findingSeverity": {
+        "blocker": "Da correggere",
+        "major": "Da sistemare",
+        "minor": "Minore",
+        "ungraded": "Commento",
+        "unrecognized": "Livello non riconosciuto ({level})"
+      },
       "correctionIterations": "{count} iterazione di correzione. | {count} iterazioni di correzione.",
       "state": {
         "pending": "In attesa",
@@ -2069,7 +2076,9 @@
       "closeEsc": "Chiudi (Esc)",
       "companionCapHeading": "{agent} ha raggiunto il suo limite di {attempts} tentativi di rielaborazione, ancora al di sotto della soglia {threshold}.",
       "companionCapDetail": "Esegui un altro ciclo di rielaborazione automatica, procedi al passaggio successivo accettando l'output attuale, oppure arresta e reimposta l'attivita' cosi' da poter modificare gli input e reinviare.",
-      "companionStalledHeading": "{agent} ha interrotto il ciclo di rielaborazione dopo {attempts} round su {maxAttempts}: l'ultima revisione e' tornata identica e il punteggio e' rimasto sotto la soglia {threshold}.",
+      "companionCapBlockedHeading": "{agent} ha raggiunto il suo limite di {attempts} tentativi di rielaborazione con {count} rilievo bloccante ancora aperto. | {agent} ha raggiunto il suo limite di {attempts} tentativi di rielaborazione con {count} rilievi bloccanti ancora aperti.",
+      "companionCapBlockedDetail": "Procedere significa accettare il lavoro con quei rilievi irrisolti, per questo la policy di rischio di questa esecuzione non prendera' mai quella decisione al posto tuo. Esegui un altro ciclo di rielaborazione automatica, procedi comunque con l'output attuale, oppure arresta e reimposta l'attivita' cosi' da poter modificare gli input e reinviare.",
+      "companionStalledHeading": "{agent} ha interrotto il ciclo di rielaborazione dopo {attempts} round su {maxAttempts}: l'ultima revisione e' tornata identica e il punteggio non e' cambiato.",
       "companionStalledDetail": "I round rimanenti non sono stati usati perche' avrebbero solo ripetuto un verdetto gia' espresso. Esegui comunque un altro round, procedi al passaggio successivo accettando l'output attuale, oppure arresta e reimposta l'attivita' cosi' da poter modificare gli input e reinviare.",
       "infraAttempts": "Tentativi di infrastruttura",
       "hideInfraAttempts": "Nascondi i tentativi di infrastruttura",

package/i18n/locales/ja.json

@@ -1367,6 +1367,13 @@
       "awaitingChoice": "人による選択を待機中",
       "approvalGate": "承認ゲート",
       "companionReview": "コンパニオンレビュー",
+      "findingSeverity": {
+        "blocker": "要修正",
+        "major": "修正推奨",
+        "minor": "軽微",
+        "ungraded": "コメント",
+        "unrecognized": "未知のレベル ({level})"
+      },
       "correctionIterations": "{count} 回の修正イテレーション。 | {count} 回の修正イテレーション。",
       "state": {
         "pending": "保留中",
@@ -1403,7 +1410,9 @@
       "closeEsc": "閉じる (Esc)",
       "companionCapHeading": "{agent} は {attempts} 回の再作業上限に達しましたが、まだ {threshold} の基準を下回っています。",
       "companionCapDetail": "自動の再作業をもう1回実行するか、現在の出力を受け入れて次のステップに進むか、タスクを停止してリセットし、入力を編集して再送信してください。",
-      "companionStalledHeading": "{agent} は {maxAttempts} 回のうち {attempts} 回で再作業ループを停止しました。直前の修正が変更されずに返され、評価も {threshold} の基準を下回ったままでした。",
+      "companionCapBlockedHeading": "{agent} は {attempts} 回の再作業上限に達しましたが、要修正の指摘が {count} 件残っています。 | {agent} は {attempts} 回の再作業上限に達しましたが、要修正の指摘が {count} 件残っています。",
+      "companionCapBlockedDetail": "このまま進めると、これらの指摘が未修正のまま作業を受け入れることになります。そのため、この実行のリスクポリシーがこの選択を代わりに行うことはありません。自動の再作業をもう1回実行するか、現在の出力のまま進めるか、タスクを停止してリセットし、入力を編集して再送信してください。",
+      "companionStalledHeading": "{agent} は {maxAttempts} 回のうち {attempts} 回で再作業ループを停止しました。直前の修正が変更されずに返され、評価も動きませんでした。",
       "companionStalledDetail": "残りの回数は、すでに出された判定を繰り返すだけなので使われていません。それでももう1回実行するか、現在の出力を受け入れて次のステップに進むか、タスクを停止してリセットし、入力を編集して再送信してください。",
       "infraAttempts": "インフラの試行",
       "hideInfraAttempts": "インフラの試行を非表示",

package/i18n/locales/pl.json

@@ -1348,6 +1348,13 @@
       "awaitingChoice": "Oczekiwanie na wybór człowieka",
       "approvalGate": "Bramka zatwierdzenia",
       "companionReview": "Recenzja towarzysza",
+      "findingSeverity": {
+        "blocker": "Blokujące",
+        "major": "Do poprawy",
+        "minor": "Drobne",
+        "ungraded": "Komentarz",
+        "unrecognized": "Nierozpoznany poziom ({level})"
+      },
       "correctionIterations": "{count} iteracja korekty. | {count} iteracje korekty. | {count} iteracji korekty.",
       "state": {
         "pending": "Oczekuje",
@@ -1403,7 +1410,9 @@
       "closeEsc": "Zamknij (Esc)",
       "companionCapHeading": "{agent} osiągnął limit {attempts} prób przeróbki, wciąż poniżej progu {threshold}.",
       "companionCapDetail": "Wykonaj jeszcze jedną automatyczną rundę przeróbki, przejdź do następnego kroku akceptując bieżący wynik, albo zatrzymaj i zresetuj zadanie, aby edytować dane wejściowe i przesłać ponownie.",
-      "companionStalledHeading": "{agent} zatrzymał pętlę przeróbek po {attempts} z {maxAttempts} rund: ostatnia poprawka wróciła bez zmian, a ocena pozostała poniżej progu {threshold}.",
+      "companionCapBlockedHeading": "{agent} osiągnął limit {attempts} prób przeróbki, a {count} uwaga blokująca pozostaje otwarta. | {agent} osiągnął limit {attempts} prób przeróbki, a {count} uwagi blokujące pozostają otwarte. | {agent} osiągnął limit {attempts} prób przeróbki, a {count} uwag blokujących pozostaje otwartych.",
+      "companionCapBlockedDetail": "Kontynuacja oznacza przyjęcie pracy z tymi nienaprawionymi uwagami, dlatego polityka ryzyka tego przebiegu nigdy nie podejmie takiej decyzji za ciebie. Wykonaj jeszcze jedną automatyczną rundę przeróbki, kontynuuj mimo to z bieżącym wynikiem, albo zatrzymaj i zresetuj zadanie, aby edytować dane wejściowe i przesłać ponownie.",
+      "companionStalledHeading": "{agent} zatrzymał pętlę przeróbek po {attempts} z {maxAttempts} rund: ostatnia poprawka wróciła bez zmian, a ocena się nie zmieniła.",
       "companionStalledDetail": "Pozostałe rundy nie zostały wykorzystane, bo tylko powtórzyłyby już wydaną ocenę. Wykonaj mimo to jeszcze jedną rundę, przejdź do następnego kroku akceptując bieżący wynik, albo zatrzymaj i zresetuj zadanie, aby edytować dane wejściowe i przesłać ponownie.",
       "infraAttempts": "Próby infrastrukturalne",
       "hideInfraAttempts": "Ukryj próby infrastrukturalne",

package/i18n/locales/tr.json

@@ -1367,6 +1367,13 @@
       "awaitingChoice": "Bir kullanıcı seçimi bekleniyor",
       "approvalGate": "Onay kapısı",
       "companionReview": "Yardımcı incelemesi",
+      "findingSeverity": {
+        "blocker": "Mutlaka düzeltilmeli",
+        "major": "Düzeltilmeli",
+        "minor": "Küçük",
+        "ungraded": "Yorum",
+        "unrecognized": "Tanınmayan düzey ({level})"
+      },
       "correctionIterations": "{count} düzeltme yinelemesi. | {count} düzeltme yinelemesi.",
       "state": {
         "pending": "Beklemede",
@@ -1403,7 +1410,9 @@
       "closeEsc": "Kapat (Esc)",
       "companionCapHeading": "{agent} {attempts} deneme yeniden çalışma sınırına ulaştı, hâlâ {threshold} barının altında.",
       "companionCapDetail": "Bir otomatik yeniden çalışma turu daha yapın, mevcut çıktıyı kabul ederek sonraki adıma geçin ya da durup görevi sıfırlayarak girdileri düzenleyip yeniden gönderin.",
-      "companionStalledHeading": "{agent}, {maxAttempts} turun {attempts} turunda yeniden çalışma döngüsünü durdurdu: son revizyon değişmeden döndü ve puan {threshold} barının altında kaldı.",
+      "companionCapBlockedHeading": "{agent} {attempts} deneme yeniden çalışma sınırına ulaştı, mutlaka düzeltilmesi gereken {count} bulgu hâlâ açık. | {agent} {attempts} deneme yeniden çalışma sınırına ulaştı, mutlaka düzeltilmesi gereken {count} bulgu hâlâ açık.",
+      "companionCapBlockedDetail": "Devam etmek, bu bulgular düzeltilmeden işi kabul etmek demektir; bu yüzden bu çalışmanın risk politikası bu seçimi sizin yerinize asla yapmaz. Bir otomatik yeniden çalışma turu daha yapın, mevcut çıktıyla yine de devam edin ya da durup görevi sıfırlayarak girdileri düzenleyip yeniden gönderin.",
+      "companionStalledHeading": "{agent}, {maxAttempts} turun {attempts} turunda yeniden çalışma döngüsünü durdurdu: son revizyon değişmeden döndü ve puan hiç değişmedi.",
       "companionStalledDetail": "Kalan turlar kullanılmadı, çünkü yalnızca verilmiş bir kararı yineleyeceklerdi. Yine de bir tur daha yapın, mevcut çıktıyı kabul ederek sonraki adıma geçin ya da durup görevi sıfırlayarak girdileri düzenleyip yeniden gönderin.",
       "infraAttempts": "Altyapı denemeleri",
       "hideInfraAttempts": "Altyapı denemelerini gizle",

package/i18n/locales/uk.json

@@ -1348,6 +1348,13 @@
       "awaitingChoice": "Очікування вибору людини",
       "approvalGate": "Гейт затвердження",
       "companionReview": "Огляд компаньйона",
+      "findingSeverity": {
+        "blocker": "Блокувальне",
+        "major": "Треба виправити",
+        "minor": "Незначне",
+        "ungraded": "Коментар",
+        "unrecognized": "Нерозпізнаний рівень ({level})"
+      },
       "correctionIterations": "{count} ітерація виправлення. | {count} ітерації виправлення. | {count} ітерацій виправлення.",
       "state": {
         "pending": "Очікує",
@@ -1403,7 +1410,9 @@
       "closeEsc": "Закрити (Esc)",
       "companionCapHeading": "{agent} досяг ліміту в {attempts} спроб переробки, усе ще нижче планки {threshold}.",
       "companionCapDetail": "Виконайте ще один автоматичний раунд переробки, перейдіть до наступного кроку, прийнявши поточний вивід, або зупиніться та скиньте завдання, щоб відредагувати вхідні дані й надіслати повторно.",
-      "companionStalledHeading": "{agent} зупинив цикл переробки після {attempts} з {maxAttempts} раундів: остання версія повернулася без змін, а оцінка залишилася нижче планки {threshold}.",
+      "companionCapBlockedHeading": "{agent} досяг ліміту в {attempts} спроб переробки, {count} блокувальне зауваження досі відкрите. | {agent} досяг ліміту в {attempts} спроб переробки, {count} блокувальні зауваження досі відкриті. | {agent} досяг ліміту в {attempts} спроб переробки, {count} блокувальних зауважень досі відкриті.",
+      "companionCapBlockedDetail": "Продовження означає прийняття роботи з невиправленими зауваженнями, тому політика ризику цього запуску ніколи не зробить цей вибір за вас. Виконайте ще один автоматичний раунд переробки, продовжте попри це з поточним виводом, або зупиніться та скиньте завдання, щоб відредагувати вхідні дані й надіслати повторно.",
+      "companionStalledHeading": "{agent} зупинив цикл переробки після {attempts} з {maxAttempts} раундів: остання версія повернулася без змін, а оцінка не змінилася.",
       "companionStalledDetail": "Решта раундів залишилися невикористаними, бо лише повторили б уже винесений висновок. Виконайте ще один раунд усе одно, перейдіть до наступного кроку, прийнявши поточний вивід, або зупиніться та скиньте завдання, щоб відредагувати вхідні дані й надіслати повторно.",
       "infraAttempts": "Спроби інфраструктури",
       "hideInfraAttempts": "Приховати спроби інфраструктури",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.270.3",
+  "version": "0.271.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.41",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.309.0"
+    "@cat-factory/contracts": "0.310.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",