@defrex/autobuild 0.13.0 → 0.14.0

package/packages/core/src/cli/dispatcher-liveness.ts

@@ -1,30 +1,30 @@
+import { readRepositoryFacts, readDispatcherRunFacts } from '../store/reduced-reads'
 import type { RepositoryEvent } from '../events/repository'
 import type { BuildStore, RepositoryRecord } from '../store/types'
 import { formatDispatcherIdentity, projectDispatcherLiveness } from '../kernel/dispatcher-liveness'
 
-/** Bounded first; a later yielding invocation can hide the owner's identity or
- * an earlier stop. Only this correlation query falls back to full history. */
+/** Correlate only the latest, stopped and lease-holder runs through persisted values. */
 export async function readDispatcherLiveness(
   store: BuildStore,
   repo: string,
   now = new Date(),
-  subset?: RepositoryEvent[],
+  _subset?: RepositoryEvent[],
 ) {
   const record = await store.getRepo(repo)
-  let events = record === null ? [] : (subset ?? (await store.getRepoStateEvents(repo)))
-  const bounded = projectDispatcherLiveness(record, events, now)
-  if (
-    record &&
-    ((record.lease &&
-      !events.some(
-        (e) => e.type === 'dispatcher.run-started' && e.payload.run === record.lease!.holder,
-      )) ||
-      (bounded.state !== 'held' &&
-        events.some((e) => e.type === 'dispatcher.run-started') &&
-        !events.some((e) => e.type === 'dispatcher.run-stopped')))
-  ) {
-    events = await store.getRepoEvents(repo)
-  }
+  const facts = record === null ? undefined : (await readRepositoryFacts(store, repo)).value
+  const runs = new Set(
+    [facts?.latestRun, facts?.latestStoppedRun, record?.lease?.holder].filter(
+      (run): run is string => run !== undefined,
+    ),
+  )
+  const correlations = await Promise.all(
+    [...runs].map(async (run) => (await readDispatcherRunFacts(store, repo, run)).value),
+  )
+  const events = correlations.flatMap((run) =>
+    [run.start, run.latestStart, run.stop, run.tick].filter(
+      (event): event is RepositoryEvent => event !== undefined,
+    ),
+  )
   return { record, events, dispatcher: projectDispatcherLiveness(record, events, now) }
 }
 
