@cat-factory/app 0.72.0 → 0.74.0

package/app/components/pipeline/PipelineBuilder.vue

@@ -3,7 +3,12 @@ import { computed, ref, watch } from 'vue'
 import type { AgentKind, Pipeline } from '~/types/domain'
 import AgentPalette from '~/components/palettes/AgentPalette.vue'
 import AgentKindIcon from '~/components/pipeline/AgentKindIcon.vue'
-import { agentKindMeta, companionForProducer, isConsensusEligibleKind } from '~/utils/catalog'
+import {
+  agentKindMeta,
+  companionForProducer,
+  isConsensusEligibleKind,
+  isTesterKind,
+} from '~/utils/catalog'
 import type { ConsensusStrategy } from '~/types/consensus'
 
 type DraftUnit = { index: number; kind: AgentKind; companionIndex: number | null }
@@ -146,15 +151,18 @@ function companionLabel(kind: string): string | null {
 }
 
 // Surfaced as an inline hint: a gated step needs a task-estimator before it (mirrors the
-// backend validation, which also rejects the save/start).
+// backend validation, which also rejects the save/start). Both the companion estimate gate
+// (`draftGating`) and the Tester QC companion's estimate gate (`draftTesterQuality[i].gating`)
+// count — either without a preceding estimator is rejected on save.
 const gatingNeedsEstimator = computed(() => {
   const kinds = pipelines.draft
+  const hasEstimatorBefore = (i: number) =>
+    kinds.slice(0, i).some((k, j) => k === 'task-estimator' && pipelines.draftEnabled[j] !== false)
   for (let i = 0; i < kinds.length; i++) {
-    if (!pipelines.draftGating[i]?.enabled || pipelines.draftEnabled[i] === false) continue
-    const hasEstimator = kinds
-      .slice(0, i)
-      .some((k, j) => k === 'task-estimator' && pipelines.draftEnabled[j] !== false)
-    if (!hasEstimator) return true
+    if (pipelines.draftEnabled[i] === false) continue
+    const gated =
+      pipelines.draftGating[i]?.enabled || pipelines.draftTesterQuality[i]?.gating?.enabled
+    if (gated && !hasEstimatorBefore(i)) return true
   }
   return false
 })
