@cat-factory/app 0.115.0 → 0.115.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/app/stores/provisioningLogs.spec.ts

@@ -92,4 +92,92 @@ describe('provisioningLogs store — loadForExecution', () => {
     expect(store.byExecution.exec1!.entries).toHaveLength(0)
     expect(store.byExecution.exec1!.error).toBe('503')
   })
+
+  it('a slower stale load never clobbers a newer one (monotonic guard)', async () => {
+    // Two loads race: the FIRST-issued resolves LAST with a stale timeline. Without the guard its
+    // `s.entries = entries` would overwrite the fresher second result — a card/row would vanish.
+    const deferred: Array<(r: { entries: ProvisioningLogEntry[] }) => void> = []
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () =>
+        new Promise<{ entries: ProvisioningLogEntry[] }>((res) => deferred.push(res)),
+    }))
+
+    const store = useProvisioningLogsStore()
+    const first = store.loadForExecution('exec1', { silent: true }) // issued #1 (stale)
+    const second = store.loadForExecution('exec1', { silent: true }) // issued #2 (fresh)
+
+    // Resolve NEWEST first, then the older/staler one.
+    deferred[1]!({ entries: [entry({ id: 'fresh', operation: 'release' })] })
+    deferred[0]!({ entries: [entry({ id: 'stale', operation: 'dispatch' })] })
+    await Promise.all([first, second])
+
+    // The fresher result survives — the stale late-resolver was discarded.
+    expect(store.byExecution.exec1!.entries).toHaveLength(1)
+    expect(store.byExecution.exec1!.entries[0]!.id).toBe('fresh')
+  })
+
+  it('a superseding visible load owns the final entries and clears the spinner', async () => {
+    // A visible load in flight, then a newer visible load; the OLDER resolves last and must neither
+    // clobber the entries nor leave a stuck spinner.
+    const deferred: Array<(r: { entries: ProvisioningLogEntry[] }) => void> = []
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () =>
+        new Promise<{ entries: ProvisioningLogEntry[] }>((res) => deferred.push(res)),
+    }))
+
+    const store = useProvisioningLogsStore()
+    const first = store.loadForExecution('exec1')
+    const second = store.loadForExecution('exec1')
+
+    deferred[1]!({ entries: [entry({ id: 'fresh' })] })
+    deferred[0]!({ entries: [entry({ id: 'stale' })] })
+    await Promise.all([first, second])
+
+    expect(store.byExecution.exec1!.entries[0]!.id).toBe('fresh')
+    expect(store.byExecution.exec1!.loading).toBe(false)
+  })
+
+  it("evict drops a run's accumulated state (map does not grow unbounded)", async () => {
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () => Promise.resolve({ entries: [entry()] }),
+    }))
+
+    const store = useProvisioningLogsStore()
+    await store.loadForExecution('exec1')
+    expect(store.byExecution.exec1).toBeDefined()
+
+    store.evict('exec1')
+    expect(store.byExecution.exec1).toBeUndefined()
+
+    // After eviction a fresh load re-seeds cleanly (the drawer re-fetches on re-mount) — and the
+    // per-execution ticket record was dropped too, so the guard still holds for the new lifecycle.
+    await store.loadForExecution('exec1')
+    expect(store.byExecution.exec1!.entries).toHaveLength(1)
+  })
+
+  it('a load in flight when evict runs cannot resurrect stale state after the drawer re-opens', async () => {
+    // Close-then-reopen while the pre-close fetch is still pending: the drawer unmounts (evict), then
+    // re-mounts and issues a fresh load, then the OLD pre-evict fetch finally resolves. With a global
+    // (never-reset) load ticket the re-opened load out-ranks the straggler, so the stale result is
+    // discarded rather than clobbering the fresh timeline (a per-execution counter reset on evict
+    // would let the two collide on the same seq and the straggler would win).
+    const deferred: Array<(r: { entries: ProvisioningLogEntry[] }) => void> = []
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () =>
+        new Promise<{ entries: ProvisioningLogEntry[] }>((res) => deferred.push(res)),
+    }))
+
+    const store = useProvisioningLogsStore()
+    const preEvict = store.loadForExecution('exec1', { silent: true }) // issued before close
+    store.evict('exec1') // drawer unmounts mid-flight
+    const reopened = store.loadForExecution('exec1', { silent: true }) // drawer re-opens, fresh load
+
+    // The re-opened load resolves first (fresh), then the stale pre-evict straggler.
+    deferred[1]!({ entries: [entry({ id: 'fresh', operation: 'release' })] })
+    deferred[0]!({ entries: [entry({ id: 'stale', operation: 'dispatch' })] })
+    await Promise.all([preEvict, reopened])
+
+    expect(store.byExecution.exec1!.entries).toHaveLength(1)
+    expect(store.byExecution.exec1!.entries[0]!.id).toBe('fresh')
+  })
 })

