@defrex/autobuild 0.9.0 → 0.10.0

package/packages/core/src/processes/sandbox-state.ts

@@ -9,6 +9,7 @@
  * orphaned environment.
  */
 import type { RepositoryEvent } from '../events/repository'
+import { defineReducer, type IncrementalReducer } from '../kernel/incremental'
 
 export type SandboxEnvironmentState = 'live' | 'stopped' | 'released'
 
@@ -45,7 +46,18 @@ type MutableSnapshot = {
  * derived from both). Latest fact wins; `released` environments stay in the
  * result with their closing evidence so callers can distinguish them. */
 export function sandboxStates(events: readonly RepositoryEvent[]): SandboxEnvironmentSnapshot[] {
-  const byEnvironment = new Map<string, MutableSnapshot>()
+  return sandboxStatesReducer.reduce(events)
+}
+
+/** The carried accumulator: environments in `Map` insertion order (a re-set
+ * of an existing id keeps its position). */
+export type SandboxStatesAcc = MutableSnapshot[]
+
+/** Bump when `SandboxStatesAcc`'s shape or fold semantics change. */
+export const SANDBOX_STATES_REDUCER_VERSION = 1
+
+function foldSandboxStates(acc: SandboxStatesAcc, events: readonly RepositoryEvent[]): void {
+  const byEnvironment = new Map<string, MutableSnapshot>(acc.map((s) => [s.environmentId, s]))
   for (const event of events) {
     const ts = event.ts
     if (event.type === 'orchestrator.sandbox.provisioned') {
@@ -107,5 +119,17 @@ export function sandboxStates(events: readonly RepositoryEvent[]): SandboxEnviro
       })
     }
   }
-  return [...byEnvironment.values()]
+  acc.length = 0
+  acc.push(...byEnvironment.values())
 }
+
+export const sandboxStatesReducer: IncrementalReducer<
+  SandboxStatesAcc,
+  RepositoryEvent,
+  SandboxEnvironmentSnapshot[]
+> = defineReducer({
+  version: SANDBOX_STATES_REDUCER_VERSION,
+  initial: (): SandboxStatesAcc => [],
+  fold: foldSandboxStates,
+  finish: (acc) => acc.map((s) => ({ ...s })),
+})

package/packages/core/src/processes/tick-state.ts

@@ -0,0 +1,33 @@
+import type { RepositoryEvent } from '../events/repository'
+import { defineReducer } from '../kernel/incremental'
+
+export const OPEN_TICK_REDUCER_VERSION = 1
+
+/** Whether the dispatcher run's latest tick boundary (started, completed or
+ * failed) is a `dispatcher.tick-started`. A factory because the run id is a
+ * parameter of the projection; the accumulator holds only the last boundary
+ * type seen for that run. */
+export function openTickReducer(run: string) {
+  return defineReducer<{ boundary?: string }, RepositoryEvent, boolean>({
+    version: OPEN_TICK_REDUCER_VERSION,
+    initial: () => ({}),
+    fold(acc, events) {
+      for (const event of events) {
+        if (
+          'run' in event.payload &&
+          event.payload.run === run &&
+          (event.type === 'dispatcher.tick-started' ||
+            event.type === 'dispatcher.tick-completed' ||
+            event.type === 'dispatcher.tick-failed')
+        ) {
+          acc.boundary = event.type
+        }
+      }
+    },
+    finish: (acc) => acc.boundary === 'dispatcher.tick-started',
+  })
+}
+
+export function hasOpenTick(events: readonly RepositoryEvent[], run: string): boolean {
+  return openTickReducer(run).reduce(events)
+}

package/packages/core/src/store/adapter.ts

