@defrex/autobuild 0.13.0 → 0.14.0

package/packages/core/src/cli/build-control.ts

@@ -1,3 +1,4 @@
+import { readBuildFacts } from '../store/reduced-reads'
 /**
  * Durable operator controls for one build.
  *
@@ -9,12 +10,7 @@
 import type { AbEvent } from '../events/catalog'
 import type { PinnedAsset } from '../events/payloads'
 import { humanActor, KERNEL, type Via } from '../events/envelope'
-import {
-  reduceBuild,
-  discardInFlight,
-  type BuildState,
-  type OpenEscalation,
-} from '../kernel/reducer'
+import { discardInFlight, type BuildState, type OpenEscalation } from '../kernel/reducer'
 import type { ArtifactRef, BuildOutcome, BuildStatus, TicketRef } from '../ontology'
 import type { Exec } from '../ports/workspace/git-worktree'
 import { specConformance } from '../spec-standard'
@@ -276,7 +272,7 @@ async function appendConsentCommand(
   via?: Via,
 ): Promise<BuildControlResult> {
   while (true) {
-    const state = reduceBuild(await store.getEvents(slug))
+    const state = (await readBuildFacts(store, slug)).value.state
     activeState(slug, state)
     const command =
       action === 'toggle-auto-merge'
@@ -484,8 +480,8 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
     )
   }
 
-  const events = await opts.store.getEvents(opts.slug)
-  const state = reduceBuild(events)
+  const events = (await readBuildFacts(opts.store, opts.slug)).value
+  const state = events.state
   const user = opts.user?.trim() || buildControlUser(opts.env ?? {})
 
   if (opts.action.kind === 'discard') {
@@ -495,7 +491,7 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
         `build "${opts.slug}" cannot be discarded (status: ${state.status}); discard requires queued`,
       )
     }
-    const existing = events.findLast((event) => event.type === 'build.discard-requested')
+    const existing = events.latestDiscard
     if (existing !== undefined) {
       return { kind: 'command', slug: opts.slug, command: 'discard', event: existing }
     }
@@ -504,7 +500,7 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
 
   if (opts.action.kind === 'abort') {
     if (state.status !== 'queued') activeState(opts.slug, state)
-    const existing = events.findLast((event) => event.type === 'build.abort-requested')
+    const existing = events.latestAbort
     if (existing !== undefined) {
       return { kind: 'command', slug: opts.slug, command: 'abort', event: existing }
     }
@@ -658,7 +654,7 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
 
         // Re-read at the last durable moment. The PR janitor and abort
         // acknowledgement may still write while a blocked build is parked.
-        const freshState = reduceBuild(await opts.store.getEvents(opts.slug))
+        const freshState = (await readBuildFacts(opts.store, opts.slug)).value.state
         assertStillActive(opts.slug, freshState)
         const decision = decideRevise(opts.slug, freshState, captured)
         if (decision.kind === 'refuse') throwRefusal(decision)
@@ -701,7 +697,7 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
             payload: {},
           })
         }
-        const after = reduceBuild(await opts.store.getEvents(opts.slug))
+        const after = (await readBuildFacts(opts.store, opts.slug)).value.state
         const signal = terminalSignal(after)
         return {
           kind: 'answered',
@@ -729,7 +725,7 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
         const initial = dismissPartition(state, captured)
         if (initial.eligible.length === 0) throw noCitedFindings(opts.slug, initialOpen)
 
-        const freshState = reduceBuild(await opts.store.getEvents(opts.slug))
+        const freshState = (await readBuildFacts(opts.store, opts.slug)).value.state
         assertStillActive(opts.slug, freshState)
         if (hasPendingAbort(freshState)) throw abortPending(opts.slug)
         const freshOpen = selectedOpen(freshState, captured)
@@ -757,7 +753,7 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
             payload: {},
           })
         }
-        const after = reduceBuild(await opts.store.getEvents(opts.slug))
+        const after = (await readBuildFacts(opts.store, opts.slug)).value.state
         const signal = terminalSignal(after)
         return {
           kind: 'answered',

package/packages/core/src/cli/bulk-control.ts

@@ -1,3 +1,4 @@
+import { readBuildFacts } from '../store/reduced-reads'
 /**
  * Repository-wide quiescence: one keypress that parks every running build and
  * stops intake, and one that reverses it.
@@ -59,7 +60,7 @@
  * what the operator sees, and a unit test pins that agreement.
  */
 import { humanActor, type Actor, type Via } from '../events/envelope'
