@cat-factory/app 0.71.2 → 0.73.1

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(() => {

package/app/stores/pipelines.ts

@@ -2,6 +2,7 @@ import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
 import type { AgentKind, Pipeline } from '~/types/domain'
 import type { ConsensusStepConfig, StepGating } from '~/types/consensus'
+import type { TesterQualityConfig } from '@cat-factory/contracts'
 import { companionForProducer, uid } from '~/utils/catalog'
 import { useWorkspaceStore } from '~/stores/workspace'
 
@@ -59,6 +60,13 @@ export const usePipelinesStore = defineStore('pipelines', () => {
    * a `coder` step; `false` disables the companion there (default/true ⇒ enabled).
    */
   const draftFollowUps = ref<(boolean | null)[]>([])
+  /**
+   * Per-step test quality-control companion config, kept index-aligned with `draft`. Only
+   * meaningful on a Tester step (`tester-api`/`tester-ui`); `null`/absent means "enabled, no
+   * gating" (the QC companion is on by default), `{ enabled: false }` disables it, and an
+   * entry with `gating` makes it conditional on the task estimate.
+   */
+  const draftTesterQuality = ref<(TesterQualityConfig | null)[]>([])
   /** Organizational labels for the pipeline being assembled/edited. */
   const draftLabels = ref<string[]>([])
   const draftName = ref('New pipeline')
@@ -84,6 +92,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftConsensus.value.splice(index, 0, null)
     draftGating.value.splice(index, 0, null)
     draftFollowUps.value.splice(index, 0, null)
+    draftTesterQuality.value.splice(index, 0, null)
   }
 
   function addToDraft(kind: AgentKind) {
@@ -98,6 +107,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftConsensus.value.splice(index, 1)
     draftGating.value.splice(index, 1)
     draftFollowUps.value.splice(index, 1)
+    draftTesterQuality.value.splice(index, 1)
   }
 
   function moveInDraft(from: number, to: number) {
@@ -116,6 +126,8 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftGating.value.splice(to, 0, gat ?? null)
     const [fu] = draftFollowUps.value.splice(from, 1)
     draftFollowUps.value.splice(to, 0, fu ?? null)
+    const [tq] = draftTesterQuality.value.splice(from, 1)
+    draftTesterQuality.value.splice(to, 0, tq ?? null)
   }
 
   /** Whether the producer step at `index` currently has its companion attached after it. */
@@ -191,6 +203,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftConsensus.value = reorder(draftConsensus.value)
     draftGating.value = reorder(draftGating.value)
     draftFollowUps.value = reorder(draftFollowUps.value)
+    draftTesterQuality.value = reorder(draftTesterQuality.value)
   }
 
   /** Toggle the consensus mechanism on the draft step at `index` (default config / off). */
@@ -214,6 +227,33 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftFollowUps.value[index] = draftFollowUps.value[index] === false ? null : false
   }
 
+  /**
+   * Toggle the test quality-control companion on the draft (Tester) step at `index`. The
+   * companion is enabled by default (a `null` entry), so the first toggle disables it
+   * (`{ enabled: false }`, dropping any gating) and the next restores the default.
+   */
+  function toggleDraftTesterQuality(index: number) {
+    draftTesterQuality.value[index] =
+      draftTesterQuality.value[index]?.enabled === false ? null : { enabled: false }
+  }
+
+  /**
+   * Toggle estimate gating on/off for the QC companion on the draft (Tester) step at `index`.
+   * A no-op while the companion is disabled (nothing to gate). Enabling gating pins the config
+   * to `{ enabled: true, gating }` so the thresholds are editable; disabling drops back to the
+   * default `null` (enabled, ungated).
+   */
+  function toggleDraftTesterQualityGating(index: number) {
+    const cur = draftTesterQuality.value[index]
+    if (cur?.enabled === false) return
+    draftTesterQuality.value[index] = cur?.gating?.enabled
+      ? null
+      : {
+          enabled: true,
+          gating: { enabled: true, minRisk: 0.5, minImpact: 0.5, onMissingEstimate: 'run' },
+        }
+  }
+
   /** Enable/disable the draft step at `index` without removing it. */
   function toggleDraftEnabled(index: number) {
     draftEnabled.value[index] = draftEnabled.value[index] === false
@@ -227,6 +267,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftConsensus.value = []
     draftGating.value = []
     draftFollowUps.value = []
+    draftTesterQuality.value = []
     draftLabels.value = []
     draftName.value = 'New pipeline'
     editingId.value = null
@@ -241,6 +282,9 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftConsensus.value = pipeline.agentKinds.map((_, i) => pipeline.consensus?.[i] ?? null)
     draftGating.value = pipeline.agentKinds.map((_, i) => pipeline.gating?.[i] ?? null)
     draftFollowUps.value = pipeline.agentKinds.map((_, i) => pipeline.followUps?.[i] ?? null)
+    draftTesterQuality.value = pipeline.agentKinds.map(
+      (_, i) => pipeline.testerQuality?.[i] ?? null,
+    )
     draftLabels.value = [...(pipeline.labels ?? [])]
     draftName.value = pipeline.name
     editingId.value = pipeline.id
@@ -270,6 +314,12 @@ export const usePipelinesStore = defineStore('pipelines', () => {
       ...(draftFollowUps.value.some((f) => f === false)
         ? { followUps: [...draftFollowUps.value] }
         : {}),
+      // Only send testerQuality when at least one Tester step deviates from the default
+      // (companion disabled, or an estimate gate configured) — the default (null/enabled,
+      // ungated) is not worth persisting.
+      ...(draftTesterQuality.value.some((q) => q?.enabled === false || q?.gating?.enabled)
+        ? { testerQuality: [...draftTesterQuality.value] }
+        : {}),
       // Only send labels when there are any.
       ...(draftLabels.value.length ? { labels: [...draftLabels.value] } : {}),
     }
@@ -342,6 +392,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftConsensus,
     draftGating,
     draftFollowUps,
+    draftTesterQuality,
     draftLabels,
     draftName,
     editingId,
@@ -357,6 +408,8 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     toggleDraftGating,
     toggleDraftGate,
     toggleDraftFollowUps,
+    toggleDraftTesterQuality,
+    toggleDraftTesterQualityGating,
     toggleDraftEnabled,
     toggleDraftConsensus,
     setDraftConsensus,

package/app/stores/preview.ts

@@ -0,0 +1,94 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { PreviewState } from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * The browsable-frontend-preview runtime state, keyed by `frontend` frame id. Distinct from
+ * the frame's persisted `frontendConfig.previewEnabled` flag: this is the LIVE resource (a
+ * container building/serving the app on a host URL) fetched from the three preview endpoints.
+ * The three calls all return the same {@link PreviewState}, so each action just stores the
+ * result. While a preview is `starting` the store self-polls until it settles (ready/failed),
+ * so the inspector reflects the URL the moment it comes up — no manual refresh.
+ */
+export const usePreviewStore = defineStore('preview', () => {
+  const api = useApi()
+
+  /** frameId → its latest preview state. */
+  const byFrame = ref<Record<string, PreviewState>>({})
+  /** frameId → a start/stop request is in flight (drives the button loading state). */
+  const busy = ref<Record<string, boolean>>({})
+  /** frameId → the last start/stop request error (e.g. the runtime 503s), else undefined. */
+  const requestError = ref<Record<string, string | undefined>>({})
+
+  // Active poll timers while a preview is `starting`, so a settled/left preview stops polling.
+  const timers = new Map<string, ReturnType<typeof setTimeout>>()
+  const POLL_INTERVAL_MS = 2_500
+
+  function stopPolling(frameId: string) {
+    const timer = timers.get(frameId)
+    if (timer) {
+      clearTimeout(timer)
+      timers.delete(frameId)
+    }
+  }
+
+  function apply(frameId: string, state: PreviewState) {
+    byFrame.value[frameId] = state
+    if (state.status === 'starting') {
+      stopPolling(frameId)
+      timers.set(
+        frameId,
+        setTimeout(() => void refresh(frameId), POLL_INTERVAL_MS),
+      )
+    } else {
+      stopPolling(frameId)
+    }
+  }
+
+  /** Fetch the current preview state for a frame (used on mount + as the poll tick). */
+  async function refresh(frameId: string): Promise<void> {
+    const ws = useWorkspaceStore()
+    try {
+      apply(frameId, await api.getPreview(ws.requireId(), frameId))
+    } catch {
+      // A transient error leaves the last known state; stop polling so we don't spin.
+      stopPolling(frameId)
+    }
+  }
+
+  /**
+   * Start (or restart) the preview for a frame. A request failure (e.g. the runtime replies 503)
+   * is captured in {@link requestError} rather than escaping as an unhandled rejection from the
+   * click handler.
+   */
+  async function start(frameId: string): Promise<void> {
+    const ws = useWorkspaceStore()
+    busy.value[frameId] = true
+    requestError.value[frameId] = undefined
+    try {
+      apply(frameId, await api.startPreview(ws.requireId(), frameId))
+    } catch (err) {
+      requestError.value[frameId] = err instanceof Error ? err.message : String(err)
+    } finally {
+      busy.value[frameId] = false
+    }
+  }
+
+  /** Stop the preview for a frame. Failures are captured in {@link requestError}, not thrown. */
+  async function stop(frameId: string): Promise<void> {
+    const ws = useWorkspaceStore()
+    busy.value[frameId] = true
+    requestError.value[frameId] = undefined
+    try {
+      stopPolling(frameId)
+      apply(frameId, await api.stopPreview(ws.requireId(), frameId))
+    } catch (err) {
+      requestError.value[frameId] = err instanceof Error ? err.message : String(err)
+    } finally {
+      busy.value[frameId] = false
+    }
+  }
+
+  return { byFrame, busy, requestError, refresh, start, stop, stopPolling }
+})

package/app/stores/recurringPipelines.ts

@@ -13,6 +13,10 @@ import { useBoardStore } from '~/stores/board'
 export const useRecurringPipelinesStore = defineStore('recurringPipelines', () => {
   const api = useApi()
   const toast = useToast()
+  // Resolve translations through the Nuxt app's global i18n instance — a store runs outside a
+  // component `setup`, so `useI18n()` is unavailable (see the board store for the same pattern).
+  const nuxtApp = useNuxtApp()
+  const tr = (key: string): string => (nuxtApp.$i18n as { t: (k: string) => string }).t(key)
 
   const schedules = ref<PipelineSchedule[]>([])
   /** Lazily-loaded run history, keyed by schedule id. */
@@ -68,7 +72,7 @@ export const useRecurringPipelinesStore = defineStore('recurringPipelines', () =
       schedules.value = prevSchedules
       if (blockSnap) board.reattach(blockSnap)
       toast.add({
-        title: 'Could not delete recurring pipeline',
+        title: tr('board.toast.recurringDeleteFailed'),
         description: e instanceof Error ? e.message : String(e),
         icon: 'i-lucide-triangle-alert',
         color: 'error',