@@ -42,7 +42,7 @@ export type {
 export { validateCreatedEvent } from './new-build'
 export { createBuildScopedStore } from './build-scope'
 export { createSessionScopedStore } from './session-handle'
-export { DIGEST_EVENT_TYPES, reduceBuildDigest } from './digest'
+export { DIGEST_EVENT_TYPES, type DigestEventRow, reduceBuildDigest } from './digest'
 export {
   projectRepositoryStateEvents,
   REPOSITORY_RUN_SCOPED_EVENT_TYPES,
@@ -110,3 +110,12 @@ export type {
   Unsubscribe,
 } from './types'
 export { normalizeOperator } from './types'
+export {
+  loadReducerSnapshot,
+  persistReducerSnapshot,
+  reducerSnapshotWireSchema,
+  SNAPSHOT_REDUCER_NAME,
+  snapshotScopeKey,
+  snapshotSupersedes,
+} from './snapshots'
+export type { ReducerSnapshot, SnapshotScope } from './snapshots'

package/packages/core/src/store/build-scope.ts

@@ -1,3 +1,4 @@
+import type { ReducerSnapshot, SnapshotScope } from './snapshots'
 import type { EventType } from '../events/payloads'
 import type { EventWrite } from '../events/catalog'
 import type { RepositoryEventType, RepositoryEventWrite } from '../events/repository'
@@ -190,6 +191,31 @@ export function createBuildScopedStore(store: BuildStore, scope: string): BuildS
     getRepoStateEvents(repo: string): Promise<RepositoryEvent[]> {
       return Promise.reject(new BuildScopeError(scope, 'getRepoStateEvents', repo))
     },
+    getRepoHighWater(repo: string): Promise<number> {
+      return Promise.reject(new BuildScopeError(scope, 'getRepoHighWater', repo))
+    },
+    async getReducerSnapshot(
+      target: SnapshotScope,
+      reducer: string,
+      version: number,
+    ): Promise<ReducerSnapshot | null> {
+      if (target.kind !== 'build') {
+        throw new BuildScopeError(scope, 'getReducerSnapshot', target.repo)
+      }
+      own('getReducerSnapshot', target.slug)
+      return store.getReducerSnapshot(target, reducer, version)
+    },
+    async putReducerSnapshot(
+      target: SnapshotScope,
+      reducer: string,
+      snapshot: ReducerSnapshot,
+    ): Promise<boolean> {
+      if (target.kind !== 'build') {
+        throw new BuildScopeError(scope, 'putReducerSnapshot', target.repo)
+      }
+      own('putReducerSnapshot', target.slug)
+      return store.putReducerSnapshot(target, reducer, snapshot)
+    },
     getRepoBuildDigests(repo: string): Promise<Map<string, BuildDigest>> {
       return Promise.reject(new BuildScopeError(scope, 'getRepoBuildDigests', repo))
     },

package/packages/core/src/store/contract.ts

@@ -432,6 +432,81 @@ export function describeBuildStoreContract(name: string, factory: BuildStoreFact
         })
       })
 
