@cat-factory/app 0.283.0 → 0.284.0

package/app/stores/observability.spec.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useObservabilityStore } from '~/stores/observability'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { LlmCallActivity } from '~/types/execution'
+
+/**
+ * The two bounds on a store that would otherwise be a per-session accumulator: live events fold
+ * only into runs whose panel was OPENED, and a board switch drops every run. Both are about
+ * growth, so both are asserted on what SURVIVES rather than on any one row.
+ *
+ * There is deliberately NO third bound capping one run's list. That is asserted too, below: the
+ * rows a cap would evict are the ones the panel exists to show, so a long watched run keeps all
+ * of them.
+ */
+
+/** A live `llmCall` event carrying only what `appendCall` materialises a row from. */
+function activity(id: string, executionId = 'exec1'): LlmCallActivity {
+  return {
+    id,
+    executionId,
+    blockId: 'blk1',
+    agentKind: 'coder',
+    model: 'm',
+    ok: true,
+    phase: 'agent',
+    finishReason: 'stop',
+  } as unknown as LlmCallActivity
+}
+
+describe('observability store growth bounds', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+    vi.stubGlobal('useApi', () => ({
+      getLlmMetrics: () => Promise.resolve({ calls: [] }),
+    }))
+  })
+
+  it('folds live calls only into runs whose panel has been opened', async () => {
+    const store = useObservabilityStore()
+    store.appendCall(activity('never-opened'))
+    expect(store.callsFor('exec1')).toEqual([])
+
+    await store.load('exec1')
+    store.appendCall(activity('c1'))
+    expect(store.callsFor('exec1').map((c) => c.id)).toEqual(['c1'])
+  })
+
+  // A per-run cap was tried here and removed: whatever it evicted, the panel could no longer
+  // show, and no eviction rule can tell an operator which call they are now missing. The long
+  // watched run is exactly the one worth reading, so it keeps every row.
+  it('never evicts a row from an opened run, however long it runs', async () => {
+    const store = useObservabilityStore()
+    const burst = 1200
+    await store.load('exec1')
+    for (let i = 0; i < burst; i++) store.appendCall(activity(`c${i}`))
+
+    const held = store.callsFor('exec1')
+    expect(held).toHaveLength(burst)
+    // Newest-first, and the oldest call is still there to scroll back to.
+    expect(held[0]!.id).toBe(`c${burst - 1}`)
+    expect(held.at(-1)!.id).toBe('c0')
+  })
+
+  it('keeps every row a persisted read answered with when a live call lands on top', async () => {
+    const persisted = Array.from({ length: 300 }, (_, i) => ({
+      ...activity(`p${i}`),
+      turnIndex: null,
+      promptText: '',
+      promptPrefixCount: 0,
+      promptHash: '',
+      responseText: '',
+      reasoningText: '',
+    }))
+    vi.stubGlobal('useApi', () => ({
+      getLlmMetrics: () => Promise.resolve({ calls: persisted }),
+    }))
+    const store = useObservabilityStore()
+    await store.load('exec1')
+    expect(store.callsFor('exec1')).toHaveLength(300)
+
+    store.appendCall(activity('live'))
+    expect(store.callsFor('exec1')).toHaveLength(301)
+    expect(store.callsFor('exec1')[0]!.id).toBe('live')
+  })
+
+  it('evicts every per-run cache on a board switch', async () => {
+    const store = useObservabilityStore()
+    await store.load('exec1')
+    store.appendCall(activity('c1'))
+    expect(store.callsFor('exec1')).toHaveLength(1)
+
+    store.reset()
+    // Back to "never opened": the run is gone, so a stray live event for it folds nowhere.
+    store.appendCall(activity('c2'))
+    expect(store.callsFor('exec1')).toEqual([])
+    expect(store.callsByExecution).toEqual({})
+  })
+})

package/app/stores/observability.ts

@@ -1,13 +1,10 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
-import type {
-  AgentContextSnapshot,
-  AgentSearchQuery,
-  LlmCallActivity,
-  LlmCallMetric,
-} from '~/types/execution'
+import type { LlmCallActivity, LlmCallMetric } from '~/types/execution'
 import { useWorkspaceStore } from '~/stores/workspace'
 import { createToolCallSinkState } from '~/stores/observability/toolCalls'
