@defrex/autobuild 0.12.0 → 0.14.0

package/packages/core/src/cli/dispatch-frontend.ts

@@ -1,10 +1,11 @@
+import { DispatchRepositoryFeed } from './dispatch-repository-feed'
 import { StandbyIdentityResolver } from './dispatcher-liveness'
 import { configSchema, type Config } from '../config/schema'
 import { humanActor } from '../events/envelope'
 import type { RepositoryEvent } from '../events/repository'
 import { reduceDispatchStatus, type DispatchStatus } from '../kernel/dispatch-status'
 import type { BuildState } from '../kernel/reducer'
-import { sampleUnclaimedObservationCount } from '../processes/harvest'
+import { unclaimedObservationCount } from '../processes/harvest'
 import {
   controlHarvestRun,
   OperatorControlError,
@@ -68,15 +69,6 @@ function isStaleAbortControlError(error: unknown): error is BuildControlError {
   )
 }
 
-function isDashboardRepositoryEvent(event: RepositoryEvent): boolean {
-  return (
-    event.type.startsWith('harvest.') ||
-    event.type === 'dispatcher.intake-set' ||
-    event.type === 'dispatcher.pause-set' ||
-    event.type === 'dispatcher.auto-merge-default-set'
-  )
-}
-
 interface ResumePrompt {
   slug: string
   escalationIds: string[]
@@ -121,11 +113,7 @@ export class DispatchFrontend {
   private readonly region: LiveRegion
   private readonly keyboard
   private child: DispatchChildHandle | undefined
-  private repositorySeq = 0
-  /** Set only after a successful initial fold; every later `events()` call
-   * takes the delta path. */
-  private seeded = false
-  private repositoryEvents: RepositoryEvent[] = []
+  private readonly repositoryFeed: DispatchRepositoryFeed
   private dispatchStatus: DispatchStatus = reduceDispatchStatus([], this.runId)
   private eventRefreshTail: Promise<void> = Promise.resolve()
   private cache: DashboardBuildPollCache | undefined
@@ -155,8 +143,12 @@ export class DispatchFrontend {
   private operatorStopRequested = false
 
   constructor(private readonly opts: DispatchFrontendOptions) {
-    this.standbyResolver = new StandbyIdentityResolver(opts.store, opts.repo)
     this.clock = opts.clock ?? systemClock
+    this.repositoryFeed = new DispatchRepositoryFeed(opts.store, opts.repo, this.clock)
+    this.standbyResolver = new StandbyIdentityResolver(opts.store, opts.repo, {
+      allowLookup: () => this.repositoryFeed.incompleteIdentities,
+      remember: (events, complete) => this.repositoryFeed.remember(events, complete),
+    })
     this.keyboard = createKeyboardProtocol(
       (chunk) => opts.terminal.write(chunk),
       opts.terminal.modes,
@@ -170,47 +162,14 @@ export class DispatchFrontend {
    * are retained for their existing replay reducers. */
   private async events(): Promise<RepositoryEvent[]> {
     const refresh = this.eventRefreshTail.then(async () => {
-      if (!this.seeded) {
-        // Initial fold (AUT-534): the whole-journal read the first poll used
-        // to pay is replaced by AUT-489's bounded read where that is provably
-        // equivalent. The bounded attempt is confined to the pre-launch
-        // window (`this.child === undefined`): before `launchChild` no
-        // run-scoped journal fact can carry `this.runId` (only the supervised
-        // child appends run-scoped facts with it), so every run-scoped event
-        // in the bounded subset is skipped by `reduceDispatchStatus` exactly
-        // as it would be in a full replay, and the dashboard filter keeps
-        // only durable types, which the subset carries in full. After launch
-        // a bounded subset cannot guarantee the child's `run-started` under a
-        // competing dispatcher's later anchor — dropping it would leave
-        // `effectiveConfig` unset and the first frame would never render —
-        // so a post-launch seed always takes the full read (the pre-AUT-534
-        // behavior). `once` mode's teardown fold runs after the child exits,
-        // so the same guard routes it to the full read.
-        const seed =
-          this.child === undefined
-            ? await this.opts.store.getRepoStateEvents(this.opts.repo).catch(() =>
-                // Bounded-read failure falls back to the exact pre-AUT-534
-                // full read within this same seed attempt.
-                this.opts.store.getRepoEvents(this.opts.repo, 0),
-              )
-            : await this.opts.store.getRepoEvents(this.opts.repo, 0)
-        this.standbyResolver.ingest(seed)
-        this.repositorySeq = seed.at(-1)?.seq ?? 0
-        this.dispatchStatus = reduceDispatchStatus(seed, this.runId)
-        this.repositoryEvents.push(...seed.filter(isDashboardRepositoryEvent))
-        this.seeded = true
-        return
-      }
-      const delta = await this.opts.store.getRepoEvents(this.opts.repo, this.repositorySeq)
-      if (delta.length === 0) return
+      const delta = await this.repositoryFeed.refresh(false)
+      this.standbyResolver.ingest(this.repositoryFeed.identities)
       this.standbyResolver.ingest(delta)
-      this.repositorySeq = delta.at(-1)!.seq
       this.dispatchStatus = reduceDispatchStatus(delta, this.runId, this.dispatchStatus)
-      this.repositoryEvents.push(...delta.filter(isDashboardRepositoryEvent))
     })
     this.eventRefreshTail = refresh.catch(() => {})
     await refresh
-    return this.repositoryEvents
+    return this.repositoryFeed.events
   }
 
   private async report(message: string, level: 'info' | 'warning' = 'info'): Promise<void> {
@@ -333,14 +292,10 @@ export class DispatchFrontend {
     }
     const config = await this.loadConfig(ref.kind, ref.rev)
     try {
-      // Journal + digests (AUT-487): one journal read for the claimed set
-      // (this class's cached `repositoryEvents` is dashboard-filtered, so the
-      // claimed set needs the full journal, exactly as the old per-build scan
-      // read it) plus one repo-scoped digest read — the sample's store
-      // traffic stays flat as finished builds accumulate. A journal record
-      // that does not yet exist reads as an empty journal (AUT-524); the
-      // sample writes nothing.
-      this.observationCount = await sampleUnclaimedObservationCount(this.opts.store, this.opts.repo)
+      this.observationCount = unclaimedObservationCount({
+        digests: await this.opts.store.getRepoBuildDigests(this.opts.repo),
+        harvestEvents: repositoryEvents,
+      })
     } catch {
       // Before the first successful sample there is no factual zero to place in
       // a complete frame. Leave the prior frame untouched and retry on the next
@@ -401,6 +356,7 @@ export class DispatchFrontend {
     ) {
       this.view = undefined
     }
+    await this.repositoryFeed.save()
     this.model = projected
     this.syncControls()
     this.paint()
@@ -1057,13 +1013,13 @@ export class DispatchFrontend {
       })
     }
 
-    // Warm the initial fold before `launchChild` (AUT-534): the bounded seed
-    // is only safe while `this.child === undefined`, so the one opportunity
-    // to take it is here. A failed warm-up leaves the seed unset; the poll
-    // loop's existing failure reporting covers the retry, which then takes
-    // the full-read path post-launch. `once` mode gains no read — its single
-    // fold runs from `finishPresentation()` after the child exits.
-    if (!this.opts.once) await this.events().catch(() => {})
+    try {
+      const delta = await this.repositoryFeed.warm()
+      this.standbyResolver.ingest(this.repositoryFeed.identities)
+      this.dispatchStatus = reduceDispatchStatus(delta, this.runId, this.dispatchStatus)
+    } catch {
+      /* Display initialization must not gate the kernel. */
+    }
 
     const options: DispatchChildOptions = {
       targetRepo: this.opts.checkout ?? this.opts.repo,
@@ -1104,6 +1060,7 @@ export class DispatchFrontend {
       this.opts.signal?.removeEventListener('abort', stop)
       await this.child.stop()
       await this.finishPresentation()
+      await this.repositoryFeed.save(true)
     }
   }
 }

package/packages/core/src/cli/dispatch-process.ts

@@ -1,6 +1,6 @@
+import { readDispatcherRunFacts, readOpenTick } from '../store/reduced-reads'
 import { distributionPath } from '../distribution'
 import { DISPATCHER } from '../events/envelope'
-import { hasOpenTick } from '../processes/tick-state'
 import type { BuildStore } from '../store/types'
 
 export const DISPATCH_CHILD_OPTIONS_ENV = 'AB_DISPATCH_CHILD_OPTIONS'
@@ -168,10 +168,8 @@ export function superviseDispatchChild(deps: DispatchChildSupervisorDeps): Dispa
   // chooses/awaits process termination, avoiding check-then-append races.
   const completed = child.exited.then(async (exitCode): Promise<DispatchChildResult> => {
     const processSignal = child.signalCode === null ? requestedSignal : String(child.signalCode)
-    const events = await deps.store.getRepoEvents(deps.repo)
-    const recorded = events.findLast(
-      (event) => event.type === 'dispatcher.run-stopped' && event.payload.run === deps.run,
-    )
+    const recorded = (await readDispatcherRunFacts(deps.store, deps.repo, deps.run, false)).value
+      .stop
     if (recorded?.type === 'dispatcher.run-stopped') {
       const signal = processSignal ?? recorded.payload.signal
       return {
@@ -245,12 +243,21 @@ export function superviseDispatchChild(deps: DispatchChildSupervisorDeps): Dispa
         // Ready with no durable build to recover. Let an open tick reach its
         // normal boundary; all non-tick work is lease-backed/recoverable and a
         // child stuck there is safe to terminate.
-        const events = await deps.store.getRepoEvents(deps.repo)
+        let open = true
+        try {
+          const record = await deps.store.getRepo(deps.repo)
+          open =
+            record?.tick?.run === deps.run
+              ? record.tick.open !== undefined
+              : await readOpenTick(deps.store, deps.repo, deps.run, false)
+        } catch {
+          // Unreadable telemetry cannot authorize an unsafe kill.
+        }
         // The child may have exited while the asynchronous journal read was in
         // flight. Re-check at the force boundary so evidence never claims a
         // SIGKILL that was not actually sent.
         if (child.exitCode !== null) return
-        if (hasOpenTick(events, deps.run)) {
+        if (open) {
           await child.exited
           return
         }

package/packages/core/src/cli/dispatch-repository-feed.ts

@@ -0,0 +1,196 @@
+import { type RepositoryEvent, validateRepositoryEventWrite } from '../events/repository'
+import { defineReducer } from '../kernel/incremental'
+import { loadReducerSnapshot, persistReducerSnapshot } from '../store/snapshots'
+import type { BuildStore, Clock } from '../store/types'
+
+export function isDashboardRepositoryEvent(event: RepositoryEvent): boolean {
+  return (
+    event.type.startsWith('harvest.') ||
+    event.type === 'dispatcher.intake-set' ||
+    event.type === 'dispatcher.pause-set' ||
+    event.type === 'dispatcher.auto-merge-default-set'
+  )
+}
+
+export const dispatchFrontendReducer = defineReducer({
+  version: 2,
+  initial: (): { retained: RepositoryEvent[]; incompleteIdentities: boolean } => ({
+    retained: [],
+    incompleteIdentities: true,
+  }),
+  fold(acc, events: readonly RepositoryEvent[]) {
+    const facts = new Map(acc.retained.map((event) => [event.seq, event]))
+    for (const event of events) {
+      if (isDashboardRepositoryEvent(event) || event.type === 'dispatcher.run-started')
+        facts.set(event.seq, event)
+    }
+    acc.retained = [...facts.values()].sort((a, b) => a.seq - b.seq)
+  },
+  finish: (acc) => acc.retained,
+})
+
+/** One serialized, frontend-only repository projection. The consumed cursor is
+ * independent of retained facts: quiet ticks must never survive in the cache. */
+export class DispatchRepositoryFeed {
+  private cursor = 0
+  private ready = false
+  private retained: RepositoryEvent[] = []
+  private tail: Promise<void> = Promise.resolve()
+  private savedAt = -Infinity
+  private boundary: number | undefined
+  private recovery = false
+  incompleteIdentities = true
+
+  constructor(
+    private readonly store: BuildStore,
+    private readonly repo: string,
+    private readonly clock: Clock,
+  ) {}
+
+  get events(): RepositoryEvent[] {
+    return this.retained.filter(isDashboardRepositoryEvent)
+  }
+  get identities(): RepositoryEvent[] {
+    return this.retained.filter((e) => e.type === 'dispatcher.run-started')
+  }
+
+  private validate(events: RepositoryEvent[], cursor: number, contiguous: boolean): void {
+    let previous = cursor
+    for (const event of events) {
+      if (
+        event.repo !== this.repo ||
+        !Number.isInteger(event.seq) ||
+        event.seq <= previous ||
+        (contiguous && event.seq !== previous + 1) ||
+        typeof event.ts !== 'string' ||
+        !Number.isFinite(Date.parse(event.ts))
+      ) {
+        throw new Error('invalid dashboard repository delta')
+      }
+      validateRepositoryEventWrite(event)
+      previous = event.seq
+    }
+  }
+
+  async warm(): Promise<RepositoryEvent[]> {
+    this.recovery = true
+    this.boundary = await this.store.getRepoHighWater(this.repo)
+    this.recovery = false
+    try {
+      return await this.refresh()
+    } catch (error) {
+      this.recovery = true
+      throw error
+    }
+  }
+
+  refresh(persist = true): Promise<RepositoryEvent[]> {
+    let result: RepositoryEvent[] = []
+    const next = this.tail.then(async () => {
+      let cursor = this.cursor
+      let retained = this.retained
+      let incompleteIdentities = this.incompleteIdentities
+      let delta: RepositoryEvent[]
+      if (!this.ready) {
+        if ((await this.store.getRepo(this.repo)) === null) {
+          this.ready = true
+          this.recovery = false
+          return
+        }
+        const high = await this.store.getRepoHighWater(this.repo)
+        const snapshot = await loadReducerSnapshot(
+          this.store,
+          { kind: 'repo', repo: this.repo },
+          'dispatchFrontend',
+          dispatchFrontendReducer,
+        )
+        let restored = false
+        if (snapshot && snapshot.cursor <= high) {
+          try {
+            const state = snapshot.state as {
+              retained: RepositoryEvent[]
+              incompleteIdentities: boolean
+            }
+            if (!Array.isArray(state.retained) || typeof state.incompleteIdentities !== 'boolean')
+              throw new Error('invalid projection')
+            this.validate(state.retained, 0, false)
+            if (
+              state.retained.some(
+                (e) =>
+                  e.seq > snapshot.cursor ||
+                  !(isDashboardRepositoryEvent(e) || e.type === 'dispatcher.run-started'),
+              )
+            )
+              throw new Error('invalid retained fact')
+            incompleteIdentities = state.incompleteIdentities
+            retained = state.retained
+            cursor = snapshot.cursor
+            restored = true
+          } catch {
+            /* A malformed cache uses the bounded seed. */
+          }
+        }
+        if (!restored) {
+          const seed = await this.store.getRepoStateEvents(this.repo)
+          this.validate(seed, 0, false)
+          incompleteIdentities = true
+          retained = dispatchFrontendReducer.reduce(seed)
+          cursor = Math.max(high, seed.at(-1)?.seq ?? 0)
+        }
+        delta = await this.store.getRepoEvents(this.repo, cursor)
+        this.validate(delta, cursor, true)
+        // A failed prelaunch seed must not skip this invocation's config/start
+        // even if a competing run advanced the bounded seed's anchor.
+        if (this.recovery) {
+          const recovery = await this.store.getRepoEvents(this.repo, this.boundary ?? 0)
+          this.validate(recovery, this.boundary ?? 0, true)
+          delta = [...new Map([...delta, ...recovery].map((e) => [e.seq, e])).values()].sort(
+            (a, b) => a.seq - b.seq,
+          )
+        }
+      } else {
+        delta = await this.store.getRepoEvents(this.repo, cursor)
+        this.validate(delta, cursor, true)
+        // A standby correlation may have supplied an older identity while the
+        // delta read was pending. Keep those memoized facts in this commit.
+        retained = this.retained
+        incompleteIdentities = this.incompleteIdentities
+      }
+      retained = dispatchFrontendReducer.advance({ retained, incompleteIdentities }, delta).retained
+      this.cursor = Math.max(cursor, delta.at(-1)?.seq ?? 0)
+      this.incompleteIdentities = incompleteIdentities
+      this.retained = retained
+      this.ready = true
+      this.recovery = false
+      result = delta
+      if (persist) await this.save()
+    })
+    this.tail = next.catch(() => {})
+    return next.then(() => result)
+  }
+
+  remember(events: readonly RepositoryEvent[], complete = false): void {
+    this.retained = dispatchFrontendReducer.advance(
+      { retained: this.retained, incompleteIdentities: this.incompleteIdentities },
+      events.filter((e) => e.seq <= this.cursor),
+    ).retained
+    if (complete) this.incompleteIdentities = false
+  }
+
+  async save(force = false): Promise<void> {
+    if (!this.ready || (!force && this.clock().getTime() - this.savedAt < 5000)) return
+    // A rejected equal-cursor put and an unavailable store still cost a
+    // request. Bound attempts, not just successful writes, on quiet polls.
+    this.savedAt = this.clock().getTime()
+    await persistReducerSnapshot(
+      this.store,
+      { kind: 'repo', repo: this.repo },
+      'dispatchFrontend',
+      {
+        version: dispatchFrontendReducer.version,
+        cursor: this.cursor,
+        state: { retained: this.retained, incompleteIdentities: this.incompleteIdentities },
+      },
+    )
+  }
+}