+      test('executionOpen and reclaimPending follow the openExecution and pendingPrAttachmentReclaims rules', async () => {
+        await withStore(factory, undefined, async (store) => {
+          const repo = 'acme/dg-work'
+          const slug = 'dg-work'
+          await store.createBuild(sampleBuildInput(slug, { repo }))
+          await store.append(slug, buildCreatedWrite())
+          const flags = async (): Promise<{ executionOpen?: true; reclaimPending?: true }> => {
+            const digest = (await store.getRepoBuildDigests(repo)).get(slug)!
+            return {
+              ...(digest.executionOpen ? { executionOpen: true as const } : {}),
+              ...(digest.reclaimPending ? { reclaimPending: true as const } : {}),
+            }
+          }
+          const started = (instance: string): EventWrite<'execution.started'> => ({
+            actor: DISPATCHER,
+            type: 'execution.started',
+            payload: { provider: 'p', workspaceRef: 'w', instance },
+          })
+          const ended = (instance: string): EventWrite<'execution.ended'> => ({
+            actor: DISPATCHER,
+            type: 'execution.ended',
+            payload: { instance, workspaceRef: 'w', outcome: 'completed' },
+          })
+          expect(await flags()).toEqual({})
+
+          await store.append(slug, started('a'))
+          expect(await flags()).toEqual({ executionOpen: true })
+          // A mismatched end leaves the execution open.
+          await store.append(slug, ended('other'))
+          expect(await flags()).toEqual({ executionOpen: true })
+          await store.append(slug, ended('a'))
+          expect(await flags()).toEqual({})
+          await store.append(slug, started('b'))
+          expect(await flags()).toEqual({ executionOpen: true })
+          // Completion does not close an execution.
+          await store.append(slug, {
+            actor: DISPATCHER,
+            type: 'build.completed',
+            payload: { outcome: 'abandoned' },
+          })
+          expect(await flags()).toEqual({ executionOpen: true })
+          await store.append(slug, ended('b'))
+          expect(await flags()).toEqual({})
+
+          const hosted = await store.append(slug, {
+            actor: KERNEL,
+            type: 'pr-attachment.hosted',
+            payload: {
+              designationSeq: 1,
+              asset: {
+                provider: 'github-release',
+                repository: 'acme/assets',
+                releaseId: 1,
+                assetId: 2,
+                url: 'https://example.invalid/a.png',
+              },
+            },
+          })
+          expect(await flags()).toEqual({ reclaimPending: true })
+          // Unknown and backwards acks do not clear it.
+          await store.append(slug, {
+            actor: DISPATCHER,
+            type: 'pr-attachment.reclaimed',
+            payload: { hostedSeq: hosted.seq + 100 },
+          })
+          expect(await flags()).toEqual({ reclaimPending: true })
+          await store.append(slug, {
+            actor: DISPATCHER,
+            type: 'pr-attachment.reclaimed',
+            payload: { hostedSeq: hosted.seq },
+          })
+          expect(await flags()).toEqual({})
+        })
+      })
+
       test('the digest equals the full-log ground truth over every lifecycle shape', async () => {
         await withStore(factory, undefined, async (store) => {
           const repo = 'acme/dg-life'
@@ -803,6 +878,268 @@ export function describeBuildStoreContract(name: string, factory: BuildStoreFact
       })
     })
 
+    describe('getRepoHighWater', () => {
+      test('unknown repo rejects like getRepoEvents and creates nothing', async () => {
+        await withStore(factory, undefined, async (store) => {
+          await expect(store.getRepoHighWater('acme/never-seen')).rejects.toThrow(/unknown repo/)
+          expect(await store.getRepo('acme/never-seen')).toBeNull()
+        })
+      })
+
+      test('an empty journal answers 0', async () => {
+        await withStore(factory, undefined, async (store) => {
+          await store.ensureRepo('acme/hw-empty')
+          expect(await store.getRepoHighWater('acme/hw-empty')).toBe(0)
+        })
+      })
+
+      test('equals the last appended seq regardless of event type', async () => {
+        await withStore(factory, undefined, async (store) => {
+          await store.ensureRepo('acme/hw')
+          await store.appendRepo('acme/hw', {
+            actor: humanActor('op'),
+            type: 'dispatcher.intake-set',
+            payload: { enabled: false },
+          })
+          expect(await store.getRepoHighWater('acme/hw')).toBe(1)
+          // A run-scoped, non-durable type must still move the mark.
+          const tick = await store.appendRepo('acme/hw', {
+            actor: DISPATCHER,
+            type: 'dispatcher.tick-started',
+            payload: { run: 'r1' },
+          })
+          expect(tick.seq).toBe(2)
+          expect(await store.getRepoHighWater('acme/hw')).toBe(2)
+          expect((await store.getRepoEvents('acme/hw')).at(-1)?.seq).toBe(2)
+        })
+      })
+    })
+
+    describe('reducer snapshots (a cache beside the log, never an authority)', () => {
+      const buildScope = (slug: string) => ({ kind: 'build' as const, slug })
+      const repoScope = (repo: string) => ({ kind: 'repo' as const, repo })
+
+      async function buildWithEvents(store: BuildStore, slug: string, count: number) {
+        await store.createBuild(sampleBuildInput(slug))
+        for (let index = 0; index < count; index += 1) {
+          await store.append(slug, sampleEventWrite(`event ${index}`))
+        }
+      }
+
+      /** Deterministic shuffle so a failure replays. */
+      function shuffled<T>(items: T[]): T[] {
+        const out = [...items]
+        let seed = 7
+        for (let index = out.length - 1; index > 0; index -= 1) {
+          seed = (seed * 1103515245 + 12345) & 0x7fffffff
+          const swap = seed % (index + 1)
+          ;[out[index], out[swap]] = [out[swap]!, out[index]!]
+        }
+        return out
+      }
+
+      test('an absent snapshot reads null and an unknown scope reads null with no side effects', async () => {
+        await withStore(factory, undefined, async (store) => {
+          await buildWithEvents(store, 'snap-absent', 2)
+          expect(await store.getReducerSnapshot(buildScope('snap-absent'), 'build', 1)).toBeNull()
+          expect(await store.getReducerSnapshot(buildScope('snap-nobuild'), 'build', 1)).toBeNull()
+          expect(await store.getReducerSnapshot(repoScope('acme/snap-norepo'), 'j', 1)).toBeNull()
+          expect(
+            await store.putReducerSnapshot(buildScope('snap-nobuild'), 'build', {
+              version: 1,
+              cursor: 0,
+              state: {},
+            }),
+          ).toBe(false)
+          expect(
+            await store.putReducerSnapshot(repoScope('acme/snap-norepo'), 'j', {
+              version: 1,
+              cursor: 0,
+              state: {},
+            }),
+          ).toBe(false)
+          expect(await store.getRepo('acme/snap-norepo')).toBeNull()
+          expect(await store.getBuild('snap-nobuild')).toBeNull()
+        })
+      })
+
+      test('round-trips JSON state per scope and reducer, isolated from callers', async () => {
+        await withStore(factory, undefined, async (store) => {
+          await buildWithEvents(store, 'snap-rt', 3)
+          await store.ensureRepo('acme/snap-rt')
+          await store.appendRepo('acme/snap-rt', {
+            actor: humanActor('op'),
+            type: 'dispatcher.intake-set',
+            payload: { enabled: false },
+          })
+          const state = { counts: { a: 1 }, list: [1, 'two', null], flag: true }
+          expect(
+            await store.putReducerSnapshot(buildScope('snap-rt'), 'build', {
+              version: 2,
+              cursor: 3,
+              state,
+            }),
+          ).toBe(true)
+          state.counts.a = 99
+          const read = await store.getReducerSnapshot(buildScope('snap-rt'), 'build', 2)
+          expect(read).toEqual({
+            version: 2,
+            cursor: 3,
+            state: { counts: { a: 1 }, list: [1, 'two', null], flag: true },
+          })
+          ;(read!.state as { counts: { a: number } }).counts.a = 5
+          expect(
+            (await store.getReducerSnapshot(buildScope('snap-rt'), 'build', 2))?.state,
+          ).toEqual({ counts: { a: 1 }, list: [1, 'two', null], flag: true })
+          // Other reducers and the other scope kind are independent.
+          expect(await store.getReducerSnapshot(buildScope('snap-rt'), 'logIndex', 2)).toBeNull()
+          expect(await store.getReducerSnapshot(repoScope('acme/snap-rt'), 'build', 2)).toBeNull()
+          expect(
+            await store.putReducerSnapshot(repoScope('acme/snap-rt'), 'journalView', {
+              version: 1,
+              cursor: 1,
+              state: { retained: [] },
+            }),
+          ).toBe(true)
+          expect(
+            (await store.getReducerSnapshot(repoScope('acme/snap-rt'), 'journalView', 1))?.cursor,
+          ).toBe(1)
+          expect((await store.getReducerSnapshot(buildScope('snap-rt'), 'build', 2))?.cursor).toBe(
+            3,
+          )
+        })
+      })
+
+      test('a stored snapshot of another version is ignored, then replaced by an advancing write', async () => {
+        await withStore(factory, undefined, async (store) => {
+          await buildWithEvents(store, 'snap-ver', 5)
+          const scope = buildScope('snap-ver')
+          await store.putReducerSnapshot(scope, 'build', { version: 1, cursor: 3, state: 'v1' })
+          expect(await store.getReducerSnapshot(scope, 'build', 2)).toBeNull()
+          // Same cursor, lower version: no-op.
+          expect(
+            await store.putReducerSnapshot(scope, 'build', { version: 1, cursor: 3, state: 'x' }),
+          ).toBe(false)
+          // Higher version at an unchanged cursor replaces the old shape.
+          expect(
+            await store.putReducerSnapshot(scope, 'build', { version: 2, cursor: 3, state: 'v2' }),
+          ).toBe(true)
+          expect(await store.getReducerSnapshot(scope, 'build', 1)).toBeNull()
+          expect((await store.getReducerSnapshot(scope, 'build', 2))?.state).toBe('v2')
+          // A lower version replaces once the cursor advances past the stored one.
+          expect(
+            await store.putReducerSnapshot(scope, 'build', { version: 1, cursor: 4, state: 'v1b' }),
+          ).toBe(true)
+          expect(await store.getReducerSnapshot(scope, 'build', 2)).toBeNull()
+          expect((await store.getReducerSnapshot(scope, 'build', 1))?.cursor).toBe(4)
+          // But never at a lower cursor, whatever its version.
+          expect(
+            await store.putReducerSnapshot(scope, 'build', { version: 9, cursor: 2, state: 'old' }),
+          ).toBe(false)
+          expect((await store.getReducerSnapshot(scope, 'build', 1))?.state).toBe('v1b')
+        })
+      })
+
+      test('an equal or lower cursor is a no-op and the stored row is untouched', async () => {
+        await withStore(factory, undefined, async (store) => {
+          await buildWithEvents(store, 'snap-mono', 4)
+          const scope = buildScope('snap-mono')
+          expect(
+            await store.putReducerSnapshot(scope, 'build', { version: 1, cursor: 3, state: 'a' }),
+          ).toBe(true)
+          expect(
+            await store.putReducerSnapshot(scope, 'build', { version: 1, cursor: 3, state: 'b' }),
+          ).toBe(false)
+          expect(
+            await store.putReducerSnapshot(scope, 'build', { version: 1, cursor: 2, state: 'c' }),
+          ).toBe(false)
+          expect(await store.getReducerSnapshot(scope, 'build', 1)).toEqual({
+            version: 1,
+            cursor: 3,
+            state: 'a',
+          })
+          expect(
+            await store.putReducerSnapshot(scope, 'build', { version: 1, cursor: 4, state: 'd' }),
+          ).toBe(true)
+        })
+      })
+
+      test('a cursor ahead of the log tail is refused on write and hidden on read', async () => {
+        await withStore(factory, undefined, async (store) => {
+          await buildWithEvents(store, 'snap-ahead', 2)
+          const scope = buildScope('snap-ahead')
+          expect(
+            await store.putReducerSnapshot(scope, 'build', { version: 1, cursor: 3, state: 'x' }),
+          ).toBe(false)
+          expect(await store.getReducerSnapshot(scope, 'build', 1)).toBeNull()
+          // Within the tail it is accepted, and stays readable as the log grows.
+          expect(
+            await store.putReducerSnapshot(scope, 'build', { version: 1, cursor: 2, state: 'ok' }),
+          ).toBe(true)
+          await store.append('snap-ahead', sampleEventWrite('more'))
+          expect((await store.getReducerSnapshot(scope, 'build', 1))?.cursor).toBe(2)
+        })
+      })
+
+      test('two interleaved writers never regress the stored cursor', async () => {
+        await withStore(factory, undefined, async (store) => {
+          const tail = 12
+          await buildWithEvents(store, 'snap-race', tail)
+          const scope = buildScope('snap-race')
+          const cursors = shuffled(Array.from({ length: tail }, (_, index) => index + 1))
+          const writerA = cursors.filter((_, index) => index % 2 === 0)
+          const writerB = cursors.filter((_, index) => index % 2 === 1)
+          // Each writer reads back sequentially, so its own series is ordered;
+          // reads from different writers overlap and complete in any order, so
+          // only per-writer monotonicity is meaningful.
+          const write = async (list: number[]): Promise<number[]> => {
+            const seen: number[] = []
+            for (const cursor of list) {
+              await store.putReducerSnapshot(scope, 'build', {
+                version: 1,
+                cursor,
+                state: { cursor },
+              })
+              const read = await store.getReducerSnapshot(scope, 'build', 1)
+              if (read !== null) seen.push(read.cursor)
+            }
+            return seen
+          }
+          const series = await Promise.all([write(writerA), write(writerB)])
+          const final = await store.getReducerSnapshot(scope, 'build', 1)
+          expect(final?.cursor).toBe(tail)
+          expect(final?.state).toEqual({ cursor: tail })
+          for (const seen of series) {
+            for (let index = 1; index < seen.length; index += 1) {
+              expect(seen[index]!).toBeGreaterThanOrEqual(seen[index - 1]!)
+            }
+          }
+        })
+      })
+
+      test('writers on mixed versions still only ever raise the stored cursor', async () => {
+        await withStore(factory, undefined, async (store) => {
+          const tail = 9
+          await buildWithEvents(store, 'snap-mixed', tail)
+          const scope = buildScope('snap-mixed')
+          const writes = shuffled(
+            Array.from({ length: tail * 3 }, (_, index) => ({
+              version: (index % 3) + 1,
+              cursor: Math.floor(index / 3) + 1,
+            })),
+          )
+          await Promise.all(
+            writes.map((write) =>
+              store.putReducerSnapshot(scope, 'build', { ...write, state: write }),
+            ),
+          )
+          // The cursor is the max; at that cursor the highest version won.
+          const final = await store.getReducerSnapshot(scope, 'build', 3)
+          expect(final).toEqual({ version: 3, cursor: tail, state: { version: 3, cursor: tail } })
+        })
+      })
+    })
+
     describe('getRepoStateEvents (bounded journal read, AUT-489)', () => {
       /** One no-op hosted dispatcher invocation: the ~4 facts an invocation
        * appends whether or not it did anything. */

package/packages/core/src/store/digest.ts

@@ -10,6 +10,7 @@
  * history.
  */
 import type { AbEvent } from '../events/catalog'
+import { defineReducer, type IncrementalReducer } from '../kernel/incremental'
 import type { BuildDigest } from './types'
 
 /** The event types a digest is derived from. Adapters filter their event
@@ -20,30 +21,82 @@ export const DIGEST_EVENT_TYPES = [
   'build.aborted',
   'observation.recorded',
   'pr.merged',
+  'pr-attachment.hosted',
+  'pr-attachment.reclaimed',
+  'execution.started',
+  'execution.ended',
 ] as const
 
+/** The digest-relevant slice of one event row. Adapters ship `hostedSeq` for
+ * `pr-attachment.reclaimed` rows and `instance` for `execution.started` /
+ * `execution.ended` rows instead of whole payloads. */
+export type DigestEventRow = Pick<AbEvent, 'type' | 'seq' | 'ts'> & {
+  hostedSeq?: number
+  instance?: string
+}
+
 /** The digest-relevant projection of one build's events, in log order.
  * `terminal` follows `reduceBuild` exactly: `build.completed` sets `done`,
  * `build.aborted` sets `aborted`, latest wins (in-order overwrite) — and
  * `merged` follows the same overwrite pattern for `pr.merged` timestamps.
  * The events carry no slug, so the result is slug-less; every adapter attaches
  * `slug` itself when grouping its per-build event rows. */
-export function reduceBuildDigest(
-  events: Pick<AbEvent, 'type' | 'seq' | 'ts'>[],
-): Omit<BuildDigest, 'slug'> {
-  let terminal: BuildDigest['terminal']
-  let merged: string | undefined
-  const observations: { seq: number; ts: string }[] = []
-  for (const event of events) {
-    if (event.type === 'build.completed') terminal = 'done'
-    else if (event.type === 'build.aborted') terminal = 'aborted'
-    else if (event.type === 'pr.merged') merged = event.ts
-    else if (event.type === 'observation.recorded')
-      observations.push({ seq: event.seq, ts: event.ts })
-  }
-  return {
-    observations,
-    ...(merged !== undefined ? { merged } : {}),
-    ...(terminal !== undefined ? { terminal } : {}),
-  }
+export type DigestEvent = DigestEventRow
+
+/** The carried accumulator for `reduceBuildDigest`. */
+export interface DigestAcc {
+  terminal?: BuildDigest['terminal']
+  merged?: string
+  observations: { seq: number; ts: string }[]
+  /** `pendingPrAttachmentReclaims`: seqs of hosted events. */
+  hosted: number[]
+  /** Hosted seqs named by a reclaimed event with a later seq. */
+  reclaimed: number[]
+  /** `openExecution`: the latest start's instance, cleared only by an instance-matched end. */
+  openInstance: string | null
+}
+
+/** Bump when `DigestAcc`'s shape or fold semantics change. */
+export const BUILD_DIGEST_REDUCER_VERSION = 2
+
+export const buildDigestReducer: IncrementalReducer<
+  DigestAcc,
+  DigestEvent,
+  Omit<BuildDigest, 'slug'>
+> = defineReducer({
+  version: BUILD_DIGEST_REDUCER_VERSION,
+  initial: (): DigestAcc => ({ observations: [], hosted: [], reclaimed: [], openInstance: null }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'build.completed') acc.terminal = 'done'
+      else if (event.type === 'build.aborted') acc.terminal = 'aborted'
+      else if (event.type === 'pr.merged') acc.merged = event.ts
+      else if (event.type === 'observation.recorded')
+        acc.observations.push({ seq: event.seq, ts: event.ts })
+      else if (event.type === 'pr-attachment.hosted') acc.hosted.push(event.seq)
+      else if (event.type === 'pr-attachment.reclaimed') {
+        if (event.hostedSeq !== undefined && event.seq > event.hostedSeq)
+          acc.reclaimed.push(event.hostedSeq)
+      } else if (event.type === 'execution.started') acc.openInstance = event.instance ?? null
+      else if (event.type === 'execution.ended') {
+        if (acc.openInstance !== null && event.instance === acc.openInstance)
+          acc.openInstance = null
+      }
+    }
+  },
+  finish: ({ terminal, merged, observations, hosted, reclaimed, openInstance }) => {
+    const reclaimedSet = new Set(reclaimed)
+    const reclaimPending = hosted.some((seq) => !reclaimedSet.has(seq))
+    return {
+      observations: [...observations],
+      ...(merged !== undefined ? { merged } : {}),
+      ...(terminal !== undefined ? { terminal } : {}),
+      ...(reclaimPending ? { reclaimPending: true as const } : {}),
+      ...(openInstance !== null ? { executionOpen: true as const } : {}),
+    }
+  },
+})
+
+export function reduceBuildDigest(events: DigestEvent[]): Omit<BuildDigest, 'slug'> {
+  return buildDigestReducer.reduce(events)
 }

package/packages/core/src/store/local/schema.ts

@@ -105,6 +105,23 @@ export const ticketAssets = sqliteTable(
   (t) => [primaryKey({ columns: [t.repo, t.ticketId, t.kind, t.name, t.revision] })],
 )
 
+/** Reducer snapshots (store/snapshots.ts): a cache of one reducer's state as of
+ * a log cursor, per scope (`scope_kind` build|repo, `scope_key` the slug or
+ * repo). Never an authority — the log regenerates any row. */
+export const reducerSnapshots = sqliteTable(
+  'reducer_snapshots',
+  {
+    scopeKind: text('scope_kind').notNull(),
+    scopeKey: text('scope_key').notNull(),
+    reducer: text('reducer').notNull(),
+    version: integer('version').notNull(),
+    cursor: integer('cursor').notNull(),
+    state: text('state').notNull(),
+    updatedAt: text('updated_at').notNull(),
+  },
+  (t) => [primaryKey({ columns: [t.scopeKind, t.scopeKey, t.reducer] })],
+)
+
 /** Operator sessions (SPEC §7.1.1): hosted-only durable orchestrator
  * conversation state. Adapters implement the contract uniformly; nothing
  * local creates one. */