@cat-factory/app 0.111.2 → 0.111.3

package/app/stores/execution.spec.ts

@@ -134,3 +134,55 @@ describe('execution store snapshot/event reconcile', () => {
     expect(store.getInstance('e1')?.status).toBe('done')
   })
 })
+
+/** A run whose steps carry an (optional) per-step metrics rollup. */
+function runWithMetrics(
+  id: string,
+  rev: number,
+  steps: Array<{ agentKind: string; metrics?: { calls: number } | null }>,
+): ExecutionInstance {
+  return { id, blockId: `blk_${id}`, steps, status: 'running', rev } as unknown as ExecutionInstance
+}
+
+describe('execution store metrics preservation (live-only rollup)', () => {
+  let store: ReturnType<typeof useExecutionStore>
+  beforeEach(() => {
+    store = useExecutionStore()
+  })
+
+  it('a metric-less running-fold event does not blank the last-known step metrics', () => {
+    // A step-boundary emit carried the rollup...
+    store.upsert(runWithMetrics('e1', 1, [{ agentKind: 'coder', metrics: { calls: 3 } }]))
+    // ...a later progress-only fold (higher rev) omits it — the backend skips the rollup there.
+    store.upsert(runWithMetrics('e1', 2, [{ agentKind: 'coder' }]))
+    const step = store.getInstance('e1')!.steps[0] as unknown as { metrics?: { calls: number } }
+    expect(step.metrics?.calls).toBe(3)
+    expect(store.getInstance('e1')?.rev).toBe(2) // the fold still won (progress/subtasks applied)
+  })
+
+  it('a fresh rollup overrides the preserved value', () => {
+    store.upsert(runWithMetrics('e1', 1, [{ agentKind: 'coder', metrics: { calls: 3 } }]))
+    store.upsert(runWithMetrics('e1', 2, [{ agentKind: 'coder' }])) // fold: preserved
+    store.upsert(runWithMetrics('e1', 3, [{ agentKind: 'coder', metrics: { calls: 7 } }]))
+    const step = store.getInstance('e1')!.steps[0] as unknown as { metrics?: { calls: number } }
+    expect(step.metrics?.calls).toBe(7)
+  })
+
+  it('does not carry metrics across a reshaped step (agentKind mismatch at the index)', () => {
+    store.upsert(runWithMetrics('e1', 1, [{ agentKind: 'coder', metrics: { calls: 3 } }]))
+    // A different kind at index 0 must not inherit the coder's rollup.
+    store.upsert(runWithMetrics('e1', 2, [{ agentKind: 'reviewer' }]))
+    const step = store.getInstance('e1')!.steps[0] as unknown as { metrics?: { calls: number } }
+    expect(step.metrics).toBeUndefined()
+  })
+
+  it('preserves metrics through a lagging full refresh that omits them (hydrate)', () => {
+    // Establish the workspace first (a fresh-workspace hydrate replaces outright by design).
+    store.hydrate([runWithMetrics('e1', 1, [{ agentKind: 'coder' }])], 'ws1')
+    store.upsert(runWithMetrics('e1', 2, [{ agentKind: 'coder', metrics: { calls: 5 } }]))
+    // A snapshot never carries metrics (never persisted); a same-rev refresh must not blank it.
+    store.hydrate([runWithMetrics('e1', 2, [{ agentKind: 'coder' }])], 'ws1')
+    const step = store.getInstance('e1')!.steps[0] as unknown as { metrics?: { calls: number } }
+    expect(step.metrics?.calls).toBe(5)
+  })
+})

package/app/stores/execution.ts

@@ -40,6 +40,33 @@ export const useExecutionStore = defineStore('execution', () => {
     return status === 'done' || status === 'failed'
   }
 
+  /**
+   * Carry forward each step's LLM-metrics rollup (`step.metrics`) when an incoming
+   * instance omits it. Metrics is DERIVED, LIVE-ONLY state: the backend attaches it only
+   * on step-boundary/terminal emits (not on the frequent progress-only running folds — a
+   * perf optimisation that skips the per-run metrics GROUP BY on every poll tick) and
+   * never persists it, so it rides neither the snapshot nor a running-fold event. A plain
+   * REPLACE would blank the per-step metrics bar on every progress tick; per the live-push
+   * coherence rules a REPLACE must not drop live-only state, so preserve the last-known
+   * rollup per step. Steps are positionally stable within a run (same id ⇒ same shape), so
+   * match by index; the agentKind guard is belt-and-suspenders against a reshaped list.
+   */
+  function withPreservedMetrics(
+    incoming: ExecutionInstance,
+    cached: ExecutionInstance | undefined,
+  ): ExecutionInstance {
+    if (!cached) return incoming
+    let changed = false
+    const steps = incoming.steps.map((step, i) => {
+      if (step.metrics != null) return step
+      const prior = cached.steps[i]
+      if (prior?.metrics == null || prior.agentKind !== step.agentKind) return step
+      changed = true
+      return { ...step, metrics: prior.metrics }
+    })
+    return changed ? { ...incoming, steps } : incoming
+  }
+
   /**
    * Reconcile the cached executions with a server snapshot for `workspaceId`. A snapshot
    * is authoritative EXCEPT where a live `execution` event already advanced (or ADDED) a
@@ -81,7 +108,8 @@ export const useExecutionStore = defineStore('execution', () => {
     const held = new Map(instances.value.map((e) => [e.id, e]))
     const reconciled = next.map((incoming) => {
       const current = held.get(incoming.id)
-      return current && revOf(current) > revOf(incoming) ? current : incoming
+      if (current && revOf(current) > revOf(incoming)) return current
+      return withPreservedMetrics(incoming, current)
     })
     // Preserve a cached-only run UNLESS it is the terminal predecessor a retry replaced: a
     // finished (`done`/`failed`) run whose block the snapshot now covers under a fresh id.
@@ -101,7 +129,8 @@ export const useExecutionStore = defineStore('execution', () => {
   function upsert(instance: ExecutionInstance) {
     const i = instances.value.findIndex((e) => e.id === instance.id)
     if (i >= 0) {
-      if (revOf(instance) >= revOf(instances.value[i]!)) instances.value[i] = instance
+      if (revOf(instance) >= revOf(instances.value[i]!))
+        instances.value[i] = withPreservedMetrics(instance, instances.value[i]!)
     } else instances.value.push(instance)
   }
 

package/package.json

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