@cat-factory/app 0.72.0 → 0.73.1

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/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')
+  })
+})

package/app/stores/clarity.ts

@@ -87,6 +87,16 @@ export const useClarityStore = defineStore('clarity', () => {
     reviews.value = { ...reviews.value, [review.blockId]: review }
   }
 
+  /** Patch the cache from a live `clarity` stream event (newest wins per block). */
+  function upsert(review: ClarityReview) {
+    const existing = reviews.value[review.blockId]
+    // 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 review the response already delivered.
+    if (existing && existing.id === review.id && existing.updatedAt > review.updatedAt) return
+    store(review)
+  }
+
   /** Drop all cached reviews + in-flight state (called on workspace switch). */
   function reset() {
     available.value = null
@@ -205,7 +215,6 @@ export const useClarityStore = defineStore('clarity', () => {
     proceed,
     resolveExceeded,
     reset,
-    // Patch the cache from a live `clarity` stream event.
-    upsert: store,
+    upsert,
   }
 })

package/app/stores/execution.spec.ts

@@ -18,26 +18,84 @@ describe('execution store gate grouping', () => {
   })
 
   it('decisionsByBlock groups open (unchosen) decisions by block', () => {
-    store.hydrate([
-      instance('e1', 'b1', [
-        { agentKind: 'coder', decision: { id: 'd1', chosen: null } },
-        { agentKind: 'coder', decision: { id: 'd2', chosen: 'yes' } }, // chosen ⇒ excluded
-      ]),
-      instance('e2', 'b2', [{ agentKind: 'architect', decision: { id: 'd3', chosen: null } }]),
-    ])
+    store.hydrate(
+      [
+        instance('e1', 'b1', [
+          { agentKind: 'coder', decision: { id: 'd1', chosen: null } },
+          { agentKind: 'coder', decision: { id: 'd2', chosen: 'yes' } }, // chosen ⇒ excluded
+        ]),
+        instance('e2', 'b2', [{ agentKind: 'architect', decision: { id: 'd3', chosen: null } }]),
+      ],
+      'ws1',
+    )
     expect(store.decisionsByBlock.get('b1')?.map((d) => d.decision.id)).toEqual(['d1'])
     expect(store.decisionsByBlock.get('b2')?.map((d) => d.decision.id)).toEqual(['d3'])
     expect(store.decisionsByBlock.has('missing')).toBe(false)
   })
 
   it('approvalsByBlock groups pending approvals by block', () => {
-    store.hydrate([
-      instance('e1', 'b1', [
-        { agentKind: 'merger', approval: { id: 'a1', status: 'pending' } },
-        { agentKind: 'merger', approval: { id: 'a2', status: 'approved' } }, // not pending ⇒ excluded
-      ]),
-    ])
+    store.hydrate(
+      [
+        instance('e1', 'b1', [
+          { agentKind: 'merger', approval: { id: 'a1', status: 'pending' } },
+          { agentKind: 'merger', approval: { id: 'a2', status: 'approved' } }, // not pending ⇒ excluded
+        ]),
+      ],
+      'ws1',
+    )
     expect(store.approvalsByBlock.get('b1')?.map((a) => a.approval.id)).toEqual(['a1'])
     expect(store.approvalsByBlock.get('b2')).toBeUndefined()
   })
 })