+import { createAgentContextSinkState } from '~/stores/observability/agentContext'
+import { useSingleFlight } from '~/composables/useSingleFlight'
 
 /**
  * LLM observability state: the full per-call model activity for a run (prompts,
@@ -23,6 +20,13 @@ export const useObservabilityStore = defineStore('observability', () => {
   const api = useApi()
   const workspace = useWorkspaceStore()
 
+  /**
+   * One in-flight read per run for the call log below. Its load is triggered by a panel OPENING,
+   * and two openers in one tick is the normal case (the window and its shell, a deep link plus the
+   * click behind it), so it fired twice for one answer. The extracted sinks hold their own.
+   */
+  const loads = useSingleFlight<string, void>()
+
   /**
    * The TOOL-CALL sink, extracted whole: two reads at two different bounds, plus the rule that
    * keeps them apart (see `observability/toolCalls.ts`). The store owns the workspace binding and
@@ -34,22 +38,28 @@ export const useObservabilityStore = defineStore('observability', () => {
     fetchFailures: (executionId) => api.getToolCallFailures(workspace.requireId(), executionId),
   })
 
-  /** Per-execution-id call list (newest first). */
-  const callsByExecution = ref<Record<string, LlmCallMetric[]>>({})
-  /** Per-execution-id provided-context snapshot list (newest first). */
-  const contextByExecution = ref<Record<string, AgentContextSnapshot[]>>({})
-  /** Execution ids whose context is currently loading. */
-  const contextLoading = ref<Set<string>>(new Set())
   /**
-   * Last context-load error message per execution id, or null. Distinguishes a genuine fetch
-   * failure from a run with no captured context: without this, a swallowed error rendered as
-   * the "no context stored" empty state — indistinguishable from success-with-nothing.
+   * The AGENT-CONTEXT and SEARCH-QUERY sinks, extracted as one pair for the same reason as the
+   * tool-call one beside it: both are per-dispatch records the panel loads on open and neither is
+   * pushed live (see `observability/agentContext.ts`).
    */
-  const contextErrors = ref<Record<string, string | null>>({})
-  /** Per-execution-id performed-search-query list (newest first). */
-  const searchQueriesByExecution = ref<Record<string, AgentSearchQuery[]>>({})
-  /** Execution ids whose search queries are currently loading. */
-  const searchQueriesLoading = ref<Set<string>>(new Set())
+  const agentContext = createAgentContextSinkState({
+    ready: () => !!workspace.workspaceId,
+    fetchContext: (executionId) => api.getAgentContext(workspace.requireId(), executionId),
+    fetchSearchQueries: (executionId) => api.getSearchQueries(workspace.requireId(), executionId),
+  })
+
+  /**
+   * Per-execution-id call list (newest first).
+   *
+   * DELIBERATELY UNCAPPED. A per-run cap was tried and removed: the rows it evicted are the ones
+   * this panel exists to show, and no eviction rule can tell an operator which call they now
+   * cannot read. What bounds this store instead costs nothing: {@link appendCall} folds live
+   * events only into runs whose panel has been OPENED, and {@link reset} drops every run on a
+   * board switch. What is left growing is one open run's own log while someone watches it, which
+   * is a list they asked for and are reading.
+   */
+  const callsByExecution = ref<Record<string, LlmCallMetric[]>>({})
   /** Execution ids currently loading. */
   const loading = ref<Set<string>>(new Set())
   /** Execution ids currently exporting. */
