@cat-factory/app 0.191.0 → 0.192.0

package/app/components/prReview/PrReviewWindow.vue

@@ -7,6 +7,10 @@
 // findings to a Fixer that commits fixes onto the PR branch), `Post` (publish them as inline PR
 // review comments), or `Finish` (just record the curated selection). Fix/Post act on the
 // selection, so they require at least one selected finding.
+//
+// While the review is still RUNNING it also offers `Resume`, which re-dispatches a review that
+// appears stuck for only the slices that never reported (see `canResume` for why it is always
+// offered rather than gated on an activity heuristic).
 import { computed, ref, watch } from 'vue'
 import { useResultView } from '~/composables/useResultView'
 import { useExecutionStore } from '~/stores/execution'
@@ -208,6 +212,25 @@ async function onResolve(action: PrReviewResolution): Promise<void> {
   await prReview.resolve(id, activeSelectedIds.value, action).catch(() => {})
 }
 
+/**
+ * RESUME a review that appears stuck. Offered throughout the `reviewing` phase — including the
+ * neutral "planning" sub-state, since a wedge is just as possible before a plan is reported as
+ * after — because the whole complaint this answers is that a stuck review had no visible
+ * affordance at all. Deliberately NOT hidden behind a staleness heuristic: `lastActivityAt` freezes
+ * on a long silent turn (a single completion emits no tool call and grows no subagent transcript),
+ * so the platform cannot tell a wedged review from a quiet-but-working one, and hiding the control
+ * until it thinks it can would put it out of reach in exactly the case that motivated it.
+ */
+const canResume = computed(
+  () => status.value === 'reviewing' && !prReview.resuming && access.canExecuteRuns.value,
+)
+
+async function onResume(): Promise<void> {
+  const id = instanceId.value
+  if (!id || !canResume.value) return
+  await prReview.resume(id).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)
@@ -273,7 +296,7 @@ async function onDismiss(id: string): Promise<void> {
           <div
             v-if="planning"
             data-testid="pr-review-planning"
-            class="flex h-full flex-col items-center justify-center gap-2 py-10 text-center text-slate-400"
+            class="flex flex-1 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.planning.title') }}</p>
@@ -395,6 +418,37 @@ async function onDismiss(id: string): Promise<void> {
               </ul>
             </template>
           </div>
+
+          <!-- Nudge a review that looks stuck. Present in BOTH reviewing sub-states, and never
+               gated on a staleness guess: the heartbeat freezes on a long silent turn, so nothing
+               here can tell wedged from quiet-but-working (see `canResume`). Re-reviews only the
+               slices that never reported; the finished ones are re-aggregated from their captured
+               reports. -->
+          <div class="mt-4 border-t border-slate-800 pt-3">
+            <p
+              v-if="prReview.error"
+              data-testid="pr-review-resume-error"
+              class="mb-2 rounded-md bg-rose-500/10 px-3 py-2 text-[12px] text-rose-300"
+            >
+              {{ prReview.error }}
+            </p>
+            <div class="flex items-start justify-between gap-3">
+              <p class="min-w-0 text-[11px] text-slate-500">{{ t('prReview.resume.hint') }}</p>
+              <UButton
+                data-testid="pr-review-resume"
+                size="xs"
+                color="neutral"
+                variant="soft"
+                icon="i-lucide-rotate-ccw"
+                :loading="prReview.resuming"
+                :disabled="!canResume"
+                :title="access.canExecuteRuns.value ? undefined : t('access.noRunExecute')"
+                @click="onResume"
+              >
+                {{ t('prReview.resume.action') }}
+              </UButton>
+            </div>
+          </div>
         </div>
 
         <!-- A resolution is executing: the Fixer is committing / comments are being posted. -->

package/app/composables/api/prReview.ts

@@ -3,6 +3,7 @@ import {
   dismissPrReviewFindingContract,
   getPrReviewContract,
   resolvePrReviewContract,
+  resumePrReviewContract,
 } from '@cat-factory/contracts'
 import type { ApiContext } from './context'
 
@@ -32,6 +33,15 @@ export function prReviewApi({ send, ws }: ApiContext) {
         body,
       }),
 
+    // Re-trigger a review stuck mid-`reviewing`: only the slices that never reported are
+    // re-reviewed. No body — the engine derives what to redo from what it observed.
+    resumePrReview: (workspaceId: string, executionId: string) =>
+      send(resumePrReviewContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId },
+        body: {},
+      }),
+
     // Dismiss a parked finding entirely (drops it + prunes it from the selection).
     dismissPrReviewFinding: (workspaceId: string, executionId: string, findingId: string) =>
       send(dismissPrReviewFindingContract, {

package/app/stores/execution.spec.ts

@@ -186,3 +186,90 @@ describe('execution store metrics preservation (live-only rollup)', () => {
     expect(step.metrics?.calls).toBe(5)
   })
 })
