@cat-factory/app 0.146.3 → 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()
@@ -46,18 +48,51 @@ const step = computed(() => {
 const state = computed<PrReviewStepState | null>(() => step.value?.prReview ?? null)
 const status = computed(() => state.value?.status ?? null)
 const awaiting = computed(() => status.value === 'awaiting_selection')
+// A finding is being re-examined by the Challenge Investigator (the whole review is `challenging`
+// while it runs). The findings stay visible — the challenged one shows a spinner — but the
+// 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')
@@ -101,6 +136,27 @@ const groups = computed(() => {
   return out
 })
 
+/** A finding the Challenge Investigator RETRACTED — it can no longer be acted on (auto-deselected). */
+function isRetracted(f: PrReviewFinding): boolean {
+  return f.challenge?.status === 'retracted'
+}
+/** A finding currently being re-examined by the Challenge Investigator. */
+function isInvestigating(f: PrReviewFinding): boolean {
+  return f.challenge?.status === 'investigating'
+}
+/** A finding the investigator UPHELD + strengthened after a challenge (its body actually changed). */
+function isAmended(f: PrReviewFinding): boolean {
+  return f.challenge?.status === 'amended'
+}
+/** A finding the investigator UPHELD as written after a challenge (kept, no revision). */
+function isUpheld(f: PrReviewFinding): boolean {
+  return f.challenge?.status === 'upheld'
+}
+/** A finding whose challenge investigation FAILED — the finding is kept as-is; re-challenge allowed. */
+function isChallengeFailed(f: PrReviewFinding): boolean {
+  return f.challenge?.status === 'failed'
+}
+
 // The human's selection — a set of finding ids. Defaults to every finding (the human deselects
 // the noise), so "Finish" without touching anything keeps all. Re-seeded ONLY when the set of
 // finding IDS actually changes — NOT on every execution-stream re-emit (which hands us a fresh
@@ -111,11 +167,17 @@ const selected = ref<Set<string>>(new Set())
 watch(
   findingIdKey,
   () => {
-    selected.value = new Set(findings.value.map((f) => f.id))
+    selected.value = new Set(findings.value.filter((f) => !isRetracted(f)).map((f) => f.id))
   },
   { immediate: true },
 )
 
+// The effective selection: checked AND not retracted. A retracted finding is never acted on even
+// if its box was checked before the investigator dropped it (it's disabled + unchecked visually).
+const activeSelectedIds = computed(() =>
+  findings.value.filter((f) => selected.value.has(f.id) && !isRetracted(f)).map((f) => f.id),
+)
+
 function toggle(id: string): void {
   const next = new Set(selected.value)
   if (next.has(id)) next.delete(id)
@@ -123,7 +185,7 @@ function toggle(id: string): void {
   selected.value = next
 }
 function selectAll(): void {
-  selected.value = new Set(findings.value.map((f) => f.id))
+  selected.value = new Set(findings.value.filter((f) => !isRetracted(f)).map((f) => f.id))
 }
 function clearAll(): void {
   selected.value = new Set()
@@ -132,13 +194,40 @@ function clearAll(): void {
 const canResolve = computed(() => awaiting.value && !prReview.resolving)
 // Fix / Post act on the selection, so they need at least one selected finding; Finish always
 // works (it just records the — possibly empty — curated selection and completes the review).
-const hasSelection = computed(() => selected.value.size > 0)
+const hasSelection = computed(() => activeSelectedIds.value.length > 0)
 
 async function onResolve(action: PrReviewResolution): Promise<void> {
   const id = instanceId.value
   if (!id || !canResolve.value) return
   if ((action === 'fix' || action === 'post') && !hasSelection.value) return
-  await prReview.resolve(id, [...selected.value], action).catch(() => {})
+  await prReview.resolve(id, activeSelectedIds.value, action).catch(() => {})
+}
+
+// Per-finding CHALLENGE: the open finding's id (its inline concern box is showing) + the drafted
+// concern text. Dispatching moves the whole review to `challenging` until the verdict lands.
+const challengeForId = ref<string | null>(null)
+const challengeText = ref('')
+function openChallenge(id: string): void {
+  challengeForId.value = id
+  challengeText.value = ''
+}
+function cancelChallenge(): void {
+  challengeForId.value = null
+  challengeText.value = ''
+}
+async function submitChallenge(id: string): Promise<void> {
+  const inst = instanceId.value
+  if (!inst || !canResolve.value) return
+  const question = challengeText.value.trim()
+  challengeForId.value = null
+  challengeText.value = ''
+  await prReview.challenge(inst, id, question || undefined).catch(() => {})
+}
+async function onDismiss(id: string): Promise<void> {
+  const inst = instanceId.value
+  if (!inst || !canResolve.value) return
+  if (challengeForId.value === id) cancelChallenge()
+  await prReview.dismiss(inst, id).catch(() => {})
 }
 </script>
 
@@ -165,24 +254,39 @@ async function onResolve(action: PrReviewResolution): 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">
@@ -200,46 +304,74 @@ async function onResolve(action: PrReviewResolution): 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>
 
@@ -335,10 +467,20 @@ async function onResolve(action: PrReviewResolution): Promise<void> {
         </div>
 
         <template v-else>
+          <!-- A challenge is in flight: the Challenge Investigator is re-examining a finding. -->
+          <div
+            v-if="challenging"
+            data-testid="pr-review-challenging"
+            class="mb-3 flex items-center gap-2 rounded-md border border-indigo-500/40 bg-indigo-500/10 px-3 py-2 text-[12px] text-indigo-200"
+          >
+            <UIcon name="i-lucide-loader-circle" class="h-4 w-4 shrink-0 animate-spin" />
+            <span>{{ t('prReview.challenge.investigatingBanner') }}</span>
+          </div>
+
           <!-- Selection toolbar -->
           <div v-if="awaiting" class="mb-2 flex items-center gap-3 text-[11px] text-slate-400">
             <span data-testid="pr-review-selected-count">
-              {{ t('prReview.selectedCount', { count: selected.size }) }}
+              {{ t('prReview.selectedCount', { count: activeSelectedIds.length }) }}
             </span>
             <button class="text-indigo-300 hover:underline" @click="selectAll">
               {{ t('prReview.selectAll') }}
@@ -361,19 +503,21 @@ async function onResolve(action: PrReviewResolution): Promise<void> {
               :key="f.id"
               data-testid="pr-review-finding"
               class="mb-1.5 rounded-xl border px-3 py-2 transition"
-              :class="
-                awaiting && selected.has(f.id)
+              :class="[
+                awaiting && selected.has(f.id) && !isRetracted(f)
                   ? 'border-indigo-500/60 bg-indigo-500/5'
-                  : 'border-slate-800 bg-slate-900/60'
-              "
+                  : 'border-slate-800 bg-slate-900/60',
+                isRetracted(f) ? 'opacity-60' : '',
+              ]"
             >
               <div class="flex items-start gap-2">
                 <input
-                  v-if="awaiting"
+                  v-if="awaiting || challenging"
                   type="checkbox"
                   class="mt-1 accent-indigo-500"
                   data-testid="pr-review-finding-toggle"
-                  :checked="selected.has(f.id)"
+                  :checked="selected.has(f.id) && !isRetracted(f)"
+                  :disabled="!awaiting || isRetracted(f)"
                   @change="toggle(f.id)"
                 />
                 <div class="min-w-0 flex-1">
@@ -394,7 +538,47 @@ async function onResolve(action: PrReviewResolution): Promise<void> {
                     >
                       {{ t('prReview.postReport.postedBadge') }}
                     </span>
-                    <h4 class="min-w-0 flex-1 text-[13px] font-medium text-slate-100">
+                    <!-- Challenge outcome badges -->
+                    <span
+                      v-if="isRetracted(f)"
+                      data-testid="pr-review-finding-retracted"
+                      class="rounded bg-rose-500/15 px-1.5 py-0.5 text-[10px] font-semibold uppercase text-rose-300 ring-1 ring-rose-500/30"
+                    >
+                      {{ t('prReview.challenge.retractedBadge') }}
+                    </span>
+                    <span
+                      v-else-if="isAmended(f)"
+                      data-testid="pr-review-finding-amended"
+                      class="rounded bg-sky-500/15 px-1.5 py-0.5 text-[10px] font-semibold uppercase text-sky-300 ring-1 ring-sky-500/30"
+                    >
+                      {{ t('prReview.challenge.strengthenedBadge') }}
+                    </span>
+                    <span
+                      v-else-if="isUpheld(f)"
+                      data-testid="pr-review-finding-upheld"
+                      class="rounded bg-emerald-500/15 px-1.5 py-0.5 text-[10px] font-semibold uppercase text-emerald-300 ring-1 ring-emerald-500/30"
+                    >
+                      {{ t('prReview.challenge.upheldBadge') }}
+                    </span>
+                    <span
+                      v-else-if="isChallengeFailed(f)"
+                      data-testid="pr-review-finding-challenge-failed"
+                      class="rounded bg-amber-500/15 px-1.5 py-0.5 text-[10px] font-semibold uppercase text-amber-300 ring-1 ring-amber-500/30"
+                    >
+                      {{ t('prReview.challenge.failedBadge') }}
+                    </span>
+                    <span
+                      v-else-if="isInvestigating(f)"
+                      data-testid="pr-review-finding-investigating"
+                      class="flex items-center gap-1 rounded bg-indigo-500/15 px-1.5 py-0.5 text-[10px] font-semibold uppercase text-indigo-300 ring-1 ring-indigo-500/30"
+                    >
+                      <UIcon name="i-lucide-loader-circle" class="h-3 w-3 animate-spin" />
+                      {{ t('prReview.challenge.investigatingBadge') }}
+                    </span>
+                    <h4
+                      class="min-w-0 flex-1 text-[13px] font-medium text-slate-100"
+                      :class="isRetracted(f) ? 'line-through' : ''"
+                    >
                       {{ f.title }}
                     </h4>
                   </div>
@@ -404,7 +588,10 @@ async function onResolve(action: PrReviewResolution): Promise<void> {
                       · {{ t('prReview.line', { line: f.line }) }}</template
                     >
                   </p>
-                  <p class="mt-1 whitespace-pre-wrap text-[12px] text-slate-300">
+                  <p
+                    class="mt-1 whitespace-pre-wrap text-[12px] text-slate-300"
+                    :class="isRetracted(f) ? 'line-through' : ''"
+                  >
                     {{ f.detail }}
                   </p>
                   <p
@@ -414,6 +601,92 @@ async function onResolve(action: PrReviewResolution): Promise<void> {
                     <span class="text-slate-500">{{ t('prReview.suggestedFix') }}</span>
                     {{ f.suggestedFix }}
                   </p>
+
+                  <!-- The investigator's justification (why the finding holds up / was retracted),
+                       or the reason the challenge investigation failed. -->
+                  <p
+                    v-if="f.challenge?.justification"
+                    data-testid="pr-review-finding-justification"
+                    class="mt-1.5 whitespace-pre-wrap rounded-md px-2 py-1 text-[11px]"
+                    :class="
+                      isRetracted(f)
+                        ? 'bg-rose-500/10 text-rose-200'
+                        : isChallengeFailed(f)
+                          ? 'bg-amber-500/10 text-amber-200'
+                          : 'bg-sky-500/10 text-sky-200'
+                    "
+                  >
+                    <span class="font-medium">{{
+                      isChallengeFailed(f)
+                        ? t('prReview.challenge.failedLabel')
+                        : t('prReview.challenge.verdictLabel')
+                    }}</span>
+                    {{ f.challenge.justification }}
+                  </p>
+
+                  <!-- Per-finding actions: Challenge + Dismiss (only while awaiting a selection). -->
+                  <div
+                    v-if="awaiting && !isInvestigating(f)"
+                    class="mt-1.5 flex items-center gap-3 text-[11px]"
+                  >
+                    <button
+                      v-if="!isRetracted(f)"
+                      data-testid="pr-review-finding-challenge"
+                      class="flex items-center gap-1 text-indigo-300 hover:underline disabled:opacity-50"
+                      :disabled="!canResolve || !access.canExecuteRuns.value"
+                      @click="openChallenge(f.id)"
+                    >
+                      <UIcon name="i-lucide-gavel" class="h-3.5 w-3.5" />
+                      {{
+                        f.challenge
+                          ? t('prReview.challenge.reChallenge')
+                          : t('prReview.challenge.action')
+                      }}
+                    </button>
+                    <button
+                      data-testid="pr-review-finding-dismiss"
+                      class="flex items-center gap-1 text-slate-400 hover:text-rose-300 hover:underline disabled:opacity-50"
+                      :disabled="!canResolve || !access.canExecuteRuns.value"
+                      @click="onDismiss(f.id)"
+                    >
+                      <UIcon name="i-lucide-trash-2" class="h-3.5 w-3.5" />
+                      {{ t('prReview.challenge.dismiss') }}
+                    </button>
+                  </div>
+
+                  <!-- The inline challenge box: an OPTIONAL specific concern for the investigator. -->
+                  <div
+                    v-if="challengeForId === f.id"
+                    data-testid="pr-review-challenge-box"
+                    class="mt-2 rounded-md border border-indigo-500/40 bg-slate-900/80 p-2"
+                  >
+                    <textarea
+                      v-model="challengeText"
+                      data-testid="pr-review-challenge-input"
+                      rows="2"
+                      :placeholder="t('prReview.challenge.placeholder')"
+                      class="w-full resize-y rounded border border-slate-700 bg-slate-950/60 px-2 py-1 text-[12px] text-slate-200 outline-none focus:border-indigo-500"
+                    />
+                    <p class="mt-1 text-[10px] text-slate-500">
+                      {{ t('prReview.challenge.hint') }}
+                    </p>
+                    <div class="mt-1.5 flex justify-end gap-2">
+                      <button
+                        class="rounded px-2 py-1 text-[11px] text-slate-400 hover:text-slate-200"
+                        @click="cancelChallenge"
+                      >
+                        {{ t('common.cancel') }}
+                      </button>
+                      <button
+                        data-testid="pr-review-challenge-submit"
+                        class="rounded bg-indigo-500/80 px-2 py-1 text-[11px] font-medium text-white hover:bg-indigo-500 disabled:opacity-50"
+                        :disabled="!canResolve"
+                        @click="submitChallenge(f.id)"
+                      >
+                        {{ t('prReview.challenge.submit') }}
+                      </button>
+                    </div>
+                  </div>
                 </div>
               </div>
             </article>

package/app/composables/api/prReview.ts

@@ -1,4 +1,9 @@
-import { getPrReviewContract, resolvePrReviewContract } from '@cat-factory/contracts'
+import {
+  challengePrReviewFindingContract,
+  dismissPrReviewFindingContract,
+  getPrReviewContract,
+  resolvePrReviewContract,
+} from '@cat-factory/contracts'
 import type { ApiContext } from './context'
 
 /**
@@ -26,5 +31,25 @@ export function prReviewApi({ send, ws }: ApiContext) {
         pathParams: { executionId },
         body,
       }),
+
+    // Dismiss a parked finding entirely (drops it + prunes it from the selection).
+    dismissPrReviewFinding: (workspaceId: string, executionId: string, findingId: string) =>
+      send(dismissPrReviewFindingContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId, findingId },
+      }),
+
+    // Challenge a parked finding — dispatch the Challenge Investigator (optional specific concern).
+    challengePrReviewFinding: (
+      workspaceId: string,
+      executionId: string,
+      findingId: string,
+      body: { question?: string },
+    ) =>
+      send(challengePrReviewFindingContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId, findingId },
+        body,
+      }),
   }
 }

package/app/stores/prReview.ts

@@ -82,5 +82,50 @@ export const usePrReviewStore = defineStore('prReview', () => {
     }
   }
 
-  return { resolving, error, load, resolve }
+  /** Dismiss a finding entirely: it's removed from the review (and the selection). Stays parked. */
+  async function dismiss(executionId: string, findingId: string): Promise<void> {
+    error.value = null
+    resolving.value = true
+    try {
+      const state = await api.dismissPrReviewFinding(workspace.requireId(), executionId, findingId)
+      reflect(executionId, state as PrReviewStepState)
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to dismiss finding'
+      throw e
+    } finally {
+      resolving.value = false
+    }
+  }
+
+  /**
+   * Challenge a finding: dispatch the Challenge Investigator with an OPTIONAL specific concern
+   * (blank ⇒ the generic "dig deeper + validate" prompt). The review moves to `challenging` while
+   * the investigator digs in; its verdict (strengthen / retract the finding) arrives via the stream.
+   */
+  async function challenge(
+    executionId: string,
+    findingId: string,
+    question?: string,
+  ): Promise<void> {
+    error.value = null
+    resolving.value = true
+    try {
+      const state = await api.challengePrReviewFinding(
+        workspace.requireId(),
+        executionId,
+        findingId,
+        {
+          question,
+        },
+      )
+      reflect(executionId, state as PrReviewStepState)
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to challenge finding'
+      throw e
+    } finally {
+      resolving.value = false
+    }
+  }
+
+  return { resolving, error, load, resolve, dismiss, challenge }
 })

package/app/types/execution.ts

@@ -45,6 +45,7 @@ export type {
   ForkDecisionStepState,
   PrReviewStepState,
   PrReviewFinding,
+  PrReviewFindingChallenge,
   PrReviewSlice,
   PrReviewSeverity,
   PrReviewCategory,

package/app/utils/catalog.ts

@@ -412,6 +412,20 @@ export const SYSTEM_AGENT_META: Record<string, AgentArchetype> = {
     color: '#22d3ee',
     description: 'Maps the repository into the service → modules blueprint.',
   },
+  // The read-only Challenge Investigator: dispatched off a parked `pr-reviewer` step when a human
+  // challenges a finding, it re-examines that ONE finding against the full source and upholds
+  // (strengthening) or retracts it. Never a palette block; modelled here purely so it is a
+  // configurable per-kind default in the Model Defaults panel — a workspace can point it at a
+  // different (stronger) model than the reviewer. Its output renders in the pr-review window.
+  'challenge-investigator': {
+    kind: 'challenge-investigator',
+    label: 'Challenge Investigator',
+    icon: 'i-lucide-gavel',
+    color: '#6366f1',
+    description:
+      'Re-examines a single challenged PR-review finding against the full source, then upholds ' +
+      '(strengthening it) or retracts it with a justification. Configurable separately from the reviewer.',
+  },
   // The single environment provisioner: an operational (non-LLM) step that stands up the ephemeral
   // environment the tester / human-test gate run against for a kubernetes/custom service, and is a
   // fast no-op for docker-compose / infraless. Seeded before the first tester/human-test step in the
@@ -634,6 +648,9 @@ export const MODEL_CONFIGURABLE_SYSTEM_KINDS: AgentArchetype[] = [
     'fixer',
     'merger',
     'kaizen',
+    // The PR-review Challenge Investigator — pinnable to its own (stronger) model, separately
+    // from the reviewer that produced the findings.
+    'challenge-investigator',
   ].map((kind) => SYSTEM_AGENT_META[kind]!),
   // Companions run LLMs but aren't palette-addable (they're producer toggles), so include
   // them here to keep their per-workspace default model pinnable in the Model Defaults panel.

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,39 @@
     "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",
+      "reChallenge": "Erneut anfechten",
+      "dismiss": "Verwerfen",
+      "submit": "Untersuchen",
+      "placeholder": "Optional: Was genau ist an diesem Befund falsch oder nicht überzeugend?",
+      "hint": "Leer lassen, damit der Prüfer tiefer gräbt, den Befund begründet und prüft, ob er zutreffend und relevant ist.",
+      "investigatingBanner": "Der Challenge-Investigator prüft einen Befund erneut anhand des Quellcodes…",
+      "investigatingBadge": "Wird untersucht",
+      "strengthenedBadge": "Bestärkt",
+      "upheldBadge": "Bestätigt",
+      "retractedBadge": "Zurückgezogen",
+      "verdictLabel": "Prüfer:",
+      "failedBadge": "Anfechtung fehlgeschlagen",
+      "failedLabel": "Anfechtung fehlgeschlagen:"
     },
     "fixing": {
       "title": "Ausgewählte Befunde werden behoben…",

package/i18n/locales/en.json

@@ -5072,10 +5072,39 @@
     "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",
+      "reChallenge": "Challenge again",
+      "dismiss": "Dismiss",
+      "submit": "Investigate",
+      "placeholder": "Optional: what specifically is wrong or unconvincing about this finding?",
+      "hint": "Leave blank to have the investigator dig deeper, justify the finding, and check it's accurate and relevant.",
+      "investigatingBanner": "The Challenge Investigator is re-examining a finding against the source…",
+      "investigatingBadge": "Investigating",
+      "strengthenedBadge": "Strengthened",
+      "upheldBadge": "Upheld",
+      "retractedBadge": "Retracted",
+      "verdictLabel": "Investigator:",
+      "failedBadge": "Challenge failed",
+      "failedLabel": "Challenge failed:"
     },
     "fixing": {
       "title": "Fixing the selected findings…",

package/i18n/locales/es.json

@@ -4931,10 +4931,39 @@
     "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",
+      "reChallenge": "Cuestionar de nuevo",
+      "dismiss": "Descartar",
+      "submit": "Investigar",
+      "placeholder": "Opcional: ¿qué es exactamente lo incorrecto o poco convincente de este hallazgo?",
+      "hint": "Déjalo en blanco para que el investigador profundice, justifique el hallazgo y compruebe que es preciso y relevante.",
+      "investigatingBanner": "El Investigador de Objeciones está reexaminando un hallazgo frente al código fuente…",
+      "investigatingBadge": "Investigando",
+      "strengthenedBadge": "Reforzado",
+      "upheldBadge": "Confirmado",
+      "retractedBadge": "Retirado",
+      "verdictLabel": "Investigador:",
+      "failedBadge": "Cuestionamiento fallido",
+      "failedLabel": "Cuestionamiento fallido:"
     },
     "fixing": {
       "title": "Corrigiendo los hallazgos seleccionados…",

package/i18n/locales/fr.json

@@ -4931,10 +4931,39 @@
     "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",
+      "reChallenge": "Contester à nouveau",
+      "dismiss": "Écarter",
+      "submit": "Enquêter",
+      "placeholder": "Facultatif : qu'y a-t-il précisément d'incorrect ou de peu convaincant dans ce constat ?",
+      "hint": "Laissez vide pour que l'enquêteur approfondisse, justifie le constat et vérifie qu'il est exact et pertinent.",
+      "investigatingBanner": "L'enquêteur de contestation réexamine un constat par rapport au code source…",
+      "investigatingBadge": "Enquête en cours",
+      "strengthenedBadge": "Renforcé",
+      "upheldBadge": "Confirmé",
+      "retractedBadge": "Retiré",
+      "verdictLabel": "Enquêteur :",
+      "failedBadge": "Échec de la contestation",
+      "failedLabel": "Échec de la contestation :"
     },
     "fixing": {
       "title": "Correction des points sélectionnés…",

package/i18n/locales/he.json

@@ -4942,10 +4942,39 @@
     "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": "ערער",
+      "reChallenge": "ערער שוב",
+      "dismiss": "התעלם",
+      "submit": "חקור",
+      "placeholder": "רשות: מה בדיוק שגוי או לא משכנע בממצא הזה?",
+      "hint": "השאירו ריק כדי שהחוקר יעמיק, ינמק את הממצא ויוודא שהוא מדויק ורלוונטי.",
+      "investigatingBanner": "חוקר הערעורים בוחן מחדש ממצא מול קוד המקור…",
+      "investigatingBadge": "בחקירה",
+      "strengthenedBadge": "חוזק",
+      "upheldBadge": "אושר",
+      "retractedBadge": "בוטל",
+      "verdictLabel": "חוקר:",
+      "failedBadge": "הערעור נכשל",
+      "failedLabel": "הערעור נכשל:"
     },
     "fixing": {
       "title": "מתקן את הממצאים שנבחרו…",

package/i18n/locales/it.json

@@ -4943,10 +4943,39 @@
     "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",
+      "reChallenge": "Contesta di nuovo",
+      "dismiss": "Scarta",
+      "submit": "Indaga",
+      "placeholder": "Facoltativo: cosa c'è di preciso di sbagliato o poco convincente in questo rilievo?",
+      "hint": "Lascia vuoto per far approfondire l'investigatore, giustificare il rilievo e verificarne accuratezza e pertinenza.",
+      "investigatingBanner": "L'investigatore delle contestazioni sta riesaminando un rilievo rispetto al codice sorgente…",
+      "investigatingBadge": "In esame",
+      "strengthenedBadge": "Rafforzato",
+      "upheldBadge": "Confermato",
+      "retractedBadge": "Ritirato",
+      "verdictLabel": "Investigatore:",
+      "failedBadge": "Contestazione non riuscita",
+      "failedLabel": "Contestazione non riuscita:"
     },
     "fixing": {
       "title": "Correzione dei rilievi selezionati…",

package/i18n/locales/ja.json

@@ -4943,10 +4943,39 @@
     "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": "異議を唱える",
+      "reChallenge": "再度異議を唱える",
+      "dismiss": "却下",
+      "submit": "調査する",
+      "placeholder": "任意: この指摘のどこが誤り、または納得できないかを記入してください。",
+      "hint": "空欄のままにすると、調査担当がさらに深く掘り下げ、指摘の根拠を示し、正確性と関連性を検証します。",
+      "investigatingBanner": "異議調査担当がソースコードに照らして指摘を再検証しています…",
+      "investigatingBadge": "調査中",
+      "strengthenedBadge": "強化済み",
+      "upheldBadge": "支持",
+      "retractedBadge": "撤回済み",
+      "verdictLabel": "調査担当:",
+      "failedBadge": "異議調査に失敗",
+      "failedLabel": "異議調査に失敗:"
     },
     "fixing": {
       "title": "選択した指摘を修正中…",

package/i18n/locales/pl.json

@@ -4931,10 +4931,39 @@
     "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",
+      "reChallenge": "Zakwestionuj ponownie",
+      "dismiss": "Odrzuć",
+      "submit": "Zbadaj",
+      "placeholder": "Opcjonalnie: co dokładnie jest błędne lub nieprzekonujące w tym ustaleniu?",
+      "hint": "Pozostaw puste, aby badacz zgłębił temat, uzasadnił ustalenie i sprawdził, czy jest trafne i istotne.",
+      "investigatingBanner": "Badacz zastrzeżeń ponownie analizuje ustalenie w oparciu o kod źródłowy…",
+      "investigatingBadge": "Badanie",
+      "strengthenedBadge": "Wzmocnione",
+      "upheldBadge": "Podtrzymane",
+      "retractedBadge": "Wycofane",
+      "verdictLabel": "Badacz:",
+      "failedBadge": "Zakwestionowanie nie powiodło się",
+      "failedLabel": "Zakwestionowanie nie powiodło się:"
     },
     "fixing": {
       "title": "Naprawianie wybranych uwag…",

package/i18n/locales/tr.json

@@ -4943,10 +4943,39 @@
     "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",
+      "reChallenge": "Tekrar itiraz et",
+      "dismiss": "Yoksay",
+      "submit": "İncele",
+      "placeholder": "İsteğe bağlı: Bu bulguda tam olarak yanlış veya ikna edici olmayan nedir?",
+      "hint": "Araştırmacının daha derine inmesi, bulguyu gerekçelendirmesi ve doğru ve ilgili olduğunu doğrulaması için boş bırakın.",
+      "investigatingBanner": "İtiraz Araştırmacısı bir bulguyu kaynak koda göre yeniden inceliyor…",
+      "investigatingBadge": "İnceleniyor",
+      "strengthenedBadge": "Güçlendirildi",
+      "upheldBadge": "Onaylandı",
+      "retractedBadge": "Geri çekildi",
+      "verdictLabel": "Araştırmacı:",
+      "failedBadge": "İtiraz başarısız oldu",
+      "failedLabel": "İtiraz başarısız oldu:"
     },
     "fixing": {
       "title": "Seçili bulgular düzeltiliyor…",

package/i18n/locales/uk.json

@@ -4931,10 +4931,39 @@
     "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": "Оскаржити",
+      "reChallenge": "Оскаржити знову",
+      "dismiss": "Відхилити",
+      "submit": "Дослідити",
+      "placeholder": "Необов'язково: що саме неправильне або непереконливе в цьому зауваженні?",
+      "hint": "Залиште порожнім, щоб дослідник копнув глибше, обґрунтував зауваження та перевірив його точність і доречність.",
+      "investigatingBanner": "Дослідник оскаржень повторно перевіряє зауваження за вихідним кодом…",
+      "investigatingBadge": "Дослідження",
+      "strengthenedBadge": "Посилено",
+      "upheldBadge": "Підтверджено",
+      "retractedBadge": "Відкликано",
+      "verdictLabel": "Дослідник:",
+      "failedBadge": "Оскарження не вдалося",
+      "failedLabel": "Оскарження не вдалося:"
     },
     "fixing": {
       "title": "Виправлення вибраних зауважень…",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.146.3",
+  "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",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.153.0"
+    "@cat-factory/contracts": "0.154.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",