@@ -434,6 +442,30 @@ async function clone(p: Pipeline) {
                     "
                     @click="pipelines.toggleDraftFollowUps(unit.index)"
                   />
+                  <!-- Test quality-control companion: audits the Tester's report for coverage
+                     before the greenlight/fixer decision and loops the Tester on gaps (Tester
+                     steps only). Enabled by default. -->
+                  <UButton
+                    v-if="isTesterKind(unit.kind)"
+                    :icon="
+                      pipelines.draftTesterQuality[unit.index]?.enabled === false
+                        ? 'i-lucide-shield-off'
+                        : 'i-lucide-shield-check'
+                    "
+                    :color="
+                      pipelines.draftTesterQuality[unit.index]?.enabled === false
+                        ? 'neutral'
+                        : 'secondary'
+                    "
+                    variant="ghost"
+                    size="xs"
+                    :title="
+                      pipelines.draftTesterQuality[unit.index]?.enabled === false
+                        ? t('pipeline.builder.testerQualityEnableTooltip')
+                        : t('pipeline.builder.testerQualityDisableTooltip')
+                    "
+                    @click="pipelines.toggleDraftTesterQuality(unit.index)"
+                  />
                   <UButton
                     icon="i-lucide-chevron-up"
                     color="neutral"
@@ -642,6 +674,77 @@ async function clone(p: Pipeline) {
                   </template>
                 </div>
               </div>
+
+              <!-- Test quality-control companion config (shown when QC is enabled on a Tester
+                 step): an optional estimate gate so only heavy tasks get the coverage audit. -->
+              <div
+                v-if="
+                  isTesterKind(unit.kind) &&
+                  pipelines.draftTesterQuality[unit.index]?.enabled !== false
+                "
+                class="ms-6 space-y-2 rounded-md border border-sky-800/40 bg-sky-950/20 p-2 text-xs"
+              >
+                <div class="flex items-center gap-1.5">
+                  <UIcon name="i-lucide-shield-check" class="h-3.5 w-3.5 text-sky-400" />
+                  <span class="min-w-0 flex-1 truncate text-slate-200">
+                    {{ t('pipeline.builder.testerQualityLabel') }}
+                  </span>
+                  <UButton
+                    :icon="
+                      pipelines.draftTesterQuality[unit.index]?.gating?.enabled
+                        ? 'i-lucide-toggle-right'
+                        : 'i-lucide-toggle-left'
+                    "
+                    :color="
+                      pipelines.draftTesterQuality[unit.index]?.gating?.enabled
+                        ? 'success'
+                        : 'neutral'
+                    "
+                    variant="ghost"
+                    size="xs"
+                    :label="t('pipeline.builder.gateOnEstimate')"
+                    :title="t('pipeline.builder.testerQualityGateTooltip')"
+                    @click="pipelines.toggleDraftTesterQualityGating(unit.index)"
+                  />
+                </div>
+                <div
+                  v-if="pipelines.draftTesterQuality[unit.index]?.gating?.enabled"
+                  class="flex flex-wrap items-center gap-2 border-t border-slate-800 pt-2"
+                >
+                  <span class="text-[10px] text-slate-500">{{
+                    t('pipeline.builder.runWhenAny')
+                  }}</span>
+                  <label class="text-slate-400">{{
+                    t('pipeline.builder.complexityThreshold')
+                  }}</label>
+                  <input
+                    v-model.number="pipelines.draftTesterQuality[unit.index]!.gating!.minComplexity"
+                    type="number"
+                    min="0"
+                    max="1"
+                    step="0.1"
+                    class="w-14 rounded border border-slate-700 bg-slate-900 px-1.5 py-0.5 text-slate-100"
+                  />
+                  <label class="text-slate-400">{{ t('pipeline.builder.riskThreshold') }}</label>
+                  <input
+                    v-model.number="pipelines.draftTesterQuality[unit.index]!.gating!.minRisk"
+                    type="number"
+                    min="0"
+                    max="1"
+                    step="0.1"
+                    class="w-14 rounded border border-slate-700 bg-slate-900 px-1.5 py-0.5 text-slate-100"
+                  />
+                  <label class="text-slate-400">{{ t('pipeline.builder.impactThreshold') }}</label>
+                  <input
+                    v-model.number="pipelines.draftTesterQuality[unit.index]!.gating!.minImpact"
+                    type="number"
+                    min="0"
+                    max="1"
+                    step="0.1"
+                    class="w-14 rounded border border-slate-700 bg-slate-900 px-1.5 py-0.5 text-slate-100"
+                  />
+                </div>
+              </div>
             </li>
           </ol>
         </div>

package/app/components/requirements/RequirementsReviewWindow.vue

@@ -414,6 +414,8 @@ async function resolveExceeded(choice: 'extra-round' | 'proceed' | 'stop-reset')
     >
       <div
         class="flex max-h-[90dvh] w-full max-w-5xl flex-col overflow-hidden rounded-2xl border border-slate-800 bg-slate-900 shadow-2xl"
+        role="dialog"
+        aria-modal="true"
       >
         <!-- header -->
         <header class="flex items-center gap-3 border-b border-slate-800 px-6 py-4">

package/app/components/spec/ServiceSpecWindow.vue

@@ -123,6 +123,8 @@ function kindLabel(item: RequirementItem): string {
     >
       <div
         class="flex max-h-[90dvh] w-full max-w-5xl flex-col overflow-hidden rounded-2xl border border-slate-800 bg-slate-900 shadow-2xl"
+        role="dialog"
+        aria-modal="true"
       >
         <!-- header -->
         <header class="flex items-center gap-3 border-b border-slate-800 px-6 py-4">

package/app/components/testing/TestReportWindow.vue

@@ -47,6 +47,12 @@ const testState = computed(() => step.value?.test ?? null)
 // ended), newest first, so the otherwise-opaque fixer sub-jobs have a surface here.
 const fixerAttempts = computed(() => [...(testState.value?.attemptLog ?? [])].reverse())
 
+// Test quality-control companion state: the coverage audit the QC reviewer ran on each report
+// (before the greenlight/fixer decision) plus its loop budget. Verdicts newest-first, so the
+// most recent audit leads. Absent when the companion is disabled or never ran.
+const quality = computed(() => step.value?.testerQuality ?? null)
+const qualityVerdicts = computed(() => [...(quality.value?.verdicts ?? [])].reverse())
+
 // Infrastructure observability — parity with the Coder's generic step detail, so the
 // Tester window surfaces WHERE its job runs (the container lifecycle: spinning up /
 // running phase / id+url / errored), the ephemeral environment it tests against, and the
@@ -551,6 +557,91 @@ const GROUP_STATUS_META: Record<ScenarioGroup['status'], { icon: string; text: s
               </ol>
             </section>
 
+            <!-- Test quality-control companion: the coverage audit(s) the QC reviewer ran on
+                 the report before the greenlight/fixer decision. Each verdict says whether the
+                 report adequately covered what the task needed tested, with the gaps that
+                 looped the Tester for a focused additional pass. -->
+            <section
+              v-if="quality && qualityVerdicts.length"
+              data-testid="tester-quality"
+              class="space-y-2"
+            >
+              <div class="flex items-center gap-2">
+                <h3 class="text-[11px] font-semibold uppercase tracking-wide text-slate-500">
+                  {{ t('testing.quality.heading') }}
+                </h3>
+                <span
+                  v-if="quality.attempts"
+                  class="text-[11px] text-slate-400"
+                  :title="t('testing.quality.reruns')"
+                >
+                  {{
+                    t('testing.quality.rerunCount', {
+                      attempts: quality.attempts,
+                      max: quality.maxAttempts,
+                    })
+                  }}
+                </span>
+                <UBadge
+                  v-if="quality.exceeded"
+                  color="warning"
+                  variant="subtle"
+                  size="sm"
+                  data-testid="tester-quality-exceeded"
+                >
+                  {{ t('testing.quality.exceeded') }}
+                </UBadge>
+              </div>
+              <ol class="space-y-2">
+                <li
+                  v-for="(vd, vi) in qualityVerdicts"
+                  :key="`qc${vi}`"
+                  data-testid="tester-quality-verdict"
+                  class="rounded-lg border border-slate-800 bg-slate-900/60 px-3 py-2"
+                >
+                  <div class="flex items-center gap-2">
+                    <UIcon
+                      :name="vd.adequate ? 'i-lucide-shield-check' : 'i-lucide-shield-alert'"
+                      class="h-3.5 w-3.5 shrink-0"
+                      :class="vd.adequate ? 'text-emerald-400' : 'text-amber-300'"
+                    />
+                    <span class="text-[13px] font-medium text-slate-200">
+                      {{
+                        vd.adequate
+                          ? t('testing.quality.adequate')
+                          : t('testing.quality.inadequate')
+                      }}
+                    </span>
+                    <span v-if="vd.model" class="ms-auto font-mono text-[10px] text-slate-500">{{
+                      vd.model
+                    }}</span>
+                    <span class="text-[11px] text-slate-500" :class="{ 'ms-auto': !vd.model }">{{
+                      d(new Date(vd.at), 'short')
+                    }}</span>
+                  </div>
+                  <p v-if="vd.feedback" class="mt-1 text-[12px] leading-snug text-slate-400">
+                    {{ vd.feedback }}
+                  </p>
+                  <div v-if="vd.gaps.length" class="mt-1.5">
+                    <p class="text-[11px] text-slate-500">{{ t('testing.quality.gaps') }}</p>
+                    <ul class="mt-1 space-y-0.5">
+                      <li
+                        v-for="(gap, gi) in vd.gaps"
+                        :key="`qc${vi}-g${gi}`"
+                        class="flex items-start gap-1.5 text-[12px] text-slate-300"
+                      >
+                        <UIcon
+                          name="i-lucide-dot"
+                          class="mt-0.5 h-3.5 w-3.5 shrink-0 text-amber-400"
+                        />
+                        <span>{{ gap }}</span>
+                      </li>
+                    </ul>
+                  </div>
+                </li>
+              </ol>
+            </section>
+
             <div
               v-if="!report"
               class="flex flex-col items-center justify-center gap-2 py-12 text-center text-slate-400"

package/app/composables/api/github.ts

@@ -71,9 +71,14 @@ export function githubApi({ send, ws }: ApiContext) {
       send(createGitHubRepoContract, { pathPrefix: ws(workspaceId), body }),
 
     // Repos the connected installation can access, annotated with whether this
-    // workspace links each (drives the per-workspace repo picker).
-    listGitHubAvailableRepos: (workspaceId: string) =>
-      send(listGitHubAvailableReposContract, { pathPrefix: ws(workspaceId) }),
+    // workspace links each (drives the per-workspace repo picker). An optional `q`
+    // filters `owner/name` server-side so the add-service picker searches instead of
+    // prefetching the whole (possibly huge) installation; omitting it browses all.
+    listGitHubAvailableRepos: (workspaceId: string, q?: string) =>
+      send(listGitHubAvailableReposContract, {
+        pathPrefix: ws(workspaceId),
+        queryParams: { q },
+      }),
 
     // Set the exact set of repos this workspace links.
     setGitHubLinkedRepos: (workspaceId: string, repoGithubIds: number[]) =>

package/app/composables/useKeyboardShortcuts.ts

@@ -20,9 +20,17 @@ export function useKeyboardShortcuts(): void {
   const board = useBoardStore()
   const { deleteBlock } = useBlockDeletion()
 
-  /** A modal (UModal) is on screen — let it own the keyboard; don't run global shortcuts. */
+  /** A modal / full-screen window is on screen — let it own the keyboard; don't run global
+   * shortcuts (else e.g. Delete would delete the selected block hidden BEHIND the window). The
+   * hand-rolled result-view + focus windows now carry `role="dialog"`, so the DOM check catches
+   * them; the store flags are belt-and-suspenders for the same windows. */
   function modalOpen(): boolean {
-    return ui.commandBarOpen || !!document.querySelector('[role="dialog"]')
+    return (
+      ui.commandBarOpen ||
+      !!ui.resultView ||
+      !!ui.focusBlockId ||
+      !!document.querySelector('[role="dialog"]')
+    )
   }
 
   /** The event originates from a text field, so printable/Delete keys are edits, not shortcuts. */

package/app/pages/index.vue

@@ -3,6 +3,7 @@ import BoardCanvas from '~/components/board/BoardCanvas.vue'
 import SideBar from '~/components/layout/SideBar.vue'
 import BoardToolbar from '~/components/layout/BoardToolbar.vue'
 import SpendWarningBanner from '~/components/layout/SpendWarningBanner.vue'
+import ConnectionStatusBanner from '~/components/layout/ConnectionStatusBanner.vue'
 import TranslationWarningBanner from '~/components/layout/TranslationWarningBanner.vue'
 import GitHubPatBanner from '~/components/layout/GitHubPatBanner.vue'
 import AiProvidersBanner from '~/components/layout/AiProvidersBanner.vue'
@@ -275,7 +276,7 @@ watch(
       class="m-auto flex flex-col items-center gap-3 text-slate-400"
     >
       <UIcon name="i-lucide-loader" class="h-8 w-8 animate-spin" />
-      <span class="text-sm">Loading…</span>
+      <span class="text-sm">{{ $t('app.loading') }}</span>
     </div>
 
     <!-- App enabled but not installed on this workspace: hard onboarding gate. -->
@@ -312,6 +313,7 @@ watch(
         />
         <BoardToolbar />
         <SpendWarningBanner />
+        <ConnectionStatusBanner :connected="streamConnected" />
         <InspectorPanel />
         <!-- Code-split focus view. The fade lives here (not inside the component) so the
              leave animation still plays when `focusBlockId` clears and the v-if unmounts
@@ -368,17 +370,17 @@ watch(
     <!-- Backend unreachable / bootstrap failed -->
     <div v-else-if="workspace.error" class="m-auto max-w-md p-8 text-center">
       <UIcon name="i-lucide-plug-zap" class="mx-auto mb-3 h-10 w-10 text-amber-400" />
-      <h1 class="mb-1 text-lg font-semibold">Can’t reach the backend</h1>
+      <h1 class="mb-1 text-lg font-semibold">{{ $t('app.backendUnreachable') }}</h1>
       <p class="mb-4 text-sm text-slate-400">{{ workspace.error }}</p>
       <UButton color="primary" icon="i-lucide-rotate-ccw" @click="workspace.init()">
-        Retry
+        {{ $t('common.retry') }}
       </UButton>
     </div>
 
     <!-- Initial load -->
     <div v-else class="m-auto flex flex-col items-center gap-3 text-slate-400">
       <UIcon name="i-lucide-loader" class="h-8 w-8 animate-spin" />
-      <span class="text-sm">Loading board…</span>
+      <span class="text-sm">{{ $t('app.loadingBoard') }}</span>
     </div>
   </div>
 </template>

package/app/stores/board.spec.ts

@@ -1,6 +1,8 @@
-import { describe, it, expect, beforeEach } from 'vitest'
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { setActivePinia, createPinia } from 'pinia'
 import type { Block, BlockStatus } from '~/types/domain'
 import { useBoardStore } from '~/stores/board'
+import { useWorkspaceStore } from '~/stores/workspace'
 
 /** Minimal Block factory — only the fields the read getters care about. */
 function block(id: string, over: Partial<Block> = {}): Block {
@@ -224,6 +226,22 @@ describe('board store read getters', () => {
     expect(() => store.previewMove('missing', { x: 1, y: 1 })).not.toThrow()
   })
 
+  it('updateBlock restores the patched fields and toasts when the write fails', async () => {
+    // Capture the toast the store surfaces on failure. Re-stub before creating the store so it
+    // binds this spy (the store resolves `useToast()` once at setup).
+    const addSpy = vi.fn()
+    vi.stubGlobal('useToast', () => ({ add: addSpy }))
+    setActivePinia(createPinia())
+    const s = useBoardStore()
+    s.hydrate([frame('f1', { title: 'Original', description: 'orig' })])
+    // With no active workspace, `requireId()` throws inside updateBlock's try — the same catch
+    // that a rejected API write hits — so this exercises the optimistic-rollback + toast path.
+    await s.updateBlock('f1', { title: 'Edited', description: 'changed' })
+    expect(s.getBlock('f1')?.title).toBe('Original')
+    expect(s.getBlock('f1')?.description).toBe('orig')
+    expect(addSpy).toHaveBeenCalledWith(expect.objectContaining({ color: 'error' }))
+  })
+
   it('hydrate replaces and upsert inserts/updates cached blocks', () => {
     store.hydrate([frame('f1')])
     store.upsert(task('t1', 'f1', { title: 'first' }))
@@ -233,3 +251,42 @@ describe('board store read getters', () => {
     expect(store.allTasks).toHaveLength(1)
   })
 })
+
+describe('board store optimistic rollback', () => {
+  // These instantiate their own store AFTER stubbing the api (the store captures
+  // `useApi()` at setup), unlike the read-getter suite above.
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('moveBlock restores the pre-drag position when the API rejects', async () => {
+    vi.stubGlobal('useApi', () => ({
+      moveBlock: () => Promise.reject(new Error('conflict')),
+    }))
+    const store = useBoardStore()
+    store.hydrate([frame('f1'), task('t1', 'f1', { position: { x: 10, y: 20 } })])
+    await store.moveBlock('t1', { x: 500, y: 600 })
+    expect(store.getBlock('t1')?.position).toEqual({ x: 10, y: 20 })
+  })
+
+  it('moveBlock keeps the new position on success', async () => {
+    vi.stubGlobal('useApi', () => ({
+      moveBlock: async () => task('t1', 'f1', { position: { x: 500, y: 600 } }),
+    }))
+    const store = useBoardStore()
+    store.hydrate([frame('f1'), task('t1', 'f1', { position: { x: 10, y: 20 } })])
+    await store.moveBlock('t1', { x: 500, y: 600 })
+    expect(store.getBlock('t1')?.position).toEqual({ x: 500, y: 600 })
+  })
+
+  it('updateBlock restores only the patched fields when the API rejects', async () => {
+    vi.stubGlobal('useApi', () => ({
+      updateBlock: () => Promise.reject(new Error('validation')),
+    }))
+    const store = useBoardStore()
+    store.hydrate([frame('f1'), task('t1', 'f1', { title: 'orig', description: 'keep' })])
+    await store.updateBlock('t1', { title: 'renamed' })
+    expect(store.getBlock('t1')?.title).toBe('orig')
+    expect(store.getBlock('t1')?.description).toBe('keep')
+  })
+})

package/app/stores/board.ts

@@ -29,6 +29,11 @@ interface RemovalSnapshot {
 export const useBoardStore = defineStore('board', () => {
   const api = useApi()
   const toast = useToast()
+  // Stores run outside a component `setup`, so resolve translations through the Nuxt app's
+  // global i18n instance (the same handle `plugins/locale.client.ts` uses) rather than
+  // `useI18n()`, which requires an active component instance.
+  const nuxtApp = useNuxtApp()
+  const tr = (key: string): string => (nuxtApp.$i18n as { t: (k: string) => string }).t(key)
   const blocks = ref<Block[]>([])
 
   // Pure derivations (hierarchy, status/progress, sizing) live in the composable.
@@ -162,7 +167,7 @@ export const useBoardStore = defineStore('board', () => {
     } catch (e) {
       t.epicId = prev
       toast.add({
-        title: 'Could not change epic',
+        title: tr('board.toast.epicFailed'),
         description: e instanceof Error ? e.message : String(e),
         icon: 'i-lucide-triangle-alert',
         color: 'error',
@@ -216,7 +221,7 @@ export const useBoardStore = defineStore('board', () => {
       b.parentId = prevParentId
       b.position = prevPosition
       toast.add({
-        title: 'Could not move',
+        title: tr('board.toast.moveFailed'),
         description: e instanceof Error ? e.message : String(e),
         icon: 'i-lucide-triangle-alert',
         color: 'error',
@@ -289,7 +294,7 @@ export const useBoardStore = defineStore('board', () => {
     } catch (e) {
       reattach(snap)
       toast.add({
-        title: 'Could not delete',
+        title: tr('board.toast.deleteFailed'),
         description: e instanceof Error ? e.message : String(e),
         icon: 'i-lucide-triangle-alert',
         color: 'error',
@@ -313,26 +318,65 @@ export const useBoardStore = defineStore('board', () => {
   async function moveBlock(id: string, position: { x: number; y: number }) {
     const b = getBlock(id)
     if (!b) return
+    const prevPosition = b.position
     b.position = position // optimistic: keep the drag feeling instant
-    // A mounted service frame's position is a PER-WORKSPACE layout override on the mount, not
-    // on the (shared) block — so route a frame drag there. Other moves write the block.
-    const services = useServicesStore()
-    const mount = services.serviceByFrameBlock[id]
-      ? services.byServiceId[services.serviceByFrameBlock[id]!.id]
-      : undefined
-    if (mount) {
-      await services.updateLayout(mount.serviceId, position)
-      return
+    try {
+      // A mounted service frame's position is a PER-WORKSPACE layout override on the mount, not
+      // on the (shared) block — so route a frame drag there. Other moves write the block.
+      const services = useServicesStore()
+      const mount = services.serviceByFrameBlock[id]
+        ? services.byServiceId[services.serviceByFrameBlock[id]!.id]
+        : undefined
+      if (mount) {
+        await services.updateLayout(mount.serviceId, position)
+        return
+      }
+      upsert(await api.moveBlock(useWorkspaceStore().requireId(), id, { position }))
+    } catch (e) {
+      // Restore the pre-drag position — a rejected move must not leave the block at a
+      // spot the server never stored (a lie that survives until the next re-hydrate).
+      b.position = prevPosition
+      toast.add({
+        title: 'Could not move',
+        description: e instanceof Error ? e.message : String(e),
+        icon: 'i-lucide-triangle-alert',
+        color: 'error',
+      })
     }
-    upsert(await api.moveBlock(useWorkspaceStore().requireId(), id, { position }))
   }
 
   /** Patch the user-editable fields of a block (title, features, threshold…). */
   async function updateBlock(id: string, patch: UpdateBlockInput) {
     const b = getBlock(id)
     if (!b) return
+    // Snapshot ONLY the fields this patch touches so a rejected write restores them exactly
+    // (a patch may set several at once) rather than leaving a stale optimistic value stuck on
+    // screen with no feedback — the same rollback contract the other mutations here follow.
+    const prev: Record<string, unknown> = {}
+    const patchRecord = patch as Record<string, unknown>
+    const record = b as unknown as Record<string, unknown>
+    for (const key of Object.keys(patch)) prev[key] = record[key]
     Object.assign(b, patch) // optimistic
-    upsert(await api.updateBlock(useWorkspaceStore().requireId(), id, patch))
+    try {
+      upsert(await api.updateBlock(useWorkspaceStore().requireId(), id, patch))
+    } catch (e) {
+      // Re-resolve the block: a live event may have replaced its object reference (`upsert`
+      // swaps in a fresh one) while the write was in flight, so `b` can be stale. Only revert
+      // fields that still hold OUR optimistic value, so a newer server value that landed
+      // mid-flight isn't clobbered by the rollback.
+      const cur = getBlock(id) as unknown as Record<string, unknown> | undefined
+      if (cur) {
+        for (const key of Object.keys(patch)) {
+          if (cur[key] === patchRecord[key]) cur[key] = prev[key]
+        }
+      }
+      toast.add({
+        title: tr('board.toast.updateFailed'),
+        description: e instanceof Error ? e.message : String(e),
+        icon: 'i-lucide-triangle-alert',
+        color: 'error',
+      })
+    }
   }
 
   /**
@@ -346,7 +390,7 @@ export const useBoardStore = defineStore('board', () => {
       upsert(await api.toggleDependency(useWorkspaceStore().requireId(), targetId, { sourceId }))
     } catch (e) {
       toast.add({
-        title: 'Could not link tasks',
+        title: tr('board.toast.linkFailed'),
         description: e instanceof Error ? e.message : String(e),
         icon: 'i-lucide-triangle-alert',
         color: 'error',

package/app/stores/brainstorm.spec.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest'
+import type { BrainstormSession } from '~/types/brainstorm'
+import { useBrainstormStore } from '~/stores/brainstorm'
+
+/** Minimal session factory — only the fields the upsert guard touches. */
+function session(over: Partial<BrainstormSession> = {}): BrainstormSession {
+  return {
+    id: 'bs1',
+    blockId: 'b1',
+    stage: 'requirements',
+    status: 'ready',
+    options: [],
+    updatedAt: 1000,
+    ...over,
+  } as BrainstormSession
+}
+
+describe('brainstorm store live-event upsert guard', () => {
+  it('an out-of-order stream event cannot revert a newer cached session', () => {
+    const store = useBrainstormStore()
+    store.upsert(session({ updatedAt: 2000, status: 'merged' }))
+    store.upsert(session({ updatedAt: 1000, status: 'ready' })) // stale event → ignored
+    expect(store.sessionFor('b1', 'requirements')?.status).toBe('merged')
+    store.upsert(session({ updatedAt: 3000, status: 'incorporated' }))
+    expect(store.sessionFor('b1', 'requirements')?.status).toBe('incorporated')
+  })
+
+  it('sessions are keyed per block+stage — one stage cannot clobber another', () => {
+    const store = useBrainstormStore()
+    store.upsert(session({ updatedAt: 2000 }))
+    store.upsert(session({ id: 'bs2', stage: 'architecture', updatedAt: 1000 }))
+    expect(store.sessionFor('b1', 'requirements')?.id).toBe('bs1')
+    expect(store.sessionFor('b1', 'architecture')?.id).toBe('bs2')
+  })
+})

package/app/stores/brainstorm.ts

@@ -84,6 +84,16 @@ export const useBrainstormStore = defineStore('brainstorm', () => {
     sessions.value = { ...sessions.value, [key(session.blockId, session.stage)]: session }
   }
 
+  /** Patch the cache from a live `brainstorm` stream event (newest wins per block+stage). */
+  function upsert(session: BrainstormSession) {
+    const existing = sessions.value[key(session.blockId, session.stage)]
+    // Keep the freshest by updatedAt (the consensus-store guard): `store()` also runs on
+    // API responses, so a slightly-older event racing a just-submitted answer over the
+    // separate WS transport must not revert the session the response already delivered.
+    if (existing && existing.id === session.id && existing.updatedAt > session.updatedAt) return
+    store(session)
+  }
+
   /** Drop all cached sessions + in-flight state (called on workspace switch). */
   function reset() {
     available.value = null
@@ -215,7 +225,6 @@ export const useBrainstormStore = defineStore('brainstorm', () => {
     proceed,
     resolveExceeded,
     reset,
-    // Patch the cache from a live `brainstorm` stream event.
-    upsert: store,
+    upsert,
   }
 })

package/app/stores/clarity.spec.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest'
+import type { ClarityReview } from '~/types/clarity'
+import { useClarityStore } from '~/stores/clarity'
+
+/** Minimal review factory — only the fields the upsert guard touches. */
+function review(over: Partial<ClarityReview> = {}): ClarityReview {
+  return {
+    id: 'cr1',
+    blockId: 'b1',
+    status: 'ready',
+    items: [],
+    updatedAt: 1000,
+    ...over,
+  } as ClarityReview
+}
+
+describe('clarity store live-event upsert guard', () => {
+  it('an out-of-order stream event cannot revert a newer cached review', () => {
+    const store = useClarityStore()
+    store.upsert(review({ updatedAt: 2000, status: 'merged' }))
+    store.upsert(review({ updatedAt: 1000, status: 'ready' })) // stale event → ignored
+    expect(store.reviewFor('b1')?.status).toBe('merged')
+    store.upsert(review({ updatedAt: 3000, status: 'incorporated' }))
+    expect(store.reviewFor('b1')?.status).toBe('incorporated')
+  })
+
+  it('a NEW review (different id) for the block replaces regardless of updatedAt', () => {
+    const store = useClarityStore()
+    store.upsert(review({ updatedAt: 2000 }))
+    store.upsert(review({ id: 'cr2', updatedAt: 1000 }))
+    expect(store.reviewFor('b1')?.id).toBe('cr2')
+  })
+})