+
+// Regression for the optimistic-echo CLOBBER. `upsert`/`hydrate` are monotonic by `rev`, but an
+// action store's echo used to reach into the cached run and assign a step's sub-state directly,
+// comparing nothing — so a slow HTTP response overwrote state the stream had already advanced, and
+// no later event restored it. `echoAfter` closes that by capturing the run's `rev` before the
+// request and re-reading it after.
+//
+// The fork-decision chat is the case that caught it in CI: `chat` emits the one-message `answering`
+// state and then wakes the driver, which appends the reply and emits again. With a canned (no-model)
+// reply the two-message thread routinely lands first, and echoing the response dropped the reply
+// permanently — a parked run emits nothing more.
+describe('execution store echoAfter (optimistic-echo guard)', () => {
+  let store: ReturnType<typeof useExecutionStore>
+  beforeEach(() => {
+    store = useExecutionStore()
+  })
+
+  const run = (rev: number, chat: unknown[]): ExecutionInstance =>
+    ({
+      id: 'e1',
+      blockId: 'b1',
+      rev,
+      currentStep: 0,
+      steps: [{ agentKind: 'coder', forkDecision: { status: 'answering', chat } }],
+    }) as unknown as ExecutionInstance
+
+  const chatOf = () =>
+    (store.getInstance('e1')!.steps[0] as unknown as { forkDecision: { chat: unknown[] } })
+      .forkDecision.chat
+
+  it('applies the echo when nothing newer arrived while the request was in flight', () => {
+    store.hydrate([run(1, ['human'])], 'ws1')
+    return store
+      .echoAfter(
+        'e1',
+        async () => ({ status: 'answering', chat: ['human', 'echoed'] }),
+        (state, instance) => {
+          ;(instance.steps[0] as unknown as { forkDecision: unknown }).forkDecision = state
+        },
+      )
+      .then(() => expect(chatOf()).toEqual(['human', 'echoed']))
+  })
+
+  it('DROPS the echo when the stream delivered a newer revision first', async () => {
+    store.hydrate([run(1, ['human'])], 'ws1')
+    // The driver's reply lands (rev 2, two messages) while the chat POST is still in flight...
+    await store.echoAfter(
+      'e1',
+      async () => {
+        store.upsert(run(2, ['human', 'assistant reply']))
+        return { status: 'answering', chat: ['human'] }
+      },
+      (state, instance) => {
+        ;(instance.steps[0] as unknown as { forkDecision: unknown }).forkDecision = state
+      },
+    )
+    // ...so the one-message response must not put the thread back. Unguarded, this was ['human'],
+    // the reply was gone, and the "thinking…" bubble spun forever.
+    expect(chatOf()).toEqual(['human', 'assistant reply'])
+  })
+
+  it('still returns the response body when the echo is dropped', async () => {
+    store.hydrate([run(1, [])], 'ws1')
+    const returned = await store.echoAfter(
+      'e1',
+      async () => {
+        store.upsert(run(5, ['newer']))
+        return 'body'
+      },
+      () => {
+        throw new Error('apply must not run')
+      },
+    )
+    expect(returned).toBe('body')
+  })
+
+  it('skips the echo for a run the cache does not hold, rather than throwing', async () => {
+    const returned = await store.echoAfter(
+      'missing',
+      async () => 'body',
+      () => {
+        throw new Error('apply must not run')
+      },
+    )
+    expect(returned).toBe('body')
+  })
+})

package/app/stores/execution.ts

@@ -130,6 +130,44 @@ export const useExecutionStore = defineStore('execution', () => {
     } else instances.value.push(instance)
   }
 
