@cat-factory/app 0.147.0 → 0.147.1

package/app/components/prReview/PrReviewWindow.vue

@@ -17,9 +17,11 @@ import type {
   PrReviewResolution,
   PrReviewSeverity,
   PrReviewStepState,
+  StepSubtaskItem,
   StepSubtasks,
 } from '~/types/execution'
 import { subtaskIconClass } from '~/utils/pipelineRender'
+import { activeChunkLabels, chunkReviewPercent, isSlicingChunks } from '~/utils/prReviewProgress'
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
 
 const execution = useExecutionStore()
@@ -51,17 +53,46 @@ const awaiting = computed(() => status.value === 'awaiting_selection')
 // selection controls + per-finding actions are disabled until the verdict lands and it re-parks.
 const challenging = computed(() => status.value === 'challenging')
 // The reviewer's live todo list while it works, streamed onto the step. Its entries are the
-// cohesive slices/chunks the agent grouped the diff into (plus a final "aggregate" step), so it
-// surfaces slices-reviewed-so-far progress during the `reviewing` phase — richer than a spinner.
+// cohesive slices/chunks the agent grouped the diff into (plus a final "aggregate" step). The
+// derivation of the two `reviewing`-phase sub-states from it lives in `~/utils/prReviewProgress`
+// (pure + unit-tested); see that module for the slicing-vs-reviewing signal.
 const subtasks = computed<StepSubtasks | null>(() => step.value?.subtasks ?? null)
-const hasProgress = computed(() => (subtasks.value?.total ?? 0) > 0)
+
+/**
+ * Slicing sub-phase: the reviewer is still grouping the diff into chunks (no todo list yet).
+ * Once the list exists, slicing is done and we render the per-chunk status list instead.
+ */
+const slicing = computed(() => status.value === 'reviewing' && isSlicingChunks(subtasks.value))
+
+/** Chunk-review completion, clamped 0..100 for the progress bar. */
+const chunkPercent = computed(() => chunkReviewPercent(subtasks.value))
+
+/** The chunks the reviewer is actively working through right now (their labels), for the callout. */
+const activeChunks = computed<string[]>(() => activeChunkLabels(subtasks.value))
 
 /** Icon per todo-item status (matches the pipeline timeline's live subtask breakdown). */
