@cat-factory/app 0.118.0 → 0.119.0

package/app/components/prReview/PrReviewWindow.vue

@@ -3,14 +3,21 @@
 // prioritized findings, opened via the universal result-view host. It reads the live review
 // state straight off the run's `pr-reviewer` step (`step.prReview`, kept fresh by the
 // execution stream) and lets a human multi-SELECT which findings matter, grouped by slice and
-// sorted by severity, then finish the review. The Fixer / inline-comment resolutions are the
-// tracked PR 3 follow-up; this window's `Finish review` records the curated selection.
+// sorted by severity, then resolve the review one of three ways: `Fix` (feed the selected
+// 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.
 import { computed, ref, watch } from 'vue'
 import { useResultView } from '~/composables/useResultView'
 import { useExecutionStore } from '~/stores/execution'
 import { useBoardStore } from '~/stores/board'
 import { usePrReviewStore } from '~/stores/prReview'
-import type { PrReviewFinding, PrReviewSeverity, PrReviewStepState } from '~/types/execution'
+import type {
+  PrReviewFinding,
+  PrReviewResolution,
+  PrReviewSeverity,
+  PrReviewStepState,
+} from '~/types/execution'
 
 const execution = useExecutionStore()
 const board = useBoardStore()
@@ -35,6 +42,9 @@ 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 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')
 const findings = computed<PrReviewFinding[]>(() => state.value?.findings ?? [])
 
 /** Severity → chip classes (styling, not copy). */
@@ -97,12 +107,16 @@ function clearAll(): void {
   selected.value = new Set()
 }
 
-const canFinish = computed(() => awaiting.value && !prReview.resolving)
+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)
 
