@defrex/autobuild 0.13.0 → 0.14.0

package/packages/core/src/cli/publication-settlement.ts

@@ -1,14 +1,8 @@
+import { readBuildFacts } from '../store/reduced-reads'
 import type { IdSource } from '../ids'
 import { DISPATCHER, KERNEL } from '../events/envelope'
 import type { Forge, WorkspacePublication } from '../ports/types'
 import type { Exec } from '../ports/workspace/git-worktree'
-import { openExecution } from '../processes/execution-settlement'
-import {
-  latestUncompletedPublicationRequest,
-  publicationLostRecorded,
-  publicationRequestCompleted,
-  publicationRequestSettled,
-} from '../processes/publication-state'
 import { systemClock, type BuildStore, type Clock } from '../store/types'
 import { completeFinalizePr } from './terminals'
 
@@ -41,11 +35,11 @@ export async function settlePendingPublication(
 ): Promise<void> {
   const publication = deps.publication
   if (publication === undefined) return
-  let events = await deps.store.getEvents(slug)
-  const request = latestUncompletedPublicationRequest(events)
+  let events = (await readBuildFacts(deps.store, slug)).value
+  const request = events.publication.latestUncompletedRequest()
   if (request === undefined) return
 
-  const abandoned = publicationRequestSettled(events, request)
+  const abandoned = events.publication.requestSettled(request)
   // Consulted for every uncompleted request, not only abandoned ones: a guest
   // that pushed its branch before dying is owed its completion fact, not a
   // re-push or a loss record.
@@ -59,7 +53,7 @@ export async function settlePendingPublication(
     // returning silently — the exact drop that lost the validate-hosted-
     // dispatcher generation-1 work. The finalize-step publish-failure path
     // below is unchanged: it already settles loudly via its failed outcome.
-    if (!publicationLostRecorded(events, request)) {
+    if (!events.publication.lostRecorded(request)) {
       await deps.store.append(slug, {
         actor: DISPATCHER,
         type: 'publication.lost',
@@ -85,12 +79,8 @@ export async function settlePendingPublication(
       const leaseLive =
         record?.lease !== undefined &&
         new Date(record.lease.expiresAt).getTime() > clock().getTime()
-      if (openExecution(events) !== null && leaseLive) return
-      let ref: string | undefined
-      for (const event of events) {
-        if (event.type === 'workspace.provisioned') ref = event.payload.ref
-        else if (event.type === 'workspace.released') ref = undefined
-      }
+      if (events.open !== null && leaseLive) return
+      const ref = events.workspace?.ref
       if (ref === undefined)
         throw new Error(`build ${slug} has a publication request but no open workspace`)
       await publication.publish({ ref, sha: request.payload.sha, branch: request.payload.branch })
@@ -115,8 +105,8 @@ export async function settlePendingPublication(
     })
     return
   }
-  events = await deps.store.getEvents(slug)
-  if (publicationRequestCompleted(events, request)) return
+  events = (await readBuildFacts(deps.store, slug)).value
+  if (events.publication.requestCompleted(request)) return
 
   if (request.payload.operation === 'implement') {
     await deps.store.append(slug, {
@@ -157,7 +147,7 @@ export async function settlePendingPublication(
   const newline = text.indexOf('\n')
   const title = (newline === -1 ? text : text.slice(0, newline)).replace(/^#+\s*/, '').trim()
   if (title === '') throw new Error(`empty PR title for ${slug}`)
-  const created = events.findLast((event) => event.type === 'build.created')
+  const created = events.lastCreated
   if (created?.type !== 'build.created') throw new Error(`missing build.created for ${slug}`)
 
   await completeFinalizePr(

package/packages/core/src/cli/repository-status.ts

@@ -1,3 +1,4 @@
+import { readRepositoryFacts, type RepositoryReadFacts } from '../store/reduced-reads'
 import {
   formatDispatcherIdentity,
   projectDispatcherLiveness,
@@ -99,6 +100,37 @@ export function projectRepositoryStatus(
   }
 }
 
+export function repositoryStatusFromFacts(
+  repo: string,
+  facts: RepositoryReadFacts,
+  dispatcher: DispatcherLiveness,
+): RepositoryStatus {
+  return {
+    repo,
+    dispatcher,
+    ...facts.settings,
+    ...(facts.health === undefined ? {} : { ticketSourceDegradation: facts.health }),
+    sandboxes: facts.sandboxes
+      .filter((state) => state.state !== 'released')
+      .map((state) => ({
+        operator: state.operator,
+        environmentId: state.environmentId,
+        provider: state.provider,
+        state: state.state === 'stopped' ? ('stopped' as const) : ('live' as const),
+        lastEvidenceAt: state.lastEvidenceTs,
+      })),
+    publications: [...facts.publications].reverse().map((event) => ({
+      operator: event.payload.operator,
+      branch: event.payload.branch,
+      sha: event.payload.sha,
+      prNumber: event.payload.pr.number,
+      prUrl: event.payload.pr.url,
+      ...(event.payload.session !== undefined ? { session: event.payload.session } : {}),
+      at: event.ts,
+    })),
+  }
+}
+
 export function renderRepositoryStatus(status: RepositoryStatus): string[] {
   const setting = (enabled: boolean): string => (enabled ? 'ON' : 'OFF')
   const active = status.ticketSourceDegradation
@@ -147,8 +179,12 @@ export async function abRepositoryStatus(opts: RepositoryStatusOpts): Promise<vo
   await withSessionlessStore(opts, async ({ store, repo }) => {
     // A fresh store has no repository row. Do not call ensureRepo: this query's
     // empty-stream defaults must remain a genuinely read-only operation.
-    const { events, dispatcher } = await readDispatcherLiveness(store, repo, opts.now?.())
-    const status = projectRepositoryStatus(repo, events, dispatcher)
+    const { dispatcher } = await readDispatcherLiveness(store, repo, opts.now?.())
+    const status = repositoryStatusFromFacts(
+      repo,
+      (await readRepositoryFacts(store, repo)).value,
+      dispatcher,
+    )
     if (opts.json === true) {
       opts.stdout(JSON.stringify(status, null, 2))
       return

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

@@ -1,3 +1,6 @@
+import { readBuildDigests } from '../store/reduced-reads'
+import { readBuildFacts } from '../store/reduced-reads'
+import type { BuildFacts } from '../processes/repo-view'
 /**
  * `ab builds` and `ab build status <slug>` — the read-only query surface on
  * build state (SPEC §8.2, §15.5). Their invocation forms require no session,
@@ -44,9 +47,9 @@ import {
 } from '../processes/build-execution-state'
 import type { PipelineSourceMeta } from '../config/pipeline-source'
 import { openExecution } from '../processes/execution-settlement'
-import { currentAutoMergeDeferral } from '../kernel/auto-merge'
+import { currentAutoMergeDeferralFrom } from '../kernel/auto-merge'
 import { autoMergeDisplay, type AutoMergeDisplay } from './dashboard/model'
-import { decideNext } from '../kernel/engine'
+import { decideNextFromFacts } from '../kernel/engine'
 import {
   reduceBuild,
   type BuildState,
@@ -271,7 +274,31 @@ export function detail(
   decision?: BuildDecisionProjection,
   streams?: readonly StreamRecord[],
 ): BuildDetail {
-  const state = reduceBuild(events)
+  return detailFromFacts(
+    record,
+    {
+      state: reduceBuild(events),
+      observations: events
+        .filter((event) => event.type === 'observation.recorded')
+        .map((event) => event.payload),
+      open: openExecution(events),
+    },
+    now,
+    eventCount === undefined ? undefined : events.slice(-eventCount),
+    decision,
+    streams,
+  )
+}
+
+export function detailFromFacts(
+  record: BuildRecord,
+  facts: Pick<BuildFacts, 'state' | 'open'> & { observations: BuildState['observations'] },
+  now: Date,
+  events?: AbEvent[],
+  decision?: BuildDecisionProjection,
+  streams?: readonly StreamRecord[],
+): BuildDetail {
+  const state = facts.state
   const streamStatus = new Map<string, { stream?: string; status: 'open' | 'closed' }>()
   if (streams !== undefined) {
     for (const record of streams) {
@@ -316,15 +343,13 @@ export function detail(
     }),
     // Observations are historical facts rather than a derived current-state
     // opinion. Preserve event order and exact optional evidence fields.
-    observations: events
-      .filter((event) => event.type === 'observation.recorded')
-      .map((event) => ({
-        id: event.payload.id,
-        kind: event.payload.kind,
-        summary: event.payload.summary,
-        ...(event.payload.files !== undefined ? { files: event.payload.files } : {}),
-        ...(event.payload.refs !== undefined ? { refs: event.payload.refs } : {}),
-      })),
+    observations: facts.observations.map((observation) => ({
+      id: observation.id,
+      kind: observation.kind,
+      summary: observation.summary,
+      ...(observation.files !== undefined ? { files: observation.files } : {}),
+      ...(observation.refs !== undefined ? { refs: observation.refs } : {}),
+    })),
     ...(state.setupFailure !== undefined
       ? {
           setupFailure: {
@@ -338,7 +363,7 @@ export function detail(
     ...(state.executions.at(-1) !== undefined ? { execution: state.executions.at(-1)! } : {}),
     // Durable supervision: a recorded execution with no following end is the
     // source of truth for whether a guest may still be running.
-    executionOpen: openExecution(events) !== null,
+    executionOpen: facts.open !== null,
     ...(state.infrastructureFailure !== undefined
       ? { infrastructureFailure: state.infrastructureFailure }
       : {}),
@@ -364,7 +389,7 @@ export function detail(
       : {}),
     // getEvents returns seq-ordered events, so the newest n slice out already
     // chronological — which is what the AC asks for.
-    ...(eventCount !== undefined ? { events: events.slice(-eventCount) } : {}),
+    ...(events !== undefined ? { events } : {}),
     ...(state.outcome !== undefined ? { outcome: state.outcome } : {}),
   }
 }
@@ -742,7 +767,7 @@ export async function abBuilds(opts: AbBuildsOpts): Promise<void> {
     // round trip and the listing's store cost stays flat as finished builds
     // accumulate. The `--all` scope includes terminal statuses, so it takes no
     // digest read and skips nothing — byte-for-byte the old loop.
-    const digests = opts.all === true ? undefined : await store.getRepoBuildDigests(identity)
+    const digests = opts.all === true ? undefined : await readBuildDigests(store, identity)
     const summaries: BuildSummary[] = []
     for (const record of records) {
       if (digests !== undefined && record.repo === identity) {
@@ -766,7 +791,11 @@ export async function abBuilds(opts: AbBuildsOpts): Promise<void> {
       // entry under `identity` — `getRepoBuildDigests` groups by `record.repo`
       // exactly — so it keeps its per-build history read (correct, just not
       // accelerated).
-      const summary = summarize(record, await store.getEvents(record.slug), now)
+      const summary = summarizeFrom(
+        record,
+        (await readBuildFacts(store, record.slug)).value.state,
+        now,
+      )
       if (wanted.has(summary.status)) summaries.push(summary)
     }
     summaries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
@@ -797,7 +826,7 @@ export interface AbBuildStatusOpts extends StatusOpts {
   events?: number
 }
 
-function openWorkspacePath(events: AbEvent[]): string | undefined {
+function _openWorkspacePath(events: AbEvent[]): string | undefined {
   let path: string | undefined
   for (const event of events) {
     if (event.type === 'workspace.provisioned') {
@@ -812,15 +841,11 @@ function openWorkspacePath(events: AbEvent[]): string | undefined {
 /** The kernel tail both config sources share, so the deposited artifact and
  * the workspace file cannot drift in what they compute — the sources differ
  * only in where the config comes from, never in what is decided with it. */
-function decideFromConfig(
-  events: AbEvent[],
-  state: BuildState,
-  config: Config,
-): BuildDecisionProjection {
-  const decision = decideNext(events, config)
+function decideFromConfig(facts: BuildFacts, config: Config): BuildDecisionProjection {
+  const decision = decideNextFromFacts(facts.state, facts.log, config)
   if (decision.kind !== 'wait') return { kind: 'runner-work' }
   if (decision.reason !== 'awaiting-pr') return { kind: 'parked', reason: decision.reason }
-  const reason = currentAutoMergeDeferral(events, state)
+  const reason = currentAutoMergeDeferralFrom(facts.deferral, facts.state)
   return { kind: 'awaiting-pr', ...(reason !== undefined ? { reason } : {}) }
 }
 
@@ -840,10 +865,10 @@ function decideFromConfig(
  * the read-only command fail. */
 async function projectBuildDecision(
   slug: string,
-  events: AbEvent[],
+  facts: BuildFacts,
   store: Pick<BuildStore, 'getArtifact'>,
 ): Promise<BuildDecisionProjection | undefined> {
-  const state = reduceBuild(events)
+  const state = facts.state
   const active =
     state.status === 'running' || state.status === 'paused' || state.status === 'blocked'
   if (!active) return undefined
@@ -858,7 +883,7 @@ async function projectBuildDecision(
   const artifact = await store.getArtifact(slug, BUILD_EFFECTIVE_CONFIG_ARTIFACT)
   if (artifact !== null) {
     try {
-      return decideFromConfig(events, state, parseEffectiveBuildConfig(artifact))
+      return decideFromConfig(facts, parseEffectiveBuildConfig(artifact))
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
       return {
@@ -870,7 +895,7 @@ async function projectBuildDecision(
 
   // Source 2 — the local workspace, exactly as before, only when no artifact
   // is deposited.
-  const workspace = openWorkspacePath(events)
+  const workspace = facts.workspace?.path ?? facts.workspace?.ref
   if (workspace === undefined) {
     return {
       kind: 'unavailable',
@@ -879,7 +904,7 @@ async function projectBuildDecision(
   }
 
   try {
-    return decideFromConfig(events, state, await loadConfig(join(workspace, 'autobuild.toml')))
+    return decideFromConfig(facts, await loadConfig(join(workspace, 'autobuild.toml')))
   } catch {
     // The raw error deliberately stays here: ENOENT/ENOTDIR messages embed the
     // recorded workspace path, which for a remote build is a guest location.
@@ -944,8 +969,13 @@ export async function abBuildStatus(opts: AbBuildStatusOpts): Promise<void> {
   const now = (opts.now ?? (() => new Date()))()
   await withAmbientReadStore(opts, async (context) => {
     const record = await requireReadableBuild(opts, context)
-    const events = await context.store.getEvents(opts.slug)
-    const decision = await projectBuildDecision(opts.slug, events, context.store)
+    const current = await readBuildFacts(context.store, opts.slug)
+    const facts = current.value
+    const events =
+      opts.events === undefined
+        ? undefined
+        : await context.store.getEvents(opts.slug, Math.max(0, current.cursor - opts.events))
+    const decision = await projectBuildDecision(opts.slug, facts, context.store)
     // Stream enrichment is presentation (SPEC §9): an unavailable read
     // degrades to payload-carried ids without a status, never a failure.
     let streams: StreamRecord[] | undefined
@@ -957,7 +987,7 @@ export async function abBuildStatus(opts: AbBuildStatusOpts): Promise<void> {
     } catch {
       streams = undefined
     }
-    const projected = detail(record, events, now, opts.events, decision, streams)
+    const projected = detailFromFacts(record, facts, now, events, decision, streams)
     // Operator visibility (SPEC §16.1): which autobuild.toml the build's
     // pinned pipeline came from, alongside the effective-config revision.
     const configArtifact = await context.store.getArtifact(

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

@@ -1,3 +1,4 @@
+import { readBuildFacts, readTerminalGuard, type CurrentBuildFacts } from '../store/reduced-reads'
 /**
  * The three terminal commands — `ab done`, `ab verdict`, `ab escalate`
  * (SPEC §8.4 D5, §8.5 D6, §8.6 D7).
@@ -18,7 +19,7 @@
 import { join } from 'node:path'
 import { z } from 'zod'
 import { loadConfig } from '../config/load'
-import type { AbEvent, EventEnvelope } from '../events/catalog'
+import type { EventEnvelope } from '../events/catalog'
 import { agentActor, KERNEL } from '../events/envelope'
 import { isRemoteWorkspace } from '../events/workspace-remote'
 import type { IdSource } from '../ids'
@@ -29,7 +30,6 @@ import {
 } from '../kernel/auto-merge'
 import { phaseSpecFor } from '../kernel/phases'
 import { resolvePlanVerifySteps } from '../kernel/plan-verify-selection'
-import { reduceBuild } from '../kernel/reducer'
 import {
   findingDraftSchema,
   isVerifyPhase,
@@ -75,114 +75,9 @@ export interface TerminalDeps {
  * round, so a still-in-flight CLI process from the failed session must not
  * land a terminal the runner will misattribute to the retry).
  */
-function assertNoPriorTerminal(events: AbEvent[], env: CliEnv): void {
-  const spec = phaseSpecFor(env.phase)
-  // §6.3 restart boundary: verify attempts and finalize completion RESET
-  // across a spec.revised (decideNext ignores pre-restart results and
-  // re-runs the pipeline from plan), so a pre-restart verify.completed or
-  // finalize.completed must not shadow the rebuilt pipeline's terminal.
-  // Loop-phase rounds continue monotonically across restarts (engine
-  // LoopIndex.maxRoundEver) and never collide, so they match over the full
-  // log; the reconcile epilogue is restart-orthogonal (§15.7).
-  let restartSeq = 0
-  for (const event of events) {
-    if (event.type === 'spec.revised') restartSeq = event.seq
-  }
-  // reconcile.completed carries no attempt (§15.3); pair it with the latest
-  // reconcile.started seen before it.
-  let reconcileAttempt = 0
-  let sessionStartedSeq: number | undefined
-  for (const event of events) {
-    if (event.type === 'reconcile.started') reconcileAttempt = event.payload.attempt
-    if (event.type === 'session.started' && event.payload.session === env.session) {
-      sessionStartedSeq = event.seq
-    }
-    if (event.type === 'session.ended' && event.payload.session === env.session) {
-      throw new Error(
-        `terminal rejected (D5): session "${env.session}" already ended ` +
-          `(session.ended at seq ${event.seq}) — a session that ended without ` +
-          'a terminal was failed and retried; only the live retry may complete ' +
-          'this phase round (§8.4).',
-      )
-    }
-    if (
-      sessionStartedSeq !== undefined &&
-      event.type === 'phase.failed' &&
-      event.payload.phase === env.phase &&
-      event.payload.round === env.round &&
-      event.seq > sessionStartedSeq
-    ) {
-      throw new Error(
-        `terminal rejected (D5): ${env.phase}@${env.round} already failed after ` +
-          `this session started (phase.failed at seq ${event.seq}) — the retry ` +
-          'session owns this round now (§8.4).',
-      )
-    }
-    if (
-      event.type === 'escalation.raised' &&
-      event.actor.kind === 'agent' &&
-      event.actor.session === env.session
-    ) {
-      throw new Error(
-        `second terminal call rejected (D5): this session already escalated — ` +
-          `escalation.raised "${event.payload.id}" at seq ${event.seq}. ` +
-          'Every phase ends with exactly one terminal command (§8.4).',
-      )
-    }
-    if (
-      event.type === 'publication.requested' &&
-      event.actor.kind === 'agent' &&
-      event.actor.session === env.session &&
-      ((env.phase === 'implement' &&
-        event.payload.operation === 'implement' &&
-        event.payload.round === env.round) ||
-        (env.phase === 'reconcile' && event.payload.operation === 'reconcile') ||
-        (env.phase === 'finalize' && event.payload.operation === 'finalize'))
-    ) {
-      throw new Error(
-        `second terminal call rejected (D5): ${event.type} for ` +
-          `${env.phase}@${env.round} already recorded at seq ${event.seq}. ` +
-          'Remote publication is pending; do not run ab done again (§8.4).',
-      )
-    }
-    if (event.type !== spec.terminalEvent) continue
-    if (
-      (event.type === 'verify.completed' || event.type === 'finalize.completed') &&
-      event.seq <= restartSeq
-    ) {
-      continue
-    }
-    if (!terminalMatchesRound(event, env, reconcileAttempt)) continue
-    throw new Error(
-      `second terminal call rejected (D5): ${event.type} for ` +
-        `${env.phase}@${env.round} already recorded at seq ${event.seq}. ` +
-        'Every phase ends with exactly one terminal command (§8.4).',
-    )
-  }
-}
-
-function terminalMatchesRound(event: AbEvent, env: CliEnv, reconcileAttempt: number): boolean {
-  switch (event.type) {
-    case 'plan.completed':
-    case 'plan-review.verdict':
-    case 'implement.completed':
-    case 'code-review.verdict':
-      return event.payload.round === env.round
-    case 'verify.completed':
-      return (
-        isVerifyPhase(env.phase) &&
-        event.payload.step === verifyStep(env.phase) &&
-        event.payload.attempt === env.round
-      )
-    case 'finalize.completed':
-      // finalize runs once per build (§5) — any prior completion counts.
-      return true
-    case 'reconcile.completed':
-      // No started event before it → conservative match (total over any log).
-      return reconcileAttempt === env.round || reconcileAttempt === 0
-    default:
-      return false
-  }
+async function assertNoPriorTerminal(store: BuildStore, env: CliEnv): Promise<void> {
+  const result = await readTerminalGuard(store, env.build, env.phase, env.round, env.session)
+  if (result.diagnostic) throw new Error(result.diagnostic)
 }
 
 // ── Small helpers ────────────────────────────────────────────────────────────
@@ -240,28 +135,21 @@ async function assertCleanWorktree(deps: TerminalDeps): Promise<void> {
   }
 }
 
-function baseBranchOf(events: AbEvent[]): string {
-  for (const event of events) {
-    if (event.type === 'build.created') return event.payload.baseBranch
-  }
+function baseBranchOf(events: CurrentBuildFacts): string {
+  if (events.created) return events.created.payload.baseBranch
   throw new Error('this build has no build.created event — cannot resolve its baseBranch (§15.3)')
 }
 
-function requireImplementationProvisioning(events: AbEvent[]): void {
-  if (events.some((event) => event.type === 'workspace.provisioned')) return
+function requireImplementationProvisioning(events: CurrentBuildFacts): void {
+  if (events.workspaceGenerations > 0) return
   throw new Error(
     "implement's 'ab done' requires workspace.provisioned provenance — " +
       'this build has no workspace.provisioned event (§7.4, §15.3)',
   )
 }
 
-function remotePublication(events: readonly AbEvent[]): boolean {
-  let remote = false
-  for (const event of events) {
-    if (event.type === 'workspace.provisioned') remote = isRemoteWorkspace(event.payload)
-    else if (event.type === 'workspace.released') remote = false
-  }
-  return remote
+function remotePublication(events: CurrentBuildFacts): boolean {
+  return events.workspace !== null && isRemoteWorkspace(events.workspace)
 }
 
 async function buildBranch(deps: TerminalDeps): Promise<string> {
@@ -281,7 +169,7 @@ async function buildBranch(deps: TerminalDeps): Promise<string> {
  */
 async function implementationReviewBoundary(
   deps: TerminalDeps,
-  events: AbEvent[],
+  events: CurrentBuildFacts,
 ): Promise<{ branch: string; base: string; head: string }> {
   const diagnostic = 'cannot establish implementation review boundary'
   try {
@@ -384,7 +272,7 @@ export interface FinalizePrInput {
  * requested head before entering this idempotent PR-side sequence. */
 export async function completeFinalizePr(
   deps: TerminalDeps,
-  events: AbEvent[],
+  events: CurrentBuildFacts,
   input: FinalizePrInput,
 ): Promise<EventEnvelope> {
   const { env, store } = deps
@@ -404,8 +292,8 @@ export async function completeFinalizePr(
 
   await preparePrAttachments(deps, events, pr.url)
 
-  const latest = await store.getEvents(env.build)
-  const autoMerge = pendingAutoMerge(reduceBuild(latest))
+  const latest = (await readBuildFacts(store, env.build)).value
+  const autoMerge = pendingAutoMerge(latest.state)
   const autoMergeResult =
     autoMerge === undefined
       ? undefined
@@ -452,8 +340,8 @@ export async function done(deps: TerminalDeps, opts: DoneOpts = {}): Promise<Eve
         `${spec.kind} phase; use 'ab verdict' (§8.2)`,
     )
   }
-  const events = await store.getEvents(env.build)
-  assertNoPriorTerminal(events, env)
+  const events = (await readBuildFacts(store, env.build)).value
+  await assertNoPriorTerminal(store, env)
   const actor = agentActor(env.phase, env.session)
 
   switch (spec.name) {
@@ -466,12 +354,7 @@ export async function done(deps: TerminalDeps, opts: DoneOpts = {}): Promise<Eve
       // still the already-reviewed plan, re-entering review as if revised.
       const revs = await store.listArtifacts(env.build, 'plan')
       const latest = revs[revs.length - 1]
-      let lastCited = -1
-      for (const event of events) {
-        if (event.type === 'plan.completed') {
-          lastCited = Math.max(lastCited, event.payload.artifact.rev)
-        }
-      }
+      const lastCited = events.maxPlanRevision
       if (latest === undefined || latest.revision <= lastCited) {
         throw new Error(
           `plan@${env.round} 'ab done' requires this round's plan deposit: found ` +
@@ -704,8 +587,8 @@ export async function verdict(deps: TerminalDeps, opts: VerdictOpts): Promise<Ev
         `accept pass|fail|skip. ${env.phase} accepts: ${vocabulary.join('|')}`,
     )
   }
-  const events = await store.getEvents(env.build)
-  assertNoPriorTerminal(events, env)
+  const events = (await readBuildFacts(store, env.build)).value
+  await assertNoPriorTerminal(store, env)
   const actor = agentActor(env.phase, env.session)
 
   if (spec.kind === 'agent-verify') {
@@ -717,7 +600,7 @@ export async function verdict(deps: TerminalDeps, opts: VerdictOpts): Promise<Ev
 async function reviewVerdict(
   deps: TerminalDeps,
   opts: VerdictOpts,
-  events: AbEvent[],
+  events: CurrentBuildFacts,
   actor: ReturnType<typeof agentActor>,
 ): Promise<EventEnvelope[]> {
   const { env, store } = deps
@@ -816,7 +699,7 @@ export function renderFindingsIssues(issues: readonly z.core.$ZodIssue[]): strin
 async function parseFindings(
   deps: TerminalDeps,
   path: string,
-  events: AbEvent[],
+  events: CurrentBuildFacts,
 ): Promise<Finding[]> {
   const raw = await readTextFile(path, '--findings')
   let json: unknown
@@ -841,7 +724,7 @@ async function parseFindings(
   // `persists` may only reference ids from prior rounds of THIS loop (§15.4;
   // ids are deposit-stamped, so a reviewer can only ever see rounds it was
   // shown — §8.3).
-  const state = reduceBuild(events)
+  const state = events.state
   const loop =
     deps.env.phase === 'plan-review'
       ? state.reviewFindings.planReview
@@ -969,8 +852,8 @@ export async function escalate(
   if (opts.question.trim() === '') {
     throw new Error("'ab escalate' requires a question — it is what the human answers (§11)")
   }
-  const events = await store.getEvents(env.build)
-  assertNoPriorTerminal(events, env)
+  const _events = (await readBuildFacts(store, env.build)).value
+  await assertNoPriorTerminal(store, env)
   return store.append(env.build, {
     actor: agentActor(env.phase, env.session),
     type: 'escalation.raised',

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

@@ -1,3 +1,4 @@
+import { readBuildFacts } from '../store/reduced-reads'
 import { exportTickets, importTickets } from '../ports/tickets/migration'
 import { composeTicketAssets } from '../store/ticket-assets'
 import { editTicket, type TicketEditorRunner } from './ticket-editor'
@@ -29,7 +30,6 @@ import type {
   TicketStateInfo,
   TicketUpdate,
 } from '../ports/types'
-import { reduceBuild } from '../kernel/reducer'
 import type { BuildStore } from '../store/types'
 import { spawnExec, type Exec } from '../ports/workspace/git-worktree'
 import type { TicketAssetSummary } from '../store/ticket-assets'
@@ -478,7 +478,7 @@ async function activeBuildsFor(store: BuildStore, repo: string, id: string): Pro
     const active: string[] = []
     for (const record of await store.listBuilds()) {
       if (record.repo !== repo || record.ticket?.id !== id) continue
-      const { status } = reduceBuild(await store.getEvents(record.slug))
+      const { status } = (await readBuildFacts(store, record.slug)).value.state
       if (status !== 'done' && status !== 'aborted') active.push(record.slug)
     }
     return active