-const ITEM_ICON: Record<string, string> = {
+const ITEM_ICON: Record<StepSubtaskItem['status'], string> = {
   completed: 'i-lucide-check-circle-2',
   in_progress: 'i-lucide-loader-circle',
   pending: 'i-lucide-circle',
 }
+
+// Per-chunk status label + chip styling. The key map is an exhaustive Record over the subtask
+// status union, so adding a status without a label fails the typecheck (the sanctioned dynamic
+// enum→key pattern — tier 1 can't see a runtime-built key).
+const CHUNK_STATUS_KEY: Record<StepSubtaskItem['status'], string> = {
+  completed: 'prReview.reviewing.chunkStatus.completed',
+  in_progress: 'prReview.reviewing.chunkStatus.in_progress',
+  pending: 'prReview.reviewing.chunkStatus.pending',
+}
+const CHUNK_STATUS_CLASS: Record<StepSubtaskItem['status'], string> = {
+  completed: 'bg-emerald-500/15 text-emerald-300',
+  in_progress: 'bg-indigo-500/15 text-indigo-300',
+  pending: 'bg-slate-700/60 text-slate-400',
+}
+function chunkStatusLabel(status: StepSubtaskItem['status']): string {
+  return t(CHUNK_STATUS_KEY[status])
+}
 // A resolution is executing (the Fixer is committing, or comments are being posted) — show a
 // working state between the human's choice and the run advancing/the stream echoing `done`.
 const working = computed(() => status.value === 'fixing' || status.value === 'posting')
@@ -223,24 +254,39 @@ async function onDismiss(id: string): Promise<void> {
     </template>
 
     <div class="min-h-0 flex-1 overflow-y-auto px-5 py-4">
-      <!-- Reviewing: the read-only reviewer is still working. Once it starts maintaining its
-           per-slice todo list, surface the live chunk progress (slices reviewed / total + the
-           breakdown) instead of a bare spinner. -->
+      <!-- Reviewing: the read-only reviewer is still working. The phase is told apart precisely —
+           SLICING (still grouping the diff into chunks, no plan yet) vs REVIEWING (slicing done,
+           working through the chunks) — so the copy never claims "reviewing" while it's slicing. -->
       <div
         v-if="status === 'reviewing'"
         data-testid="pr-review-reviewing"
         class="flex h-full flex-col"
       >
-        <!-- Live chunk progress once the reviewer has planned its slices. -->
-        <div v-if="hasProgress" class="py-2">
+        <!-- SLICING: no todo list yet — the reviewer is still grouping the diff into chunks. -->
+        <div
+          v-if="slicing"
+          data-testid="pr-review-slicing"
+          class="flex h-full flex-col items-center justify-center gap-2 py-10 text-center text-slate-400"
+        >
+          <UIcon name="i-lucide-loader-circle" class="h-8 w-8 animate-spin opacity-60" />
+          <p class="text-sm text-slate-200">{{ t('prReview.reviewing.slicing.title') }}</p>
+          <p class="max-w-sm text-[11px] text-slate-500">
+            {{ t('prReview.reviewing.slicing.hint') }}
+          </p>
+        </div>
+
+        <!-- REVIEWING: slicing is done — show every chunk with its status + which are active now. -->
+        <div v-else data-testid="pr-review-reviewing-chunks" class="py-2">
           <div class="mb-1 flex items-center gap-2 text-sm text-slate-200">
             <UIcon
               name="i-lucide-loader-circle"
               class="h-4 w-4 shrink-0 animate-spin text-indigo-300"
             />
-            <span>{{ t('prReview.reviewing.title') }}</span>
+            <span>{{ t('prReview.reviewing.reviewingChunks.title') }}</span>
           </div>
-          <p class="mb-3 text-[11px] text-slate-500">{{ t('prReview.reviewing.hint') }}</p>
+          <p class="mb-3 text-[11px] text-slate-500">
+            {{ t('prReview.reviewing.reviewingChunks.hint') }}
+          </p>
 
           <div class="flex items-center justify-between text-[11px] text-slate-400">
             <span data-testid="pr-review-chunk-count">
@@ -258,46 +304,74 @@ async function onDismiss(id: string): Promise<void> {
           <div class="mt-1 h-1.5 overflow-hidden rounded-full bg-slate-700/60">
             <div
               class="h-full rounded-full bg-indigo-400 transition-all duration-500"
-              :style="{ width: `${(subtasks!.completed / subtasks!.total) * 100}%` }"
+              :style="{ width: `${chunkPercent}%` }"
             />
           </div>
 
-          <!-- The slice/todo breakdown the agent is working through. -->
-          <ul
-            v-if="subtasks!.items?.length"
-            class="mt-3 space-y-1.5"
-            data-testid="pr-review-chunks"
+          <!-- The chunk(s) being actively reviewed right now, called out on their own. -->
+          <div
+            v-if="activeChunks.length"
+            data-testid="pr-review-active-chunks"
+            class="mt-3 rounded-lg border border-indigo-500/30 bg-indigo-500/5 px-2.5 py-2"
           >
-            <li
-              v-for="(item, i) in subtasks!.items"
-              :key="i"
-              class="flex items-start gap-1.5 text-[12px]"
-              :class="
-                item.status === 'completed'
-                  ? 'text-slate-500 line-through'
-                  : item.status === 'in_progress'
-                    ? 'text-slate-100'
-                    : 'text-slate-400'
-              "
-            >
-              <UIcon
-                :name="ITEM_ICON[item.status]"
-                class="mt-0.5 h-3.5 w-3.5 shrink-0"
-                :class="subtaskIconClass(item.status, false)"
-              />
-              <span>{{ item.label }}</span>
-            </li>
-          </ul>
-        </div>
+            <p class="mb-1 text-[10px] font-semibold uppercase tracking-wide text-indigo-300">
+              {{ t('prReview.reviewing.activeHeading') }}
+            </p>
+            <ul class="space-y-1">
+              <li
+                v-for="(label, i) in activeChunks"
+                :key="i"
+                class="flex items-start gap-1.5 text-[12px] text-slate-100"
+              >
+                <UIcon
+                  name="i-lucide-loader-circle"
+                  class="mt-0.5 h-3.5 w-3.5 shrink-0 animate-spin text-indigo-300"
+                />
+                <span class="min-w-0">{{ label }}</span>
+              </li>
+            </ul>
+          </div>
 
-        <!-- Before the reviewer has planned its slices: the cold-start spinner. -->
-        <div
-          v-else
-          class="flex h-full flex-col items-center justify-center gap-2 py-10 text-center text-slate-400"
-        >
-          <UIcon name="i-lucide-loader-circle" class="h-8 w-8 animate-spin opacity-60" />
-          <p class="text-sm">{{ t('prReview.reviewing.title') }}</p>
-          <p class="max-w-sm text-[11px] text-slate-500">{{ t('prReview.reviewing.hint') }}</p>
+          <!-- Every chunk with its explicit status (Reviewed / Reviewing… / Queued). -->
+          <template v-if="subtasks!.items?.length">
+            <p class="mb-1.5 mt-3 text-[10px] font-semibold uppercase tracking-wide text-slate-400">
+              {{ t('prReview.reviewing.chunksHeading') }}
+            </p>
+            <ul class="space-y-1.5" data-testid="pr-review-chunks">
+              <li
+                v-for="(item, i) in subtasks!.items"
+                :key="i"
+                data-testid="pr-review-chunk"
+                class="flex items-center gap-1.5 text-[12px]"
+                :class="
+                  item.status === 'completed'
+                    ? 'text-slate-500'
+                    : item.status === 'in_progress'
+                      ? 'text-slate-100'
+                      : 'text-slate-400'
+                "
+              >
+                <UIcon
+                  :name="ITEM_ICON[item.status]"
+                  class="h-3.5 w-3.5 shrink-0"
+                  :class="subtaskIconClass(item.status, false)"
+                />
+                <span
+                  class="min-w-0 flex-1 truncate"
+                  :class="item.status === 'completed' ? 'line-through' : ''"
+                >
+                  {{ item.label }}
+                </span>
+                <span
+                  data-testid="pr-review-chunk-status"
+                  class="shrink-0 rounded px-1.5 py-0.5 text-[10px] font-medium uppercase"
+                  :class="CHUNK_STATUS_CLASS[item.status]"
+                >
+                  {{ chunkStatusLabel(item.status) }}
+                </span>
+              </li>
+            </ul>
+          </template>
         </div>
       </div>
 

package/app/utils/prReviewProgress.spec.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest'
+import type { StepSubtasks } from '~/types/execution'
+import { activeChunkLabels, chunkReviewPercent, isSlicingChunks } from './prReviewProgress'
+
+const subtasks = (over: Partial<StepSubtasks>): StepSubtasks => ({
+  completed: 0,
+  inProgress: 0,
+  total: 0,
+  ...over,
+})
+
+describe('isSlicingChunks', () => {
+  it('is slicing when there is no todo list yet (null/undefined or empty)', () => {
+    // No plan committed → the reviewer is still grouping the diff into chunks.
+    expect(isSlicingChunks(null)).toBe(true)
+    expect(isSlicingChunks(undefined)).toBe(true)
+    expect(isSlicingChunks(subtasks({ total: 0 }))).toBe(true)
+  })
+
+  it('is not slicing once the todo list exists (slicing is done)', () => {
+    expect(isSlicingChunks(subtasks({ total: 3, completed: 1 }))).toBe(false)
+    // A single-chunk plan still counts as sliced — a plan of size 1 is a committed plan.
+    expect(isSlicingChunks(subtasks({ total: 1 }))).toBe(false)
+  })
+})
+
+describe('chunkReviewPercent', () => {
+  it('is 0 with no plan (avoids 0/0 → NaN)', () => {
+    expect(chunkReviewPercent(null)).toBe(0)
+    expect(chunkReviewPercent(subtasks({ total: 0, completed: 0 }))).toBe(0)
+  })
+
+  it('rounds completion to an integer percent', () => {
+    expect(chunkReviewPercent(subtasks({ total: 4, completed: 1 }))).toBe(25)
+    // 1/3 → 33.33… rounds to 33 (the old inline math emitted a fractional width).
+    expect(chunkReviewPercent(subtasks({ total: 3, completed: 1 }))).toBe(33)
+  })
+
+  it('clamps to 0..100 even if counts are inconsistent', () => {
+    expect(chunkReviewPercent(subtasks({ total: 2, completed: 5 }))).toBe(100)
+    expect(chunkReviewPercent(subtasks({ total: 2, completed: -1 }))).toBe(0)
+  })
+})
+
+describe('activeChunkLabels', () => {
+  it('returns only the in-progress chunk labels, in order', () => {
+    const s = subtasks({
+      total: 3,
+      completed: 1,
+      inProgress: 1,
+      items: [
+        { label: 'auth', status: 'completed' },
+        { label: 'db layer', status: 'in_progress' },
+        { label: 'ui', status: 'pending' },
+      ],
+    })
+    expect(activeChunkLabels(s)).toEqual(['db layer'])
+  })
+
+  it('is empty with no items or no in-progress chunk', () => {
+    expect(activeChunkLabels(null)).toEqual([])
+    expect(activeChunkLabels(subtasks({ total: 2 }))).toEqual([])
+    expect(
+      activeChunkLabels(
+        subtasks({
+          total: 1,
+          completed: 1,
+          items: [{ label: 'only', status: 'completed' }],
+        }),
+      ),
+    ).toEqual([])
+  })
+})

package/app/utils/prReviewProgress.ts

@@ -0,0 +1,28 @@
+import type { StepSubtasks } from '~/types/execution'
+
+// Pure derivation of the PR deep-reviewer's `reviewing`-phase progress, factored out of
+// `PrReviewWindow.vue` so it is unit-testable independently of the Vue component.
+//
+// The reviewer maintains a per-slice todo list (`step.subtasks`) once it has grouped the diff
+// into cohesive chunks. The PRESENCE of that list is the signal that slicing is done, so the two
+// `reviewing` sub-phases are told apart by it:
+//   - no todo list yet (`total === 0`) → still SLICING the diff into chunks (no plan committed).
+//   - todo list present (`total > 0`) → slicing DONE, working through the chunks.
+
+/** True while the reviewer is still grouping the diff into chunks (it has not committed a plan). */
+export function isSlicingChunks(subtasks: StepSubtasks | null | undefined): boolean {
+  return (subtasks?.total ?? 0) <= 0
+}
+
+/** Chunk-review completion as an integer percent, clamped 0..100, for the progress bar. */
+export function chunkReviewPercent(subtasks: StepSubtasks | null | undefined): number {
+  const total = subtasks?.total ?? 0
+  if (total <= 0) return 0
+  const completed = subtasks?.completed ?? 0
+  return Math.min(100, Math.max(0, Math.round((completed / total) * 100)))
+}
+
+/** Labels of the chunk(s) the reviewer is actively working through right now (for the callout). */
+export function activeChunkLabels(subtasks: StepSubtasks | null | undefined): string[] {
+  return subtasks?.items?.filter((i) => i.status === 'in_progress').map((i) => i.label) ?? []
+}

package/i18n/locales/de.json

@@ -4943,10 +4943,23 @@
     "suggestedFix": "Lösungsvorschlag:",
     "line": "Zeile {line}",
     "reviewing": {
-      "title": "Pull Request wird geprüft…",
-      "hint": "Der Diff wird in zusammenhängende Teile zerlegt und einzeln geprüft.",
+      "slicing": {
+        "title": "Diff wird in Abschnitte zerlegt…",
+        "hint": "Die geänderten Dateien werden in zusammenhängende Abschnitte gruppiert, damit jeder einzeln geprüft werden kann. Die Abschnittsliste erscheint hier, sobald die Zerlegung abgeschlossen ist."
+      },
+      "reviewingChunks": {
+        "title": "Abschnitte werden geprüft…",
+        "hint": "Die Zerlegung ist abgeschlossen. Jeder Abschnitt wird nacheinander geprüft und die Ergebnisse werden gesammelt."
+      },
       "chunks": "{completed} von {total} Abschnitten geprüft",
-      "inProgress": "{count} in Bearbeitung"
+      "inProgress": "{count} in Bearbeitung",
+      "activeHeading": "Wird jetzt geprüft",
+      "chunksHeading": "Abschnitte",
+      "chunkStatus": {
+        "completed": "Geprüft",
+        "in_progress": "Wird geprüft…",
+        "pending": "In Warteschlange"
+      }
     },
     "challenge": {
       "action": "Anfechten",

package/i18n/locales/en.json

@@ -5072,10 +5072,23 @@
     "suggestedFix": "Suggested fix:",
     "line": "line {line}",
     "reviewing": {
-      "title": "Reviewing the pull request…",
-      "hint": "Slicing the diff into cohesive chunks and reviewing each one.",
+      "slicing": {
+        "title": "Slicing the diff into chunks…",
+        "hint": "Grouping the changed files into cohesive chunks so each can be reviewed on its own. The chunk list appears here once slicing is done."
+      },
+      "reviewingChunks": {
+        "title": "Reviewing the chunks…",
+        "hint": "Slicing is done. Working through each chunk one at a time and collecting findings."
+      },
       "chunks": "{completed} of {total} chunks reviewed",
-      "inProgress": "{count} in progress"
+      "inProgress": "{count} in progress",
+      "activeHeading": "Reviewing now",
+      "chunksHeading": "Chunks",
+      "chunkStatus": {
+        "completed": "Reviewed",
+        "in_progress": "Reviewing…",
+        "pending": "Queued"
+      }
     },
     "challenge": {
       "action": "Challenge",

package/i18n/locales/es.json

@@ -4931,10 +4931,23 @@
     "suggestedFix": "Corrección sugerida:",
     "line": "línea {line}",
     "reviewing": {
-      "title": "Revisando el pull request…",
-      "hint": "Dividiendo el diff en bloques coherentes y revisando cada uno.",
+      "slicing": {
+        "title": "Dividiendo el diff en fragmentos…",
+        "hint": "Agrupando los archivos modificados en fragmentos coherentes para revisar cada uno por separado. La lista de fragmentos aparecerá aquí cuando termine la división."
+      },
+      "reviewingChunks": {
+        "title": "Revisando los fragmentos…",
+        "hint": "La división ha terminado. Revisando cada fragmento de uno en uno y recopilando los hallazgos."
+      },
       "chunks": "{completed} de {total} fragmentos revisados",
-      "inProgress": "{count} en curso"
+      "inProgress": "{count} en curso",
+      "activeHeading": "Revisando ahora",
+      "chunksHeading": "Fragmentos",
+      "chunkStatus": {
+        "completed": "Revisado",
+        "in_progress": "Revisando…",
+        "pending": "En cola"
+      }
     },
     "challenge": {
       "action": "Cuestionar",

package/i18n/locales/fr.json

@@ -4931,10 +4931,23 @@
     "suggestedFix": "Correction suggérée :",
     "line": "ligne {line}",
     "reviewing": {
-      "title": "Revue de la pull request…",
-      "hint": "Découpage du diff en blocs cohérents et revue de chacun.",
+      "slicing": {
+        "title": "Découpage du diff en sections…",
+        "hint": "Regroupement des fichiers modifiés en sections cohérentes afin de pouvoir examiner chacune séparément. La liste des sections apparaîtra ici une fois le découpage terminé."
+      },
+      "reviewingChunks": {
+        "title": "Revue des sections…",
+        "hint": "Le découpage est terminé. Chaque section est examinée l'une après l'autre et les remarques sont rassemblées."
+      },
       "chunks": "{completed} sur {total} sections examinées",
-      "inProgress": "{count} en cours"
+      "inProgress": "{count} en cours",
+      "activeHeading": "Revue en cours",
+      "chunksHeading": "Sections",
+      "chunkStatus": {
+        "completed": "Examinée",
+        "in_progress": "En cours d'examen…",
+        "pending": "En attente"
+      }
     },
     "challenge": {
       "action": "Contester",

package/i18n/locales/he.json

@@ -4942,10 +4942,23 @@
     "suggestedFix": "תיקון מוצע:",
     "line": "שורה {line}",
     "reviewing": {
-      "title": "בודק את בקשת המשיכה…",
-      "hint": "מחלק את ההבדלים לקטעים לכידים ובודק כל אחד.",
+      "slicing": {
+        "title": "מחלק את ההבדלים למקטעים…",
+        "hint": "מקבץ את הקבצים שהשתנו למקטעים לכידים כדי לבדוק כל אחד בנפרד. רשימת המקטעים תופיע כאן לאחר סיום החלוקה."
+      },
+      "reviewingChunks": {
+        "title": "בודק את המקטעים…",
+        "hint": "החלוקה הסתיימה. בודק כל מקטע בנפרד ואוסף את הממצאים."
+      },
       "chunks": "{completed} מתוך {total} מקטעים נבדקו",
-      "inProgress": "{count} בתהליך"
+      "inProgress": "{count} בתהליך",
+      "activeHeading": "נבדק כעת",
+      "chunksHeading": "מקטעים",
+      "chunkStatus": {
+        "completed": "נבדק",
+        "in_progress": "בבדיקה…",
+        "pending": "בתור"
+      }
     },
     "challenge": {
       "action": "ערער",

package/i18n/locales/it.json

@@ -4943,10 +4943,23 @@
     "suggestedFix": "Correzione suggerita:",
     "line": "riga {line}",
     "reviewing": {
-      "title": "Revisione della pull request…",
-      "hint": "Suddivisione del diff in blocchi coerenti e revisione di ciascuno.",
+      "slicing": {
+        "title": "Suddivisione del diff in blocchi…",
+        "hint": "Raggruppamento dei file modificati in blocchi coerenti per esaminare ciascuno separatamente. L'elenco dei blocchi comparirà qui al termine della suddivisione."
+      },
+      "reviewingChunks": {
+        "title": "Revisione dei blocchi…",
+        "hint": "La suddivisione è terminata. Ogni blocco viene esaminato uno alla volta e le osservazioni vengono raccolte."
+      },
       "chunks": "{completed} di {total} sezioni esaminate",
-      "inProgress": "{count} in corso"
+      "inProgress": "{count} in corso",
+      "activeHeading": "In revisione ora",
+      "chunksHeading": "Blocchi",
+      "chunkStatus": {
+        "completed": "Esaminato",
+        "in_progress": "In revisione…",
+        "pending": "In coda"
+      }
     },
     "challenge": {
       "action": "Contesta",

package/i18n/locales/ja.json

@@ -4943,10 +4943,23 @@
     "suggestedFix": "修正案:",
     "line": "{line}行目",
     "reviewing": {
-      "title": "プルリクエストをレビュー中…",
-      "hint": "差分をまとまりのある単位に分割し、各単位をレビューしています。",
+      "slicing": {
+        "title": "差分をチャンクに分割中…",
+        "hint": "変更されたファイルをまとまりのあるチャンクにグループ化し、各チャンクを個別にレビューできるようにしています。分割が完了すると、ここにチャンク一覧が表示されます。"
+      },
+      "reviewingChunks": {
+        "title": "チャンクをレビュー中…",
+        "hint": "分割は完了しました。各チャンクを一つずつレビューし、指摘事項を収集しています。"
+      },
       "chunks": "{total} 個中 {completed} 個のチャンクをレビュー済み",
-      "inProgress": "{count} 件処理中"
+      "inProgress": "{count} 件処理中",
+      "activeHeading": "レビュー中",
+      "chunksHeading": "チャンク",
+      "chunkStatus": {
+        "completed": "レビュー済み",
+        "in_progress": "レビュー中…",
+        "pending": "待機中"
+      }
     },
     "challenge": {
       "action": "異議を唱える",

package/i18n/locales/pl.json

@@ -4931,10 +4931,23 @@
     "suggestedFix": "Sugerowana poprawka:",
     "line": "wiersz {line}",
     "reviewing": {
-      "title": "Przeglądanie pull requesta…",
-      "hint": "Dzielenie zmian na spójne części i przeglądanie każdej z nich.",
+      "slicing": {
+        "title": "Dzielenie zmian na fragmenty…",
+        "hint": "Grupowanie zmienionych plików w spójne fragmenty, aby każdy można było przejrzeć osobno. Lista fragmentów pojawi się tutaj po zakończeniu podziału."
+      },
+      "reviewingChunks": {
+        "title": "Przeglądanie fragmentów…",
+        "hint": "Podział zakończony. Przeglądanie każdego fragmentu po kolei i zbieranie uwag."
+      },
       "chunks": "Sprawdzono {completed} z {total} fragmentów",
-      "inProgress": "{count} w toku"
+      "inProgress": "{count} w toku",
+      "activeHeading": "Przeglądane teraz",
+      "chunksHeading": "Fragmenty",
+      "chunkStatus": {
+        "completed": "Sprawdzony",
+        "in_progress": "Przeglądanie…",
+        "pending": "W kolejce"
+      }
     },
     "challenge": {
       "action": "Zakwestionuj",

package/i18n/locales/tr.json

@@ -4943,10 +4943,23 @@
     "suggestedFix": "Önerilen düzeltme:",
     "line": "satır {line}",
     "reviewing": {
-      "title": "Pull request inceleniyor…",
-      "hint": "Fark tutarlı parçalara bölünüp her biri inceleniyor.",
+      "slicing": {
+        "title": "Fark parçalara bölünüyor…",
+        "hint": "Değiştirilen dosyalar, her biri ayrı ayrı incelenebilsin diye tutarlı parçalara gruplanıyor. Bölme tamamlandığında parça listesi burada görünecek."
+      },
+      "reviewingChunks": {
+        "title": "Parçalar inceleniyor…",
+        "hint": "Bölme tamamlandı. Her parça tek tek inceleniyor ve bulgular toplanıyor."
+      },
       "chunks": "{total} bölümden {completed} tanesi incelendi",
-      "inProgress": "{count} devam ediyor"
+      "inProgress": "{count} devam ediyor",
+      "activeHeading": "Şimdi inceleniyor",
+      "chunksHeading": "Parçalar",
+      "chunkStatus": {
+        "completed": "İncelendi",
+        "in_progress": "İnceleniyor…",
+        "pending": "Sırada"
+      }
     },
     "challenge": {
       "action": "İtiraz et",

package/i18n/locales/uk.json

@@ -4931,10 +4931,23 @@
     "suggestedFix": "Пропоноване виправлення:",
     "line": "рядок {line}",
     "reviewing": {
-      "title": "Перевірка pull request…",
-      "hint": "Поділ змін на цілісні частини та огляд кожної з них.",
+      "slicing": {
+        "title": "Поділ змін на фрагменти…",
+        "hint": "Групування змінених файлів у цілісні фрагменти, щоб кожен можна було переглянути окремо. Список фрагментів з'явиться тут після завершення поділу."
+      },
+      "reviewingChunks": {
+        "title": "Огляд фрагментів…",
+        "hint": "Поділ завершено. Кожен фрагмент переглядається по черзі, а зауваження збираються."
+      },
       "chunks": "Перевірено {completed} з {total} фрагментів",
-      "inProgress": "{count} у процесі"
+      "inProgress": "{count} у процесі",
+      "activeHeading": "Переглядається зараз",
+      "chunksHeading": "Фрагменти",
+      "chunkStatus": {
+        "completed": "Переглянуто",
+        "in_progress": "Огляд…",
+        "pending": "У черзі"
+      }
     },
     "challenge": {
       "action": "Оскаржити",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.147.0",
+  "version": "0.147.1",
   "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",