-async function onFinish(): Promise<void> {
+async function onResolve(action: PrReviewResolution): Promise<void> {
   const id = instanceId.value
-  if (!id || !canFinish.value) return
-  await prReview.resolve(id, [...selected.value]).catch(() => {})
+  if (!id || !canResolve.value) return
+  if ((action === 'fix' || action === 'post') && !hasSelection.value) return
+  await prReview.resolve(id, [...selected.value], action).catch(() => {})
 }
 </script>
 
@@ -162,6 +176,21 @@ async function onFinish(): Promise<void> {
             <p class="max-w-sm text-[11px] text-slate-500">{{ t('prReview.reviewing.hint') }}</p>
           </div>
 
+          <!-- A resolution is executing: the Fixer is committing / comments are being posted. -->
+          <div
+            v-else-if="working"
+            data-testid="pr-review-working"
+            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">
+              {{ status === 'fixing' ? t('prReview.fixing.title') : t('prReview.posting.title') }}
+            </p>
+            <p class="max-w-sm text-[11px] text-slate-500">
+              {{ status === 'fixing' ? t('prReview.fixing.hint') : t('prReview.posting.hint') }}
+            </p>
+          </div>
+
           <template v-else>
             <p
               v-if="prReview.error"
@@ -274,14 +303,32 @@ async function onFinish(): Promise<void> {
           class="flex items-center justify-end gap-2 border-t border-slate-800 px-5 py-3"
         >
           <UButton
-            color="primary"
-            :loading="prReview.resolving"
-            :disabled="!canFinish"
+            color="neutral"
+            variant="ghost"
+            :disabled="!canResolve"
             data-testid="pr-review-finish"
-            @click="onFinish"
+            @click="onResolve('finish')"
           >
             {{ t('prReview.finish') }}
           </UButton>
+          <UButton
+            color="neutral"
+            variant="soft"
+            :disabled="!canResolve || !hasSelection"
+            data-testid="pr-review-post"
+            @click="onResolve('post')"
+          >
+            {{ t('prReview.post') }}
+          </UButton>
+          <UButton
+            color="primary"
+            :loading="prReview.resolving"
+            :disabled="!canResolve || !hasSelection"
+            data-testid="pr-review-fix"
+            @click="onResolve('fix')"
+          >
+            {{ t('prReview.fix') }}
+          </UButton>
         </footer>
       </div>
     </div>

package/app/composables/api/prReview.ts

@@ -14,11 +14,12 @@ export function prReviewApi({ send, ws }: ApiContext) {
     getPrReview: (workspaceId: string, executionId: string) =>
       send(getPrReviewContract, { pathPrefix: ws(workspaceId), pathParams: { executionId } }),
 
-    // Resolve a parked PR review: the curated finding selection + how it was resolved.
+    // Resolve a parked PR review: the curated finding selection + how it was resolved
+    // (`finish` completes it, `fix` feeds a Fixer, `post` publishes inline PR comments).
     resolvePrReview: (
       workspaceId: string,
       executionId: string,
-      body: { action?: 'finish'; findingIds?: string[] },
+      body: { action?: 'finish' | 'fix' | 'post'; findingIds?: string[] },
     ) =>
       send(resolvePrReviewContract, {
         pathPrefix: ws(workspaceId),

package/app/stores/board.ts

@@ -42,6 +42,16 @@ export const useBoardStore = defineStore('board', () => {
       params ?? {},
     )
   const blocks = ref<Block[]>([])
+  // Client-side monotonic guard against a stale full-snapshot `hydrate` CLOBBERING newer live
+  // state. A run's status transitions (…→ in_progress → pr_ready/done) reach the board as
+  // targeted `execution`-event `upsert`s; a `refresh()` whose snapshot was FETCHED earlier (its
+  // block still `in_progress`) can resolve AFTER such an upsert and, since `hydrate` REPLACES the
+  // list, overwrite the just-applied terminal status back to the stale value — with no further
+  // event to restore it (the documented real-time coherence hazard; reliably hit under CI
+  // latency). Blocks carry no server revision, so we stamp each live `upsert` with a monotonic
+  // sequence and let `hydrate` preserve any block upserted AFTER the refresh's captured baseline.
+  let liveUpsertSeq = 0
+  const liveUpsertAt = new Map<string, number>()
   // Archived service frames (`archived === true`): hidden from the board but preserved and
   // restorable with no expiry. Hydrated from the snapshot's `archivedServices`; the frames
   // themselves are NOT in `blocks` (the snapshot filters an archived frame + its subtree out).
@@ -111,10 +121,22 @@ export const useBoardStore = defineStore('board', () => {
     }
     return s
   }
-  function hydrate(next: Block[]) {
+  /**
+   * Baseline for {@link hydrate}: capture this BEFORE a refresh's snapshot fetch and pass it
+   * back in, so a block that received a live `upsert` while the fetch was in flight is preserved
+   * (its live state is newer than the snapshot). Callers that don't pass a baseline get a plain
+   * full replace (initial load / board switch — no live-upsert race to guard).
+   */
+  function hydrateBaseline(): number {
+    return liveUpsertSeq
+  }
+  function hydrate(next: Block[], since = liveUpsertSeq) {
     const prev = new Map(blocks.value.map((b) => [b.id, b]))
     const reconciled = next.map((n) => {
       const existing = prev.get(n.id)
+      // A block live-`upsert`ed AFTER this refresh's fetch started is newer than the snapshot —
+      // keep the live version instead of clobbering it back to the stale snapshot value.
+      if (existing && (liveUpsertAt.get(n.id) ?? 0) > since) return existing
       return existing && jsonFor(existing) === jsonFor(n) ? existing : n
     })
     // Keep blocks the user just deleted hidden while their delete is still pending.
@@ -147,6 +169,8 @@ export const useBoardStore = defineStore('board', () => {
   function upsert(block: Block) {
     // A live event for a block awaiting its deferred delete must not resurrect it.
     if (pendingDoomed.has(block.id)) return
+    // Stamp the live-upsert order so a later, staler refresh `hydrate` can't clobber this.
+    liveUpsertAt.set(block.id, ++liveUpsertSeq)
     const i = blocks.value.findIndex((b) => b.id === block.id)
     if (i >= 0) blocks.value[i] = block
     else blocks.value.push(block)
@@ -612,6 +636,7 @@ export const useBoardStore = defineStore('board', () => {
     blocks,
     archived,
     hydrate,
+    hydrateBaseline,
     hydrateArchived,
     upsert,
     ...queries,

package/app/stores/prReview.ts

@@ -1,6 +1,6 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
-import type { PrReviewStepState } from '~/types/execution'
+import type { PrReviewResolution, PrReviewStepState } from '~/types/execution'
 import { useApi } from '~/composables/useApi'
 import { useWorkspaceStore } from '~/stores/workspace'
 import { useExecutionStore } from '~/stores/execution'
@@ -56,15 +56,21 @@ export const usePrReviewStore = defineStore('prReview', () => {
   }
 
   /**
-   * Resolve the review: record the curated finding selection and complete the read-only review
-   * (the run then advances to done). PR 2 supports only the `finish` action.
+   * Resolve the review: record the curated finding selection and act on it. `finish` completes
+   * the read-only review; `fix` feeds the selected findings to a Fixer (which commits fixes onto
+   * the reviewed PR's branch); `post` publishes them as inline PR review comments. The run then
+   * advances (or re-dispatches for `fix`). `fix`/`post` require ≥1 selected finding.
    */
-  async function resolve(executionId: string, findingIds: string[]): Promise<void> {
+  async function resolve(
+    executionId: string,
+    findingIds: string[],
+    action: PrReviewResolution = 'finish',
+  ): Promise<void> {
     error.value = null
     resolving.value = true
     try {
       const state = await api.resolvePrReview(workspace.requireId(), executionId, {
-        action: 'finish',
+        action,
         findingIds,
       })
       reflect(executionId, state as PrReviewStepState)

package/app/stores/workspace.spec.ts

@@ -111,6 +111,44 @@ describe('workspace store refresh ordering', () => {
     // The fresh snapshot won and the stale one was discarded: the spawned card survives.
     expect(board.getBlock('spawned')).toBeDefined()
   })
+
+  // Regression for the SECOND clobber axis: a refresh vs an interleaved live `upsert`. The
+  // `refreshSeq` guard above only orders refreshes against each OTHER — it does nothing when a
+  // single refresh's (slow) fetch overlaps a targeted live event. A run's status transitions
+  // (…→ in_progress → pr_ready/done) arrive as `execution`-event `board.upsert`s; a refresh whose
+  // snapshot was FETCHED while the block was still `in_progress` must not, on resolving later,
+  // replace that block back to the stale status. This was the reliable-under-CI-latency e2e
+  // timeout where a run never showed a terminal `data-status`. The board store now stamps each
+  // live upsert and `refresh()` captures a baseline before its fetch so the newer live state wins.
+  it('a refresh started before a live upsert does not clobber the newer live status', async () => {
+    const frame = block('f1')
+    const task = block('t1', { level: 'task', parentId: 'f1', status: 'in_progress' })
+    let resolveRefresh!: (s: WorkspaceSnapshot) => void
+    const getWorkspace = vi
+      .fn()
+      // 1) switchTo — the task is mid-run (`in_progress`).
+      .mockResolvedValueOnce(snapshot('ws1', [frame, task]))
+      // 2) a refresh whose fetch is in flight while a live terminal event lands.
+      .mockReturnValueOnce(new Promise<WorkspaceSnapshot>((r) => (resolveRefresh = r)))
+    vi.stubGlobal('useApi', () => ({ getWorkspace }))
+
+    const ws = useWorkspaceStore()
+    const board = useBoardStore()
+    await ws.switchTo('ws1')
+    expect(board.getBlock('t1')?.status).toBe('in_progress')
+
+    // A refresh starts (captures the board baseline; its snapshot still shows `in_progress`).
+    const pass = ws.refresh()
+    // A live execution event lands mid-fetch: the run reached terminal, so the block is `done`.
+    board.upsert(block('t1', { level: 'task', parentId: 'f1', status: 'done' }))
+    expect(board.getBlock('t1')?.status).toBe('done')
+    // The now-stale refresh resolves with its older `in_progress` snapshot.
+    resolveRefresh(snapshot('ws1', [frame, block('t1', { level: 'task', parentId: 'f1' })]))
+    await pass
+
+    // The live terminal status survives — the stale refresh did NOT clobber it back.
+    expect(board.getBlock('t1')?.status).toBe('done')
+  })
 })
 
 // Cold-open waterfall flattening (app-startup initiative, item 8): `init()` fetches the persisted

package/app/stores/workspace.ts

@@ -85,8 +85,13 @@ export const useWorkspaceStore = defineStore(
       () => workspaces.value.find((w) => w.id === workspaceId.value) ?? null,
     )
 
-    /** Push a snapshot into the data stores. */
-    function hydrate(snapshot: WorkspaceSnapshot) {
+    /**
+     * Push a snapshot into the data stores. `boardSince` (captured BEFORE this snapshot's fetch)
+     * lets the board store preserve any block live-`upsert`ed while the fetch was in flight, so a
+     * slower refresh can't clobber a newer live status (see `useBoardStore().hydrate`). Omitted by
+     * fresh loads (init/switch/create), where there is no in-flight-upsert race to guard.
+     */
+    function hydrate(snapshot: WorkspaceSnapshot, boardSince?: number) {
       // A change of active board (or the first load) — drop the per-block caches that are
       // NOT part of the snapshot (reviews, brainstorm/consensus sessions, the GitHub
       // projection) so a switched-to board never shows the previous one's stale state.
@@ -116,7 +121,7 @@ export const useWorkspaceStore = defineStore(
       const i = workspaces.value.findIndex((w) => w.id === snapshot.workspace.id)
       if (i >= 0) workspaces.value[i] = snapshot.workspace
       else workspaces.value.unshift(snapshot.workspace)
-      useBoardStore().hydrate(snapshot.blocks)
+      useBoardStore().hydrate(snapshot.blocks, boardSince)
       useBoardStore().hydrateArchived(snapshot.archivedServices ?? [])
       usePipelinesStore().hydrate(snapshot.pipelines, snapshot.pipelineCatalogVersions)
       useExecutionStore().hydrate(snapshot.executions, snapshot.workspace.id)
@@ -291,11 +296,17 @@ export const useWorkspaceStore = defineStore(
       const targetId = workspaceId.value
       if (!targetId) return
       const seq = ++refreshSeq
+      // Capture the board's live-upsert baseline BEFORE the fetch: any block upserted by a live
+      // event while this (potentially slow) snapshot is in flight is newer than the snapshot, so
+      // `hydrate` must NOT clobber it back. The `refreshSeq` guard below only orders refreshes
+      // against each OTHER — this guards a refresh against an interleaved live upsert (e.g. a
+      // run's terminal status landing mid-fetch), the coherence hazard under CI latency.
+      const boardSince = useBoardStore().hydrateBaseline()
       const snapshot = await api.getWorkspace(targetId)
       // A newer refresh was issued (or the active board switched) while this fetch was in flight —
       // discard this older/staler result so it can't clobber the newer hydrate.
       if (seq !== refreshSeq || workspaceId.value !== targetId) return
-      hydrate(snapshot)
+      hydrate(snapshot, boardSince)
     }
 
     /** The active workspace id, or throw if the app isn't bootstrapped yet. */

package/app/types/execution.ts

@@ -43,6 +43,7 @@ export type {
   PrReviewSlice,
   PrReviewSeverity,
   PrReviewCategory,
+  PrReviewResolution,
   GateFailingCheck,
   GateAttempt,
   GateStepState,

package/i18n/locales/de.json

@@ -4717,12 +4717,22 @@
     "clear": "Zurücksetzen",
     "selectedCount": "{count} ausgewählt",
     "finish": "Review abschließen",
+    "fix": "Ausgewählte beheben",
+    "post": "Als Kommentare posten",
     "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."
     },
+    "fixing": {
+      "title": "Ausgewählte Befunde werden behoben…",
+      "hint": "Ein Fixer committet Änderungen für die ausgewählten Befunde auf den Pull-Request-Branch."
+    },
+    "posting": {
+      "title": "Review-Kommentare werden gepostet…",
+      "hint": "Die ausgewählten Befunde werden als Inline-Kommentare im Pull Request veröffentlicht."
+    },
     "severity": {
       "blocker": "Blocker",
       "high": "Hoch",

package/i18n/locales/en.json

@@ -4843,12 +4843,22 @@
     "clear": "Clear",
     "selectedCount": "{count} selected",
     "finish": "Finish review",
+    "fix": "Fix selected",
+    "post": "Post as comments",
     "suggestedFix": "Suggested fix:",
     "line": "line {line}",
     "reviewing": {
       "title": "Reviewing the pull request…",
       "hint": "Slicing the diff into cohesive chunks and reviewing each one."
     },
+    "fixing": {
+      "title": "Fixing the selected findings…",
+      "hint": "A fixer is committing changes for the selected findings onto the pull request branch."
+    },
+    "posting": {
+      "title": "Posting review comments…",
+      "hint": "Publishing the selected findings as inline comments on the pull request."
+    },
     "severity": {
       "blocker": "Blocker",
       "high": "High",

package/i18n/locales/es.json

@@ -4705,12 +4705,22 @@
     "clear": "Limpiar",
     "selectedCount": "{count} seleccionados",
     "finish": "Finalizar revisión",
+    "fix": "Corregir seleccionados",
+    "post": "Publicar como comentarios",
     "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."
     },
+    "fixing": {
+      "title": "Corrigiendo los hallazgos seleccionados…",
+      "hint": "Un corrector está confirmando cambios para los hallazgos seleccionados en la rama del pull request."
+    },
+    "posting": {
+      "title": "Publicando comentarios de revisión…",
+      "hint": "Publicando los hallazgos seleccionados como comentarios en línea en el pull request."
+    },
     "severity": {
       "blocker": "Bloqueante",
       "high": "Alta",

package/i18n/locales/fr.json

@@ -4705,12 +4705,22 @@
     "clear": "Effacer",
     "selectedCount": "{count} sélectionné(s)",
     "finish": "Terminer la revue",
+    "fix": "Corriger la sélection",
+    "post": "Publier en commentaires",
     "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."
     },
+    "fixing": {
+      "title": "Correction des points sélectionnés…",
+      "hint": "Un correcteur valide des modifications pour les points sélectionnés sur la branche de la pull request."
+    },
+    "posting": {
+      "title": "Publication des commentaires de revue…",
+      "hint": "Publication des points sélectionnés en commentaires en ligne sur la pull request."
+    },
     "severity": {
       "blocker": "Bloquant",
       "high": "Élevée",

package/i18n/locales/he.json

@@ -4716,12 +4716,22 @@
     "clear": "נקה",
     "selectedCount": "{count} נבחרו",
     "finish": "סיים בדיקה",
+    "fix": "תקן נבחרים",
+    "post": "פרסם כהערות",
     "suggestedFix": "תיקון מוצע:",
     "line": "שורה {line}",
     "reviewing": {
       "title": "בודק את בקשת המשיכה…",
       "hint": "מחלק את ההבדלים לקטעים לכידים ובודק כל אחד."
     },
+    "fixing": {
+      "title": "מתקן את הממצאים שנבחרו…",
+      "hint": "מתקן מבצע commit לשינויים עבור הממצאים שנבחרו אל ענף בקשת המשיכה."
+    },
+    "posting": {
+      "title": "מפרסם הערות בדיקה…",
+      "hint": "מפרסם את הממצאים שנבחרו כהערות מוטבעות בבקשת המשיכה."
+    },
     "severity": {
       "blocker": "חוסם",
       "high": "גבוה",

package/i18n/locales/it.json

@@ -4717,12 +4717,22 @@
     "clear": "Cancella",
     "selectedCount": "{count} selezionati",
     "finish": "Concludi revisione",
+    "fix": "Correggi selezionati",
+    "post": "Pubblica come commenti",
     "suggestedFix": "Correzione suggerita:",
     "line": "riga {line}",
     "reviewing": {
       "title": "Revisione della pull request…",
       "hint": "Suddivisione del diff in blocchi coerenti e revisione di ciascuno."
     },
+    "fixing": {
+      "title": "Correzione dei rilievi selezionati…",
+      "hint": "Un fixer sta effettuando il commit delle modifiche per i rilievi selezionati sul branch della pull request."
+    },
+    "posting": {
+      "title": "Pubblicazione dei commenti di revisione…",
+      "hint": "Pubblicazione dei rilievi selezionati come commenti inline sulla pull request."
+    },
     "severity": {
       "blocker": "Bloccante",
       "high": "Alta",

package/i18n/locales/ja.json

@@ -4717,12 +4717,22 @@
     "clear": "クリア",
     "selectedCount": "{count}件選択中",
     "finish": "レビューを完了",
+    "fix": "選択項目を修正",
+    "post": "コメントとして投稿",
     "suggestedFix": "修正案:",
     "line": "{line}行目",
     "reviewing": {
       "title": "プルリクエストをレビュー中…",
       "hint": "差分をまとまりのある単位に分割し、各単位をレビューしています。"
     },
+    "fixing": {
+      "title": "選択した指摘を修正中…",
+      "hint": "フィクサーが選択した指摘の変更をプルリクエストのブランチにコミットしています。"
+    },
+    "posting": {
+      "title": "レビューコメントを投稿中…",
+      "hint": "選択した指摘をプルリクエストのインラインコメントとして公開しています。"
+    },
     "severity": {
       "blocker": "ブロッカー",
       "high": "高",

package/i18n/locales/pl.json

@@ -4705,12 +4705,22 @@
     "clear": "Wyczyść",
     "selectedCount": "Wybrano: {count}",
     "finish": "Zakończ przegląd",
+    "fix": "Napraw wybrane",
+    "post": "Opublikuj jako komentarze",
     "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."
     },
+    "fixing": {
+      "title": "Naprawianie wybranych uwag…",
+      "hint": "Fixer zatwierdza zmiany dla wybranych uwag w gałęzi pull requesta."
+    },
+    "posting": {
+      "title": "Publikowanie komentarzy przeglądu…",
+      "hint": "Publikowanie wybranych uwag jako komentarzy w treści pull requesta."
+    },
     "severity": {
       "blocker": "Blokujące",
       "high": "Wysokie",

package/i18n/locales/tr.json

@@ -4717,12 +4717,22 @@
     "clear": "Temizle",
     "selectedCount": "{count} seçildi",
     "finish": "İncelemeyi bitir",
+    "fix": "Seçilenleri düzelt",
+    "post": "Yorum olarak gönder",
     "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."
     },
+    "fixing": {
+      "title": "Seçili bulgular düzeltiliyor…",
+      "hint": "Bir düzeltici, seçili bulgular için değişiklikleri pull request dalına işliyor."
+    },
+    "posting": {
+      "title": "İnceleme yorumları gönderiliyor…",
+      "hint": "Seçili bulgular pull request üzerinde satır içi yorum olarak yayımlanıyor."
+    },
     "severity": {
       "blocker": "Engelleyici",
       "high": "Yüksek",

package/i18n/locales/uk.json

@@ -4705,12 +4705,22 @@
     "clear": "Очистити",
     "selectedCount": "Вибрано: {count}",
     "finish": "Завершити огляд",
+    "fix": "Виправити вибрані",
+    "post": "Опублікувати як коментарі",
     "suggestedFix": "Пропоноване виправлення:",
     "line": "рядок {line}",
     "reviewing": {
       "title": "Перевірка pull request…",
       "hint": "Поділ змін на цілісні частини та огляд кожної з них."
     },
+    "fixing": {
+      "title": "Виправлення вибраних зауважень…",
+      "hint": "Фіксер комітить зміни для вибраних зауважень у гілку pull request."
+    },
+    "posting": {
+      "title": "Публікація коментарів огляду…",
+      "hint": "Публікація вибраних зауважень як вбудованих коментарів у pull request."
+    },
     "severity": {
       "blocker": "Блокер",
       "high": "Високий",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.118.0",
+  "version": "0.119.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",
@@ -34,7 +34,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.39",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.131.0"
+    "@cat-factory/contracts": "0.132.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",