@@ -39,6 +39,10 @@ export class StandbyIdentityResolver {
   constructor(
     private readonly store: BuildStore,
     private readonly repo: string,
+    private readonly history?: {
+      allowLookup: () => boolean
+      remember: (events: RepositoryEvent[], complete: boolean) => void
+    },
   ) {}
 
   ingest(events: readonly RepositoryEvent[]): void {
@@ -51,11 +55,14 @@ export class StandbyIdentityResolver {
     const pending = this.pending.get(holder)
     if (pending !== undefined) return pending
     if (this.starts.has(holder) || this.attempted.has(holder)) return
+    if (this.history && !this.history.allowLookup()) return
     this.attempted.add(holder)
     const lookup = (async () => {
       try {
-        this.ingest(await this.store.getRepoStateEvents(this.repo))
-        if (!this.starts.has(holder)) this.ingest(await this.store.getRepoEvents(this.repo, 0))
+        const facts = (await readDispatcherRunFacts(this.store, this.repo, holder)).value
+        this.ingest(facts.start ? [facts.start] : [])
+        const complete = false // This lookup correlates one holder, not the complete journal.
+        this.history?.remember([...this.starts.values()], complete)
       } catch {
         // Identity is best effort; the sampled holder id remains sufficient.
       }

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

@@ -1,3 +1,4 @@
+import { readRepositoryFacts, type RepositoryReadFacts } from '../store/reduced-reads'
 /** Typed agent/operator surface for repository-scoped harvest workflows. Agent
  * stdout is never interpreted: proposal sets and review verdicts land through
  * this module as validated repository events and versioned artifacts. */
@@ -67,8 +68,8 @@ async function writeJson(path: string, value: unknown): Promise<void> {
   await writeFile(path, `${JSON.stringify(value, null, 2)}\n`)
 }
 
-function runForEnv(events: RepositoryEvent[], env: HarvestCliEnv): HarvestRunState {
-  const run = reduceHarvest(events).runs.find((candidate) => candidate.run === env.run)
+function runForEnv(events: RepositoryReadFacts, env: HarvestCliEnv): HarvestRunState {
+  const run = events.harvest.runs.find((candidate) => candidate.run === env.run)
   if (!run) throw new Error(`unknown harvest run "${env.run}" in repo "${env.repo}"`)
   if (run.status !== 'running') {
     throw new Error(
@@ -78,34 +79,44 @@ function runForEnv(events: RepositoryEvent[], env: HarvestCliEnv): HarvestRunSta
   return run
 }
 
-function assertNoSessionTerminal(events: RepositoryEvent[], env: HarvestCliEnv): void {
-  for (const event of events) {
-    if (
-      event.type === 'harvest.proposals.submitted' &&
-      env.phase === 'synthesize' &&
-      event.payload.run === env.run &&
-      event.payload.round === env.round
-    ) {
-      throw new Error(
-        `second harvest terminal rejected: proposals for ${env.run} synthesize@${env.round} already landed at repo seq ${event.seq}`,
-      )
-    }
-    if (
-      event.type === 'harvest.review.verdict' &&
-      env.phase === 'review' &&
-      event.payload.run === env.run &&
-      event.payload.round === env.round
-    ) {
-      throw new Error(
-        `second harvest terminal rejected: verdict for ${env.run} review@${env.round} already landed at repo seq ${event.seq}`,
-      )
-    }
-    if (event.type === 'harvest.session.ended' && event.payload.session === env.session) {
-      throw new Error(
-        `harvest terminal rejected: session "${env.session}" already ended at repo seq ${event.seq}`,
-      )
-    }
-  }
+function assertNoSessionTerminal(events: RepositoryReadFacts, env: HarvestCliEnv): void {
+  const run = events.harvest.runs.find((run) => run.run === env.run)
+  const proposal =
+    env.phase === 'synthesize'
+      ? run?.proposals.find((proposal) => proposal.round === env.round)
+      : undefined
+  const review =
+    env.phase === 'review'
+      ? events.harvestVerdicts[JSON.stringify([env.run, env.round])]?.first
+      : undefined
+  const ended = events.harvestSessionEndings[JSON.stringify(env.session)]
+  const errors = [
+    ...(proposal
+      ? [
+          {
+            seq: proposal.seq,
+            message: `second harvest terminal rejected: proposals for ${env.run} synthesize@${env.round} already landed at repo seq ${proposal.seq}`,
+          },
+        ]
+      : []),
+    ...(review
+      ? [
+          {
+            seq: review.seq,
+            message: `second harvest terminal rejected: verdict for ${env.run} review@${env.round} already landed at repo seq ${review.seq}`,
+          },
+        ]
+      : []),
+    ...(ended
+      ? [
+          {
+            seq: ended,
+            message: `harvest terminal rejected: session "${env.session}" already ended at repo seq ${ended}`,
+          },
+        ]
+      : []),
+  ].sort((a, b) => a.seq - b.seq)
+  if (errors[0]) throw new Error(errors[0].message)
 }
 
 async function readArtifactJson(
@@ -122,7 +133,7 @@ async function readArtifactJson(
 export async function buildHarvestContext(deps: HarvestCliDeps): Promise<HarvestContextManifest> {
   const { store, env, workspacePath } = deps
   // Bounded read (AUT-489): runForEnv reduces harvest facts only.
-  const events = await store.getRepoStateEvents(env.repo)
+  const events = (await readRepositoryFacts(store, env.repo)).value
   const run = runForEnv(events, env)
   const packet = await loadScanPacket(store, env.repo, run.scan)
   const abDir = join(workspacePath, '.ab')
@@ -230,7 +241,7 @@ export async function submitHarvestProposals(
   }
   // Bounded read (AUT-489): runForEnv and assertNoSessionTerminal consume
   // harvest facts only.
-  const events = await store.getRepoStateEvents(env.repo)
+  const events = (await readRepositoryFacts(store, env.repo)).value
   const run = runForEnv(events, env)
   assertNoSessionTerminal(events, env)
 
@@ -322,7 +333,7 @@ export async function submitHarvestVerdict(
   }
   // Bounded read (AUT-489): runForEnv and assertNoSessionTerminal consume
   // harvest facts only.
-  const events = await store.getRepoStateEvents(env.repo)
+  const events = (await readRepositoryFacts(store, env.repo)).value
   const run = runForEnv(events, env)
   assertNoSessionTerminal(events, env)
   if (proposalArtifactForRound(run, env.round) === undefined) {
@@ -602,19 +613,35 @@ function projectHarvestRunStatus(run: HarvestRunState): Omit<HarvestRunStatusVie
 
 export function projectHarvestStatus(
   repo: string,
-  events: RepositoryEvent[],
+  events: RepositoryEvent[] | RepositoryReadFacts,
   newestEvents?: number,
   streams?: readonly StreamRecord[],
 ): HarvestStatusView {
-  const state = reduceHarvest(events)
+  const state = Array.isArray(events) ? reduceHarvest(events) : events.harvest
   const history =
-    newestEvents === undefined ? undefined : events.filter(isHarvestEvent).slice(-newestEvents)
+    newestEvents === undefined || !Array.isArray(events)
+      ? undefined
+      : events.filter(isHarvestEvent).slice(-newestEvents)
   const unresolved = [...parkedHarvestRuns(state), ...unresolvedHarvestAttentionRuns(state)]
   const open = openHarvestRuns(state)
   const included = new Set(
     [...unresolved, ...open, ...(state.latest ? [state.latest] : [])].map((run) => run.run),
   )
-  const sessionsByRun = projectHarvestSessions(events, streams)
+  const sessionsByRun = Array.isArray(events)
+    ? projectHarvestSessions(events, streams)
+    : new Map<string, HarvestSessionStatusView[]>()
+  if (!Array.isArray(events))
+    for (const { run, ...session } of events.harvestSessions) {
+      const record = streams?.find(
+        (record) => record.scope.kind === 'repo' && record.label === `session:${session.session}`,
+      )
+      const list = sessionsByRun.get(run) ?? []
+      list.push({
+        ...session,
+        ...(record ? { stream: record.id, streamStatus: record.status } : {}),
+      })
+      sessionsByRun.set(run, list)
+    }
   const runs = state.runs
     .filter((run) => included.has(run.run))
     .map((run) => ({
@@ -802,7 +829,7 @@ export async function abHarvestStatus(opts: HarvestStatusOpts): Promise<void> {
     async ({ store, repo }) => {
       const record = await store.getRepo(repo)
       // Bounded read (AUT-489): projectHarvestStatus reduces harvest facts only.
-      const events = record === null ? [] : await store.getRepoStateEvents(repo)
+      const events = (await readRepositoryFacts(store, repo)).value
       // Best-effort stream enrichment for the session rows, mirroring the
       // degrade-gracefully pattern of 'ab build status': a store that cannot
       // list streams keeps the payload-derived projection instead of failing.
@@ -814,7 +841,12 @@ export async function abHarvestStatus(opts: HarvestStatusOpts): Promise<void> {
           streams = undefined
         }
       }
-      const view = projectHarvestStatus(repo, events, opts.events, streams)
+      const view = projectHarvestStatus(repo, events, undefined, streams)
+      if (opts.events !== undefined)
+        view.events =
+          record === null
+            ? []
+            : (await store.getRepoEvents(repo)).filter(isHarvestEvent).slice(-opts.events)
       if (opts.json === true) opts.stdout(JSON.stringify(view, null, 2))
       else for (const line of renderHarvestStatus(view)) opts.stdout(line)
     },

package/packages/core/src/cli/historical-build-state.ts

@@ -0,0 +1,27 @@
+import type { BuildStore } from '../store/types'
+import { buildStreamSeedReducer, type BuildStreamSeed } from '../kernel/read-facts'
+
+/** Only explicit old --since cursors need historical reconstruction. Ordinary
+ * registration and the first event batch must use the persisted seed. */
+export async function historicalBuildState(
+  store: BuildStore,
+  slug: string,
+  requested: number,
+  current: { cursor: number; value: BuildStreamSeed },
+) {
+  if (requested >= current.cursor) return current.value
+  const events = await store.getEvents(slug)
+  return buildStreamSeedReducer.reduce(events.filter((event) => event.seq <= requested))
+}
+
+import { repositoryAttentionReducer } from '../kernel/repository-attention'
+export async function historicalRepositoryAttention(
+  store: BuildStore,
+  repo: string,
+  requested: number,
+  current: { cursor: number; value: ReturnType<typeof repositoryAttentionReducer.finish> },
+) {
+  if (requested >= current.cursor) return current.value
+  const events = await store.getRepoEvents(repo)
+  return repositoryAttentionReducer.reduce(events.filter((event) => event.seq <= requested))
+}

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

@@ -1,3 +1,4 @@
+import { readBuildFacts } from '../store/reduced-reads'
 import { preparePinnedAssets } from '../store/ticket-assets'
 import type { PinnedAsset } from '../events/payloads'
 import { abConnect, abDisconnect } from './connect'
@@ -21,7 +22,6 @@ import { textContent } from '../store/types'
 import type { Forge } from '../ports/types'
 import { spawnExec, type Exec } from '../ports/workspace/git-worktree'
 import type { IdSource } from '../ids'
-import { reduceBuild } from '../kernel/reducer'
 import { artifactDownload, artifactDownloadStream, artifactGet, artifactPut } from './artifact'
 import { multiFlag, parseArgs, stringFlag, type ParsedArgs } from './args'
 import { abBuildControl, type BuildControlAction, type BuildControlResult } from './build-control'
@@ -1372,8 +1372,8 @@ async function dispatch(argv: string[], deps: SessionlessCliDeps): Promise<numbe
         // external side effect is best-effort after the atomic designation.
         if (attach) {
           try {
-            const events = await session.store.getEvents(session.env.build)
-            const pr = reduceBuild(events).pr
+            const events = (await readBuildFacts(session.store, session.env.build)).value
+            const pr = events.state.pr
             if (pr !== undefined) {
               try {
                 await preparePrAttachments(session, events, pr.url)

package/packages/core/src/cli/pr-attachments.ts

@@ -1,11 +1,8 @@
-import type { AbEvent, EventEnvelope } from '../events/catalog'
+import type { CurrentBuildFacts } from '../store/reduced-reads'
+import type { EventEnvelope } from '../events/catalog'
 import { KERNEL } from '../events/envelope'
 import type { IdSource } from '../ids'
-import {
-  currentPrAttachments,
-  frozenPrImageHost,
-  hostedPrAttachments,
-} from '../kernel/pr-attachments'
+import type { currentPrAttachments } from '../kernel/pr-attachments'
 import { hostedPrAttachmentAssetSchema, type HostedPrAttachmentAsset } from '../ontology'
 import type { Forge } from '../ports/types'
 import type { BuildStore } from '../store/types'
@@ -25,7 +22,7 @@ function errorMessage(error: unknown): string {
 
 async function recordHostingFailure(
   deps: PrAttachmentDeps,
-  events: AbEvent[],
+  events: CurrentBuildFacts,
   designation: ReturnType<typeof currentPrAttachments>[number],
   error: unknown,
   extraRefs: string[] = [],
@@ -44,7 +41,7 @@ async function recordHostingFailure(
         refs: [`${artifact.kind}@${artifact.rev}`, ...extraRefs],
       },
     })
-    events.push(observed)
+    events.observations.push(observed.payload)
   } catch {
     // Hosting is a best-effort review affordance. A secondary failure to
     // record its follow-up must not hide the complete text projection or turn
@@ -61,14 +58,14 @@ async function recordHostingFailure(
  */
 export async function preparePrAttachments(
   deps: PrAttachmentDeps,
-  events: AbEvent[],
+  events: CurrentBuildFacts,
   prUrl: string,
 ): Promise<void> {
-  const target = frozenPrImageHost(events)
+  const target = events.imageHost
   if (target === undefined) return
 
-  const designations = currentPrAttachments(events)
-  const hosted = hostedPrAttachments(events, designations)
+  const designations = events.designations
+  const hosted = new Map(events.hostedImages)
   for (const designation of designations) {
     if (!designation.payload.mediaType.startsWith('image/')) continue
     if (hosted.has(designation.seq)) continue
@@ -132,7 +129,7 @@ export async function preparePrAttachments(
       )
       throw error
     }
-    events.push(event)
+    events.hostedImages.push([designation.seq, event])
     hosted.set(designation.seq, event)
   }
 }

package/packages/core/src/cli/pr-summary-publication.ts

@@ -1,11 +1,9 @@
-import { summaryBoundary, pendingSummaryRequests } from '../kernel/pr-summary'
+import { readBuildFacts, type CurrentBuildFacts } from '../store/reduced-reads'
 export { summaryBoundary, pendingSummaryRequests } from '../kernel/pr-summary'
 import type { AbEvent } from '../events/catalog'
 import { KERNEL } from '../events/envelope'
 import { isRemoteWorkspace } from '../events/workspace-remote'
-import { reduceBuild } from '../kernel/reducer'
 import { currentPrAttachments } from '../kernel/pr-attachments'
-import { openExecution } from '../processes/execution-settlement'
 import type { Forge } from '../ports/types'
 import { githubRateLimitUntil } from '../ports/forge/github-transport'
 import { summaryMarker } from '../ports/forge/summary-marker'
@@ -27,7 +25,7 @@ interface SummaryDeps {
  * is deliberately not designated, avoiding recursive growth. */
 export async function boundedSummary(
   deps: SummaryDeps,
-  events: readonly AbEvent[],
+  events: readonly AbEvent[] | CurrentBuildFacts,
 ): Promise<string> {
   const env = {
     build: deps.slug,
@@ -48,7 +46,7 @@ export async function boundedSummary(
     summaryMarker(deps.slug),
     `## Autobuild: ${html(deps.slug)}`,
     '',
-    `The full summary exceeds the comment limit. It includes ${currentPrAttachments(events).length} PR attachments.`,
+    `The full summary exceeds the comment limit. It includes ${(Array.isArray(events) ? currentPrAttachments(events) : (events as CurrentBuildFacts).designations).length} PR attachments.`,
     `Store: <code>${html(deps.storeRef)}</code>`,
     '',
     'Download the complete summary, including all pinned artifact commands and hosted links:',
@@ -65,26 +63,16 @@ export async function publishSummary(
   boundary: { occurrence: number; boundary: number },
 ): Promise<'attempted' | 'skipped' | 'deferred'> {
   try {
-    const events = await deps.store.getEvents(deps.slug)
-    const pr = reduceBuild(events).pr
+    const events = (await readBuildFacts(deps.store, deps.slug)).value
+    const pr = events.state.pr
     if (pr === undefined) return 'skipped'
+    if (events.summaryAttempts.includes(boundary.occurrence)) return 'attempted'
     if (
-      events.some(
-        (event) =>
-          event.type === 'pr-summary.attempted' && event.payload.occurrence === boundary.occurrence,
-      )
-    )
-      return 'attempted'
-    if (
-      events.some(
-        (event) =>
-          event.type === 'pr-summary.result' &&
-          event.payload.eligibleAfter !== undefined &&
-          Date.parse(event.payload.eligibleAfter) > deps.clock().getTime(),
-      )
+      events.summaryEligibleAfter !== undefined &&
+      Date.parse(events.summaryEligibleAfter) > deps.clock().getTime()
     )
       return 'deferred'
-    const claim = await deps.store.appendIfCurrent(deps.slug, events.at(-1)?.seq ?? 0, {
+    const claim = await deps.store.appendIfCurrent(deps.slug, events.state.lastSeq, {
       actor: KERNEL,
       type: 'pr-summary.attempted',
       payload: { ...boundary, pr: pr.number },
@@ -93,7 +81,7 @@ export async function publishSummary(
     let outcome: 'success' | 'failure' | 'rate-limited' = 'success'
     let eligibleAfter: string | undefined
     try {
-      const body = await boundedSummary(deps, await deps.store.getEvents(deps.slug))
+      const body = await boundedSummary(deps, (await readBuildFacts(deps.store, deps.slug)).value)
       await deps.forge.commentOnPr(deps.workspacePath, pr.number, body)
     } catch (error) {
       eligibleAfter = githubRateLimitUntil(error, deps.clock().getTime())
@@ -118,45 +106,24 @@ export async function publishSummary(
  * prevent pipeline progress, including a failed request deposit. */
 export async function refreshSummaryBoundary(deps: SummaryDeps): Promise<boolean> {
   try {
-    const events = await deps.store.getEvents(deps.slug)
-    const boundary = summaryBoundary(events)
+    const events = (await readBuildFacts(deps.store, deps.slug)).value
+    const boundary = events.summaryBoundary
     if (boundary === undefined) return false
-    const workspace = events.findLast((event) => event.type === 'workspace.provisioned')
+    const workspace = events.latestWorkspace
     if (workspace?.type === 'workspace.provisioned' && isRemoteWorkspace(workspace.payload)) {
-      const request = events.find(
-        (event) =>
-          event.type === 'pr-summary.requested' && event.payload.occurrence === boundary.occurrence,
-      )
+      const request = events.summaryRequested[String(boundary.occurrence)]
       if (request !== undefined) {
         // A lost result/disposition append must not repeatedly park a guest.
+        if (events.summaryAttempts.includes(boundary.occurrence)) return false
         if (
-          events.some(
-            (event) =>
-              event.type === 'pr-summary.attempted' &&
-              event.payload.occurrence === boundary.occurrence,
-          )
-        )
-          return false
-        if (
-          events.some(
-            (event) =>
-              event.type === 'pr-summary.result' &&
-              event.payload.eligibleAfter !== undefined &&
-              Date.parse(event.payload.eligibleAfter) > deps.clock().getTime(),
-          )
+          events.summaryEligibleAfter !== undefined &&
+          Date.parse(events.summaryEligibleAfter) > deps.clock().getTime()
         )
           return false
-        return pendingSummaryRequests(events).some((event) => event.seq === request.seq)
+        return events.summaryRequests.some((event) => event.seq === request.seq)
       }
-      if (
-        reduceBuild(events).pr === undefined &&
-        !events.some(
-          (event) =>
-            event.type === 'publication.requested' && event.payload.operation === 'finalize',
-        )
-      )
-        return false
-      const written = await deps.store.appendIfCurrent(deps.slug, events.at(-1)?.seq ?? 0, {
+      if (events.state.pr === undefined && !events.finalizePublicationRequested) return false
+      const written = await deps.store.appendIfCurrent(deps.slug, events.state.lastSeq, {
         actor: KERNEL,
         type: 'pr-summary.requested',
         payload: boundary,
@@ -178,10 +145,10 @@ export async function settleSummaryRequests(
   let acquired = false
   let heartbeat: ReturnType<typeof setInterval> | undefined
   try {
-    let events = await deps.store.getEvents(deps.slug)
-    if (openExecution(events) !== null) return
+    let events = (await readBuildFacts(deps.store, deps.slug)).value
+    if (events.open !== null) return
     // Repair a crash after terminal/session completion but before guest handoff.
-    const workspace = events.findLast((event) => event.type === 'workspace.provisioned')
+    const workspace = events.latestWorkspace
     if (workspace?.type !== 'workspace.provisioned' || !isRemoteWorkspace(workspace.payload)) return
     const holder = deps.reservation ?? deps.holder
     acquired = await deps.store.claimLease(deps.slug, holder, 60_000)
@@ -189,11 +156,11 @@ export async function settleSummaryRequests(
     heartbeat = setInterval(() => {
       void deps.store.heartbeat(deps.slug, holder).catch(() => {})
     }, 15_000)
-    events = await deps.store.getEvents(deps.slug)
-    if (openExecution(events) !== null) return
+    events = (await readBuildFacts(deps.store, deps.slug)).value
+    if (events.open !== null) return
     await refreshSummaryBoundary(deps)
-    events = await deps.store.getEvents(deps.slug)
-    const requests = pendingSummaryRequests(events)
+    events = (await readBuildFacts(deps.store, deps.slug)).value
+    const requests = events.summaryRequests
     const latest = requests.at(-1)
     for (const request of requests) {
       if (request.type !== 'pr-summary.requested') continue

package/packages/core/src/cli/pr-summary.ts

@@ -1,3 +1,4 @@
+import type { CurrentBuildFacts } from '../store/reduced-reads'
 import { summaryMarker } from '../ports/forge/summary-marker'
 import type { AbEvent } from '../events/catalog'
 import {
@@ -33,12 +34,21 @@ export function shellQuote(value: string): string {
   return `'${value.replaceAll("'", `'"'"'`)}'`
 }
 
-export function renderPrAttachmentSection(env: CliEnv, events: readonly AbEvent[]): string[] {
-  const designations = currentPrAttachments(events)
+export function renderPrAttachmentSection(
+  env: CliEnv,
+  events: readonly AbEvent[] | CurrentBuildFacts,
+): string[] {
+  const designations = Array.isArray(events)
+    ? currentPrAttachments(events)
+    : (events as CurrentBuildFacts).designations
   if (designations.length === 0) return []
 
-  const target = frozenPrImageHost(events)
-  const hosted = hostedPrAttachments(events, designations)
+  const target = Array.isArray(events)
+    ? frozenPrImageHost(events)
+    : (events as CurrentBuildFacts).imageHost
+  const hosted = Array.isArray(events)
+    ? hostedPrAttachments(events, designations)
+    : new Map((events as CurrentBuildFacts).hostedImages)
   const lines = [
     '',
     '### PR attachments',
@@ -81,19 +91,39 @@ export function renderPrAttachmentSection(env: CliEnv, events: readonly AbEvent[
 }
 
 /** The complete PR summary projection, rendered only from durable facts. */
-export function renderPrSummary(env: CliEnv, events: readonly AbEvent[]): string {
+export function renderPrSummary(
+  env: CliEnv,
+  events: readonly AbEvent[] | CurrentBuildFacts,
+): string {
   const verdicts: string[] = []
   const verifies: string[] = []
-  for (const event of events) {
-    if (event.type === 'plan-review.verdict' || event.type === 'code-review.verdict') {
-      const phase = event.type === 'plan-review.verdict' ? 'plan-review' : 'code-review'
-      const count = event.payload.findings.length
+  const history = Array.isArray(events)
+    ? events.flatMap((event): CurrentBuildFacts['summaryHistory'] =>
+        event.type === 'plan-review.verdict' || event.type === 'code-review.verdict'
+          ? [
+              {
+                kind: 'review',
+                phase: event.type === 'plan-review.verdict' ? 'plan-review' : 'code-review',
+                round: event.payload.round,
+                verdict: event.payload.verdict,
+                count: event.payload.findings.length,
+              },
+            ]
+          : event.type === 'verify.completed'
+            ? [{ kind: 'verify', result: event.payload }]
+            : [],
+      )
+    : (events as CurrentBuildFacts).summaryHistory
+  for (const entry of history) {
+    if (entry.kind === 'review') {
+      const phase = entry.phase
+      const count = entry.count
       const detail =
-        event.payload.verdict === 'revise' ? ` (${count} finding${count === 1 ? '' : 's'})` : ''
-      verdicts.push(`- ${phase} r${event.payload.round}: ${event.payload.verdict}${detail}`)
+        entry.verdict === 'revise' ? ` (${count} finding${count === 1 ? '' : 's'})` : ''
+      verdicts.push(`- ${phase} r${entry.round}: ${entry.verdict}${detail}`)
     }
-    if (event.type === 'verify.completed') {
-      const result = normalizeVerifyCompletion(event.payload)
+    if (entry.kind === 'verify' && entry.result) {
+      const result = normalizeVerifyCompletion(entry.result)
       const detail =
         result.outcome === 'skipped'
           ? ` — ${html(result.reason ?? '')}`