@defrex/autobuild 0.8.0 → 0.10.0

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

@@ -3,7 +3,7 @@ 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 { scanUnclaimedObservations } from '../processes/harvest'
+import { sampleUnclaimedObservationCount } from '../processes/harvest'
 import {
   controlHarvestRun,
   OperatorControlError,
@@ -120,6 +120,9 @@ export class DispatchFrontend {
   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 dispatchStatus: DispatchStatus = reduceDispatchStatus([], this.runId)
   private eventRefreshTail: Promise<void> = Promise.resolve()
@@ -164,6 +167,36 @@ 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.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
       this.repositorySeq = delta.at(-1)!.seq
@@ -295,8 +328,14 @@ export class DispatchFrontend {
     }
     const config = await this.loadConfig(ref.kind, ref.rev)
     try {
-      const scan = await scanUnclaimedObservations(this.opts.store, this.opts.repo)
-      this.observationCount = scan.observations.length
+      // 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)
     } 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
@@ -677,6 +716,7 @@ export class DispatchFrontend {
       repo: this.opts.repo,
       user: buildControlUser(this.opts.env),
       setting: 'intake',
+      run: this.runId,
     })
     await this.report(`dispatcher intake ${event.enabled ? 'ON' : 'OFF'}`)
     await this.renderOnce()
@@ -688,6 +728,7 @@ export class DispatchFrontend {
       repo: this.opts.repo,
       user: buildControlUser(this.opts.env),
       setting: 'auto-merge-default',
+      run: this.runId,
     })
     await this.report(`dispatcher auto-merge default ${event.enabled ? 'ON' : 'OFF'}`)
     await this.renderOnce()
@@ -990,17 +1031,25 @@ export class DispatchFrontend {
       await this.opts.store.appendRepo(this.opts.repo, {
         actor,
         type: 'dispatcher.intake-set',
-        payload: { enabled: this.opts.intake },
+        payload: { enabled: this.opts.intake, run: this.runId },
       })
     }
     if (this.opts.defaultAutoMerge !== undefined) {
       await this.opts.store.appendRepo(this.opts.repo, {
         actor,
         type: 'dispatcher.auto-merge-default-set',
-        payload: { enabled: this.opts.defaultAutoMerge },
+        payload: { enabled: this.opts.defaultAutoMerge, run: this.runId },
       })
     }
 
+    // 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(() => {})
+
     const options: DispatchChildOptions = {
       targetRepo: this.opts.checkout ?? this.opts.repo,
       storeRef: this.opts.storeRef,

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

@@ -1,6 +1,6 @@
 import { distributionPath } from '../distribution'
 import { DISPATCHER } from '../events/envelope'
-import type { RepositoryEvent } from '../events/repository'
+import { hasOpenTick } from '../processes/tick-state'
 import type { BuildStore } from '../store/types'
 
 export const DISPATCH_CHILD_OPTIONS_ENV = 'AB_DISPATCH_CHILD_OPTIONS'
@@ -132,18 +132,6 @@ export interface DispatchChildSupervisorDeps {
   }) => DispatchSubprocess
 }
 
-function hasOpenTick(events: readonly RepositoryEvent[], run: string): boolean {
-  const boundary = events.findLast(
-    (event) =>
-      'run' in event.payload &&
-      event.payload.run === run &&
-      (event.type === 'dispatcher.tick-started' ||
-        event.type === 'dispatcher.tick-completed' ||
-        event.type === 'dispatcher.tick-failed'),
-  )
-  return boundary?.type === 'dispatcher.tick-started'
-}
-
 function defaultSpawn(input: {
   entrypoint: string
   cwd: string