-import { reduceBuild, type BuildState } from '../kernel/reducer'
+import type { BuildState } from '../kernel/reducer'
 import type { Exec } from '../ports/workspace/git-worktree'
 import type { BuildRecord, BuildStore } from '../store/types'
 import { BuildControlError, buildControlUser } from './build-control'
@@ -132,7 +133,7 @@ async function requestOne(
   direction: BulkDirection,
 ): Promise<boolean> {
   while (true) {
-    const state = reduceBuild(await store.getEvents(slug))
+    const state = (await readBuildFacts(store, slug)).value.state
     if (!eligible(state, direction)) return false
     // The two branches are written out rather than selecting the event type
     // into a variable so `appendIfCurrent`'s `T extends EventType` infers a

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

@@ -1,3 +1,4 @@
+import { readBuildFacts, type CurrentBuildFacts } from '../store/reduced-reads'
 /**
  * The `ab context` materializer (SPEC §8.3): a phase-scoped hydration of the
  * gitignored `.ab/` scratch dir. Everything derives from
@@ -16,14 +17,13 @@ import { mkdir, rm, writeFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { parseConfig } from '../config/load'
 import type { VerifyStepConfig } from '../config/schema'
-import type { AbEvent } from '../events/catalog'
 import {
   allowedTerminals,
   phaseSpecFor,
   type PhaseSpec,
   type TerminalCommand,
 } from '../kernel/phases'
-import { reduceBuild, type BuildState } from '../kernel/reducer'
+import type { BuildState } from '../kernel/reducer'
 import {
   isVerifyPhase,
   verifyReportKind,
@@ -113,69 +113,12 @@ function requiredKinds(spec: PhaseSpec, phase: Phase): string[] {
 
 /** All finding objects ever deposited, by id — verdict payloads carry them in
  * full (§15.3), so feedback-by-id resolves without touching artifacts. */
-function findingsById(events: AbEvent[]): Map<string, Finding> {
-  const byId = new Map<string, Finding>()
-  for (const event of events) {
-    if (event.type === 'plan-review.verdict' || event.type === 'code-review.verdict') {
-      for (const finding of event.payload.findings) byId.set(finding.id, finding)
-    }
-  }
-  return byId
+function findingsById(events: CurrentBuildFacts): Map<string, Finding> {
+  return new Map(Object.values(events.findings).map((finding) => [finding.id, finding]))
 }
-
-/**
- * The feedback carried by this occurrence's `*.started` event (§15.3).
- * `implement.started`, `plan.started`, and agent `verify.started` may carry
- * feedback — the carrier that gets answered guidance to a fresh session after
- * a parked build re-attaches (§15.6-B). A `plan.started` without one (logs
- * predating the field) falls
- * back to deriving round-N feedback from the round-(N-1)
- * `plan-review.verdict` — the plan loop's verdicts ARE its findings channel
- * (§8.3: "prior plan rev + findings").
- */
-function currentFeedback(events: AbEvent[], phase: Phase, round: number): Feedback | null {
-  if (isVerifyPhase(phase)) {
-    const step = verifyStep(phase)
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-      const event = events[i]!
-      if (
-        event.type === 'verify.started' &&
-        event.payload.step === step &&
-        event.payload.attempt === round
-      ) {
-        return event.payload.feedback ?? null
-      }
-    }
-    return null
-  }
-  if (phase === 'implement') {
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-      const event = events[i]!
-      if (event.type === 'implement.started' && event.payload.round === round) {
-        return event.payload.feedback ?? null
-      }
-    }
-    return null
-  }
-  if (phase === 'plan') {
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-      const event = events[i]!
-      if (event.type === 'plan.started' && event.payload.round === round) {
-        if (event.payload.feedback !== undefined) return event.payload.feedback
-        break // legacy start without the field — derive from the prior verdict
-      }
-    }
-    if (round <= 1) return null
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-      const event = events[i]!
-      if (event.type === 'plan-review.verdict' && event.payload.round === round - 1) {
-        return event.payload.verdict === 'revise'
-          ? { findings: event.payload.findings.map((finding) => finding.id) }
-          : null
-      }
-    }
-  }
-  return null
+function currentFeedback(events: CurrentBuildFacts, phase: Phase, round: number): Feedback | null {
+  const explicit = events.feedback[JSON.stringify([phase, round])]
+  return explicit ?? (phase === 'plan' ? (events.planFeedback[String(round)] ?? null) : null)
 }
 
 /** Empty and recreate `.ab/`; callers restore any tracked legacy entries. */