+  /**
+   * Run an action that returns a run's authoritative sub-state and apply that state to the cached
+   * run as an OPTIMISTIC ECHO — but only when the event stream has not delivered a newer revision
+   * while the request was in flight.
+   *
+   * WHY THIS EXISTS. {@link upsert} and {@link hydrate} are monotonic by `rev`, so a stale stream
+   * event can never regress a run. An action store's echo bypassed both: it reached into the cached
+   * instance and assigned `step.forkDecision` / `step.prReview` / `step.judge` / `step.followUps`
+   * directly, with nothing comparing revisions. That is a live-push CLOBBER in its optimistic-echo
+   * form, and it loses state that no later event restores.
+   *
+   * The fork-decision chat is the case that caught it. `chat` records the human turn and wakes the
+   * durable driver, which computes the reply and re-parks — two separate emits. With no model wired
+   * the reply is canned, so the driver routinely emits the two-message thread BEFORE the browser has
+   * even processed the HTTP response carrying the one-message `answering` state. Echoing that
+   * response then dropped the reply back off the thread, permanently: the run is parked, so nothing
+   * emits again. It read as a hung "thinking…" bubble to a user and as a flaky spec in CI.
+   *
+   * The guard is the run's own `rev`, captured BEFORE the request and re-read after. Any advance
+   * means the stream has already delivered this write (or something later), so the echo has nothing
+   * left to add and is skipped. Unchanged means the echo is still the freshest thing available,
+   * which is exactly what it is for. Taking the request as a thunk keeps the capture-then-compare
+   * ordering here rather than at four call sites that each have to remember it.
+   */
+  async function echoAfter<T>(
+    executionId: string,
+    send: () => Promise<T>,
+    apply: (state: T, instance: ExecutionInstance) => void,
+  ): Promise<T> {
+    const before = byId.value.get(executionId)
+    const revBefore = before ? revOf(before) : -1
+    const state = await send()
+    const instance = byId.value.get(executionId)
+    if (!instance || revOf(instance) !== revBefore) return state
+    apply(state, instance)
+    return state
+  }
+
   const byId = computed(() => {
     const map = new Map<string, ExecutionInstance>()
     for (const e of instances.value) map.set(e.id, e)
@@ -248,6 +286,7 @@ export const useExecutionStore = defineStore('execution', () => {
     instances,
     hydrate,
     upsert,
+    echoAfter,
     byId,
     getInstance,
     getByBlock,

package/app/stores/followUps.ts

@@ -33,7 +33,7 @@ export const useFollowUpsStore = defineStore('followUps', () => {
     acting.value = next
   }
 
-  /** Run one decide action, reflecting the returned state onto the run's Coder step. */
+  /** Run one decide action, echoing the returned state onto the run's Coder step. */
   async function act(
     executionId: string,
     itemId: string,
@@ -42,13 +42,19 @@ export const useFollowUpsStore = defineStore('followUps', () => {
     error.value = null
     mark(itemId, true)
     try {
-      const state = await call(workspace.requireId())
-      // Reflect the authoritative state immediately (the stream will also echo it).
-      const instance = execution.getInstance(executionId)
-      const step = instance?.steps.find((s) => s.followUps?.enabled)
-      if (step && state && typeof state === 'object') {
-        step.followUps = state as typeof step.followUps
-      }
+      // Echo the authoritative state immediately (the stream also delivers it), but only when the
+      // stream has not already delivered something NEWER — deciding a follow-up can re-arm the run,
+      // so the driver emits while this response is still in flight. See `execution.echoAfter`.
+      await execution.echoAfter(
+        executionId,
+        () => call(workspace.requireId()),
+        (state, instance) => {
+          const step = instance.steps.find((s) => s.followUps?.enabled)
+          if (step && state && typeof state === 'object') {
+            step.followUps = state as typeof step.followUps
+          }
+        },
+      )
     } catch (e) {
       error.value = e instanceof Error ? e.message : 'Action failed'
       throw e

package/app/stores/forkDecision.ts

@@ -26,17 +26,20 @@ export const useForkDecisionStore = defineStore('forkDecision', () => {
   const error = ref<string | null>(null)
 
   /**
-   * Reflect an authoritative fork-decision state onto the run's Coder step. A pipeline may
+   * Apply an authoritative fork-decision state to the run's Coder step. A pipeline may
    * carry more than one `coder` step, so target the step this decision is about rather than
    * the first one that happens to hold fork state: prefer the step that is still live
    * (proposing / awaiting the choice / answering), then the current step, and only then fall
-   * back to the first step carrying fork state. The stream corrects any mismatch, but this
-   * keeps the immediate optimistic echo on the right step.
+   * back to the first step carrying fork state.
+   *
+   * Only ever called through {@link ExecutionStore.echoAfter}, which drops the echo when the event
+   * stream already delivered a newer revision — without that guard this assignment silently
+   * regressed the chat thread (see `echoAfter` for the failure it caused).
    */
-  function reflect(executionId: string, state: ForkDecisionStepState | null): void {
-    if (!state) return
-    const instance = execution.getInstance(executionId)
-    if (!instance) return
+  function assign(
+    instance: ReturnType<typeof execution.getInstance> & object,
+    state: ForkDecisionStepState,
+  ): void {
     const isLive = (s: (typeof instance.steps)[number]) =>
       s.agentKind === 'coder' &&
       (s.forkDecision?.status === 'awaiting_choice' ||
@@ -54,8 +57,13 @@ export const useForkDecisionStore = defineStore('forkDecision', () => {
   async function load(executionId: string): Promise<void> {
     error.value = null
     try {
-      const state = await api.getForkDecision(workspace.requireId(), executionId)
-      reflect(executionId, state as ForkDecisionStepState | null)
+      await execution.echoAfter(
+        executionId,
+        () => api.getForkDecision(workspace.requireId(), executionId),
+        (state, instance) => {
+          if (state) assign(instance, state as ForkDecisionStepState)
+        },
+      )
     } catch (e) {
       error.value = e instanceof Error ? e.message : 'Failed to load'
     }
@@ -72,8 +80,11 @@ export const useForkDecisionStore = defineStore('forkDecision', () => {
     error.value = null
     choosing.value = true
     try {
-      const state = await api.chooseFork(workspace.requireId(), executionId, choice)
-      reflect(executionId, state as ForkDecisionStepState)
+      await execution.echoAfter(
+        executionId,
+        () => api.chooseFork(workspace.requireId(), executionId, choice),
+        (state, instance) => assign(instance, state as ForkDecisionStepState),
+      )
     } catch (e) {
       error.value = e instanceof Error ? e.message : 'Failed to choose'
       throw e
@@ -85,15 +96,24 @@ export const useForkDecisionStore = defineStore('forkDecision', () => {
   /**
    * Send a grounded chat message about the surfaced forks. The reply is computed inline in the
    * durable driver and arrives via the execution stream; the immediate response is the
-   * `answering` state (the human message already appended), which we reflect so the thread shows
-   * the sent turn + a "thinking…" bubble without waiting for the stream.
+   * `answering` state (the human message already appended), echoed so the thread shows the sent
+   * turn + a "thinking…" bubble without waiting for the stream.
+   *
+   * The echo is the RACIEST one in the app and must stay guarded: `chat` emits the one-message
+   * `answering` state and then wakes the driver, which appends the reply and emits again, so with a
+   * canned (no-model) reply the two-message thread frequently reaches the browser first. Applying
+   * this response unconditionally dropped the reply and left the bubble spinning forever, since a
+   * parked run emits nothing more.
    */
   async function chat(executionId: string, text: string): Promise<void> {
     error.value = null
     chatting.value = true
     try {
-      const state = await api.forkChat(workspace.requireId(), executionId, text)
-      reflect(executionId, state as ForkDecisionStepState)
+      await execution.echoAfter(
+        executionId,
+        () => api.forkChat(workspace.requireId(), executionId, text),
+        (state, instance) => assign(instance, state as ForkDecisionStepState),
+      )
     } catch (e) {
       error.value = e instanceof Error ? e.message : 'Failed to send message'
       throw e

package/app/stores/judge.ts

@@ -27,13 +27,16 @@ export const useJudgeStore = defineStore('judge', () => {
    * Reflect an authoritative judge state onto the run's judge step. A pipeline may place more
    * than one judge, so target the step this verdict is about rather than the first one holding
    * judge state: prefer the step still awaiting a decision, then the current step, and only then
-   * fall back to the first step carrying judge state. The stream corrects any mismatch; this
-   * keeps the immediate optimistic echo on the right step.
+   * fall back to the first step carrying judge state.
+   *
+   * Only ever called through {@link ExecutionStore.echoAfter}, which drops the echo when the event
+   * stream already delivered a newer revision — a `bounce` re-arms the producing step, so the
+   * driver is emitting fresh state while this response is still in flight.
    */
-  function reflect(executionId: string, state: JudgeStepState | null): void {
-    if (!state) return
-    const instance = execution.getInstance(executionId)
-    if (!instance) return
+  function assign(
+    instance: ReturnType<typeof execution.getInstance> & object,
+    state: JudgeStepState,
+  ): void {
     const current = instance.steps[instance.currentStep]
     const step =
       instance.steps.find((s) => s.judge?.status === 'awaiting_decision') ??
@@ -46,8 +49,13 @@ export const useJudgeStore = defineStore('judge', () => {
   async function load(executionId: string): Promise<void> {
     error.value = null
     try {
-      const state = await api.getJudgeState(workspace.requireId(), executionId)
-      reflect(executionId, state as JudgeStepState | null)
+      await execution.echoAfter(
+        executionId,
+        () => api.getJudgeState(workspace.requireId(), executionId),
+        (state, instance) => {
+          if (state) assign(instance, state as JudgeStepState)
+        },
+      )
     } catch (e) {
       error.value = e instanceof Error ? e.message : 'Failed to load'
     }
@@ -66,11 +74,15 @@ export const useJudgeStore = defineStore('judge', () => {
     error.value = null
     resolving.value = true
     try {
-      const state = await api.resolveJudge(workspace.requireId(), executionId, {
-        choice,
-        ...(feedback ? { feedback } : {}),
-      })
-      reflect(executionId, state as JudgeStepState)
+      await execution.echoAfter(
+        executionId,
+        () =>
+          api.resolveJudge(workspace.requireId(), executionId, {
+            choice,
+            ...(feedback ? { feedback } : {}),
+          }),
+        (state, instance) => assign(instance, state as JudgeStepState),
+      )
     } catch (e) {
       error.value = e instanceof Error ? e.message : 'Failed to resolve'
       throw e

package/app/stores/prReview.ts

@@ -20,20 +20,30 @@ export const usePrReviewStore = defineStore('prReview', () => {
 
   /** True while a resolve call is in flight (drives the Finish button spinner / disabled state). */
   const resolving = ref(false)
+  /**
+   * True while a RESUME call is in flight. Kept separate from `resolving` rather than folded into
+   * it: a resume acts during the `reviewing` phase and a resolve during `awaiting_selection`, so
+   * sharing one flag would let either action's spinner appear on the other's controls.
+   */
+  const resuming = ref(false)
   /** The last error message from an action, surfaced inline; cleared on the next action. */
   const error = ref<string | null>(null)
 
   /**
-   * Reflect an authoritative PR-review state onto the run's `pr-reviewer` step. A pipeline could
+   * Apply an authoritative PR-review state to the run's `pr-reviewer` step. A pipeline could
    * carry more than one such step, so target the step this review is about: prefer the step that
    * is still awaiting a selection, then the current step, and only then the first step carrying
-   * review state. The stream corrects any mismatch; this keeps the immediate optimistic echo on
-   * the right step.
+   * review state.
+   *
+   * Only ever called through {@link ExecutionStore.echoAfter}, which drops the echo when the event
+   * stream already delivered a newer revision. `resume` needs that guard most: it returns a
+   * `reviewing` state and then the re-dispatched reviewer starts publishing slice reviews, so an
+   * unguarded echo could put the freshly-captured reports back to what the resume saw.
    */
-  function reflect(executionId: string, state: PrReviewStepState | null): void {
-    if (!state) return
-    const instance = execution.getInstance(executionId)
-    if (!instance) return
+  function assign(
+    instance: ReturnType<typeof execution.getInstance> & object,
+    state: PrReviewStepState,
+  ): void {
     const isLive = (s: (typeof instance.steps)[number]) =>
       s.agentKind === 'pr-reviewer' && s.prReview?.status === 'awaiting_selection'
     const current = instance.steps[instance.currentStep]
@@ -48,8 +58,13 @@ export const usePrReviewStore = defineStore('prReview', () => {
   async function load(executionId: string): Promise<void> {
     error.value = null
     try {
-      const state = await api.getPrReview(workspace.requireId(), executionId)
-      reflect(executionId, state as PrReviewStepState | null)
+      await execution.echoAfter(
+        executionId,
+        () => api.getPrReview(workspace.requireId(), executionId),
+        (state, instance) => {
+          if (state) assign(instance, state as PrReviewStepState)
+        },
+      )
     } catch (e) {
       error.value = e instanceof Error ? e.message : 'Failed to load'
     }
@@ -69,11 +84,11 @@ export const usePrReviewStore = defineStore('prReview', () => {
     error.value = null
     resolving.value = true
     try {
-      const state = await api.resolvePrReview(workspace.requireId(), executionId, {
-        action,
-        findingIds,
-      })
-      reflect(executionId, state as PrReviewStepState)
+      await execution.echoAfter(
+        executionId,
+        () => api.resolvePrReview(workspace.requireId(), executionId, { action, findingIds }),
+        (state, instance) => assign(instance, state as PrReviewStepState),
+      )
     } catch (e) {
       error.value = e instanceof Error ? e.message : 'Failed to resolve review'
       throw e
@@ -82,13 +97,38 @@ export const usePrReviewStore = defineStore('prReview', () => {
     }
   }
 
+  /**
+   * Resume a review stuck mid-`reviewing`: the reviewer is re-dispatched for only the slices that
+   * never reported, and the already-captured reports are fed back in so the finished slices are
+   * re-aggregated rather than re-reviewed. Rejected (409) unless the review is still `reviewing`.
+   */
+  async function resume(executionId: string): Promise<void> {
+    error.value = null
+    resuming.value = true
+    try {
+      await execution.echoAfter(
+        executionId,
+        () => api.resumePrReview(workspace.requireId(), executionId),
+        (state, instance) => assign(instance, state as PrReviewStepState),
+      )
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to resume review'
+      throw e
+    } finally {
+      resuming.value = false
+    }
+  }
+
   /** 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)
+      await execution.echoAfter(
+        executionId,
+        () => api.dismissPrReviewFinding(workspace.requireId(), executionId, findingId),
+        (state, instance) => assign(instance, state as PrReviewStepState),
+      )
     } catch (e) {
       error.value = e instanceof Error ? e.message : 'Failed to dismiss finding'
       throw e
@@ -110,15 +150,14 @@ export const usePrReviewStore = defineStore('prReview', () => {
     error.value = null
     resolving.value = true
     try {
-      const state = await api.challengePrReviewFinding(
-        workspace.requireId(),
+      await execution.echoAfter(
         executionId,
-        findingId,
-        {
-          question,
-        },
+        () =>
+          api.challengePrReviewFinding(workspace.requireId(), executionId, findingId, {
+            question,
+          }),
+        (state, instance) => assign(instance, state as PrReviewStepState),
       )
-      reflect(executionId, state as PrReviewStepState)
     } catch (e) {
       error.value = e instanceof Error ? e.message : 'Failed to challenge finding'
       throw e
@@ -127,5 +166,5 @@ export const usePrReviewStore = defineStore('prReview', () => {
     }
   }
 
-  return { resolving, error, load, resolve, dismiss, challenge }
+  return { resolving, resuming, error, load, resolve, resume, dismiss, challenge }
 })

package/i18n/locales/de.json

@@ -5660,6 +5660,10 @@
         "pending": "In Warteschlange"
       }
     },
+    "resume": {
+      "action": "Review fortsetzen",
+      "hint": "Hängt es? Beim Fortsetzen werden nur die Abschnitte erneut geprüft, die nie zurückgemeldet haben; die Ergebnisse der fertigen bleiben erhalten."
+    },
     "phase": {
       "planning": "Wird geprüft…",
       "reviewing": "Prüfe {completed}/{total} Abschnitte",

package/i18n/locales/en.json

@@ -5836,6 +5836,10 @@
         "pending": "Queued"
       }
     },
+    "resume": {
+      "action": "Resume review",
+      "hint": "Looks stuck? Resuming re-reviews only the chunks that never came back, and keeps the findings from the ones that did."
+    },
     "phase": {
       "planning": "Reviewing…",
       "reviewing": "Reviewing {completed}/{total} slices",

package/i18n/locales/es.json

@@ -5648,6 +5648,10 @@
         "pending": "En cola"
       }
     },
+    "resume": {
+      "action": "Reanudar la revisión",
+      "hint": "¿Parece atascada? Al reanudar solo se vuelven a revisar los fragmentos que nunca respondieron y se conservan los hallazgos de los ya terminados."
+    },
     "phase": {
       "planning": "Revisando…",
       "reviewing": "Revisando {completed}/{total} secciones",

package/i18n/locales/fr.json

@@ -5648,6 +5648,10 @@
         "pending": "En attente"
       }
     },
+    "resume": {
+      "action": "Reprendre la revue",
+      "hint": "Elle semble bloquée ? La reprise ne réexamine que les sections qui n’ont jamais répondu et conserve les constats de celles déjà terminées."
+    },
     "phase": {
       "planning": "Révision…",
       "reviewing": "Révision {completed}/{total} sections",

package/i18n/locales/he.json

@@ -5659,6 +5659,10 @@
         "pending": "בתור"
       }
     },
+    "resume": {
+      "action": "המשך סקירה",
+      "hint": "נראה שנתקע? המשך יבדוק מחדש רק את המקטעים שלא חזרו, וישמור את הממצאים של אלה שכבר הושלמו."
+    },
     "phase": {
       "planning": "בודק…",
       "reviewing": "בודק {completed}/{total} מקטעים",

package/i18n/locales/it.json

@@ -5660,6 +5660,10 @@
         "pending": "In coda"
       }
     },
+    "resume": {
+      "action": "Riprendi la revisione",
+      "hint": "Sembra bloccata? La ripresa riesamina solo i blocchi che non hanno mai risposto e conserva i rilievi di quelli già completati."
+    },
     "phase": {
       "planning": "Revisione…",
       "reviewing": "Revisione {completed}/{total} sezioni",

package/i18n/locales/ja.json

@@ -5660,6 +5660,10 @@
         "pending": "待機中"
       }
     },
+    "resume": {
+      "action": "レビューを再開",
+      "hint": "停止しているように見えますか？再開すると、応答がなかったチャンクだけを再レビューし、完了済みチャンクの指摘はそのまま引き継ぎます。"
+    },
     "phase": {
       "planning": "レビュー中…",
       "reviewing": "レビュー中 {completed}/{total} 区分",

package/i18n/locales/pl.json

@@ -5648,6 +5648,10 @@
         "pending": "W kolejce"
       }
     },
+    "resume": {
+      "action": "Wznów przegląd",
+      "hint": "Wygląda na zawieszony? Wznowienie sprawdza ponownie tylko te fragmenty, które nigdy nie odpowiedziały, i zachowuje ustalenia z już ukończonych."
+    },
     "phase": {
       "planning": "Przegląd…",
       "reviewing": "Przegląd {completed}/{total} fragmentów",

package/i18n/locales/tr.json

@@ -5660,6 +5660,10 @@
         "pending": "Sırada"
       }
     },
+    "resume": {
+      "action": "İncelemeyi sürdür",
+      "hint": "Takılmış gibi mi görünüyor? Sürdürme yalnızca hiç yanıt vermeyen parçaları yeniden inceler ve tamamlananların bulgularını korur."
+    },
     "phase": {
       "planning": "İnceleniyor…",
       "reviewing": "İnceleniyor {completed}/{total} bölüm",

package/i18n/locales/uk.json

@@ -5648,6 +5648,10 @@
         "pending": "У черзі"
       }
     },
+    "resume": {
+      "action": "Відновити рецензування",
+      "hint": "Схоже, що зависло? Відновлення повторно перевіряє лише ті фрагменти, які не відповіли, і зберігає висновки вже завершених."
+    },
     "phase": {
       "planning": "Перевірка…",
       "reviewing": "Перевірка {completed}/{total} фрагментів",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.191.0",
+  "version": "0.192.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.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.198.0"
+    "@cat-factory/contracts": "0.199.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",