@cat-factory/app 0.115.0 → 0.115.1

package/app/components/provisioning/ProvisioningLogsDrawer.vue

@@ -76,7 +76,12 @@ watch(
 )
 
 onMounted(() => reload())
-onBeforeUnmount(stopPolling)
+onBeforeUnmount(() => {
+  stopPolling()
+  // Drop this run's accumulated log state so the per-execution map doesn't grow for the app's
+  // lifetime (a re-opened drawer re-fetches on mount). Subsystem mode keeps its fixed-size state.
+  if (props.executionId) store.evict(props.executionId)
+})
 
 // Exhaustive enum→label maps of literal `t(...)` keys (keeps the typed-key drift guard
 // live for these runtime-indexed lookups).

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/package.json

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