@defrex/autobuild 0.12.0 → 0.14.0

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 ?? '')}`

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/self-update.ts

@@ -1,3 +1,4 @@
+import { join } from 'node:path'
 import { checkUpgradeCompatibility, type CompatibilityFetch } from './upgrade-compatibility'
 import { readFile, writeFile } from 'node:fs/promises'
 import semver from 'semver'
@@ -363,6 +364,7 @@ export async function selfUpdate(options: SelfUpdateOptions): Promise<SelfUpdate
   const inspection = await inspectInstallation({
     distRoot,
     globalBin: globalBinResult.stdout.trim(),
+    cwd: options.targetRepo,
   })
   if (inspection.kind !== 'bun-forge' && inspection.kind !== 'npm-registry') {
     return explicit ? fail(options, inspection.reason) : warn(options, inspection.reason)
@@ -469,7 +471,9 @@ export async function selfUpdate(options: SelfUpdateOptions): Promise<SelfUpdate
 
   let updated: DistributionIdentity
   try {
-    updated = await readDistributionIdentity(distRoot)
+    updated = await readDistributionIdentity(
+      join(install.ownerRoot, 'node_modules', ...install.packageName.split('/')),
+    )
     // Injected command fixtures do not rewrite disk; a real successful Bun
     // operation must. Keep the check injectable by accepting the old identity
     // only when the command seam itself was supplied.

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(