@@ -75,7 +85,11 @@ export const useObservabilityStore = defineStore('observability', () => {
   }
 
   /** Load (or refresh) the per-call detail for a run. */
-  async function load(executionId: string) {
+  function load(executionId: string): Promise<void> {
+    return loads.run(`calls:${executionId}`, () => fetchCalls(executionId))
+  }
+
+  async function fetchCalls(executionId: string) {
     if (!workspace.workspaceId) return
     withFlag(loading, executionId, true)
     errors.value = { ...errors.value, [executionId]: null }
@@ -141,58 +155,23 @@ export const useObservabilityStore = defineStore('observability', () => {
       responseText: '',
       reasoningText: '',
     }
-    callsByExecution.value = { ...callsByExecution.value, [executionId]: [row, ...existing] }
-  }
-
-  function contextFor(executionId: string): AgentContextSnapshot[] {
-    return contextByExecution.value[executionId] ?? []
-  }
-  function isContextLoading(executionId: string): boolean {
-    return contextLoading.value.has(executionId)
-  }
-
-  /** Load (or refresh) the per-dispatch provided-context snapshots for a run. */
-  async function loadContext(executionId: string) {
-    if (!workspace.workspaceId) return
-    withFlag(contextLoading, executionId, true)
-    contextErrors.value = { ...contextErrors.value, [executionId]: null }
-    try {
-      const { snapshots } = await api.getAgentContext(workspace.requireId(), executionId)
-      contextByExecution.value = { ...contextByExecution.value, [executionId]: snapshots }
-    } catch (err) {
-      // Record the error so the panel can offer a retry instead of masquerading the failure as
-      // the "no context stored" empty state.
-      contextErrors.value = {
-        ...contextErrors.value,
-        [executionId]: err instanceof Error ? err.message : 'Failed to load context',
-      }
-    } finally {
-      withFlag(contextLoading, executionId, false)
+    callsByExecution.value = {
+      ...callsByExecution.value,
+      [executionId]: [row, ...existing],
     }
   }
 
-  function searchQueriesFor(executionId: string): AgentSearchQuery[] {
-    return searchQueriesByExecution.value[executionId] ?? []
-  }
-  function isSearchQueriesLoading(executionId: string): boolean {
-    return searchQueriesLoading.value.has(executionId)
-  }
-
-  /** Load (or refresh) the performed web-search queries for a run. */
-  async function loadSearchQueries(executionId: string) {
-    if (!workspace.workspaceId) return
-    withFlag(searchQueriesLoading, executionId, true)
-    try {
-      const { searchQueries } = await api.getSearchQueries(workspace.requireId(), executionId)
-      searchQueriesByExecution.value = {
-        ...searchQueriesByExecution.value,
-        [executionId]: searchQueries,
-      }
-    } catch {
-      // Best-effort: the panel shows an empty state; nothing is persisted client-side.
-    } finally {
-      withFlag(searchQueriesLoading, executionId, false)
-    }
+  /**
+   * Drop every per-run cache. Called on a board SWITCH: an execution id is scoped to the board
+   * that owns it, nothing here is part of the snapshot, and no id was ever evicted otherwise, so
+   * without this the session accumulates every run of every board it visits. Each panel re-loads
+   * on open, which is how these were populated in the first place.
+   */
+  function reset() {
+    callsByExecution.value = {}
+    errors.value = {}
+    agentContext.resetAgentContext()
+    toolCalls.resetToolCalls()
   }
 
   /**
@@ -220,21 +199,14 @@ export const useObservabilityStore = defineStore('observability', () => {
   return {
     callsByExecution,
     callsFor,
+    reset,
     isLoading,
     isExporting,
     errors,
     load,
     appendCall,
     downloadExport,
-    contextByExecution,
-    contextErrors,
-    contextFor,
-    isContextLoading,
-    loadContext,
-    searchQueriesByExecution,
-    searchQueriesFor,
-    isSearchQueriesLoading,
-    loadSearchQueries,
+    ...agentContext,
     ...toolCalls,
   }
 })

package/app/stores/requirements/settlement.ts

@@ -0,0 +1,55 @@
+import type { RequirementReview } from '~/types/requirements'
+
+/**
+ * What a requirements review's findings ADD UP TO: how many still need a human, how many the human
+ * answered, and the three dispositions the window's action rail derives from that pair.
+ *
+ * Pure functions of one review, so they live beside the store rather than inside it. They also
+ * share ONE pass over the findings, memoised on the review OBJECT: they compose (`canIncorporate`
+ * asks `allSettled`, which asks `openCount`, and then asks `answeredCount`), so a card rendering a
+ * review's state filtered its item list up to five times. Keying on identity is safe and
+ * self-invalidating because the store REPLACES the review object on every write, so a tallied
+ * object can never change under the cache; a `WeakMap` also lets a superseded review be collected
+ * along with its tally.
+ */
+const tallies = new WeakMap<RequirementReview, { open: number; answered: number }>()
+
+function tally(review: RequirementReview): { open: number; answered: number } {
+  let counts = tallies.get(review)
+  if (!counts) {
+    counts = { open: 0, answered: 0 }
+    for (const item of review.items) {
+      if (item.status === 'open') counts.open++
+      else if (item.status === 'answered' || item.status === 'resolved') counts.answered++
+    }
+    tallies.set(review, counts)
+  }
+  return counts
+}
+
+/** Findings still needing a human (status `open`). */
+export function openCount(review: RequirementReview): number {
+  return tally(review).open
+}
+
+/** Findings the human answered (a reply recorded), which the companion folds in. */
+export function answeredCount(review: RequirementReview): number {
+  return tally(review).answered
+}
+
+/** Every finding is settled (answered or dismissed), none still open. */
+export function allSettled(review: RequirementReview): boolean {
+  return tally(review).open === 0
+}
+
+/** Incorporation is possible: all findings settled AND at least one was answered. */
+export function canIncorporate(review: RequirementReview): boolean {
+  const { open, answered } = tally(review)
+  return open === 0 && answered > 0
+}
+
+/** Proceed (skip the companion) is possible: all findings settled but none answered. */
+export function canProceed(review: RequirementReview): boolean {
+  const { open, answered } = tally(review)
+  return open === 0 && answered === 0
+}

package/app/stores/requirements.ts

@@ -1,11 +1,21 @@
 import { defineStore } from 'pinia'
-import { ref } from 'vue'
+import { computed, ref } from 'vue'
 import type {
   RequirementReview,
   ResolveRequirementsExceededChoice,
   ReviewItemStatus,
 } from '~/types/requirements'
 import { useWorkspaceStore } from '~/stores/workspace'
+// The settlement derivations over one review's findings (`stores/requirements/settlement.ts`):
+// pure, memoised per review object, and re-exported below so every caller keeps reading them off
+// the store.
+import {
+  allSettled,
+  answeredCount,
+  canIncorporate,
+  canProceed,
+  openCount,
+} from '~/stores/requirements/settlement'
 import { createRecommendationCommands } from '~/stores/requirements/recommendations'
 
 /**
@@ -48,8 +58,21 @@ export const useRequirementsStore = defineStore('requirements', () => {
   /** Whether the Requirement Writer is still producing recommendations for a block (a `pending`
    * placeholder exists). Server-derived, so the "Recommending…" state survives the window closing
    * and a page reload — the client-local `recommending` set only covers the request round-trip. */
+  /**
+   * Blocks whose stored review still carries a `pending` recommendation placeholder, derived once
+   * per change to `reviews` rather than per call. {@link backgroundStage} asks this on the per-CARD
+   * path, so as a function it re-scanned one review's recommendation list for every card on the
+   * board on every event.
+   */
+  const blocksAwaitingRecommendations = computed(() => {
+    const blocks = new Set<string>()
+    for (const [blockId, review] of Object.entries(reviews.value)) {
+      if ((review?.recommendations ?? []).some((r) => r.status === 'pending')) blocks.add(blockId)
+    }
+    return blocks
+  })
   function hasPendingRecommendations(blockId: string): boolean {
-    return (reviews.value[blockId]?.recommendations ?? []).some((r) => r.status === 'pending')
+    return blocksAwaitingRecommendations.value.has(blockId)
   }
   /**
    * The async background stage a block's review is in, or null. While the driver folds the
@@ -73,27 +96,6 @@ export const useRequirementsStore = defineStore('requirements', () => {
     return incorporating.value.has(reviewId)
   }
 
-  /** Findings still needing a human (status `open`). */
-  function openCount(review: RequirementReview): number {
-    return review.items.filter((i) => i.status === 'open').length
-  }
-  /** Findings the human answered (a reply recorded), which the companion folds in. */
-  function answeredCount(review: RequirementReview): number {
-    return review.items.filter((i) => i.status === 'answered' || i.status === 'resolved').length
-  }
-  /** Every finding is settled (answered or dismissed) — none still open. */
-  function allSettled(review: RequirementReview): boolean {
-    return openCount(review) === 0
-  }
-  /** Incorporation is possible: all findings settled AND at least one was answered. */
-  function canIncorporate(review: RequirementReview): boolean {
-    return allSettled(review) && answeredCount(review) > 0
-  }
-  /** Proceed (skip the companion) is possible: all findings settled but none answered. */
-  function canProceed(review: RequirementReview): boolean {
-    return allSettled(review) && answeredCount(review) === 0
-  }
-
   function store(review: RequirementReview) {
     reviews.value = { ...reviews.value, [review.blockId]: review }
   }

package/app/stores/workspace/hydrate.ts

@@ -11,6 +11,8 @@ import { useExecutionStore } from '~/stores/execution'
 import { useFragmentsStore } from '~/stores/fragments'
 import { useGitHubStore } from '~/stores/github'
 import { useInitiativesStore } from '~/stores/initiative'
+import { useKaizenStore } from '~/stores/kaizen'
+import { useObservabilityStore } from '~/stores/observability'
 import { useModelPresetsStore } from '~/stores/modelPresets'
 import { useConsensusGroupsStore } from '~/stores/consensusGroups'
 import { useNotificationsStore } from '~/stores/notifications'
@@ -43,6 +45,15 @@ export function resetPerBoardCaches() {
   useGitHubStore().reset()
   useInitiativesStore().reset()
   useDocInterviewStore().reset()
+  // The per-RUN observability + Kaizen caches. An execution id belongs to the board that owns it
+  // and neither store is part of the snapshot, so nothing else ever evicted a key: a session that
+  // visited several boards kept every run it had ever opened a panel on.
+  useObservabilityStore().reset()
+  useKaizenStore().reset()
+  // The whole-run reads behind the step-detail overlays. The runs themselves ride the snapshot
+  // (`hydrate` replaces them), but the pending/failed marks and the requests still in flight are
+  // keyed by run ids the switched-to board does not have.
+  useExecutionStore().resetFullReads()
   // The fragment picker catalog is per-board (the merged tenant catalog), so drop
   // it too — the next inspector open re-fetches it for the switched-to board rather
   // than showing the previous board's (or a raw-id placeholder for) fragments.

package/app/stores/workspace/refreshFunnel.spec.ts

@@ -176,8 +176,21 @@ describe('refresh funnel', () => {
    * the funnel holding a fetch that never settles and every later caller queued behind it forever.
    */
   describe('deadline', () => {
+    /**
+     * The deadline is per FUNNEL, so a test that both times a fetch out AND then drives a second
+     * one to completion needs a value that satisfies both halves. The first half is satisfied by
+     * any value (its fetch never settles, so the timer always wins in the end, it just waits that
+     * long); the second is satisfied only while every turn AFTER the timeout fits inside the same
+     * budget. Sized at 5ms that budget was two macrotask turns plus assertions, which a loaded CI
+     * runner overruns: the recovery fetch timed out instead, the test failed on its own deadline
+     * and the abandoned promise surfaced as an unhandled rejection. So this is deliberately
+     * generous and must NOT be tightened for speed: it costs one wait, and what it buys is a
+     * timing assumption the runner cannot break.
+     */
+    const GENEROUS_DEADLINE_MS = 250
+
     it('fails the caller, aborts the request and frees the slot when a fetch never settles', async () => {
-      const h = harness('ws1', 5)
+      const h = harness('ws1', GENEROUS_DEADLINE_MS)
       const stalled = expect(h.funnel.refresh()).rejects.toThrow(/timed out/)
       await stalled
       expect(h.aborted()).toBe(true)
@@ -193,6 +206,7 @@ describe('refresh funnel', () => {
       expect(h.applied()).toEqual(['recovered'])
     })
 
+    // Nothing here outlives the timeout, so this one can stay fast.
     it('does not count a timed-out fetch as coverage', async () => {
       const h = harness('ws1', 5)
       const mark = h.funnel.refreshMark()

package/i18n/locales/de.json

@@ -2291,6 +2291,10 @@
       "dryRun": "Probelauf: nichts zusammenführen",
       "dryRunForced": "Probelauf: Läufe deiner Rolle werden hier nie zusammengeführt",
       "dryRunHint": "Dieser Lauf öffnet einen Pull Request und führt nichts zusammen."
+    },
+    "runDetail": {
+      "loading": "Vollständiger Lauf wird geladen…",
+      "loadFailed": "Vollständiger Lauf konnte nicht geladen werden: {reason}"
     }
   },
   "layout": {

package/i18n/locales/en.json

@@ -1809,6 +1809,10 @@
       "dryRun": "Dry run: merge nothing",
       "dryRunForced": "Dry run: your role's runs never merge here",
       "dryRunHint": "This run opens a pull request and merges nothing."
+    },
+    "runDetail": {
+      "loading": "Loading the full run…",
+      "loadFailed": "Couldn't load the full run: {reason}"
     }
   },
   "observability": {

package/i18n/locales/es.json

@@ -1705,6 +1705,10 @@
       "dryRun": "Ejecución de prueba: no fusionar nada",
       "dryRunForced": "Ejecución de prueba: las ejecuciones de tu rol nunca se fusionan aquí",
       "dryRunHint": "Esta ejecución abre una pull request y no fusiona nada."
+    },
+    "runDetail": {
+      "loading": "Cargando la ejecución completa…",
+      "loadFailed": "No se pudo cargar la ejecución completa: {reason}"
     }
   },
   "observability": {

package/i18n/locales/fr.json

@@ -1705,6 +1705,10 @@
       "dryRun": "Exécution à blanc : ne rien fusionner",
       "dryRunForced": "Exécution à blanc : les exécutions de votre rôle ne sont jamais fusionnées ici",
       "dryRunHint": "Cette exécution ouvre une pull request et ne fusionne rien."
+    },
+    "runDetail": {
+      "loading": "Chargement de l'exécution complète…",
+      "loadFailed": "Impossible de charger l'exécution complète : {reason}"
     }
   },
   "observability": {

package/i18n/locales/he.json

@@ -1705,6 +1705,10 @@
       "dryRun": "הרצת יבש: לא למזג דבר",
       "dryRunForced": "הרצת יבש: הרצות של התפקיד שלך לעולם אינן ממוזגות כאן",
       "dryRunHint": "ההרצה הזו פותחת בקשת משיכה ואינה ממזגת דבר."
+    },
+    "runDetail": {
+      "loading": "טוען את ההרצה המלאה…",
+      "loadFailed": "לא ניתן לטעון את ההרצה המלאה: {reason}"
     }
   },
   "observability": {

package/i18n/locales/it.json

@@ -2291,6 +2291,10 @@
       "dryRun": "Prova: non unire nulla",
       "dryRunForced": "Prova: le esecuzioni del tuo ruolo qui non vengono mai unite",
       "dryRunHint": "Questa esecuzione apre una pull request e non unisce nulla."
+    },
+    "runDetail": {
+      "loading": "Caricamento dell'esecuzione completa…",
+      "loadFailed": "Impossibile caricare l'esecuzione completa: {reason}"
     }
   },
   "layout": {

package/i18n/locales/ja.json

@@ -1705,6 +1705,10 @@
       "dryRun": "ドライラン: マージしない",
       "dryRunForced": "ドライラン: あなたのロールの実行はここではマージされません",
       "dryRunHint": "この実行はプルリクエストを開きますが、マージは行いません。"
+    },
+    "runDetail": {
+      "loading": "実行の全体を読み込んでいます…",
+      "loadFailed": "実行の全体を読み込めませんでした: {reason}"
     }
   },
   "observability": {

package/i18n/locales/pl.json

@@ -1705,6 +1705,10 @@
       "dryRun": "Uruchomienie próbne: nic nie scalaj",
       "dryRunForced": "Uruchomienie próbne: uruchomienia twojej roli nigdy nie są tu scalane",
       "dryRunHint": "To uruchomienie otwiera pull request i niczego nie scala."
+    },
+    "runDetail": {
+      "loading": "Wczytywanie pełnego przebiegu…",
+      "loadFailed": "Nie udało się wczytać pełnego przebiegu: {reason}"
     }
   },
   "observability": {

package/i18n/locales/tr.json

@@ -1705,6 +1705,10 @@
       "dryRun": "Prova çalışması: hiçbir şeyi birleştirme",
       "dryRunForced": "Prova çalışması: rolünün başlattığı çalıştırmalar burada asla birleştirilmez",
       "dryRunHint": "Bu çalıştırma bir pull request açar ve hiçbir şeyi birleştirmez."
+    },
+    "runDetail": {
+      "loading": "Çalıştırmanın tamamı yükleniyor…",
+      "loadFailed": "Çalıştırmanın tamamı yüklenemedi: {reason}"
     }
   },
   "observability": {

package/i18n/locales/uk.json

@@ -1705,6 +1705,10 @@
       "dryRun": "Пробний запуск: нічого не зливати",
       "dryRunForced": "Пробний запуск: запуски твоєї ролі тут ніколи не зливаються",
       "dryRunHint": "Цей запуск відкриває pull request і нічого не зливає."
+    },
+    "runDetail": {
+      "loading": "Завантаження повного запуску…",
+      "loadFailed": "Не вдалося завантажити повний запуск: {reason}"
     }
   },
   "observability": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.283.0",
+  "version": "0.284.0",
   "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",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.41",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.325.0"
+    "@cat-factory/contracts": "0.326.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",