@defrex/autobuild 0.12.0 → 0.14.0

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
@@ -327,12 +350,17 @@ export async function reconcileHarvestLedger(
   )
   if (entries.length === 0) return []
 
-  const ids = entries.map((entry) => entry.ticket.id)
+  const ids = entries
+    .filter((entry) => entry.ticket.source === tickets.name)
+    .map((entry) => entry.ticket.id)
   const states = await tickets.dependencyStates(ids)
+  const byId = new Map(states.map((state) => [state.id, state]))
   const out: HarvestLedgerTicket[] = []
   for (let index = 0; index < entries.length; index += 1) {
     const entry = entries[index]!
-    const dependency = states[index] ?? {
+    const dependency = (entry.ticket.source === tickets.name
+      ? byId.get(entry.ticket.id)
+      : undefined) ?? {
       id: entry.ticket.id,
       exists: false,
       resolved: false,
@@ -341,7 +369,7 @@ export async function reconcileHarvestLedger(
     const current = dependency.exists ? await tickets.get(entry.ticket.id) : null
     out.push({
       proposalKey: entry.proposalKey,
-      ticket: structuredClone(entry.ticket),
+      ticket: structuredClone(current?.ref ?? entry.ticket),
       exists: dependency.exists,
       resolved: dependency.resolved,
       ...(current?.title !== undefined ? { title: current.title } : {}),
@@ -371,15 +399,25 @@ export async function reconcileOriginatingTickets(
   const states = matchingIds.length > 0 ? await tickets.dependencyStates(matchingIds) : []
   const byId = new Map(states.map((state) => [state.id, state]))
 
-  return refs.map((ticket) => {
-    const sourceMatches = ticket.source === tickets.name
-    const state = sourceMatches ? byId.get(ticket.id) : undefined
-    return {
-      ticket,
-      sourceMatches,
-      exists: state?.exists ?? false,
-      resolved: state?.resolved ?? false,
-    }
+  const identity = new Set<string>()
+  const projected = await Promise.all(
+    refs.map(async (ticket) => {
+      const sourceMatches = ticket.source === tickets.name
+      const state = sourceMatches ? byId.get(ticket.id) : undefined
+      const current = sourceMatches && state?.exists ? await tickets.get(ticket.id) : null
+      return {
+        ticket: current?.ref ?? ticket,
+        sourceMatches,
+        exists: state?.exists ?? false,
+        resolved: state?.resolved ?? false,
+      }
+    }),
+  )
+  return projected.filter((entry) => {
+    const key = `${entry.ticket.source}:${entry.ticket.id}`
+    if (identity.has(key)) return false
+    identity.add(key)
+    return true
   })
 }
 
@@ -536,9 +574,14 @@ export async function resolveHarvestCreateBlockers(
     const state = byId.get(id)
     return state?.exists === true && !state.resolved
   })
+  const canonical = new Map<string, string>()
+  for (const id of candidates) {
+    if (byId.get(id)?.exists) canonical.set(id, (await tickets.get(id))?.ref.id ?? id)
+  }
+  const project = (ids: string[]) => [...new Set(ids.map((id) => canonical.get(id) ?? id))]
   return {
-    blockedBy: [...new Set([...declared, ...derived])],
-    provenance: { declared, derived },
+    blockedBy: project([...declared, ...derived]),
+    provenance: { declared: project(declared), derived: project(derived) },
   }
 }
 

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/phase-failure-budget.ts

@@ -12,6 +12,7 @@ export const POLICY_PHASE_FAILURE_RESET_SCOPES = {
   'verify-failure-limit': 'all-phase-rounds',
   'reconcile-no-progress': 'none',
   'dispatch-failure-limit': 'none',
+  'execution-no-progress': 'none',
   'setup-failure-limit': 'none',
   'infrastructure-failure-limit': 'none',
   'phase-attempt-limit': 'matching-round',

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
 }