package/app/stores/provisioningLogs.ts

@@ -30,6 +30,17 @@ export const useProvisioningLogsStore = defineStore('provisioningLogs', () => {
     container: emptyState(),
   })
   const byExecution = reactive<Record<string, LogState>>({})
+  // Monotonic load-ordering guard: the drawer's silent background poll and a manual/visible refresh
+  // can be in flight at once, and each ends in a REPLACE-style `s.entries = entries`. Without ordering
+  // a slower/staler fetch resolving AFTER a newer one clobbers the fresher timeline (the same
+  // out-of-order-overwrite hazard the CLAUDE.md live-push rules warn about, and that
+  // stores/workspace.ts guards its full refresh with). Each load takes a ticket from a single
+  // ever-increasing counter; `latestLoad` records the newest ticket issued per execution, and only
+  // that load commits. The counter is GLOBAL (never reset on `evict`) so a drawer re-opened for an
+  // evicted execution always out-ranks any still-in-flight prior load — no seq collision can let a
+  // stale fetch win. NOT reactive — pure bookkeeping the UI never reads.
+  let loadTicket = 0
+  const latestLoad = new Map<string, number>()
 
   async function load(subsystem: ProvisioningSubsystem) {
     const ws = useWorkspaceStore()
@@ -60,23 +71,45 @@ export const useProvisioningLogsStore = defineStore('provisioningLogs', () => {
       s.loading = true
       s.error = null
     }
+    const seq = ++loadTicket
+    latestLoad.set(executionId, seq)
     try {
       const { entries } = await api.listProvisioningLogs(ws.requireId(), {
         executionId,
         limit: 200,
       })
+      // A newer load (silent poll or manual refresh) superseded this one while it was in flight —
+      // discard this staler result so it can't clobber the fresher timeline.
+      if (latestLoad.get(executionId) !== seq) return
       s.entries = entries
       s.error = null
     } catch (err) {
+      if (latestLoad.get(executionId) !== seq) return
       // A background poll keeps the last snapshot on a blip; only a visible load reports.
       if (!opts?.silent) {
         s.error = err instanceof Error ? err.message : 'Failed to load logs'
         s.entries = []
       }
     } finally {
+      // The visible spinner is owned by the visible request that turned it on, so clear it in its
+      // own finally regardless of supersession — a superseded load still ends its own spinner.
       if (!opts?.silent) s.loading = false
     }
   }
 
-  return { bySubsystem, byExecution, load, loadForExecution }
+  /**
+   * Drop a run's accumulated log state (called by the drawer on unmount). `byExecution` would
+   * otherwise accrete one entry per execution viewed and never evict — a slow memory creep across
+   * a long board session. The drawer re-fetches on re-mount, so dropping a closed run's state is
+   * free; keeping it while OPEN is what the manual-refresh-after-terminal affordance relies on.
+   */
+  function evict(executionId: string) {
+    delete byExecution[executionId]
+    // Drop the per-execution ticket record too (its map must not grow unbounded either). The global
+    // `loadTicket` counter is deliberately NOT reset, so a re-opened drawer still out-ranks any load
+    // that was in flight when this ran.
+    latestLoad.delete(executionId)
+  }
+
+  return { bySubsystem, byExecution, load, loadForExecution, evict }
 })

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",