+
+/** A run fixture carrying the fields the reconcile guards read (`id`, `rev`, `status`). */
+function run(id: string, rev: number, status: string): ExecutionInstance {
+  return { id, blockId: `blk_${id}`, steps: [], status, rev } as unknown as ExecutionInstance
+}
+
+describe('execution store snapshot/event reconcile', () => {
+  let store: ReturnType<typeof useExecutionStore>
+  beforeEach(() => {
+    store = useExecutionStore()
+  })
+
+  it('a lagging snapshot cannot regress a run a live event already advanced (REGRESS)', () => {
+    store.hydrate([run('e1', 3, 'running')], 'ws1')
+    // Live event: the run reached a terminal state (rev 4). It emits nothing further.
+    store.upsert(run('e1', 4, 'done'))
+    // A snapshot read BEFORE the event resolves after it — same run at the older rev.
+    store.hydrate([run('e1', 3, 'running')], 'ws1')
+    expect(store.getInstance('e1')?.status).toBe('done')
+  })
+
+  it('keeps a live-added run a lagging snapshot never saw (DROP)', () => {
+    store.hydrate([run('e1', 1, 'running')], 'ws1')
+    store.upsert(run('e2', 1, 'running'))
+    store.hydrate([run('e1', 2, 'running')], 'ws1') // stale read: predates e2
+    expect(store.getInstance('e2')).toBeTruthy()
+    expect(store.getInstance('e1')?.rev).toBe(2)
+  })
+
+  it('a workspace switch replaces the cache outright (no cross-board leak)', () => {
+    store.hydrate([run('e1', 1, 'running')], 'ws1')
+    store.upsert(run('e2', 1, 'running'))
+    store.hydrate([run('e3', 1, 'running')], 'ws2')
+    expect(store.getInstance('e1')).toBeUndefined()
+    expect(store.getInstance('e2')).toBeUndefined()
+    expect(store.getInstance('e3')).toBeTruthy()
+  })
+
+  it('an out-of-order live event cannot regress a newer cached run; same-rev replaces', () => {
+    store.upsert(run('e1', 5, 'done'))
+    store.upsert(run('e1', 4, 'running')) // stale event → ignored
+    expect(store.getInstance('e1')?.status).toBe('done')
+    store.upsert(run('e1', 5, 'failed')) // equal rev → latest event wins
+    expect(store.getInstance('e1')?.status).toBe('failed')
+  })
+
+  it('treats a missing rev as 0 (legacy rows still hydrate)', () => {
+    store.hydrate([{ id: 'e1', blockId: 'b1', steps: [], status: 'running' } as never], 'ws1')
+    store.upsert(run('e1', 1, 'done'))
+    expect(store.getInstance('e1')?.status).toBe('done')
+  })
+})

package/app/stores/execution.ts

@@ -25,17 +25,55 @@ export const useExecutionStore = defineStore('execution', () => {
   // gets identical handling, including the fire-and-forget ones that never caught.
   const runErrors = usePipelineErrorToast()
   const instances = ref<ExecutionInstance[]>([])
+  // The workspace whose snapshot last hydrated the cache. Scopes the DROP-preservation
+  // below: a board SWITCH replaces the cache outright instead of leaking the previous
+  // board's runs (an ExecutionInstance carries no workspaceId of its own).
+  let hydratedWorkspaceId: string | null = null
 
-  /** Replace the cached executions with a server snapshot. */
-  function hydrate(next: ExecutionInstance[]) {
-    instances.value = next
+  /** A run's monotonic server revision (bumped on every persisted write; absent = 0). */
+  function revOf(e: ExecutionInstance): number {
+    return e.rev ?? 0
   }
 
-  /** Insert or replace a single execution instance pushed by the event stream. */
+  /**
+   * Reconcile the cached executions with a server snapshot for `workspaceId`. A snapshot
+   * is authoritative EXCEPT where a live `execution` event already advanced (or ADDED) a
+   * run past what this (possibly stale) read observed — the same two clobber hazards the
+   * `agentRuns` store guards, keyed here on the run's monotonic `rev`:
+   *   - REGRESS: a run present in BOTH — keep the newer-by-`rev` version, so a lagging
+   *     refresh (the stream's on-(re)connect resync, the debounced `board`-event refetch)
+   *     can't revert a just-terminal run to `running`. A terminal run emits nothing
+   *     further, so a regression here would strand the UI until an unrelated refresh.
+   *   - DROP: a run a live event just ADDED that the (older) snapshot never saw — keep it
+   *     rather than silently dropping it.
+   */
+  function hydrate(next: ExecutionInstance[], workspaceId: string) {
+    const sameWorkspace = hydratedWorkspaceId === workspaceId
+    hydratedWorkspaceId = workspaceId
+    if (!sameWorkspace) {
+      instances.value = next
+      return
+    }
+    const incomingIds = new Set(next.map((e) => e.id))
+    const held = new Map(instances.value.map((e) => [e.id, e]))
+    const reconciled = next.map((incoming) => {
+      const current = held.get(incoming.id)
+      return current && revOf(current) > revOf(incoming) ? current : incoming
+    })
+    const preserved = [...held.values()].filter((e) => !incomingIds.has(e.id))
+    instances.value = [...reconciled, ...preserved]
+  }
+
+  /**
+   * Insert or replace a single execution instance pushed by the event stream.
+   * Monotonic by `rev`: an out-of-order/stale event can't regress a run a newer
+   * write already advanced (same guard as {@link hydrate}).
+   */
   function upsert(instance: ExecutionInstance) {
     const i = instances.value.findIndex((e) => e.id === instance.id)
-    if (i >= 0) instances.value[i] = instance
-    else instances.value.push(instance)
+    if (i >= 0) {
+      if (revOf(instance) >= revOf(instances.value[i]!)) instances.value[i] = instance
+    } else instances.value.push(instance)
   }
 
   const byId = computed(() => {