@cat-factory/app 0.115.1 → 0.115.2

package/app/components/board/AgentStopButton.vue

@@ -22,12 +22,23 @@ const props = withDefaults(
 const { t } = useI18n()
 const agentRuns = useAgentRunsStore()
 const toast = useToast()
+const { confirm } = useConfirm()
 const stopping = ref(false)
 
 const displayLabel = computed(() => props.label ?? t('board.stop.label'))
 
 async function stop() {
   if (stopping.value) return
+  // Killing a running container discards its in-flight work — gate it behind a confirm,
+  // matching the confirm-then-mutate contract the task reset path uses.
+  const ok = await confirm({
+    title: t('board.stop.confirm.title'),
+    description: t('board.stop.confirm.body'),
+    confirmLabel: t('board.stop.confirm.confirm'),
+    variant: 'destructive',
+    icon: 'i-lucide-circle-stop',
+  })
+  if (!ok) return
   stopping.value = true
   try {
     const kind = await agentRuns.stop(props.runId)

package/app/components/panels/InspectorPanel.vue

@@ -100,6 +100,21 @@ const statusLabel = computed(() =>
 
 const runnable = computed(() => (block.value ? board.isRunnable(block.value.id) : false))
 
+// A task runs only once every dependency has merged. When the Run trigger is locked
+// it must say WHY — name the unfinished dependencies rather than showing a bare lock.
+const unmetDepTitles = computed(() =>
+  block.value && isTask.value ? board.unmetDeps(block.value.id).map((b) => b.title) : [],
+)
+const runBlockedReason = computed(() =>
+  unmetDepTitles.value.length
+    ? t(
+        'panels.inspector.runBlocked',
+        { count: unmetDepTitles.value.length, names: unmetDepTitles.value.join(', ') },
+        unmetDepTitles.value.length,
+      )
+    : null,
+)
+
 // The delete control names what it removes, so selecting a task and deleting it
 // reads as "Delete task" rather than ambiguously removing the whole service.
 const deleteLabel = computed(() =>
@@ -532,6 +547,19 @@ const showOriginalDescription = ref(false)
       <!-- initiative: status + goal, run-planning + tracker controls -->
       <InitiativeInspector v-else-if="isInitiative" :block="block" />
 
+      <!-- Locked-run explanation: a disabled task Run button reads as a dead lock unless
+           it says what's holding it. Named here (and on the button title) so the blocking
+           dependencies are visible to pointer, keyboard, and touch alike — a native title
+           on a disabled button doesn't fire hover events. -->
+      <p
+        v-if="isTask && runBlockedReason"
+        class="flex items-start gap-1.5 text-[11px] text-amber-300/90"
+        data-testid="run-blocked-reason"
+      >
+        <UIcon name="i-lucide-lock" class="mt-px h-3 w-3 shrink-0" />
+        <span>{{ runBlockedReason }}</span>
+      </p>
+
       <!-- actions -->
       <div class="flex items-center gap-2">
         <UDropdownMenu v-if="isTask" :items="runMenu">
@@ -542,6 +570,7 @@ const showOriginalDescription = ref(false)
             :icon="runnable ? 'i-lucide-play' : 'i-lucide-lock'"
             trailing-icon="i-lucide-chevron-down"
             :disabled="!runnable"
+            :title="runBlockedReason ?? undefined"
           >
             {{ instance ? t('panels.inspector.reRun') : t('panels.inspector.run') }}
           </UButton>

package/app/components/panels/inspector/TaskExecution.vue

@@ -11,6 +11,8 @@ import AgentFailureCard from '~/components/board/AgentFailureCard.vue'
 import AgentFailureHistory from '~/components/board/AgentFailureHistory.vue'
 import EmptyState from '~/components/common/EmptyState.vue'
 import InspectorSection from '~/components/panels/inspector/InspectorSection.vue'
+import { useNowTick, stepDurationLabel } from '~/composables/useStepTimer'
+import type { PipelineStep } from '~/types/execution'
 
 const props = defineProps<{ block: Block }>()
 
@@ -85,6 +87,13 @@ function stepFailed(s: { state: string }) {
   return runFailed.value && s.state === 'working'
 }
 
+// A shared 1s tick drives every step's live elapsed clock, so a running step that
+// hasn't yet emitted subtask counts reads as progressing rather than hung.
+const nowTick = useNowTick()
+function stepElapsed(s: PipelineStep): string | null {
+  return stepDurationLabel(s, nowTick.value, runFailed.value, instance.value?.failure?.occurredAt)
+}
+
 /** A gated step parked for approval reads "Needs approval", not "Needs decision". */
 function labelForStep(s: {
   state: string
@@ -148,6 +157,17 @@ function openForkFor(i: number) {
 const stopping = ref(false)
 async function stopRun() {
   if (!instance.value || stopping.value) return
+  // Killing the running container discards its in-flight work — gate it behind the same
+  // confirm the board card's stop uses (via `AgentStopButton`), so every stop surface for
+  // a run is confirm-gated identically.
+  const ok = await confirm({
+    title: t('board.stop.confirm.title'),
+    description: t('board.stop.confirm.body'),
+    confirmLabel: t('board.stop.confirm.confirm'),
+    variant: 'destructive',
+    icon: 'i-lucide-circle-stop',
+  })
+  if (!ok) return
   stopping.value = true
   try {
     await execution.stop(instance.value.id)
@@ -306,6 +326,14 @@ async function mergePr() {
             >
               <UIcon v-if="stepFailed(s)" name="i-lucide-circle-x" class="h-3 w-3 shrink-0" />
               {{ labelForStep(s) }}
+              <!-- live elapsed clock: a running step counts up, a finished one shows total -->
+              <span
+                v-if="stepElapsed(s)"
+                class="inline-flex items-center gap-0.5 font-mono tabular-nums text-slate-500"
+                :title="t('inspector.execution.elapsedTooltip')"
+              >
+                · {{ stepElapsed(s) }}
+              </span>
             </span>
             <UButton
               v-if="s.decision && !s.decision.chosen"

package/app/components/pipeline/PipelineProgress.vue

@@ -12,6 +12,7 @@ import {
   containerPhaseLabel,
 } from '~/utils/pipelineRender'
 import StepMetricsBar from '~/components/observability/StepMetricsBar.vue'
+import { useNowTick, stepDurationLabel } from '~/composables/useStepTimer'
 
 const props = defineProps<{ instance: ExecutionInstance }>()
 const emit = defineEmits<{
@@ -136,6 +137,13 @@ const STATUS_META = computed<Record<ExecutionInstance['status'], { label: string
 const steps = computed(() => props.instance.steps)
 const total = computed(() => steps.value.length)
 
+// A shared 1s tick drives every step's live elapsed clock, so a step that hasn't yet
+// emitted subtask counts still shows it is progressing rather than reading as hung.
+const nowTick = useNowTick()
+function stepElapsed(s: PipelineStep): string | null {
+  return stepDurationLabel(s, nowTick.value, runFailed.value, props.instance.failure?.occurredAt)
+}
+
 // The conditionally-run companion (e.g. the Tester's `fixer`) each step drives, with
 // its possible/running/completed/skipped state — rendered as a distinct sub-node so a
 // human can see at a glance whether the fixer ran or was skipped.
@@ -322,8 +330,20 @@ const ITEM_ICON: Record<string, string> = {
                   {{ t('pipeline.progress.companion') }}
                 </span>
               </div>
-              <div class="text-[10px] uppercase tracking-wide text-slate-500">
-                {{ t('pipeline.progress.stepOf', { current: i + 1, total }) }}
+              <div
+                class="flex items-center gap-1.5 text-[10px] uppercase tracking-wide text-slate-500"
+              >
+                <span>{{ t('pipeline.progress.stepOf', { current: i + 1, total }) }}</span>
+                <!-- live elapsed clock: a running step counts up (so no-subtask steps
+                     don't read as hung), a finished step shows its total duration -->
+                <span
+                  v-if="stepElapsed(s)"
+                  class="inline-flex items-center gap-0.5 font-mono normal-case tabular-nums text-slate-400"
+                  :title="t('pipeline.progress.elapsedTooltip')"
+                >
+                  <UIcon name="i-lucide-clock" class="h-2.5 w-2.5 shrink-0" />
+                  {{ stepElapsed(s) }}
+                </span>
               </div>
             </div>
             <span
@@ -343,7 +363,7 @@ const ITEM_ICON: Record<string, string> = {
                 color="neutral"
                 variant="ghost"
                 size="xs"
-                class="shrink-0 opacity-0 transition-opacity group-hover:opacity-100"
+                class="shrink-0 opacity-0 transition-opacity group-hover:opacity-100 group-focus-within:opacity-100 focus-visible:opacity-100"
                 :title="t('pipeline.progress.restartTooltip')"
                 @click.stop="
                   () => {

package/app/composables/useStepTimer.spec.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest'
+import type { PipelineStep } from '~/types/execution'
+import { stepDurationLabel, stepDurationMs, stepIsRunning } from '~/composables/useStepTimer'
+
+// The pure helpers encode one freeze rule shared by the list surfaces (pipeline timeline,
+// inspector run list) and the single-step overlay, so pin the precedence here:
+// finishedAt > (runFailed ? failureAt ?? startedAt) > pausedAt > live now.
+function step(overrides: Partial<PipelineStep> = {}): PipelineStep {
+  return { agentKind: 'coder', state: 'working', ...overrides } as PipelineStep
+}
+
+const NOW = 10_000
+
+describe('stepIsRunning', () => {
+  it('is false for a null step', () => {
+    expect(stepIsRunning(null, false)).toBe(false)
+  })
+
+  it('is false until the step has started', () => {
+    expect(stepIsRunning(step({ startedAt: undefined }), false)).toBe(false)
+  })
+
+  it('is true for a started, unfinished, unparked step on a live run', () => {
+    expect(stepIsRunning(step({ startedAt: 1000 }), false)).toBe(true)
+  })
+
+  it('is false once finished, parked, or the run failed', () => {
+    expect(stepIsRunning(step({ startedAt: 1000, finishedAt: 2000 }), false)).toBe(false)
+    expect(stepIsRunning(step({ startedAt: 1000, pausedAt: 1500 }), false)).toBe(false)
+    expect(stepIsRunning(step({ startedAt: 1000 }), true)).toBe(false)
+  })
+})
+
+describe('stepDurationMs', () => {
+  it('is null until the step has started', () => {
+    expect(stepDurationMs(step({ startedAt: undefined }), NOW, false, null)).toBeNull()
+    expect(stepDurationMs(null, NOW, false, null)).toBeNull()
+  })
+
+  it('counts up to now while live', () => {
+    expect(stepDurationMs(step({ startedAt: 4000 }), NOW, false, null)).toBe(6000)
+  })
+
+  it('freezes at finishedAt once finished (ignoring now)', () => {
+    expect(stepDurationMs(step({ startedAt: 4000, finishedAt: 7000 }), NOW, false, null)).toBe(3000)
+  })
+
+  it('freezes at the run failure time when the run failed', () => {
+    expect(stepDurationMs(step({ startedAt: 4000 }), NOW, true, 6000)).toBe(2000)
+  })
+
+  it('falls back to startedAt (zero) when the run failed with no failure time', () => {
+    expect(stepDurationMs(step({ startedAt: 4000 }), NOW, true, null)).toBe(0)
+  })
+
+  it('freezes at the park time when parked on a human', () => {
+    expect(stepDurationMs(step({ startedAt: 4000, pausedAt: 5500 }), NOW, false, null)).toBe(1500)
+  })
+
+  it('prefers finishedAt over the failure time', () => {
+    expect(stepDurationMs(step({ startedAt: 4000, finishedAt: 5000 }), NOW, true, 6000)).toBe(1000)
+  })
+
+  it('never returns a negative duration', () => {
+    expect(stepDurationMs(step({ startedAt: 8000 }), NOW, true, 6000)).toBe(0)
+  })
+})
+
+describe('stepDurationLabel', () => {
+  it('is null until the step has started', () => {
+    expect(stepDurationLabel(step({ startedAt: undefined }), NOW, false, null)).toBeNull()
+  })
+
+  it('formats seconds and minutes', () => {
+    expect(stepDurationLabel(step({ startedAt: 4000 }), NOW, false, null)).toBe('6s')
+    expect(stepDurationLabel(step({ startedAt: 0, finishedAt: 90_000 }), NOW, false, null)).toBe(
+      '1m 30s',
+    )
+  })
+})

package/app/composables/useStepTimer.ts

@@ -1,6 +1,63 @@
 import { ref, computed, onMounted, onUnmounted } from 'vue'
 import type { PipelineStep } from '~/types/execution'
 
+/**
+ * Whether a step is actively executing: it has started, hasn't finished, isn't
+ * parked on a human (`pausedAt`), and the run itself hasn't failed. A step in any
+ * of those states is not ticking — no spinner, no counting-up clock.
+ */
+export function stepIsRunning(step: PipelineStep | null, runFailed: boolean): boolean {
+  return !!step?.startedAt && !step?.finishedAt && step?.pausedAt == null && !runFailed
+}
+
+/**
+ * Elapsed/total execution time in ms for a step at wall-clock `nowMs`, or null until
+ * the step has started. The clock freezes once the step stops working: at its finish,
+ * else at the run's failure time once the run has failed, else at the moment it parked
+ * on a human (`pausedAt`). Otherwise it is live, counting up to `nowMs`.
+ */
+export function stepDurationMs(
+  step: PipelineStep | null,
+  nowMs: number,
+  runFailed: boolean,
+  failureAt: number | null | undefined,
+): number | null {
+  if (step?.startedAt == null) return null
+  const end =
+    step.finishedAt ?? (runFailed ? (failureAt ?? step.startedAt) : (step.pausedAt ?? nowMs))
+  return Math.max(0, end - step.startedAt)
+}
+
+/** Human-friendly elapsed label for a step at `nowMs`, or null until it has started. */
+export function stepDurationLabel(
+  step: PipelineStep | null,
+  nowMs: number,
+  runFailed: boolean,
+  failureAt: number | null | undefined,
+): string | null {
+  const ms = stepDurationMs(step, nowMs, runFailed, failureAt)
+  return ms == null ? null : formatDuration(ms)
+}
+
+/**
+ * A shared 1s wall-clock tick for surfaces that render many steps' live durations
+ * at once (the pipeline timeline, the inspector run list). One interval drives every
+ * step's elapsed label instead of a per-step timer. Stays `0` until mounted so the
+ * first paint never reads a stale time.
+ */
+export function useNowTick(intervalMs = 1000) {
+  const now = ref(0)
+  let timer: ReturnType<typeof setInterval> | undefined
+  onMounted(() => {
+    now.value = Date.now()
+    timer = setInterval(() => (now.value = Date.now()), intervalMs)
+  })
+  onUnmounted(() => {
+    if (timer) clearInterval(timer)
+  })
+  return now
+}
+
 /**
  * Live elapsed-time clock for a single pipeline step. A 1s tick drives the
  * counting-up duration while the step is actively running; the clock freezes at
@@ -12,37 +69,16 @@ export function useStepTimer(opts: {
   runFailed: () => boolean
   failureAt: () => number | null | undefined
 }) {
-  // A 1s tick so a still-running step's elapsed time counts up live while open.
-  const nowTick = ref(0)
-  let timer: ReturnType<typeof setInterval> | undefined
-  onMounted(() => {
-    nowTick.value = Date.now()
-    timer = setInterval(() => (nowTick.value = Date.now()), 1000)
-  })
-  onUnmounted(() => {
-    if (timer) clearInterval(timer)
-  })
+  const nowTick = useNowTick()
 
   // A step that is finished, failed, or parked on a human is not actively
-  // executing — no ticking clock or spinner. `pausedAt` is the "waiting on input"
-  // freeze.
-  const isRunning = computed(() => {
-    const s = opts.step()
-    return !!s?.startedAt && !s?.finishedAt && s?.pausedAt == null && !opts.runFailed()
-  })
+  // executing — no ticking clock or spinner. `pausedAt` is the "waiting on input" freeze.
+  const isRunning = computed(() => stepIsRunning(opts.step(), opts.runFailed()))
 
   /** Elapsed/total execution time in ms — null until the step has started. */
-  const durationMs = computed(() => {
-    const s = opts.step()
-    if (s?.startedAt == null) return null
-    // Freeze the clock once the step stops working: at its finish, else at the
-    // failure time once the run has failed, else at the moment it parked on a
-    // human (`pausedAt`). Otherwise it is live, so count up to the current tick.
-    const end =
-      s.finishedAt ??
-      (opts.runFailed() ? (opts.failureAt() ?? s.startedAt) : (s.pausedAt ?? nowTick.value))
-    return Math.max(0, end - s.startedAt)
-  })
+  const durationMs = computed(() =>
+    stepDurationMs(opts.step(), nowTick.value, opts.runFailed(), opts.failureAt()),
+  )
 
   const durationLabel = computed(() =>
     durationMs.value == null ? null : formatDuration(durationMs.value),
@@ -51,7 +87,7 @@ export function useStepTimer(opts: {
   return { isRunning, durationMs, durationLabel }
 }
 
-function formatDuration(ms: number): string {
+export function formatDuration(ms: number): string {
   const totalSec = Math.round(ms / 1000)
   if (totalSec < 60) return `${totalSec}s`
   const m = Math.floor(totalSec / 60)

package/app/stores/consensus.spec.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useConsensusStore } from '~/stores/consensus'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { ConsensusSession } from '~/types/consensus'
+
+/** Minimal session factory — only the fields the store reconciles/reads. */
+function session(over: Partial<ConsensusSession> = {}): ConsensusSession {
+  return {
+    id: 's1',
+    blockId: 'blk1',
+    executionId: null,
+    stepIndex: 0,
+    agentKind: 'architect',
+    strategy: 'panel',
+    status: 'complete',
+    participants: [],
+    rounds: [],
+    synthesis: null,
+    createdAt: 1,
+    updatedAt: 1,
+    ...over,
+  } as ConsensusSession
+}
+
+describe('consensus store — load vs live-push reconcile', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('load stores the fetched session', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getConsensusSession: () => Promise.resolve({ session: session() }),
+    }))
+    const store = useConsensusStore()
+    await store.load('blk1')
+    expect(store.sessionFor('blk1')?.id).toBe('s1')
+  })
+
+  it('a stale load never regresses a fresher live-pushed session', async () => {
+    // A live `consensus` push delivers the newest transcript; a `load` that started earlier
+    // resolves later with a staler snapshot. It must NOT overwrite the fresher one.
+    let resolveFetch!: (r: { session: ConsensusSession | null }) => void
+    const pending = new Promise<{ session: ConsensusSession | null }>((res) => {
+      resolveFetch = res
+    })
+    vi.stubGlobal('useApi', () => ({ getConsensusSession: () => pending }))
+    const store = useConsensusStore()
+
+    const load = store.load('blk1')
+    store.upsert(session({ updatedAt: 10, synthesis: 'fresh' }))
+    resolveFetch({ session: session({ updatedAt: 2, synthesis: 'stale' }) })
+    await load
+
+    expect(store.sessionFor('blk1')?.synthesis).toBe('fresh')
+  })
+
+  it('a load returning "none" never clobbers an existing live session', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getConsensusSession: () => Promise.resolve({ session: null }),
+    }))
+    const store = useConsensusStore()
+    store.upsert(session({ synthesis: 'live' }))
+    await store.load('blk1')
+    expect(store.sessionFor('blk1')?.synthesis).toBe('live')
+  })
+
+  it('a load returning "none" records the fetched-empty state when nothing is cached', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getConsensusSession: () => Promise.resolve({ session: null }),
+    }))
+    const store = useConsensusStore()
+    await store.load('blk1')
+    expect('blk1' in store.sessions).toBe(true)
+    expect(store.sessionFor('blk1')).toBeNull()
+  })
+})

package/app/stores/consensus.ts

@@ -46,7 +46,17 @@ export const useConsensusStore = defineStore('consensus', () => {
     loading.value = new Set(loading.value).add(blockId)
     try {
       const { session } = await api.getConsensusSession(wsId, blockId)
-      sessions.value = { ...sessions.value, [blockId]: session }
+      // Reconcile rather than blind-replace: a `load` resolving AFTER a fresher live
+      // `consensus` push (or after a newer concurrent load) must not regress the transcript —
+      // the out-of-order-overwrite hazard the CLAUDE.md live-push rules warn about. Keep
+      // whichever session is newer by `updatedAt` (any id), and never overwrite an existing
+      // (possibly live-pushed) session with a raced "none".
+      const existing = sessions.value[blockId]
+      if (session) {
+        if (!existing || session.updatedAt >= existing.updatedAt) store(session)
+      } else if (existing === undefined) {
+        sessions.value = { ...sessions.value, [blockId]: null }
+      }
     } catch {
       // Consensus off / no session — leave the cache as-is; the window shows its empty state.
     } finally {

package/app/stores/docInterview.spec.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useDocInterviewStore } from '~/stores/docInterview'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { DocInterviewSession } from '~/types/domain'
+
+/** Minimal session factory — only the fields the store reconciles/reads. */
+function session(over: Partial<DocInterviewSession> = {}): DocInterviewSession {
+  return {
+    id: 'd1',
+    blockId: 'blk1',
+    status: 'awaiting_answers',
+    round: 1,
+    maxRounds: 3,
+    qa: [],
+    brief: null,
+    model: null,
+    createdAt: 1,
+    updatedAt: 1,
+    ...over,
+  } as DocInterviewSession
+}
+
+// docInterview already routes its `load` through `upsert`'s newest-wins (`updatedAt`) guard —
+// these specs pin that so a future refactor can't reintroduce a blind-replace clobber.
+describe('docInterview store — load vs live-push reconcile', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('load stores the fetched session', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getDocInterview: () => Promise.resolve(session()),
+    }))
+    const store = useDocInterviewStore()
+    await store.load('blk1')
+    expect(store.forBlock('blk1')?.id).toBe('d1')
+  })
+
+  it('a stale load never regresses a fresher live-pushed session', async () => {
+    let resolveFetch!: (r: DocInterviewSession | null) => void
+    const pending = new Promise<DocInterviewSession | null>((res) => {
+      resolveFetch = res
+    })
+    vi.stubGlobal('useApi', () => ({ getDocInterview: () => pending }))
+    const store = useDocInterviewStore()
+
+    const load = store.load('blk1')
+    store.upsert(session({ updatedAt: 10, round: 2 }))
+    resolveFetch(session({ updatedAt: 2, round: 1 }))
+    await load
+
+    expect(store.forBlock('blk1')?.round).toBe(2)
+  })
+
+  it('a load returning "none" leaves the cache untouched', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getDocInterview: () => Promise.resolve(null),
+    }))
+    const store = useDocInterviewStore()
+    store.upsert(session({ round: 2 }))
+    await store.load('blk1')
+    expect(store.forBlock('blk1')?.round).toBe(2)
+  })
+})