@@ -184,7 +127,7 @@ async function wipeAbDir(abDir: string): Promise<void> {
   await mkdir(abDir, { recursive: true })
 }
 
-function dismissedIds(state: BuildState, events: AbEvent[]): string[] {
+function dismissedIds(state: BuildState, events: CurrentBuildFacts): string[] {
   const known = findingsById(events)
   const ids = new Set<string>()
   for (const escalation of state.answeredEscalations) {
@@ -205,8 +148,8 @@ export async function buildContext(deps: ContextDeps): Promise<ContextManifest>
   const { build, phase, round } = env
   const spec = phaseSpecFor(phase)
   const inputs = spec.inputs
-  const events = await store.getEvents(build)
-  const state = reduceBuild(events)
+  const events = (await readBuildFacts(store, build)).value
+  const state = events.state
 
   // Preserve legacy tracked scratch exactly while replacing disposable files.
   // Some adapter contract fixtures intentionally use a non-Git workspace;
@@ -271,7 +214,7 @@ export async function buildContext(deps: ContextDeps): Promise<ContextManifest>
   }
 
   if (inputs.ticket === true) {
-    const created = events.find((event) => event.type === 'build.created')
+    const created = events.created
     if (created !== undefined && created.type === 'build.created') {
       const original = created.payload.ticket
       const current =
@@ -442,13 +385,8 @@ export async function buildContext(deps: ContextDeps): Promise<ContextManifest>
     // records the execution input in reconcile.started. A crashed same-attempt
     // rerun can therefore have multiple starts; the newest matching AB_PHASE
     // attempt is authoritative.
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-      const event = events[i]!
-      if (event.type === 'reconcile.started' && event.payload.attempt === round) {
-        manifest.conflict = { baseSha: event.payload.baseSha }
-        break
-      }
-    }
+    const baseSha = events.reconcileBases[String(round)]
+    if (baseSha !== undefined) manifest.conflict = { baseSha }
     if (manifest.conflict === undefined) {
       throw new Error(
         `reconcile@${round} context requires a matching reconcile.started event ` +
@@ -488,10 +426,10 @@ export async function buildContext(deps: ContextDeps): Promise<ContextManifest>
   // Legacy tracked scratch is repository debt, not content Autobuild rewrites.
   // Record it once per build from the provisioned base so harvest can groom it.
   if (gitWorkspace && deps.ids !== undefined) {
-    const provisioned = events.find((event) => event.type === 'workspace.provisioned')
+    const provisioned = events.firstWorkspace
     const marker = 'phase-scratch:tracked-at-provisioned-base'
-    const alreadyRecorded = events.some(
-      (event) => event.type === 'observation.recorded' && event.payload.refs?.includes(marker),
+    const alreadyRecorded = events.observations.some((observation) =>
+      observation.refs?.includes(marker),
     )
     if (
       provisioned !== undefined &&

package/packages/core/src/cli/dashboard/model.ts

@@ -1,3 +1,4 @@
+import type { RepositoryReadFacts } from '../../store/reduced-reads'
 /**
  * The dashboard's pure projection: `BuildState` → what the operator sees.
  *
@@ -920,7 +921,7 @@ function escalationAttentionDismissed(events: RepositoryEvent[], terminalSeq: nu
 }
 
 function selectDashboardHarvestRun(
-  events: RepositoryEvent[],
+  events: RepositoryEvent[] | RepositoryReadFacts,
   state: HarvestState,
 ): HarvestRunState | undefined {
   const attention = state.runs.find((run) => {
@@ -928,7 +929,12 @@ function selectDashboardHarvestRun(
       return run.recoveryExhaustion?.attentionAcknowledgedSeq === undefined
     }
     if (run.status !== 'escalated') return false
-    return run.terminalSeq === undefined || !escalationAttentionDismissed(events, run.terminalSeq)
+    return (
+      run.terminalSeq === undefined ||
+      !(Array.isArray(events)
+        ? escalationAttentionDismissed(events, run.terminalSeq)
+        : events.dismissedThrough > run.terminalSeq)
+    )
   })
   return attention ?? openHarvestRun(state)
 }
@@ -937,7 +943,7 @@ function selectDashboardHarvestRun(
  * exhausted, or escalated attention outranks merely open work; completed and
  * acknowledged terminal history never hides an older actionable run. */
 function projectHarvestRun(
-  events: RepositoryEvent[],
+  events: RepositoryEvent[] | RepositoryReadFacts,
   state: HarvestState,
 ): DashboardHarvest | undefined {
   const run = selectDashboardHarvestRun(events, state)
@@ -968,25 +974,27 @@ function projectHarvestRun(
   const approved = run.reviews.some((review) => review.verdict === 'approve')
   const synthOutput = run.proposals.length > 0
   const reviewOutput = run.reviews.length > 0
-  const failedEvent =
-    run.status === 'failed'
-      ? [...events]
-          .reverse()
-          .find(
-            (event) =>
-              event.type === 'harvest.failed' &&
-              event.payload.run === run.run &&
-              event.payload.willRetry === false,
-          )
-      : undefined
+  const failureStoppedAt =
+    run.status !== 'failed'
+      ? undefined
+      : Array.isArray(events)
+        ? [...events]
+            .reverse()
+            .find(
+              (event) =>
+                event.type === 'harvest.failed' &&
+                event.payload.run === run.run &&
+                !event.payload.willRetry,
+            )?.ts
+        : events.failedAt[JSON.stringify(run.run)]
   // Both durable stop states freeze any open occurrence. A failure normally
   // closes its step immediately afterward, but projecting the boundary itself
   // must never make an errored row look like work is still accumulating time.
   const frozenAt =
     state.pausedAt !== undefined
       ? Date.parse(state.pausedAt)
-      : failedEvent !== undefined
-        ? Date.parse(failedEvent.ts)
+      : failureStoppedAt !== undefined
+        ? Date.parse(failureStoppedAt)
         : undefined
   const steps: PipelineStep[] = [
     step('scan', hasOutcome('scan', 'completed'), current('scan'), {
@@ -1073,8 +1081,10 @@ interface RepositoryHarvestProjection {
 /** The repository-journal half of a legacy dashboard frame (AUT-545): the
  * harvest projection and the pause flag exactly as `buildDashboardFromProjected`
  * derives them, exposed for tests that pin the bounded read's equivalence. */
-export function projectRepositoryHarvest(events: RepositoryEvent[]): RepositoryHarvestProjection {
-  const state = reduceHarvest(events)
+export function projectRepositoryHarvest(
+  events: RepositoryEvent[] | RepositoryReadFacts,
+): RepositoryHarvestProjection {
+  const state = Array.isArray(events) ? reduceHarvest(events) : events.harvest
   const harvest = projectHarvestRun(events, state)
   return {
     harvestPaused: state.paused,
@@ -1082,7 +1092,9 @@ export function projectRepositoryHarvest(events: RepositoryEvent[]): RepositoryH
   }
 }
 
-export function projectHarvest(events: RepositoryEvent[]): DashboardHarvest | undefined {
+export function projectHarvest(
+  events: RepositoryEvent[] | RepositoryReadFacts,
+): DashboardHarvest | undefined {
   return projectRepositoryHarvest(events).harvest
 }
 
@@ -1112,11 +1124,13 @@ export interface DashboardHeader extends DashboardFrameHeader {
 export function buildDashboardFromProjected(
   projectedBuilds: readonly DashboardBuild[],
   header: DashboardHeader,
-  repositoryEvents: RepositoryEvent[] = [],
+  repositoryEvents: RepositoryEvent[] | RepositoryReadFacts = [],
 ): DashboardModel {
   const builds = [...projectedBuilds].sort((a, b) => a.slug.localeCompare(b.slug))
   const harvestProjection = projectRepositoryHarvest(repositoryEvents)
-  const settings = reduceDispatchSettings(repositoryEvents)
+  const settings = Array.isArray(repositoryEvents)
+    ? reduceDispatchSettings(repositoryEvents)
+    : repositoryEvents.settings
   return {
     repo: header.repo,
     queued: header.queued,
@@ -1143,7 +1157,7 @@ export function buildDashboard(
   entries: { record: BuildRecord; state: BuildState; events: AbEvent[] }[],
   config: Config,
   header: DashboardFrameHeader,
-  repositoryEvents: RepositoryEvent[] = [],
+  repositoryEvents: RepositoryEvent[] | RepositoryReadFacts = [],
 ): DashboardModel {
   const builds = entries
     .map(({ record, state, events }) => projectBuild(record, state, config, events))

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
         }