@defrex/autobuild 0.12.0 → 0.14.0

package/packages/core/src/cli/wait.ts

@@ -1,3 +1,8 @@
+import { readBuildDigests } from '../store/reduced-reads'
+import { readBuildStreamSeed } from '../store/reduced-reads'
+import { buildStreamSeedReducer, type BuildStreamSeed } from '../kernel/read-facts'
+import { historicalBuildState } from './historical-build-state'
+import { currentDeferralObservationReducer, type DeferralLedger } from '../kernel/auto-merge'
 /**
  * `ab wait` — the blocking sibling of `ab watch` (§8.2, §7.2). It follows the
  * event logs of one, several, or all active builds in the repository and
@@ -31,11 +36,11 @@
  * Read-only: it appends no event, claims or renews no lease, and creates no
  * build or repository record. Output carries no ANSI, ever, in either form.
  */
-import { buildNeedsAttention, mergeDecision, mergeIdentity } from './attention'
+import { mergeDecisionFromFacts, mergeIdentity } from './attention'
 import type { AbEvent } from '../events/catalog'
 import type { EventType } from '../events/payloads'
 import type { BuildState, PrLifecycle } from '../kernel/reducer'
-import { reduceBuild } from '../kernel/reducer'
+import { buildReducer, reduceBuild } from '../kernel/reducer'
 import { isPhase, type BuildStatus, type Phase } from '../ontology'
 import type { Exec } from '../ports/workspace/git-worktree'
 import {
@@ -156,8 +161,25 @@ export function parseConditions(
   return { conditions, globs }
 }
 
+function attentionFrom(
+  input: AbEvent[] | { state: BuildState; deferral: DeferralLedger },
+  state?: BuildState,
+) {
+  return Array.isArray(input)
+    ? mergeDecisionFromFacts(
+        state ?? reduceBuild(input),
+        currentDeferralObservationReducer.reduce(input),
+        new Date(0),
+      )
+    : mergeDecisionFromFacts(input.state, input.deferral, new Date(0))
+}
+
 /** Does one condition body hold over a reduction? Attention includes current escalation and merge state. */
-function stateSatisfies(cond: ConditionBody, state: BuildState, events: AbEvent[] = []): boolean {
+function stateSatisfies(
+  cond: ConditionBody,
+  state: BuildState,
+  events: AbEvent[] | { state: BuildState; deferral: DeferralLedger } = [],
+): boolean {
   switch (cond.kind) {
     case 'status':
       return state.status === cond.status
@@ -168,7 +190,7 @@ function stateSatisfies(cond: ConditionBody, state: BuildState, events: AbEvent[
     case 'phase':
       return (state.phase ?? null) === cond.phase
     case 'attention':
-      return buildNeedsAttention(events, state)
+      return (state.openEscalations?.length ?? 0) > 0 || attentionFrom(events, state) !== null
   }
 }
 
@@ -180,7 +202,7 @@ function stateSatisfies(cond: ConditionBody, state: BuildState, events: AbEvent[
 export function matchState(
   conditions: readonly WaitCondition[],
   state: BuildState,
-  events: AbEvent[] = [],
+  events: AbEvent[] | { state: BuildState; deferral: DeferralLedger } = [],
 ): string | null {
   for (const { text, cond } of conditions) {
     if (stateSatisfies(cond, state, events)) return text
@@ -195,13 +217,12 @@ export function matchEvent(
   event: Pick<AbEvent, 'type'>,
   conditions: readonly WaitCondition[],
   globs: readonly EventGlob[],
-  events: AbEvent[] = [],
+  events: AbEvent[] | { state: BuildState; deferral: DeferralLedger } = [],
 ): string | null {
   for (const { text, cond } of conditions) {
     if (
       cond.kind === 'attention' &&
-      (isAttentionEvent(event.type) ||
-        (events.length > 0 && mergeDecision(events, new Date(0)) !== null))
+      (isAttentionEvent(event.type) || attentionFrom(events) !== null)
     )
       return text
   }
@@ -222,14 +243,13 @@ function matchFirst(
   state: BuildState,
   conditions: readonly WaitCondition[],
   globs: readonly EventGlob[],
-  events: AbEvent[] = [],
+  events: AbEvent[] | { state: BuildState; deferral: DeferralLedger } = [],
 ): string | null {
   for (const { text, cond } of conditions) {
     if (stateSatisfies(cond, state, events)) return text
     if (
       cond.kind === 'attention' &&
-      (isAttentionEvent(event.type) ||
-        (events.length > 0 && mergeDecision(events, new Date(0)) !== null))
+      (isAttentionEvent(event.type) || attentionFrom(events) !== null)
     )
       return text
   }
@@ -276,7 +296,7 @@ interface WaitStream {
   slug: string
   named: boolean
   /** The full prefix, appended in seq order — what `reduceBuild` runs over. */
-  events: AbEvent[]
+  seed: BuildStreamSeed
   lastSeq: number
   status: BuildStatus
 }
@@ -357,11 +377,7 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
       const finish = (condition: string | null, event: AbEvent, state: BuildState): number => {
         const observation =
           condition === 'attention' && event.type !== 'escalation.raised'
-            ? mergeDecision(
-                streams.get(event.build)?.events.filter((e) => e.seq <= event.seq) ?? [],
-                now(),
-                state,
-              )
+            ? mergeDecisionFromFacts(state, streams.get(event.build)!.seed.deferral, now())
             : null
         if (observation) deliveredAttention.add(mergeIdentity(event.build, observation.pr.number))
         const record = {
@@ -394,22 +410,30 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
         if (satisfied === null) satisfied = { event, state, condition }
       }
 
-      const eventConditions = (event: AbEvent, prefix: AbEvent[]): readonly WaitCondition[] => {
+      const eventConditions = (event: AbEvent, seed: BuildStreamSeed): readonly WaitCondition[] => {
         if (event.type === 'escalation.raised') return conditions
-        const observation = mergeDecision(prefix, now())
+        const observation = mergeDecisionFromFacts(
+          buildReducer.finish(seed.build),
+          seed.deferral,
+          now(),
+        )
         return observation &&
           !deliveredAttention.has(mergeIdentity(event.build, observation.pr.number))
           ? conditions
           : conditions.filter(({ cond }) => cond.kind !== 'attention')
       }
 
-      const registerStream = (slug: string, events: AbEvent[], named: boolean): WaitStream => {
-        const state = reduceBuild(events)
+      const registerStream = (
+        slug: string,
+        current: { value: BuildStreamSeed; cursor: number },
+        named: boolean,
+      ): WaitStream => {
+        const state = buildReducer.finish(current.value.build)
         const stream: WaitStream = {
           slug,
           named,
-          events,
-          lastSeq: events.at(-1)?.seq ?? 0,
+          seed: current.value,
+          lastSeq: current.cursor,
           status: state.status,
         }
         streams.set(slug, stream)
@@ -421,10 +445,10 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
        * already satisfying when it becomes targeted ends the wait with its
        * latest event. Not cursor-relative — `--since` does not suppress it. */
       const checkRegistrationState = (stream: WaitStream): void => {
-        const state = reduceBuild(stream.events)
-        const condition = matchState(conditions, state, stream.events)
-        if (condition !== null && stream.events.length > 0) {
-          match(stream.events.at(-1)!, state, condition)
+        const state = buildReducer.finish(stream.seed.build)
+        const condition = matchState(conditions, state, { state, deferral: stream.seed.deferral })
+        if (condition !== null && state.lastEvent !== undefined) {
+          match(state.lastEvent!, state, condition)
         }
       }
       /**
@@ -438,42 +462,43 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
         if (streams.has(slug)) return
         const record = await store.getBuild(slug)
         if (record === null) return
-        // AUT-545: this full-log read is deliberate, accepted growth — the
-        // retained prefix is consumed at full replay depth by every later
-        // reduction (approvals, findings, answered escalations, PR facts,
-        // observations), so bounding it would need reducer-partition store
-        // machinery out of AUT-545's scope. Required for `--since` replay and
-        // the registration state check over the full reduction.
-        const events = await store.getEvents(slug)
-        const stream = registerStream(slug, events, slugs.includes(slug))
+        const current = await readBuildStreamSeed(store, slug)
+        const stream = registerStream(slug, current, slugs.includes(slug))
         if (resumeSeq !== undefined) {
+          stream.seed = await historicalBuildState(store, slug, resumeSeq, current)
           stream.lastSeq = resumeSeq
           positions[slug] = resumeSeq
-          // Replay the backlog into a scratch prefix: each evaluated state is
-          // the reduction of the prefix ENDING at that event, never the
-          // reduction of the full loaded prefix.
-          const replay: AbEvent[] = events.filter((event) => event.seq <= resumeSeq)
           if (resumedCursor?.deliveredAttention === undefined) {
-            const historical: AbEvent[] = []
-            for (const event of replay) {
-              historical.push(event)
-              const observation = mergeDecision(historical, now())
-              if (observation) deliveredAttention.add(mergeIdentity(slug, observation.pr.number))
-            }
+            for (const pr of stream.seed.mergeAttentionPrs)
+              deliveredAttention.add(mergeIdentity(slug, pr))
           }
-          for (const event of events) {
-            if (event.seq <= resumeSeq) continue
-            replay.push(event)
+          for (const event of await store.getEvents(slug, resumeSeq)) {
+            stream.seed = buildStreamSeedReducer.advance(stream.seed, [event])
             stream.lastSeq = event.seq
             positions[slug] = event.seq
-            const condition = matchEvent(event, eventConditions(event, replay), globs, replay)
+            const state = buildReducer.finish(stream.seed.build)
+            const condition = matchEvent(event, eventConditions(event, stream.seed), globs, {
+              state,
+              deferral: stream.seed.deferral,
+            })
             if (condition !== null) {
-              match(event, reduceBuild(replay), condition)
+              match(event, state, condition)
               break
             }
           }
         }
-        if (satisfied === null) checkRegistrationState(stream)
+        if (satisfied === null) {
+          // Registration checks current state independently from historical replay.
+          const latest = buildReducer.finish(current.value.build)
+          const condition = matchState(conditions, latest, {
+            state: latest,
+            deferral: current.value.deferral,
+          })
+          if (condition !== null && latest.lastEvent) {
+            stream.seed = current.value
+            match(latest.lastEvent, latest, condition)
+          }
+        }
       }
 
       /** Builds discovery read in full and found terminal; never re-read. */
@@ -488,33 +513,20 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
        * build to appear.
        */
       const discoverBuilds = async (): Promise<void> => {
-        // AUT-545: the terminal filter is the AUT-487 digest, not a full-log read —
-        // one flat batch read replaces a full getEvents per candidate build, per
-        // discovery pass; `terminal` is reduceBuild's exact terminal rule
-        // (store/digest.ts, pinned by contract). The per-build full read below
-        // remains deliberate for builds the digest cannot retire: its retained
-        // prefix is consumed at full replay depth by every later reduction
-        // (approvals, findings, answered escalations, PR facts, observations), so
-        // bounding it would need reducer-partition store machinery out of
-        // AUT-545's scope. The reduceBuild re-check stays: it is the
-        // legacy-record fallback (a record whose `repo` predates origin
-        // normalization is in `mine` via `repoOrigin` but absent from the digest
-        // map, which keys on `record.repo`) and it keeps this filter unable to
-        // diverge from reduceBuild.
-        const digests = await store.getRepoBuildDigests(repo)
+        const digests = await readBuildDigests(store, repo)
         for (const record of (await store.listBuilds()).filter(mine)) {
           if (streams.has(record.slug) || retired.has(record.slug)) continue
           const digest = digests.get(record.slug)
           if (digest !== undefined && digest.terminal !== undefined) continue
-          const events = await store.getEvents(record.slug)
-          const status = reduceBuild(events).status
+          const current = await readBuildStreamSeed(store, record.slug)
+          const status = buildReducer.finish(current.value.build).status
           if (!NONTERMINAL_STATUSES.includes(status)) {
             // Terminal is permanent (reduceBuild never clears it): a legacy
             // record the digest cannot retire is read once, not every pass.
             retired.add(record.slug)
             continue
           }
-          const stream = registerStream(record.slug, events, false)
+          const stream = registerStream(record.slug, current, false)
           if (satisfied === null) checkRegistrationState(stream)
         }
       }
@@ -525,18 +537,15 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
       ): Promise<void> => {
         const fresh = await store.getEvents(stream.slug, stream.lastSeq, readOpts)
         for (const event of fresh) {
-          stream.events.push(event)
+          stream.seed = buildStreamSeedReducer.advance(stream.seed, [event])
           stream.lastSeq = event.seq
           positions[stream.slug] = event.seq
-          const state = reduceBuild(stream.events)
+          const state = buildReducer.finish(stream.seed.build)
           stream.status = state.status
-          const condition = matchFirst(
-            event,
+          const condition = matchFirst(event, state, eventConditions(event, stream.seed), globs, {
             state,
-            eventConditions(event, stream.events),
-            globs,
-            stream.events,
-          )
+            deferral: stream.seed.deferral,
+          })
           if (condition !== null) {
             match(event, state, condition)
             return
@@ -556,21 +565,19 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
       /** The exit-2 record: among the named builds' terminal events, the one
        * with the latest `ts` (ties broken by slug order) — the event that made
        * the final named build terminal. */
-      const pickTerminalRecord = (): { event: AbEvent; state: BuildState } => {
+      const pickTerminalRecord = async (): Promise<{ event: AbEvent; state: BuildState }> => {
         let best: { event: AbEvent; state: BuildState; slug: string } | null = null
         for (const slug of slugs) {
           const stream = streams.get(slug)
           if (stream === undefined) continue
-          const terminalEvent = [...stream.events]
-            .reverse()
-            .find((event) => event.type === 'build.completed' || event.type === 'build.aborted')
+          const terminalEvent = stream.seed.terminalEvent
           if (terminalEvent === undefined) continue
           if (
             best === null ||
             terminalEvent.ts > best.event.ts ||
             (terminalEvent.ts === best.event.ts && slug < best.slug)
           ) {
-            best = { event: terminalEvent, state: reduceBuild(stream.events), slug }
+            best = { event: terminalEvent, state: buildReducer.finish(stream.seed.build), slug }
           }
         }
         // A named build is terminal only through its terminal event, so
@@ -647,7 +654,7 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
       } else if (namedAllTerminal()) {
         // Decision 5, start form: every named build is already terminal and
         // no condition held — show how the build ended.
-        const terminal = pickTerminalRecord()
+        const terminal = await pickTerminalRecord()
         return finish(null, terminal.event, terminal.state)
       }
 
@@ -664,7 +671,7 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
           if (aborted()) break
           await tick()
           if (!hasMatch() && namedAllTerminal()) {
-            const terminal = pickTerminalRecord()
+            const terminal = await pickTerminalRecord()
             return finish(null, terminal.event, terminal.state)
           }
         }
@@ -752,7 +759,7 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
         // conditions live — so after the quiesce drain this decision re-reads
         // the same live predicates (`hasMatch`, `namedAllTerminal`, `aborted`,
         // the deadline) to pick the exit.
-        const terminal = pickTerminalRecord()
+        const terminal = await pickTerminalRecord()
         return finish(null, terminal.event, terminal.state)
       }
       if (aborted()) {

package/packages/core/src/cli/watch.ts

@@ -1,3 +1,7 @@
+import { readBuildDigests } from '../store/reduced-reads'
+import { readBuildStreamSeed, readRepositoryAttention } from '../store/reduced-reads'
+import { buildStreamSeedReducer, type BuildStreamSeed } from '../kernel/read-facts'
+import { historicalBuildState, historicalRepositoryAttention } from './historical-build-state'
 import { readDispatcherLiveness } from './dispatcher-liveness'
 import { projectDispatcherLiveness } from '../kernel/dispatcher-liveness'
 import type { RepositoryRecord } from '../store/types'
@@ -44,7 +48,7 @@ import type { AbEvent } from '../events/catalog'
 import type { EventType } from '../events/payloads'
 import type { RepositoryEvent } from '../events/repository'
 import {
-  mergeDecision,
+  mergeDecisionFromFacts,
   mergeIdentity,
   RepositoryAttention,
   repositoryNeedsAttention,
@@ -52,7 +56,7 @@ import {
   type PersistenceObservation,
 } from './attention'
 import type { BuildState, PrLifecycle } from '../kernel/reducer'
-import { reduceBuild } from '../kernel/reducer'
+import { buildReducer } from '../kernel/reducer'
 import type { BuildOutcome, BuildStatus, Phase } from '../ontology'
 import type { Exec } from '../ports/workspace/git-worktree'
 import { PhaseSessionError } from '../store/phase-session'
@@ -516,7 +520,7 @@ interface BuildStream {
   slug: string
   named: boolean
   /** The full prefix, appended in seq order — what `reduceBuild` runs over. */
-  events: AbEvent[]
+  seed: BuildStreamSeed
   lastSeq: number
   status: BuildStatus
 }
@@ -597,11 +601,9 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         ? decodeCursor(opts.since, { store: storeRef, repo })
         : undefined
       const deliveredAttention = new Set(resumedCursor?.deliveredAttention ?? [])
-      const repositoryAttention = new RepositoryAttention()
+      let repositoryAttention = new RepositoryAttention()
       let attentionInitialized = false
       let livenessEvents: RepositoryEvent[] = []
-      let livenessSeq = 0
-      let livenessInitialized = false
       const observedOwners = new Map<string, RepositoryRecord>()
       const streams = new Map<string, Stream>()
       // Every stream's position — matching or not, delivered or baselined —
@@ -674,29 +676,14 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
           if (stop) return
         }
       }
-      const baselineMerge = (slug: string, events: AbEvent[]): void => {
-        // Old cursors already consumed finalize attention. Infer every eligible
-        // historical prefix, even if consent was subsequently armed again.
-        const prefix: AbEvent[] = []
-        for (const event of events) {
-          prefix.push(event)
-          const observation = mergeDecision(prefix, now())
-          if (observation) deliveredAttention.add(mergeIdentity(slug, observation.pr.number))
-        }
+      const baselineMerge = (slug: string, seed: BuildStreamSeed): void => {
+        for (const pr of seed.mergeAttentionPrs) deliveredAttention.add(mergeIdentity(slug, pr))
       }
 
       const checkLiveness = async (): Promise<void> => {
         if (!followRepository || stop) return
-        if (!livenessInitialized) {
-          const input = await readDispatcherLiveness(store, repo, now())
-          livenessEvents = input.events
-          livenessSeq = input.events.at(-1)?.seq ?? 0
-          livenessInitialized = true
-        }
         if ((await store.getRepo(repo)) === null) return
-        const fresh = await store.getRepoEvents(repo, livenessSeq)
-        livenessEvents.push(...fresh)
-        livenessSeq = fresh.at(-1)?.seq ?? livenessSeq
+        livenessEvents = (await readDispatcherLiveness(store, repo, now())).events
         // Sample metadata after the journal. Recheck both immediately before
         // reporting: a failed read is infrastructure, never evidence of death.
         const record = await store.getRepo(repo)
@@ -709,9 +696,7 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
             Date.parse(owner.lease.expiresAt) > now().getTime()
           )
             continue
-          const delta = await store.getRepoEvents(repo, livenessSeq)
-          livenessEvents.push(...delta)
-          livenessSeq = delta.at(-1)?.seq ?? livenessSeq
+          livenessEvents = (await readDispatcherLiveness(store, repo, now())).events
           const current = await store.getRepo(repo)
           if (current?.lease?.holder === id) {
             observedOwners.set(id, current)
@@ -758,14 +743,16 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
        * stream's just-extended array; the resume path replays the backlog
        * into a scratch prefix so a resumed record never leaks state from
        * events that landed after it. */
-      const processBuildEvent = (stream: BuildStream, event: AbEvent, prefix: AbEvent[]): void => {
+      const processBuildEvent = (stream: BuildStream, event: AbEvent): void => {
         if (stop) return
         stream.lastSeq = event.seq
         positions[stream.slug] = event.seq
-        const state = reduceBuild(prefix)
+        stream.seed = buildStreamSeedReducer.advance(stream.seed, [event])
+        const state = buildReducer.finish(stream.seed.build)
+        stream.status = state.status
         if (matchesBuildFilter(event.type, filters)) emit(event, state)
         if (!filters.length && !stop) {
-          const observation = mergeDecision(prefix, now(), state)
+          const observation = mergeDecisionFromFacts(state, stream.seed.deferral, now())
           if (observation)
             emitObservation(
               observation,
@@ -799,44 +786,28 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         if (streams.has(slug)) return true
         const record = await store.getBuild(slug)
         if (record === null) return false
-        // AUT-545: this full-log read is deliberate, accepted growth — the
-        // retained prefix is consumed at full replay depth by every later
-        // reduction (approvals, findings, answered escalations, PR facts,
-        // observations), so bounding it would need reducer-partition store
-        // machinery out of AUT-545's scope. Required for `--since` replay and
-        // the baselined stream prefix. Mirrors cli/wait.ts trackBuild.
-        const events = await store.getEvents(slug)
+        const current = await readBuildStreamSeed(store, slug)
+        const seed =
+          resumeSeq === undefined
+            ? current.value
+            : await historicalBuildState(store, slug, resumeSeq, current)
         const stream: BuildStream = {
           kind: 'build',
           slug,
           named: slugs.includes(slug),
-          events,
-          lastSeq: events.at(-1)?.seq ?? 0,
-          status: reduceBuild(events).status,
+          seed,
+          lastSeq: resumeSeq ?? current.cursor,
+          status: buildReducer.finish(current.value.build).status,
         }
         streams.set(slug, stream)
         positions[slug] = stream.lastSeq
-        if (resumeSeq === undefined) {
-          baselineMerge(slug, events)
-          return true
-        }
-        positions[slug] = resumeSeq
-        if (resumedCursor?.deliveredAttention === undefined)
-          baselineMerge(
-            slug,
-            events.filter((event) => event.seq <= resumeSeq),
-          )
-        stream.lastSeq = resumeSeq
-        // Replay the backlog into a scratch prefix: each record's state is
-        // the reduction of the prefix ENDING at that event, never the
-        // reduction of the full loaded prefix, which would leak state from
-        // events that landed after the one being recorded.
-        const replay: AbEvent[] = events.filter((event) => event.seq <= resumeSeq)
-        for (const event of events) {
-          if (event.seq <= resumeSeq) continue
-          replay.push(event)
-          processBuildEvent(stream, event, replay)
-          if (stop) break
+        if (resumeSeq === undefined || resumedCursor?.deliveredAttention === undefined)
+          baselineMerge(slug, seed)
+        if (resumeSeq !== undefined) {
+          for (const event of await store.getEvents(slug, resumeSeq)) {
+            processBuildEvent(stream, event)
+            if (stop) break
+          }
         }
         return true
       }
@@ -856,26 +827,13 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
        * the throw stay tracked, so the retry neither duplicates nor skips.
        */
       const discoverBuilds = async (): Promise<void> => {
-        // AUT-545: the terminal filter is the AUT-487 digest, not a full-log read —
-        // one flat batch read replaces a full getEvents per candidate build, per
-        // discovery pass; `terminal` is reduceBuild's exact terminal rule
-        // (store/digest's reduceBuildDigest, pinned by contract). The per-build
-        // full read below remains deliberate for builds the digest cannot retire:
-        // its retained prefix is consumed at full replay depth by every later
-        // reduction (approvals, findings, answered escalations, PR facts,
-        // observations), so bounding it would need reducer-partition store
-        // machinery out of AUT-545's scope. The reduceBuild re-check stays: it is
-        // the legacy-record fallback (a record whose `repo` predates origin
-        // normalization is in `mine` via `repoOrigin` but absent from the digest
-        // map, which keys on `record.repo`) and it keeps this filter unable to
-        // diverge from reduceBuild. Mirrors cli/wait.ts discoverBuilds.
-        const digests = await store.getRepoBuildDigests(repo)
+        const digests = await readBuildDigests(store, repo)
         for (const record of (await store.listBuilds()).filter(mine)) {
           if (streams.has(record.slug) || retired.has(record.slug)) continue
           const digest = digests.get(record.slug)
           if (digest !== undefined && digest.terminal !== undefined) continue
-          const events = await store.getEvents(record.slug)
-          const status = reduceBuild(events).status
+          const current = await readBuildStreamSeed(store, record.slug)
+          const status = buildReducer.finish(current.value.build).status
           if (!NONTERMINAL_STATUSES.includes(status)) {
             // Terminal is permanent (reduceBuild never clears it): a legacy
             // record the digest cannot retire is read once, not every pass.
@@ -886,12 +844,12 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
             kind: 'build',
             slug: record.slug,
             named: false,
-            events,
-            lastSeq: events.at(-1)?.seq ?? 0,
+            seed: current.value,
+            lastSeq: current.cursor,
             status,
           }
           streams.set(record.slug, stream)
-          baselineMerge(record.slug, events)
+          baselineMerge(record.slug, current.value)
           positions[record.slug] = stream.lastSeq
         }
       }
@@ -903,18 +861,21 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         positions[REPO_STREAM_KEY] = stream.lastSeq
         try {
           if ((await store.getRepo(repo)) !== null) {
-            // Full bootstrap is intentional: degradation can predate run anchors.
-            const history = await store.getRepoEvents(repo)
-            const baseline = resumeSeq ?? history.at(-1)?.seq ?? 0
-            for (const event of history) {
-              if (event.seq <= baseline) repositoryAttention.fold(event)
-            }
+            const current = await readRepositoryAttention(store, repo)
+            const baseline = resumeSeq ?? current.cursor
+            const seed =
+              resumeSeq === undefined
+                ? current.value
+                : await historicalRepositoryAttention(store, repo, resumeSeq, current)
+            repositoryAttention = new RepositoryAttention(seed)
             attentionInitialized = true
             stream.lastSeq = baseline
             positions[REPO_STREAM_KEY] = baseline
-            for (const event of history) {
-              if (event.seq <= baseline || stop) continue
-              processRepositoryEvent(stream, event)
+            if (resumeSeq !== undefined) {
+              for (const event of await store.getRepoEvents(repo, baseline)) {
+                if (stop) break
+                processRepositoryEvent(stream, event)
+              }
             }
             if (!stop) checkPersistence()
           } else attentionInitialized = true
@@ -931,12 +892,11 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         const fresh = await store.getEvents(stream.slug, stream.lastSeq, readOpts)
         for (const event of fresh) {
           if (stop) break
-          stream.events.push(event)
-          processBuildEvent(stream, event, stream.events)
+          processBuildEvent(stream, event)
           if (stop) break
         }
         if (fresh.length > 0 && !stop) {
-          stream.status = reduceBuild(stream.events).status
+          stream.status = buildReducer.finish(stream.seed.build).status
         }
         return true
       }
@@ -951,11 +911,14 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         if ((await store.getRepo(repo)) === null) return true
         if (!attentionInitialized) {
           repositoryInitialization ??= (async () => {
-            const history = await store.getRepoEvents(repo)
-            const baseline = sinceStreams[REPO_STREAM_KEY] ?? history.at(-1)?.seq ?? 0
-            for (const event of history) {
-              if (event.seq <= baseline) repositoryAttention.fold(event)
-            }
+            const current = await readRepositoryAttention(store, repo)
+            const resumeSeq = sinceStreams[REPO_STREAM_KEY]
+            const baseline = resumeSeq ?? current.cursor
+            const seed =
+              resumeSeq === undefined
+                ? current.value
+                : await historicalRepositoryAttention(store, repo, resumeSeq, current)
+            repositoryAttention = new RepositoryAttention(seed)
             stream.lastSeq = baseline
             positions[REPO_STREAM_KEY] = baseline
             attentionInitialized = true

package/packages/core/src/config/pipeline-source.ts

@@ -55,7 +55,8 @@ export interface PipelineSource {
 export interface PipelineSourceInput {
   slug: string
   record: Pick<BuildRecord, 'branch'>
-  events: readonly AbEvent[]
+  events?: readonly AbEvent[]
+  recordedBase?: string
   /** 'origin' reads through the forge; 'checkout' reads through git exec in
    * the dispatcher's checkout (build branches are refs of the shared repo). */
   mode: 'origin' | 'checkout'
@@ -250,7 +251,7 @@ export async function resolvePipelineSource(
         }
       }
     }
-    const baseSha = recordedBaseSha(events)
+    const baseSha = input.recordedBase ?? recordedBaseSha(events ?? [])
     if (baseSha === undefined) {
       onFailure({ kind: 'no-base', detail: 'no recorded base commit (legacy build)' })
       return undefined
@@ -368,7 +369,7 @@ export async function resolvePipelineSource(
       return parsed
     }
   }
-  const baseSha = recordedBaseSha(events)
+  const baseSha = input.recordedBase ?? recordedBaseSha(events ?? [])
   if (baseSha === undefined) {
     onFailure({ kind: 'no-base', detail: 'no recorded base commit (legacy build)' })
     return undefined