package/app/stores/kaizen.spec.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useKaizenStore } from '~/stores/kaizen'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { KaizenGrading } from '~/types/domain'
+
+/** Minimal grading factory — only the fields the store reconciles/reads. */
+function grading(over: Partial<KaizenGrading> = {}): KaizenGrading {
+  return {
+    id: 'g1',
+    executionId: 'exec1',
+    blockId: 'blk1',
+    stepIndex: 0,
+    agentKind: 'coder',
+    model: 'm',
+    promptVersion: 1,
+    comboKey: 'coder|m|1',
+    status: 'complete',
+    grade: 5,
+    summary: '',
+    recommendations: [],
+    graderModel: null,
+    error: null,
+    createdAt: 1,
+    updatedAt: 1,
+    ...over,
+  } as KaizenGrading
+}
+
+describe('kaizen store — live-push clobber guards', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('loadForExecution stores the fetched gradings', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getKaizenForExecution: () => Promise.resolve({ gradings: [grading()] }),
+    }))
+    const store = useKaizenStore()
+    await store.loadForExecution('exec1')
+    expect(store.byExecution.exec1).toHaveLength(1)
+  })
+
+  it('a slower stale loadForExecution never clobbers a newer one (monotonic guard)', async () => {
+    // Two loads race for the same execution: the FIRST-issued resolves LAST with a stale list.
+    // Without the ticket guard its REPLACE would overwrite the fresher second result.
+    const deferred: Array<(r: { gradings: KaizenGrading[] }) => void> = []
+    vi.stubGlobal('useApi', () => ({
+      getKaizenForExecution: () =>
+        new Promise<{ gradings: KaizenGrading[] }>((res) => deferred.push(res)),
+    }))
+    const store = useKaizenStore()
+    const first = store.loadForExecution('exec1') // issued #1 (stale)
+    const second = store.loadForExecution('exec1') // issued #2 (fresh)
+
+    deferred[1]!({ gradings: [grading({ id: 'fresh' })] })
+    deferred[0]!({ gradings: [grading({ id: 'stale' })] })
+    await Promise.all([first, second])
+
+    expect(store.byExecution.exec1).toHaveLength(1)
+    expect(store.byExecution.exec1![0]!.id).toBe('fresh')
+  })
+
+  it('a grading pushed live mid-load survives the load (merge, not blind-replace)', async () => {
+    // A load is in flight (server response predates the newest grading); a live `upsert` lands
+    // its grading; then the load resolves. A blind replace would drop the live-only grading.
+    let resolveFetch!: (r: { gradings: KaizenGrading[] }) => void
+    const pending = new Promise<{ gradings: KaizenGrading[] }>((res) => {
+      resolveFetch = res
+    })
+    vi.stubGlobal('useApi', () => ({ getKaizenForExecution: () => pending }))
+    const store = useKaizenStore()
+
+    const load = store.loadForExecution('exec1')
+    // A live stream event arrives while the fetch is in flight.
+    store.upsert(grading({ id: 'live', stepIndex: 1 }))
+    // The load's (staler) response comes back with only the earlier grading.
+    resolveFetch({ gradings: [grading({ id: 'g1', stepIndex: 0 })] })
+    await load
+
+    const ids = store.byExecution.exec1!.map((g) => g.id).sort()
+    expect(ids).toEqual(['g1', 'live'])
+  })
+
+  it('a shared-id load keeps whichever updatedAt is newer', async () => {
+    // Stub before the store is created — it captures `useApi()` at instantiation.
+    vi.stubGlobal('useApi', () => ({
+      getKaizenForExecution: () =>
+        Promise.resolve({ gradings: [grading({ id: 'g1', updatedAt: 2, summary: 'stale' })] }),
+    }))
+    const store = useKaizenStore()
+    // Seed a fresher live grading, then a load returns a staler copy of the SAME id.
+    store.upsert(grading({ id: 'g1', updatedAt: 5, summary: 'live' }))
+    await store.loadForExecution('exec1')
+    expect(store.byExecution.exec1![0]!.summary).toBe('live')
+  })
+
+  it('loadOverview preserves a live-pushed grading in history (merge, newest-first)', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getKaizenOverview: () =>
+        Promise.resolve({
+          gradings: [grading({ id: 'old', createdAt: 1, updatedAt: 1 })],
+          verified: [],
+        }),
+    }))
+    const store = useKaizenStore()
+    // A grading arrives live before the overview list is fetched.
+    store.upsert(grading({ id: 'live', createdAt: 9, updatedAt: 9 }))
+    await store.loadOverview()
+
+    const ids = store.history.map((g) => g.id)
+    expect(ids).toContain('live')
+    expect(ids).toContain('old')
+    // The live (newest) grading stays at the front of the newest-first list.
+    expect(ids[0]).toBe('live')
+  })
+
+  it('a slower stale loadOverview never clobbers a newer one', async () => {
+    const deferred: Array<(r: { gradings: KaizenGrading[]; verified: [] }) => void> = []
+    vi.stubGlobal('useApi', () => ({
+      getKaizenOverview: () =>
+        new Promise<{ gradings: KaizenGrading[]; verified: [] }>((res) => deferred.push(res)),
+    }))
+    const store = useKaizenStore()
+    const first = store.loadOverview() // stale
+    const second = store.loadOverview() // fresh
+
+    deferred[1]!({ gradings: [grading({ id: 'fresh' })], verified: [] })
+    deferred[0]!({ gradings: [grading({ id: 'stale' })], verified: [] })
+    await Promise.all([first, second])
+
+    expect(store.history).toHaveLength(1)
+    expect(store.history[0]!.id).toBe('fresh')
+  })
+})

