@cat-factory/app 0.283.0 → 0.284.0

package/app/stores/kaizen.spec.ts

@@ -43,26 +43,41 @@ describe('kaizen store — live-push clobber guards', () => {
     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.
+  // Two loads of ONE run can no longer race: the run window and the run's grading badge both
+  // load on open, and they are coalesced onto a single request. That is what retired the
+  // per-execution load ticket, so this pins the property the ticket used to buy.
+  it('coalesces concurrent loads of the same run onto one request', async () => {
     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)
+    const first = store.loadForExecution('exec1')
+    const second = store.loadForExecution('exec1')
+    expect(deferred).toHaveLength(1)
 
-    deferred[1]!({ gradings: [grading({ id: 'fresh' })] })
-    deferred[0]!({ gradings: [grading({ id: 'stale' })] })
+    deferred[0]!({ gradings: [grading({ id: 'fresh' })] })
     await Promise.all([first, second])
 
     expect(store.byExecution.exec1).toHaveLength(1)
     expect(store.byExecution.exec1![0]!.id).toBe('fresh')
   })
 
+  it('re-asks once the first load has settled (coalescing, not caching)', async () => {
+    let calls = 0
+    vi.stubGlobal('useApi', () => ({
+      getKaizenForExecution: () => {
+        calls++
+        return Promise.resolve({ gradings: [grading({ id: `g${calls}` })] })
+      },
+    }))
+    const store = useKaizenStore()
+    await store.loadForExecution('exec1')
+    await store.loadForExecution('exec1')
+    expect(calls).toBe(2)
+  })
+
   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.
@@ -97,18 +112,19 @@ describe('kaizen store — live-push clobber guards', () => {
     expect(store.byExecution.exec1![0]!.summary).toBe('live')
   })
 
-  it('loadOverview preserves a live-pushed grading in history (merge, newest-first)', async () => {
+  it('loadOverview preserves a grading pushed while its fetch was in flight (merge, newest-first)', async () => {
+    const deferred: Array<(r: { gradings: KaizenGrading[]; verified: [] }) => void> = []
     vi.stubGlobal('useApi', () => ({
       getKaizenOverview: () =>
-        Promise.resolve({
-          gradings: [grading({ id: 'old', createdAt: 1, updatedAt: 1 })],
-          verified: [],
-        }),
+        new Promise<{ gradings: KaizenGrading[]; verified: [] }>((res) => deferred.push(res)),
     }))
     const store = useKaizenStore()
-    // A grading arrives live before the overview list is fetched.
+    // Opening the SCREEN is what makes `history` a list anything reads, so the race starts here:
+    // the grading arrives live while the overview fetch is still out.
+    const load = store.loadOverview()
     store.upsert(grading({ id: 'live', createdAt: 9, updatedAt: 9 }))
-    await store.loadOverview()
+    deferred[0]!({ gradings: [grading({ id: 'old', createdAt: 1, updatedAt: 1 })], verified: [] })
+    await load
 
     const ids = store.history.map((g) => g.id)
     expect(ids).toContain('live')
@@ -117,6 +133,53 @@ describe('kaizen store — live-push clobber guards', () => {
     expect(ids[0]).toBe('live')
   })
 
+  // The growth this gate exists to stop: a session that never opens the Kaizen screen must not
+  // accumulate one history entry per grading the workspace produces. The per-RUN cache, which the
+  // run windows read without loading first, keeps taking them.
+  it('does not fold a stream-pushed grading into history before the screen asks for it', () => {
+    const store = useKaizenStore()
+    store.upsert(grading({ id: 'g1' }))
+    expect(store.history).toEqual([])
+    expect(store.gradingsFor('exec1').map((g) => g.id)).toEqual(['g1'])
+  })
+
+  // A board SWITCH is the third writer nothing ordered against. `reset()` clears the caches, but
+  // the reads already out kept their handles: the previous board's gradings landed in the
+  // switched-to board's caches, and with `historyLoaded` back to false nothing re-asked, so it
+  // never corrected itself.
+  it('discards an overview load whose board was switched away mid-flight', 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 load = store.loadOverview()
+    store.reset()
+    deferred[0]!({ gradings: [grading({ id: 'other-board' })], verified: [] })
+    await load
+
+    expect(store.history).toEqual([])
+    // The screen never got its answer, so it must still read as un-asked rather than as loaded
+    // and empty: the next open re-asks against the board it is now on.
+    expect(store.verified).toEqual([])
+  })
+
+  it('discards a per-run load whose board was switched away mid-flight', async () => {
+    const deferred: Array<(r: { gradings: KaizenGrading[] }) => void> = []
+    vi.stubGlobal('useApi', () => ({
+      getKaizenForExecution: () =>
+        new Promise<{ gradings: KaizenGrading[] }>((res) => deferred.push(res)),
+    }))
+    const store = useKaizenStore()
+    const load = store.loadForExecution('exec1')
+    store.reset()
+    deferred[0]!({ gradings: [grading({ id: 'other-board' })] })
+    await load
+
+    expect(store.byExecution).toEqual({})
+  })
+
   it('a slower stale loadOverview never clobbers a newer one', async () => {
     const deferred: Array<(r: { gradings: KaizenGrading[]; verified: [] }) => void> = []
     vi.stubGlobal('useApi', () => ({

package/app/stores/kaizen.ts

@@ -2,6 +2,7 @@ import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
 import type { KaizenGrading, KaizenVerifiedCombo } from '~/types/domain'
 import { useWorkspaceStore } from '~/stores/workspace'
+import { useSingleFlight } from '~/composables/useSingleFlight'
 
 /**
  * Kaizen state: per-run gradings (for the run-window status surface) and the
@@ -16,6 +17,18 @@ export const useKaizenStore = defineStore('kaizen', () => {
   const byExecution = ref<Record<string, KaizenGrading[]>>({})
   /** Recent grading history for the Kaizen screen. */
   const history = ref<KaizenGrading[]>([])
+  /**
+   * Whether the Kaizen SCREEN has ASKED for its history (set when the load starts, so a grading
+   * pushed while that fetch is in flight still lands). `upsert` folds a stream-pushed grading into
+   * {@link history} only once it has: the screen is a full-panel overlay most sessions never open,
+   * and folding into a list nothing has read makes it a per-session accumulator of every grading
+   * the workspace produced. The screen loads on open, so an OPEN screen still updates live, which
+   * is the same gate `observability.appendCall` applies for the same reason.
+   *
+   * `byExecution` is deliberately NOT gated the same way: it is keyed per run, the run windows
+   * read it without loading first, and a board switch now drops it (see `reset`).
+   */
+  const historyLoaded = ref(false)
   /** The verified-combo library for the Kaizen screen. */
   const verified = ref<KaizenVerifiedCombo[]>([])
   const loadingOverview = ref(false)
@@ -23,14 +36,28 @@ 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.
+  /**
+   * One in-flight per-run read. The run window and the run's grading badge both load on open, so
+   * a single click asked for the same gradings twice. Coalescing them also retires the
+   * per-execution half of the ticket below: two loads of one run can no longer overlap.
+   */
+  const loads = useSingleFlight<string, void>()
+
+  // Monotonic load-ordering guard for the OVERVIEW, which is not coalesced (it takes no key and
+  // the screen can legitimately re-ask). It REPLACES state that also arrives live over the stream
+  // (`upsert`), so a slower/staler fetch resolving AFTER a newer one would clobber the fresher
+  // history (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>()
+
+  // Which BOARD the in-flight reads belong to, bumped by `reset()`. Distinct from the ticket
+  // above, which orders overview loads AGAINST EACH OTHER: a switch invalidates every read of
+  // either kind, and an overview load must not cancel an unrelated per-run one. Without it a
+  // board switch mid-load committed the previous board's gradings into the switched-to board's
+  // caches, with `historyLoaded` back to false so nothing ever re-asked and corrected it.
+  let boardGeneration = 0
 
   /**
    * Fold a freshly-loaded grading list into the live cache WITHOUT dropping live-only rows:
@@ -65,14 +92,22 @@ export const useKaizenStore = defineStore('kaizen', () => {
   async function loadOverview() {
     const ws = useWorkspaceStore()
     loadingOverview.value = true
+    // Mark the screen ENGAGED before awaiting, not after: `upsert` folds into `history` only
+    // once it is, and a grading pushed while this fetch is in flight is exactly what the
+    // reconcile below exists to keep.
+    historyLoaded.value = true
     const seq = ++loadTicket
     latestOverviewLoad = seq
+    const generation = boardGeneration
     try {
       const overview = await api.getKaizenOverview(ws.requireId())
+      // `available` is a DEPLOYMENT fact rather than a per-board one, so it is recorded even by a
+      // read whose board is gone: what the deployment wires did not change under the switch.
       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
+      // A newer overview load superseded this one while it was in flight, or the board it was
+      // asked for is gone. Either way the result must not land: it would clobber the fresher
+      // history, or seed the switched-to board with the previous one's gradings.
+      if (latestOverviewLoad !== seq || generation !== boardGeneration) 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)
@@ -86,18 +121,23 @@ export const useKaizenStore = defineStore('kaizen', () => {
     }
   }
 
-  async function loadForExecution(executionId: string) {
+  function loadForExecution(executionId: string): Promise<void> {
+    return loads.run(executionId, () => fetchForExecution(executionId))
+  }
+
+  async function fetchForExecution(executionId: string) {
     const ws = useWorkspaceStore()
+    const generation = boardGeneration
     loadingExecution.value = new Set(loadingExecution.value).add(executionId)
-    const seq = ++loadTicket
-    latestExecLoad.set(executionId, seq)
     try {
       const { gradings } = await api.getKaizenForExecution(ws.requireId(), executionId)
       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
+      // The board this run belongs to is gone, so its gradings have no cache left to land in.
+      if (generation !== boardGeneration) return
+      // Two loads of one run can no longer overlap (`loads` coalesces them), so the per-execution
+      // ticket this used to carry had nothing left to order and is gone. What remains is the live
+      // race: a grading pushed via `upsert` while this fetch was out, which the merge keeps rather
+      // than blind-replacing over.
       const { reconciled, liveOnly } = reconcileWithLive(
         gradings,
         byExecution.value[executionId] ?? [],
@@ -122,18 +162,36 @@ export const useKaizenStore = defineStore('kaizen', () => {
       ? current.map((g) => (g.id === grading.id ? grading : g))
       : [...current, grading]
     byExecution.value = { ...byExecution.value, [grading.executionId]: nextRun }
-    // Keep the screen history live too (newest first), if it's been loaded.
+    // Keep the screen history live too (newest first), but ONLY once the screen has loaded it.
+    // Prepending unconditionally made `history` grow one entry per grading for the session's
+    // lifetime on every board, for a screen most sessions never open.
+    if (!historyLoaded.value) return
     const inHistory = history.value.some((g) => g.id === grading.id)
     if (inHistory) history.value = history.value.map((g) => (g.id === grading.id ? grading : g))
     else history.value = [grading, ...history.value]
   }
 
+  /**
+   * Drop everything scoped to a board. Called on a board SWITCH: gradings are keyed by run and a
+   * run belongs to one board, so without this `byExecution` grows a key per run of every board the
+   * session visits and the screen shows the previous board's history until it reloads.
+   * `available` survives: whether the deployment wires Kaizen at all is not a per-board fact.
+   */
+  function reset() {
+    boardGeneration += 1
+    byExecution.value = {}
+    history.value = []
+    historyLoaded.value = false
+    verified.value = []
+  }
+
   const isLoadingExecution = (executionId: string) => loadingExecution.value.has(executionId)
   const verifiedCount = computed(() => verified.value.filter((c) => c.verified).length)
 
   return {
     byExecution,
     history,
+    reset,
     verified,
     available,
     loadingOverview,

package/app/stores/notifications.spec.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { useNotificationsStore } from '~/stores/notifications'
+import type { Notification } from '~/types/domain'
+
+/**
+ * The live-write map is what stops a lagging refresh clobbering a card that arrived while its
+ * snapshot was in flight. `hydrate` forgets whatever a snapshot has reconciled, which is what
+ * bounds it, so the case that needed a second bound is a long stream period with NO refresh in it.
+ */
+function card(id: string): Notification {
+  return {
+    id,
+    workspaceId: 'ws1',
+    blockId: 'blk1',
+    kind: 'review_wait',
+    status: 'open',
+    title: id,
+    body: '',
+    createdAt: 1,
+  } as unknown as Notification
+}
+
+describe('notifications live-write map', () => {
+  let store: ReturnType<typeof useNotificationsStore>
+  beforeEach(() => {
+    store = useNotificationsStore()
+  })
+
+  it('keeps the newest in-flight writes and forgets the oldest past the bound', () => {
+    for (let i = 0; i < 250; i++) store.upsert(card(`n${i}`))
+    // A refresh whose snapshot predates every one of those writes: what it re-inserts is exactly
+    // what the map still remembers.
+    store.hydrate([], 0)
+    const kept = store.open.map((n) => n.id)
+    expect(kept).toHaveLength(200)
+    expect(kept).toContain('n249')
+    expect(kept).not.toContain('n0')
+  })
+
+  // The bound evicts by the map's INSERTION order, which is only write order because a rewritten
+  // key is re-inserted. A bare `set` keeps a key in its original slot, so the entries rewritten
+  // most (a card whose run keeps advancing, exactly the ones still in flight) would sit at the
+  // head and be evicted FIRST, losing the protection while settled entries survived.
+  it('evicts by write order, so a rewritten card outlives older untouched ones', () => {
+    store.upsert(card('rewritten'))
+    for (let i = 0; i < 199; i++) store.upsert(card(`n${i}`))
+    // Rewriting it makes it the NEWEST write, and the next card is what pushes the map over.
+    store.upsert(card('rewritten'))
+    store.upsert(card('newest'))
+
+    store.hydrate([], 0)
+    const kept = store.open.map((n) => n.id)
+    expect(kept).toContain('rewritten')
+    expect(kept).toContain('newest')
+    // The oldest write that was never touched again is the one that goes.
+    expect(kept).not.toContain('n0')
+  })
+
+  it('still protects a write the in-flight refresh could not have seen', () => {
+    const baseline = store.hydrateBaseline()
+    store.upsert(card('live'))
+    store.hydrate([], baseline)
+    expect(store.open.map((n) => n.id)).toEqual(['live'])
+  })
+})

package/app/stores/notifications.ts

@@ -43,6 +43,31 @@ export const useNotificationsStore = defineStore('notifications', () => {
   /** Last live write per id: the notification to keep, or `null` once it was resolved. */
   const liveWrites = new Map<string, { seq: number; value: Notification | null }>()
 
+  /**
+   * How many in-flight live writes {@link liveWrites} may hold.
+   *
+   * {@link hydrate} forgets every write a snapshot has already reconciled, which is what keeps the
+   * map bounded by what is genuinely in flight. A long stream period that carries only TARGETED
+   * events triggers no hydrate at all, so the map grew one entry per notification for the session.
+   * The bound is on the OLDEST write, and it is safe to drop them: an entry only ever protects a
+   * write from a refresh whose snapshot predates it, and a refresh that far behind resolved long
+   * ago.
+   *
+   * Insertion order is sequence order only because {@link upsert} RE-INSERTS a key it already
+   * holds. A bare `set` on an existing key keeps that key's original slot, so a notification
+   * rewritten many times (exactly the ones still in flight) would sit at the head of the map and
+   * be the FIRST evicted, losing its clobber protection while older, settled entries survived.
+   */
+  const MAX_LIVE_WRITES = 200
+
+  function trimLiveWrites() {
+    while (liveWrites.size > MAX_LIVE_WRITES) {
+      const oldest = liveWrites.keys().next()
+      if (oldest.done) return
+      liveWrites.delete(oldest.value)
+    }
+  }
+
   /**
    * Baseline for {@link hydrate}: capture this BEFORE a refresh's snapshot fetch and pass it
    * back in, so a notification written live while the fetch was in flight survives the hydrate.
@@ -73,7 +98,11 @@ export const useNotificationsStore = defineStore('notifications', () => {
    */
   function upsert(notification: Notification) {
     const isOpen = notification.status === 'open'
+    // Delete before setting, so the map's insertion order stays WRITE order and the trim above
+    // evicts the genuinely oldest entry rather than the most recently rewritten one.
+    liveWrites.delete(notification.id)
     liveWrites.set(notification.id, { seq: ++liveSeq, value: isOpen ? notification : null })
+    trimLiveWrites()
     if (!isOpen) {
       remove(notification.id)
       return

package/app/stores/observability/agentContext.ts

@@ -0,0 +1,128 @@
+import { ref } from 'vue'
+import type { AgentContextSnapshot, AgentSearchQuery } from '~/types/execution'
+import { useSingleFlight } from '~/composables/useSingleFlight'
+
+/** What the two reads need from the store: the workspace binding, nothing else. */
+export interface AgentContextSinkDeps {
+  /** Whether a workspace is bound; a load is a no-op before one is. */
+  ready: () => boolean
+  fetchContext: (executionId: string) => Promise<{ snapshots: AgentContextSnapshot[] }>
+  fetchSearchQueries: (executionId: string) => Promise<{ searchQueries: AgentSearchQuery[] }>
+}
+
+/** Add or remove a key from a reactive `Set` ref, replacing it so the reactivity fires. */
+function withFlag(set: ReturnType<typeof ref<Set<string>>>, key: string, on: boolean) {
+  const next = new Set(set.value)
+  if (on) next.add(key)
+  else next.delete(key)
+  set.value = next
+}
+
+/**
+ * The observability store's AGENT-CONTEXT and SEARCH-QUERY sinks, extracted as one cohesive pair:
+ * both are per-dispatch records the drill-down panel loads on open, neither is pushed live, and
+ * both are dropped together on a board switch. A size-only split mirroring
+ * `createToolCallSinkState`, which sits beside it for the same reason.
+ *
+ * The two differ in ONE way, deliberately: a failed context load is RECORDED, because a swallowed
+ * error there renders as the "no context stored" empty state, which is a claim about the run
+ * rather than a blank tab. A search-query load has no such claim to make.
+ */
+export function createAgentContextSinkState(deps: AgentContextSinkDeps) {
+  /** One in-flight read per (sink, run): a panel's two openers routinely fire in the same tick. */
+  const loads = useSingleFlight<string, void>()
+
+  /** 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.
+   */
+  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())
+
+  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. */
+  function loadContext(executionId: string): Promise<void> {
+    return loads.run(`context:${executionId}`, () => fetchContext(executionId))
+  }
+
+  async function fetchContext(executionId: string) {
+    if (!deps.ready()) return
+    withFlag(contextLoading, executionId, true)
+    contextErrors.value = { ...contextErrors.value, [executionId]: null }
+    try {
+      const { snapshots } = await deps.fetchContext(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)
+    }
+  }
+
+  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. */
+  function loadSearchQueries(executionId: string): Promise<void> {
+    return loads.run(`searchQueries:${executionId}`, () => fetchSearchQueries(executionId))
+  }
+
+  async function fetchSearchQueries(executionId: string) {
+    if (!deps.ready()) return
+    withFlag(searchQueriesLoading, executionId, true)
+    try {
+      const { searchQueries } = await deps.fetchSearchQueries(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 both sinks. Called on a board switch from the observability store's own `reset`. */
+  function resetAgentContext() {
+    contextByExecution.value = {}
+    contextErrors.value = {}
+    searchQueriesByExecution.value = {}
+  }
+
+  return {
+    contextByExecution,
+    contextErrors,
+    contextFor,
+    isContextLoading,
+    loadContext,
+    searchQueriesByExecution,
+    searchQueriesFor,
+    isSearchQueriesLoading,
+    loadSearchQueries,
+    resetAgentContext,
+  }
+}

package/app/stores/observability/toolCalls.ts

@@ -1,5 +1,6 @@
 import { ref } from 'vue'
 import type { RunToolCallFailures, RunToolCallTrajectory } from '~/types/execution'
+import { useSingleFlight } from '~/composables/useSingleFlight'
 
 // The observability store's TOOL-CALL sink, extracted whole because it is one concern with two
 // reads and its own coherence rule between them.
@@ -48,6 +49,12 @@ function withFlag(set: ReturnType<typeof ref<Set<string>>>, key: string, on: boo
 }
 
 export function createToolCallSinkState(deps: ToolCallSinkDeps) {
+  /**
+   * One in-flight read per (sink, run). Both loads below fire on the panel OPENING, and the panel
+   * has two openers that routinely land in the same tick, so each answered twice.
+   */
+  const loads = useSingleFlight<string, void>()
+
   /**
    * Per-execution-id trajectory PREFIX (oldest first, the order the agent worked in) with the
    * flag saying whether the run made more calls than it holds.
@@ -98,7 +105,11 @@ export function createToolCallSinkState(deps: ToolCallSinkDeps) {
   }
 
   /** Load (or refresh) the tool-call trajectory for a run. */
-  async function loadToolCalls(executionId: string) {
+  function loadToolCalls(executionId: string): Promise<void> {
+    return loads.run(`trajectory:${executionId}`, () => fetchToolCalls(executionId))
+  }
+
+  async function fetchToolCalls(executionId: string) {
     if (!deps.ready()) return
     withFlag(toolCallsLoading, executionId, true)
     toolCallErrors.value = { ...toolCallErrors.value, [executionId]: null }
@@ -133,7 +144,11 @@ export function createToolCallSinkState(deps: ToolCallSinkDeps) {
    * fresh error would let the panel keep asserting a failure count the backend just refused to
    * confirm.
    */
-  async function loadToolCallFailures(executionId: string) {
+  function loadToolCallFailures(executionId: string): Promise<void> {
+    return loads.run(`failures:${executionId}`, () => fetchToolCallFailures(executionId))
+  }
+
+  async function fetchToolCallFailures(executionId: string) {
     if (!deps.ready()) return
     withFlag(toolCallFailuresLoading, executionId, true)
     toolCallFailureErrors.value = { ...toolCallFailureErrors.value, [executionId]: null }
@@ -155,7 +170,20 @@ export function createToolCallSinkState(deps: ToolCallSinkDeps) {
     }
   }
 
+  /**
+   * Drop every per-run cache. Called on a board SWITCH from the observability store's own
+   * `reset`: an execution id belongs to the board that owns it, and nothing here is evicted
+   * otherwise.
+   */
+  function resetToolCalls() {
+    toolCallsByExecution.value = {}
+    toolCallErrors.value = {}
+    toolCallFailuresByExecution.value = {}
+    toolCallFailureErrors.value = {}
+  }
+
   return {
+    resetToolCalls,
     toolCallsByExecution,
     toolCallErrors,
     toolCallsFor,