@defrex/autobuild 0.13.0 → 0.14.0

package/packages/core/src/processes/harvest-execution-state.ts

@@ -1,3 +1,4 @@
+import type { RepositoryReadFacts } from '../store/reduced-reads'
 /**
  * Durable harvest execution state: the repository-journal projection that
  * hosted-harvest supervision (AUT-305) reads instead of process memory. The
@@ -88,22 +89,27 @@ export interface HarvestExecutionClassificationInput {
  * `held`; anything else is `idle`. The result feeds the same counters a
  * locally run harvest reports. */
 export function classifyHarvestOutcome(
-  events: readonly RepositoryEvent[],
+  events: readonly RepositoryEvent[] | RepositoryReadFacts,
   input: HarvestExecutionClassificationInput,
 ): HarvestRunnerResult {
-  const state = reduceHarvest(events)
-  const started = events.find(
+  const facts = !Array.isArray(events) ? (events as RepositoryReadFacts) : undefined
+  const raw = Array.isArray(events) ? events : []
+  const state = facts?.harvest ?? reduceHarvest(raw)
+  const started = raw.find(
     (event) =>
       event.type === 'harvest.execution.started' && event.seq === input.executionStartedSeq,
   )
+  const execution =
+    facts?.harvestExecutionStarts[String(input.executionStartedSeq)] ??
+    (started?.type === 'harvest.execution.started' ? started.payload.execution : undefined)
   const authorization =
-    started?.type === 'harvest.execution.started'
-      ? events.find(
+    execution === undefined
+      ? undefined
+      : (facts?.harvestAuthorizations[JSON.stringify(execution)] ??
+        raw.find(
           (event) =>
-            event.type === 'harvest.execution.authorized' &&
-            event.payload.execution === started.payload.execution,
-        )
-      : undefined
+            event.type === 'harvest.execution.authorized' && event.payload.execution === execution,
+        ))
   const selected =
     authorization?.type === 'harvest.execution.authorized' ? authorization.payload : undefined
   const latestRun = selected

package/packages/core/src/processes/harvest-runner.ts

@@ -1,3 +1,4 @@
+import { readRepositoryFacts } from '../store/reduced-reads'
 import { ticketIdentity } from '../ports/tickets/identity'
 import { issueTicketGrant } from '../ports/tickets/grants'
 import { delegateCredential } from '../store/remote/credentials'
@@ -22,7 +23,6 @@ import {
   decideHarvestControl,
   openHarvestRun,
   proposalArtifactForRound,
-  reduceHarvest,
   type HarvestRunState,
 } from '../kernel/harvest'
 import type { ArtifactRef, Feedback, Verdict } from '../ontology'
@@ -239,28 +239,23 @@ export class HarvestRunner {
       // Bounded read (AUT-489): reduceHarvest and the verdict/failure filters
       // below consume durable types only, so the subset is replay-equivalent.
       if (this.deps.preparedRun) {
-        const events = await store.getRepoStateEvents(repo)
-        const authorization = events.find(
-          (event) =>
-            event.type === 'harvest.execution.authorized' &&
-            event.payload.execution === instance &&
-            event.payload.run === this.deps.preparedRun!.run,
-        )
+        const events = (await readRepositoryFacts(store, repo)).value
+        const authorization = events.harvestAuthorizations[JSON.stringify(instance)]
         if (authorization?.type !== 'harvest.execution.authorized')
           throw new Error('prepared harvest execution unavailable')
-        run = reduceHarvest(events).runs.find((run) => run.run === this.deps.preparedRun!.run)
+        run = events.harvest.runs.find((run) => run.run === this.deps.preparedRun!.run)
         initial = authorization.payload.launch
       } else {
-        let events = await store.getRepoStateEvents(repo)
-        let state = reduceHarvest(events)
+        let events = (await readRepositoryFacts(store, repo)).value
+        let state = events.harvest
         run = actionableHarvestRun(state)
 
         // Settle durable operator control before scanning or resuming work. The
         // selected run comes from the full journal, so a shadowed failure or
         // exhaustion barrier is recovered/reported before any later open run.
         await this.controlBoundary(run?.run)
-        events = await store.getRepoStateEvents(repo)
-        state = reduceHarvest(events)
+        events = (await readRepositoryFacts(store, repo)).value
+        state = events.harvest
         run = openHarvestRun(state)
 
         if (!run) {
@@ -274,7 +269,7 @@ export class HarvestRunner {
           // Bounded read (AUT-489): the gate's journal input is consumed only
           // through reduceHarvest, so the subset is replay-equivalent here too.
           const [gateEvents, digests] = await Promise.all([
-            store.getRepoStateEvents(repo),
+            readRepositoryFacts(store, repo).then((result) => result.value.harvest),
             store.getRepoBuildDigests(repo),
           ])
           const pressure = evaluateHarvestPressureFromDigests({
@@ -338,8 +333,8 @@ export class HarvestRunner {
             }),
           )
           // Bounded read (AUT-489): reduceHarvest consumes durable types only.
-          events = await store.getRepoStateEvents(repo)
-          run = reduceHarvest(events).runs.find((candidate) => candidate.run === runId)
+          events = (await readRepositoryFacts(store, repo)).value
+          run = events.harvest.runs.find((candidate) => candidate.run === runId)
           if (!run) throw new Error(`harvest.started did not reduce run "${runId}"`)
           // A request racing the claim parks this exact run; its snapshot stays
           // open and is resumed rather than scanned again.
@@ -503,14 +498,8 @@ export class HarvestRunner {
           )
           // Bounded read (AUT-489): only harvest.review.verdict facts are
           // filtered here, and those are durable.
-          const event = (await this.deps.store.getRepoStateEvents(this.deps.repo)).find(
-            (
-              candidate,
-            ): candidate is Extract<RepositoryEvent, { type: 'harvest.review.verdict' }> =>
-              candidate.type === 'harvest.review.verdict' &&
-              candidate.payload.run === run.run &&
-              candidate.payload.round === round,
-          )
+          const event = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value
+            .harvestVerdicts[JSON.stringify([run.run, round])]?.first
           if (!event) throw new Error('review reducer/event mismatch')
           await this.controlBoundary(run.run)
           return verdictFromEvent(event)
@@ -572,15 +561,8 @@ export class HarvestRunner {
     })
     // Bounded read (AUT-489): only harvest.review.verdict facts are filtered
     // here, and those are durable.
-    const events = await this.deps.store.getRepoStateEvents(this.deps.repo)
-    const verdict = [...events]
-      .reverse()
-      .find(
-        (event): event is Extract<RepositoryEvent, { type: 'harvest.review.verdict' }> =>
-          event.type === 'harvest.review.verdict' &&
-          event.payload.run === run.run &&
-          event.payload.round === round,
-      )
+    const events = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value
+    const verdict = events.harvestVerdicts[JSON.stringify([run.run, round])]?.latest
     if (!verdict) throw new Error(`review@${round} terminal is missing`)
     await this.completeStep(
       run.run,
@@ -624,22 +606,16 @@ export class HarvestRunner {
     await this.ensureLease()
     // Bounded read (AUT-489): reduceHarvest and the harvest.failed filter
     // consume durable types only.
-    const events = await store.getRepoStateEvents(repo)
-    const matchingFailures = events.filter(
-      (event): event is Extract<RepositoryEvent, { type: 'harvest.failed' }> =>
-        event.type === 'harvest.failed' &&
-        event.payload.run === spec.run &&
-        event.payload.step === spec.step &&
-        event.payload.round === spec.round,
-    )
-    const failures = matchingFailures.length
-    const latestFailure = matchingFailures.at(-1)
-    const current = reduceHarvest(events).runs.find((candidate) => candidate.run === spec.run)
+    const events = (await readRepositoryFacts(store, repo)).value
+    const failureFacts = events.harvestFailures[JSON.stringify([spec.run, spec.step, spec.round])]
+    const failures = failureFacts?.count ?? 0
+    const latestFailure = failureFacts?.latest
+    const current = events.harvest.runs.find((candidate) => candidate.run === spec.run)
     const resumedAfterTerminalFailure =
       latestFailure?.payload.willRetry === false &&
       current?.status === 'running' &&
       current.failure === undefined &&
-      events.some((event) => event.type === 'harvest.resumed' && event.seq > latestFailure.seq)
+      events.latestHarvestResumedSeq > latestFailure.seq
     if (failures >= this.maxSessionAttempts && !resumedAfterTerminalFailure) {
       throw new SessionFailure(`${spec.step}@${spec.round} exhausted retries`)
     }
@@ -884,17 +860,11 @@ export class HarvestRunner {
     await this.ensureLease()
     // Bounded read (AUT-489): reduceHarvest and the harvest.failed filter
     // consume durable types only.
-    const events = await store.getRepoStateEvents(repo)
-    const matchingFailures = events.filter(
-      (event): event is Extract<RepositoryEvent, { type: 'harvest.failed' }> =>
-        event.type === 'harvest.failed' &&
-        event.payload.run === spec.run &&
-        event.payload.step === spec.step &&
-        event.payload.round === spec.round,
-    )
-    const failures = matchingFailures.length
-    const latestFailure = matchingFailures.at(-1)
-    const current = reduceHarvest(events).runs.find((candidate) => candidate.run === spec.run)
+    const events = (await readRepositoryFacts(store, repo)).value
+    const failureFacts = events.harvestFailures[JSON.stringify([spec.run, spec.step, spec.round])]
+    const failures = failureFacts?.count ?? 0
+    const latestFailure = failureFacts?.latest
+    const current = events.harvest.runs.find((candidate) => candidate.run === spec.run)
     // A stopping failure may already have consumed the ordinary retry budget.
     // harvest.resumed deliberately clears that reduced stop and grants one real
     // re-entry without deleting history or resetting attempt numbers. The next
@@ -903,7 +873,7 @@ export class HarvestRunner {
       latestFailure?.payload.willRetry === false &&
       current?.status === 'running' &&
       current.failure === undefined &&
-      events.some((event) => event.type === 'harvest.resumed' && event.seq > latestFailure.seq)
+      events.latestHarvestResumedSeq > latestFailure.seq
     if (failures >= this.maxSessionAttempts && !resumedAfterTerminalFailure) {
       throw new SessionFailure(`${spec.step}@${spec.round} exhausted retries`)
     }
@@ -1366,8 +1336,8 @@ export class HarvestRunner {
     await this.ensureLease()
     // Bounded read (AUT-489): reduceHarvest and the harvest.failed filter
     // consume durable types only.
-    const events = await this.deps.store.getRepoStateEvents(this.deps.repo)
-    const state = reduceHarvest(events)
+    const events = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value
+    const state = events.harvest
     const current = state.runs.find((candidate) => candidate.run === run)
     if (current?.status !== 'running') return
     const open = [...current.steps]
@@ -1375,13 +1345,7 @@ export class HarvestRunner {
       .find((occurrence) => occurrence.completedSeq === undefined)
     const step = open?.step ?? 'file'
     const round = open?.round
-    const prior = events.filter(
-      (event) =>
-        event.type === 'harvest.failed' &&
-        event.payload.run === run &&
-        event.payload.step === step &&
-        event.payload.round === round,
-    ).length
+    const prior = events.harvestFailures[JSON.stringify([run, step, round])]?.count ?? 0
     const attempt = prior + 1
     const willRetry = attempt < this.maxSessionAttempts
     const message = errorMessage(error)
@@ -1421,7 +1385,7 @@ export class HarvestRunner {
     if (this.deps.preparedRun) return
     await this.ensureLease()
     // Bounded read (AUT-489): reduceHarvest consumes durable types only.
-    const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
+    const state = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value.harvest
     const decision = decideHarvestControl(state, this.maxRecoveryAttempts)
     if (decision.kind !== 'exhaust-recovery' || decision.run !== run) return
     await this.finalizeRecoveryExhaustion(decision.run, decision.attempts, decision.limit)
@@ -1447,7 +1411,7 @@ export class HarvestRunner {
 
     await this.ensureLease()
     // Bounded read (AUT-489): reduceHarvest consumes durable types only.
-    const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
+    const state = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value.harvest
     const decision = decideHarvestControl(state, this.maxRecoveryAttempts)
     if (
       decision.kind !== 'exhaust-recovery' ||
@@ -1484,7 +1448,7 @@ export class HarvestRunner {
     while (true) {
       await this.ensureLease()
       // Bounded read (AUT-489): reduceHarvest consumes durable types only.
-      const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
+      const state = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value.harvest
       const decision = decideHarvestControl(state, this.maxRecoveryAttempts)
       if (decision.kind === 'proceed') return
       if (this.deps.preparedRun) throw new HarvestParkedSignal(run)
@@ -1529,7 +1493,7 @@ export class HarvestRunner {
 
   private async refreshRun(run: string): Promise<HarvestRunState> {
     // Bounded read (AUT-489): reduceHarvest consumes durable types only.
-    const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
+    const state = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value.harvest
     const found = state.runs.find((candidate) => candidate.run === run)
     if (!found) throw new Error(`unknown harvest run "${run}"`)
     return found

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

@@ -1,3 +1,5 @@
+import { readBuildDigests } from '../store/reduced-reads'
+import { readRepositoryFacts, readBuildFacts } from '../store/reduced-reads'
 /** Deterministic halves of observation harvest: scan, dedup, validation, and
  * proposal rendering. Agent judgment is deliberately absent from this file. */
 import type { AbEvent } from '../events/catalog'
@@ -135,10 +137,12 @@ export function evaluateHarvestPressure(
  * so latest-wins carries exactly the drift fact the scan collects. */
 export function evaluateHarvestPressureFromDigests(input: {
   digests: Map<string, BuildDigest>
-  harvestEvents: RepositoryEvent[]
+  harvestEvents: RepositoryEvent[] | HarvestState
   policy: { harvestThreshold: number; harvestMaxDrift: number }
 }): HarvestPressure {
-  const claimed = claimedOccurrenceKeys(reduceHarvest(input.harvestEvents))
+  const claimed = claimedOccurrenceKeys(
+    Array.isArray(input.harvestEvents) ? reduceHarvest(input.harvestEvents) : input.harvestEvents,
+  )
   const unclaimed: HarvestPressureFacts['unclaimed'] = []
   const merges: HarvestPressureFacts['merges'] = []
   for (const digest of input.digests.values()) {
@@ -160,11 +164,11 @@ export function evaluateHarvestPressureFromDigests(input: {
 export async function evaluateHarvestPressureFromStore(input: {
   store: BuildStore
   repo: string
-  harvestEvents: RepositoryEvent[]
+  harvestEvents: RepositoryEvent[] | HarvestState
   policy: { harvestThreshold: number; harvestMaxDrift: number }
 }): Promise<HarvestPressure> {
   await input.store.ensureRepo(input.repo)
-  const digests = await input.store.getRepoBuildDigests(input.repo)
+  const digests = await readBuildDigests(input.store, input.repo)
   return evaluateHarvestPressureFromDigests({
     digests,
     harvestEvents: input.harvestEvents,
@@ -182,9 +186,11 @@ export function collectUnclaimedObservations(input: {
   repo: string
   records: BuildRecord[]
   eventsByBuild: Map<string, AbEvent[]>
-  harvestEvents: RepositoryEvent[]
+  harvestEvents: RepositoryEvent[] | HarvestState
 }): HarvestScanResult {
-  const state = reduceHarvest(input.harvestEvents)
+  const state = Array.isArray(input.harvestEvents)
+    ? reduceHarvest(input.harvestEvents)
+    : input.harvestEvents
   const claimed = claimedOccurrenceKeys(state)
   const observations: HarvestObservation[] = []
   const merges: HarvestMerge[] = []
@@ -235,9 +241,11 @@ export function collectUnclaimedObservations(input: {
  * are not assumed globally unique. */
 export function unclaimedObservationCount(input: {
   digests: Map<string, BuildDigest>
-  harvestEvents: RepositoryEvent[]
+  harvestEvents: RepositoryEvent[] | HarvestState
 }): number {
-  const claimed = claimedOccurrenceKeys(reduceHarvest(input.harvestEvents))
+  const claimed = claimedOccurrenceKeys(
+    Array.isArray(input.harvestEvents) ? reduceHarvest(input.harvestEvents) : input.harvestEvents,
+  )
   let count = 0
   for (const digest of input.digests.values()) {
     for (const observation of digest.observations) {
@@ -279,7 +287,7 @@ export async function sampleUnclaimedObservationCount(
 ): Promise<number> {
   const [digests, harvestEvents] = await Promise.all([
     store.getRepoBuildDigests(repo),
-    readRepoEventsIfRecorded(store, repo),
+    readRepositoryFacts(store, repo).then((result) => result.value.harvest),
   ])
   return unclaimedObservationCount({ digests, harvestEvents })
 }
@@ -292,16 +300,31 @@ export async function scanUnclaimedObservations(
   repo: string,
 ): Promise<HarvestScanResult> {
   await store.ensureRepo(repo)
-  // Bounded read (AUT-489): only harvest facts are consumed here; the
-  // per-build history reads stay as AUT-487 left them.
-  const harvestEvents = await store.getRepoStateEvents(repo)
+  const state = (await readRepositoryFacts(store, repo)).value.harvest
+  const claimed = claimedOccurrenceKeys(state)
   const records = await store.listBuilds()
-  const eventsByBuild = new Map<string, AbEvent[]>()
+  const observations: HarvestObservation[] = []
+  const merges: HarvestMerge[] = []
   for (const record of records) {
     if (record.repo !== repo) continue
-    eventsByBuild.set(record.slug, await store.getEvents(record.slug))
+    const facts = (await readBuildFacts(store, record.slug)).value
+    for (const ts of facts.mergeTimes) merges.push({ build: record.slug, ts })
+    for (const observation of facts.observationFacts) {
+      const occurrence = { build: record.slug, seq: observation.seq }
+      if (claimed.has(occurrenceKey(occurrence))) continue
+      observations.push({
+        occurrence,
+        ...observation.payload,
+        ts: observation.ts,
+        ...(record.ticket ? { ticket: structuredClone(record.ticket) } : {}),
+      })
+    }
   }
-  return collectUnclaimedObservations({ repo, records, eventsByBuild, harvestEvents })
+  observations.sort(
+    (a, b) =>
+      a.occurrence.build.localeCompare(b.occurrence.build) || a.occurrence.seq - b.occurrence.seq,
+  )
+  return { state, observations, merges }
 }
 
 /** Distinct previously filed/joined proposal tickets, reconciled through the

package/packages/core/src/processes/infrastructure-failure-budget.ts

@@ -1,3 +1,4 @@
+import { readBuildFacts, type CurrentBuildFacts } from '../store/reduced-reads'
 import type { AbEvent } from '../events/catalog'
 import { DISPATCHER } from '../events/envelope'
 import type { EventPayload } from '../events/payloads'
@@ -10,7 +11,7 @@ export type InfrastructureCause = EventPayload<'infrastructure.failed'>['cause']
 
 export interface InfrastructureFailureInput {
   slug: string
-  events: readonly AbEvent[]
+  events: readonly AbEvent[] | CurrentBuildFacts
   maxAttempts: number
   provider: string
   workspaceRef: string
@@ -23,7 +24,7 @@ export interface InfrastructureFailureInput {
 }
 
 export interface InfrastructureFailureDependencies {
-  store: Pick<BuildStore, 'append' | 'getEvents'>
+  store: Pick<BuildStore, 'append' | 'getReducerValue'>
   ids: IdSource
 }
 
@@ -104,10 +105,14 @@ export async function recordInfrastructureFailure(
   deps: InfrastructureFailureDependencies,
   input: InfrastructureFailureInput,
 ): Promise<AbEvent[]> {
-  const lastReset = infrastructureFailureResetSeq(input.events)
-  const attempt =
-    input.events.filter((event) => event.type === 'infrastructure.failed' && event.seq > lastReset)
-      .length + 1
+  const lastReset = Array.isArray(input.events)
+    ? infrastructureFailureResetSeq(input.events)
+    : (input.events as CurrentBuildFacts).infrastructureReset
+  const attempt = Array.isArray(input.events)
+    ? input.events.filter(
+        (event) => event.type === 'infrastructure.failed' && event.seq > lastReset,
+      ).length + 1
+    : (input.events as CurrentBuildFacts).infrastructureCount + 1
   const message = normalizeInfrastructureError(input.error)
   const failure = await deps.store.append(input.slug, {
     actor: DISPATCHER,
@@ -130,15 +135,8 @@ export async function recordInfrastructureFailure(
 
   if (attempt < input.maxAttempts) return appended
 
-  const currentEvents = await deps.store.getEvents(input.slug)
-  if (
-    !currentEvents.some(
-      (event) =>
-        event.seq > lastReset &&
-        event.type === 'escalation.raised' &&
-        event.payload.policyCause === 'infrastructure-failure-limit',
-    )
-  ) {
+  const current = (await readBuildFacts(deps.store, input.slug)).value
+  if (current.infrastructureRaisedSeq <= lastReset) {
     appended.push(
       await deps.store.append(input.slug, {
         actor: DISPATCHER,

package/packages/core/src/processes/orchestrator-tick.ts

@@ -1,3 +1,4 @@
+import { readBuildFacts } from '../store/reduced-reads'
 /**
  * The dispatcher tick's orchestrator step (AUT-342): resume suspended turns,
  * reap crashed ones, and wake idle sessions from build attention events.
@@ -28,7 +29,6 @@ import { buildRegistry, type OperatorToolRegistry } from '../operator/registry'
 import type { OperatorSandboxService } from '../operator/sandbox'
 import { ticketBackendFromSource } from '../operator/ticket-source-backend'
 import { reduceSession, type SessionTurnTrigger } from '../store/session-reducer'
-import { reduceBuild } from '../kernel/reducer'
 import type { AbEvent } from '../events/catalog'
 import type { BuildStore, Clock } from '../store/types'
 import type { RepoViewStore } from './repo-view'
@@ -315,7 +315,7 @@ export async function runOrchestratorTickStep(
             event,
             buildState: (options.view !== undefined
               ? await options.view.buildState(newest.build)
-              : reduceBuild(await store.getEvents(newest.build))) as unknown as Record<
+              : (await readBuildFacts(store, newest.build)).value.state) as unknown as Record<
               string,
               unknown
             >,

package/packages/core/src/processes/publication-loss.ts

@@ -1,4 +1,3 @@
-import { summaryBoundary } from '../kernel/pr-summary'
 import { isRemoteWorkspace } from '../events/workspace-remote'
 /**
  * Last-chance publication settlement at the workspace-release boundary
@@ -12,11 +11,6 @@ import { isRemoteWorkspace } from '../events/workspace-remote'
  */
 import { DISPATCHER } from '../events/envelope'
 import type { AbEvent } from '../events/catalog'
-import {
-  latestUncompletedPublicationRequest,
-  publicationLostRecorded,
-  publicationRequestCompleted,
-} from './publication-state'
 import type { BuildStore } from '../store/types'
 
 export interface PublicationLossDeps {
@@ -35,36 +29,56 @@ export interface PublicationLossDeps {
 export async function settlePublicationBeforeRelease(
   deps: PublicationLossDeps,
   slug: string,
-  events: AbEvent[],
+  _events: AbEvent[],
   reason: string,
 ): Promise<AbEvent[]> {
-  const request = latestUncompletedPublicationRequest(events)
+  const { readBuildFacts } = await import('../store/reduced-reads')
+  await settlePublicationFactsBeforeRelease(
+    deps,
+    slug,
+    (await readBuildFacts(deps.store, slug)).value,
+    reason,
+  )
+  // Legacy callers explicitly requested the raw event output.
+  return deps.store.getEvents(slug)
+}
+
+/** Current-state release guard; the returned facts follow every settlement write. */
+export async function settlePublicationFactsBeforeRelease(
+  deps: PublicationLossDeps,
+  slug: string,
+  facts: import('../store/reduced-reads').CurrentBuildFacts,
+  reason: string,
+) {
+  const { readBuildFacts } = await import('../store/reduced-reads')
+  const request = facts.publication.latestUncompletedRequest()
   if (request === undefined) {
-    const workspace = events.findLast((event) => event.type === 'workspace.provisioned')
     if (
-      workspace?.type === 'workspace.provisioned' &&
-      isRemoteWorkspace(workspace.payload) &&
-      summaryBoundary(events) !== undefined
+      facts.workspace &&
+      isRemoteWorkspace(facts.workspace) &&
+      facts.summaryBoundary !== undefined
     ) {
       try {
         await deps.settlePublication?.(slug)
       } catch {
         /* Summary is best effort. */
       }
-      return deps.store.getEvents(slug)
+      return (await readBuildFacts(deps.store, slug)).value
     }
-    return events
+    return facts
   }
   try {
     await deps.settlePublication?.(slug)
   } catch {
-    // A throw means the request is still uncompleted (or settlement failed);
-    // either way the loss record below is what makes the release safe.
+    /* Record loss before release. */
   }
-  const refreshed = await deps.store.getEvents(slug)
-  if (publicationRequestCompleted(refreshed, request)) return refreshed
-  if (publicationLostRecorded(refreshed, request)) return refreshed
-  const appended = await deps.store.append(slug, {
+  const refreshed = (await readBuildFacts(deps.store, slug)).value
+  if (
+    refreshed.publication.requestCompleted(request) ||
+    refreshed.publication.lostRecorded(request)
+  )
+    return refreshed
+  await deps.store.append(slug, {
     actor: DISPATCHER,
     type: 'publication.lost',
     payload: {
@@ -75,5 +89,5 @@ export async function settlePublicationBeforeRelease(
       reason,
     },
   })
-  return [...refreshed, appended]
+  return (await readBuildFacts(deps.store, slug)).value
 }