package/app/stores/kaizen.ts

@@ -23,6 +23,36 @@ export const useKaizenStore = defineStore('kaizen', () => {
   /** 503 ⇒ the Kaizen feature isn't configured on this deployment. */
   const available = ref<boolean | null>(null)
 
+  // Monotonic load-ordering guard. Both loads REPLACE state that also arrives live over the
+  // stream (`upsert`), so a slower/staler fetch resolving AFTER a newer one — or after a live
+  // push — would clobber the fresher gradings (the CLAUDE.md live-push out-of-order hazard,
+  // the same one `stores/provisioningLogs.ts` guards). Each load takes a ticket; only the
+  // newest-issued one commits. NOT reactive — pure bookkeeping the UI never reads.
+  let loadTicket = 0
+  let latestOverviewLoad = 0
+  const latestExecLoad = new Map<string, number>()
+
+  /**
+   * Fold a freshly-loaded grading list into the live cache WITHOUT dropping live-only rows:
+   * a grading pushed via `upsert` while the load was in flight may not be in the server's
+   * response yet, and a blind replace would silently drop it. Loaded rows are authoritative
+   * for the ids they carry (keeping whichever `updatedAt` is greater on a shared id), and any
+   * live-only rows the response hasn't caught up to are preserved. Gradings are append/update-
+   * only (never deleted), so preserving an unmatched live row can't resurrect stale state.
+   * Returns the reconciled loaded rows and the surviving live-only rows separately so each
+   * caller can splice them in its own order (execution cache appends; screen history, which is
+   * newest-first, prepends).
+   */
+  function reconcileWithLive(loaded: KaizenGrading[], existing: KaizenGrading[]) {
+    const loadedIds = new Set(loaded.map((g) => g.id))
+    const reconciled = loaded.map((l) => {
+      const live = existing.find((e) => e.id === l.id)
+      return live && live.updatedAt > l.updatedAt ? live : l
+    })
+    const liveOnly = existing.filter((e) => !loadedIds.has(e.id))
+    return { reconciled, liveOnly }
+  }
+
   function gradingsFor(executionId: string): KaizenGrading[] {
     return byExecution.value[executionId] ?? []
   }
@@ -35,11 +65,18 @@ export const useKaizenStore = defineStore('kaizen', () => {
   async function loadOverview() {
     const ws = useWorkspaceStore()
     loadingOverview.value = true
+    const seq = ++loadTicket
+    latestOverviewLoad = seq
     try {
       const overview = await api.getKaizenOverview(ws.requireId())
-      history.value = overview.gradings
-      verified.value = overview.verified
       available.value = true
+      // A newer overview load superseded this one while it was in flight — discard the staler
+      // result so it can't clobber the fresher history (and any grading live-pushed since).
+      if (latestOverviewLoad !== seq) return
+      verified.value = overview.verified
+      // History is newest-first; live-pushed gradings are the newest, so prepend the survivors.
+      const { reconciled, liveOnly } = reconcileWithLive(overview.gradings, history.value)
+      history.value = [...liveOnly, ...reconciled]
     } catch (e) {
       if ((e as { statusCode?: number; status?: number })?.statusCode === 503)
         available.value = false
@@ -52,10 +89,20 @@ export const useKaizenStore = defineStore('kaizen', () => {
   async function loadForExecution(executionId: string) {
     const ws = useWorkspaceStore()
     loadingExecution.value = new Set(loadingExecution.value).add(executionId)
+    const seq = ++loadTicket
+    latestExecLoad.set(executionId, seq)
     try {
       const { gradings } = await api.getKaizenForExecution(ws.requireId(), executionId)
-      byExecution.value = { ...byExecution.value, [executionId]: gradings }
       available.value = true
+      // A newer load for this execution (or a live `upsert`) may have landed while this fetch
+      // was in flight — discard a superseded load, and merge rather than blind-replace so a
+      // grading pushed live mid-flight isn't dropped.
+      if (latestExecLoad.get(executionId) !== seq) return
+      const { reconciled, liveOnly } = reconcileWithLive(
+        gradings,
+        byExecution.value[executionId] ?? [],
+      )
+      byExecution.value = { ...byExecution.value, [executionId]: [...reconciled, ...liveOnly] }
     } catch (e) {
       if ((e as { statusCode?: number; status?: number })?.statusCode === 503)
         available.value = false

package/i18n/locales/de.json

@@ -1174,7 +1174,8 @@
       "merged": "Gemergt",
       "open": "Öffnen",
       "mergePr": "PR mergen",
-      "chooseApproach": "Ansatz wählen"
+      "chooseApproach": "Ansatz wählen",
+      "elapsedTooltip": "Verstrichene Zeit für diesen Schritt"
     },
     "structure": {
       "title": "Struktur",
@@ -1466,7 +1467,8 @@
       "confirmArchive": {
         "title": "Diesen Dienst archivieren?",
         "body": "„{name}“ und seine Aufgaben werden vom Board ausgeblendet. Du kannst den Dienst jederzeit wiederherstellen."
-      }
+      },
+      "runBlocked": "Blockiert durch eine unerledigte Abhängigkeit: {names} | Blockiert durch {count} unerledigte Abhängigkeiten: {names}"
     }
   },
   "layout": {
@@ -2123,7 +2125,12 @@
       "bootstrapStopped": "Bootstrap gestoppt",
       "runStopped": "Lauf gestoppt",
       "stoppedDescription": "Der Container wurde beendet und der Lauf abgebrochen.",
-      "stopFailed": "Stoppen fehlgeschlagen"
+      "stopFailed": "Stoppen fehlgeschlagen",
+      "confirm": {
+        "title": "Diesen Lauf stoppen?",
+        "body": "Der laufende Container wird beendet. Der Lauf bleibt sichtbar und kann wiederholt werden.",
+        "confirm": "Lauf stoppen"
+      }
     },
     "frame": {
       "status": {
@@ -3011,7 +3018,8 @@
       "forkDecision": {
         "proposing": "Ansätze werden vorgeschlagen…",
         "choose": "Ansatz wählen"
-      }
+      },
+      "elapsedTooltip": "Verstrichene Zeit für diesen Schritt"
     },
     "health": {
       "title": "Pipeline-Zustand",

package/i18n/locales/en.json

@@ -347,7 +347,12 @@
       "bootstrapStopped": "Bootstrap stopped",
       "runStopped": "Run stopped",
       "stoppedDescription": "The container was killed and the run was cancelled.",
-      "stopFailed": "Stop failed"
+      "stopFailed": "Stop failed",
+      "confirm": {
+        "title": "Stop this run?",
+        "body": "The running container will be killed. The run stays visible and can be retried.",
+        "confirm": "Stop run"
+      }
     },
     "frame": {
       "status": {
@@ -913,7 +918,8 @@
       "merged": "Merged",
       "open": "Open",
       "mergePr": "Merge PR",
-      "chooseApproach": "Choose approach"
+      "chooseApproach": "Choose approach",
+      "elapsedTooltip": "Elapsed time on this step"
     },
     "structure": {
       "title": "Structure",
@@ -1205,6 +1211,10 @@
       "confirmArchive": {
         "title": "Archive this service?",
         "body": "\"{name}\" and its tasks will be hidden from the board. You can restore it at any time."
+      },
+      "runBlocked": "Blocked by an unfinished dependency: {names} | Blocked by {count} unfinished dependencies: {names}",
+      "@runBlocked": {
+        "description": "Count-driven plural: {count} unfinished dependencies, {names} their comma-joined titles. Languages with more than two plural forms (e.g. Polish, Ukrainian: one/few/many) need the extra pipe-separated forms."
       }
     }
   },
@@ -3324,7 +3334,8 @@
       "forkDecision": {
         "proposing": "Proposing approaches…",
         "choose": "Choose an approach"
-      }
+      },
+      "elapsedTooltip": "Elapsed time on this step"
     },
     "health": {
       "title": "Pipeline health",

package/i18n/locales/es.json

@@ -320,7 +320,12 @@
       "bootstrapStopped": "Arranque detenido",
       "runStopped": "Ejecución detenida",
       "stoppedDescription": "El contenedor se cerró y la ejecución se canceló.",
-      "stopFailed": "No se pudo detener"
+      "stopFailed": "No se pudo detener",
+      "confirm": {
+        "title": "¿Detener esta ejecución?",
+        "body": "Se detendrá el contenedor en ejecución. La ejecución seguirá visible y podrá reintentarse.",
+        "confirm": "Detener ejecución"
+      }
     },
     "frame": {
       "status": {
@@ -859,7 +864,8 @@
         "title": "Aún no hay ejecuciones",
         "body": "Inicia un pipeline para ver el historial de ejecución aquí."
       },
-      "chooseApproach": "Elegir enfoque"
+      "chooseApproach": "Elegir enfoque",
+      "elapsedTooltip": "Tiempo transcurrido en este paso"
     },
     "structure": {
       "title": "Estructura",
@@ -1151,7 +1157,8 @@
       "confirmArchive": {
         "title": "¿Archivar este servicio?",
         "body": "«{name}» y sus tareas se ocultarán del tablero. Puedes restaurarlo en cualquier momento."
-      }
+      },
+      "runBlocked": "Bloqueado por una dependencia sin terminar: {names} | Bloqueado por {count} dependencias sin terminar: {names}"
     }
   },
   "observability": {
@@ -3237,7 +3244,8 @@
       "forkDecision": {
         "proposing": "Proponiendo enfoques…",
         "choose": "Elegir un enfoque"
-      }
+      },
+      "elapsedTooltip": "Tiempo transcurrido en este paso"
     },
     "health": {
       "title": "Estado de los pipelines",

package/i18n/locales/fr.json

@@ -320,7 +320,12 @@
       "bootstrapStopped": "Initialisation arrêtée",
       "runStopped": "Exécution arrêtée",
       "stoppedDescription": "Le conteneur a été tué et l’exécution annulée.",
-      "stopFailed": "Échec de l’arrêt"
+      "stopFailed": "Échec de l’arrêt",
+      "confirm": {
+        "title": "Arrêter cette exécution ?",
+        "body": "Le conteneur en cours sera arrêté. L'exécution reste visible et peut être relancée.",
+        "confirm": "Arrêter l'exécution"
+      }
     },
     "frame": {
       "status": {
@@ -859,7 +864,8 @@
         "title": "Aucune exécution pour l'instant",
         "body": "Lancez un pipeline pour voir l'historique d'exécution ici."
       },
-      "chooseApproach": "Choisir l'approche"
+      "chooseApproach": "Choisir l'approche",
+      "elapsedTooltip": "Temps écoulé sur cette étape"
     },
     "structure": {
       "title": "Structure",
@@ -1151,7 +1157,8 @@
       "confirmArchive": {
         "title": "Archiver ce service ?",
         "body": "« {name} » et ses tâches seront masqués du tableau. Vous pouvez le restaurer à tout moment."
-      }
+      },
+      "runBlocked": "Bloqué par une dépendance non terminée : {names} | Bloqué par {count} dépendances non terminées : {names}"
     }
   },
   "observability": {
@@ -3237,7 +3244,8 @@
       "forkDecision": {
         "proposing": "Proposition d'approches…",
         "choose": "Choisir une approche"
-      }
+      },
+      "elapsedTooltip": "Temps écoulé sur cette étape"
     },
     "health": {
       "title": "État des pipelines",

package/i18n/locales/he.json

@@ -320,7 +320,12 @@
       "bootstrapStopped": "האתחול נעצר",
       "runStopped": "הריצה נעצרה",
       "stoppedDescription": "הקונטיינר הופסק והריצה בוטלה.",
-      "stopFailed": "העצירה נכשלה"
+      "stopFailed": "העצירה נכשלה",
+      "confirm": {
+        "title": "לעצור את ההרצה הזו?",
+        "body": "הקונטיינר הפעיל ייעצר. ההרצה תישאר גלויה וניתן יהיה לנסות אותה שוב.",
+        "confirm": "עצור הרצה"
+      }
     },
     "frame": {
       "status": {
@@ -859,7 +864,8 @@
         "title": "אין הרצות עדיין",
         "body": "התחל pipeline כדי לראות כאן את היסטוריית ההרצות."
       },
-      "chooseApproach": "בחר גישה"
+      "chooseApproach": "בחר גישה",
+      "elapsedTooltip": "הזמן שחלף בשלב זה"
     },
     "structure": {
       "title": "מבנה",
@@ -1151,7 +1157,8 @@
       "confirmArchive": {
         "title": "להעביר שירות זה לארכיון?",
         "body": "\"{name}\" והמשימות שלו יוסתרו מהלוח. אפשר לשחזר אותו בכל עת."
-      }
+      },
+      "runBlocked": "חסום על ידי תלות אחת שלא הושלמה: {names} | חסום על ידי {count} תלויות שלא הושלמו: {names}"
     }
   },
   "observability": {
@@ -3248,7 +3255,8 @@
       "forkDecision": {
         "proposing": "מציע גישות…",
         "choose": "בחר גישה"
-      }
+      },
+      "elapsedTooltip": "הזמן שחלף בשלב זה"
     },
     "health": {
       "title": "בריאות הצינור",

package/i18n/locales/it.json

@@ -1174,7 +1174,8 @@
       "merged": "Unita",
       "open": "Aperta",
       "mergePr": "Unisci PR",
-      "chooseApproach": "Scegli approccio"
+      "chooseApproach": "Scegli approccio",
+      "elapsedTooltip": "Tempo trascorso su questo passaggio"
     },
     "structure": {
       "title": "Struttura",
@@ -1466,7 +1467,8 @@
       "confirmArchive": {
         "title": "Archiviare questo servizio?",
         "body": "\"{name}\" e le sue attività verranno nascosti dalla board. Puoi ripristinarlo in qualsiasi momento."
-      }
+      },
+      "runBlocked": "Bloccato da una dipendenza non completata: {names} | Bloccato da {count} dipendenze non completate: {names}"
     }
   },
   "layout": {
@@ -2123,7 +2125,12 @@
       "bootstrapStopped": "Bootstrap interrotto",
       "runStopped": "Esecuzione interrotta",
       "stoppedDescription": "Il container è stato terminato e l'esecuzione è stata annullata.",
-      "stopFailed": "Interruzione fallita"
+      "stopFailed": "Interruzione fallita",
+      "confirm": {
+        "title": "Interrompere questa esecuzione?",
+        "body": "Il container in esecuzione verrà terminato. L'esecuzione resta visibile e può essere ripetuta.",
+        "confirm": "Interrompi esecuzione"
+      }
     },
     "frame": {
       "status": {
@@ -3011,7 +3018,8 @@
       "forkDecision": {
         "proposing": "Proposta di approcci…",
         "choose": "Scegli un approccio"
-      }
+      },
+      "elapsedTooltip": "Tempo trascorso su questo passaggio"
     },
     "health": {
       "title": "Stato delle pipeline",

package/i18n/locales/ja.json

@@ -320,7 +320,12 @@
       "bootstrapStopped": "ブートストラップを停止しました",
       "runStopped": "実行を停止しました",
       "stoppedDescription": "コンテナが終了され、実行はキャンセルされました。",
-      "stopFailed": "停止に失敗しました"
+      "stopFailed": "停止に失敗しました",
+      "confirm": {
+        "title": "この実行を停止しますか？",
+        "body": "実行中のコンテナが終了します。実行は表示されたまま残り、再試行できます。",
+        "confirm": "実行を停止"
+      }
     },
     "frame": {
       "status": {
@@ -859,7 +864,8 @@
         "title": "実行履歴はまだありません",
         "body": "パイプラインを開始すると、ここに実行履歴が表示されます。"
       },
-      "chooseApproach": "アプローチを選択"
+      "chooseApproach": "アプローチを選択",
+      "elapsedTooltip": "このステップの経過時間"
     },
     "structure": {
       "title": "構造",
@@ -1151,7 +1157,8 @@
       "confirmArchive": {
         "title": "このサービスをアーカイブしますか？",
         "body": "「{name}」とそのタスクはボードから非表示になります。いつでも復元できます。"
-      }
+      },
+      "runBlocked": "未完了の依存関係によってブロックされています: {names} | {count} 件の未完了の依存関係によってブロックされています: {names}"
     }
   },
   "observability": {
@@ -3249,7 +3256,8 @@
       "forkDecision": {
         "proposing": "アプローチを提案中…",
         "choose": "アプローチを選択"
-      }
+      },
+      "elapsedTooltip": "このステップの経過時間"
     },
     "health": {
       "title": "パイプラインの状態",

package/i18n/locales/pl.json

@@ -320,7 +320,12 @@
       "bootstrapStopped": "Zatrzymano inicjalizację",
       "runStopped": "Zatrzymano uruchomienie",
       "stoppedDescription": "Kontener został zabity, a uruchomienie anulowane.",
-      "stopFailed": "Nie udało się zatrzymać"
+      "stopFailed": "Nie udało się zatrzymać",
+      "confirm": {
+        "title": "Zatrzymać to uruchomienie?",
+        "body": "Działający kontener zostanie zatrzymany. Uruchomienie pozostanie widoczne i można je ponowić.",
+        "confirm": "Zatrzymaj uruchomienie"
+      }
     },
     "frame": {
       "status": {
@@ -859,7 +864,8 @@
         "title": "Brak uruchomień",
         "body": "Uruchom pipeline, aby zobaczyć tutaj historię uruchomień."
       },
-      "chooseApproach": "Wybierz podejście"
+      "chooseApproach": "Wybierz podejście",
+      "elapsedTooltip": "Czas, który upłynął na tym kroku"
     },
     "structure": {
       "title": "Struktura",
@@ -1151,7 +1157,8 @@
       "confirmArchive": {
         "title": "Zarchiwizować tę usługę?",
         "body": "„{name}” i jej zadania zostaną ukryte z tablicy. Możesz przywrócić usługę w dowolnej chwili."
-      }
+      },
+      "runBlocked": "Zablokowane przez niedokończoną zależność: {names} | Zablokowane przez {count} niedokończone zależności: {names} | Zablokowane przez {count} niedokończonych zależności: {names}"
     }
   },
   "observability": {
@@ -3237,7 +3244,8 @@
       "forkDecision": {
         "proposing": "Proponowanie podejść…",
         "choose": "Wybierz podejście"
-      }
+      },
+      "elapsedTooltip": "Czas, który upłynął na tym kroku"
     },
     "health": {
       "title": "Stan pipeline'ów",

package/i18n/locales/tr.json

@@ -320,7 +320,12 @@
       "bootstrapStopped": "Bootstrap durduruldu",
       "runStopped": "Çalıştırma durduruldu",
       "stoppedDescription": "Konteyner sonlandırıldı ve çalıştırma iptal edildi.",
-      "stopFailed": "Durdurma başarısız oldu"
+      "stopFailed": "Durdurma başarısız oldu",
+      "confirm": {
+        "title": "Bu çalıştırma durdurulsun mu?",
+        "body": "Çalışan konteyner sonlandırılacak. Çalıştırma görünür kalır ve yeniden denenebilir.",
+        "confirm": "Çalıştırmayı durdur"
+      }
     },
     "frame": {
       "status": {
@@ -859,7 +864,8 @@
         "title": "Henüz çalıştırma yok",
         "body": "Çalıştırma geçmişini burada görmek için bir pipeline başlatın."
       },
-      "chooseApproach": "Yaklaşım seç"
+      "chooseApproach": "Yaklaşım seç",
+      "elapsedTooltip": "Bu adımda geçen süre"
     },
     "structure": {
       "title": "Yapı",
@@ -1151,7 +1157,8 @@
       "confirmArchive": {
         "title": "Bu hizmet arşivlensin mi?",
         "body": "\"{name}\" ve görevleri panodan gizlenecek. İstediğin zaman geri yükleyebilirsin."
-      }
+      },
+      "runBlocked": "Tamamlanmamış bir bağımlılık tarafından engellendi: {names} | Tamamlanmamış {count} bağımlılık tarafından engellendi: {names}"
     }
   },
   "observability": {
@@ -3249,7 +3256,8 @@
       "forkDecision": {
         "proposing": "Yaklaşımlar öneriliyor…",
         "choose": "Bir yaklaşım seçin"
-      }
+      },
+      "elapsedTooltip": "Bu adımda geçen süre"
     },
     "health": {
       "title": "Pipeline sağlığı",

package/i18n/locales/uk.json

@@ -320,7 +320,12 @@
       "bootstrapStopped": "Ініціалізацію зупинено",
       "runStopped": "Запуск зупинено",
       "stoppedDescription": "Контейнер було зупинено, а запуск скасовано.",
-      "stopFailed": "Не вдалося зупинити"
+      "stopFailed": "Не вдалося зупинити",
+      "confirm": {
+        "title": "Зупинити цей запуск?",
+        "body": "Запущений контейнер буде зупинено. Запуск залишиться видимим, і його можна повторити.",
+        "confirm": "Зупинити запуск"
+      }
     },
     "frame": {
       "status": {
@@ -859,7 +864,8 @@
         "title": "Ще немає запусків",
         "body": "Запустіть pipeline, щоб побачити тут історію запусків."
       },
-      "chooseApproach": "Обрати підхід"
+      "chooseApproach": "Обрати підхід",
+      "elapsedTooltip": "Час, що минув на цьому кроці"
     },
     "structure": {
       "title": "Структура",
@@ -1151,7 +1157,8 @@
       "confirmArchive": {
         "title": "Заархівувати цей сервіс?",
         "body": "«{name}» та його завдання буде приховано з дошки. Ви можете відновити його будь-коли."
-      }
+      },
+      "runBlocked": "Заблоковано незавершеною залежністю: {names} | Заблоковано {count} незавершеними залежностями: {names} | Заблоковано {count} незавершеними залежностями: {names}"
     }
   },
   "observability": {
@@ -3237,7 +3244,8 @@
       "forkDecision": {
         "proposing": "Пропонування підходів…",
         "choose": "Оберіть підхід"
-      }
+      },
+      "elapsedTooltip": "Час, що минув на цьому кроці"
     },
     "health": {
       "title": "Стан пайплайнів",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.115.1",
+  "version": "0.115.2",
   "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",