@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/processes/execution-settlement.ts

@@ -18,58 +18,80 @@ import type {
   BuildExecutionIdentity,
   ExecutionObservation,
 } from '../ports/workspace/build-execution'
+import { defineReducer } from '../kernel/incremental'
 import type { BuildStore } from '../store/types'
 
-/** The latest `execution.started` not followed by an instance-matched
- * `execution.ended`, or null when no execution is open. */
-export function openExecution(events: AbEvent[]): {
+export interface OpenExecution {
   instance: string
   workspaceRef: string
   provider: string
   environmentId?: string
   sessionId?: string
   commandId?: string
-} | null {
-  let open: {
-    instance: string
-    workspaceRef: string
-    provider: string
-    environmentId?: string
-    sessionId?: string
-    commandId?: string
-  } | null = null
-  for (const event of events) {
-    if (event.type === 'execution.started') {
-      const payload = event.payload
-      open = {
-        instance: payload.instance,
-        workspaceRef: payload.workspaceRef,
-        provider: payload.provider,
-        ...(payload.environmentId !== undefined ? { environmentId: payload.environmentId } : {}),
-        ...(payload.sessionId !== undefined ? { sessionId: payload.sessionId } : {}),
-        ...(payload.commandId !== undefined ? { commandId: payload.commandId } : {}),
+}
+
+export const OPEN_EXECUTION_REDUCER_VERSION = 1
+
+/** The latest `execution.started` not followed by an instance-matched
+ * `execution.ended`, or null when no execution is open. */
+export const openExecutionReducer = defineReducer<
+  { open: OpenExecution | null },
+  AbEvent,
+  OpenExecution | null
+>({
+  version: OPEN_EXECUTION_REDUCER_VERSION,
+  initial: () => ({ open: null }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'execution.started') {
+        const payload = event.payload
+        acc.open = {
+          instance: payload.instance,
+          workspaceRef: payload.workspaceRef,
+          provider: payload.provider,
+          ...(payload.environmentId !== undefined ? { environmentId: payload.environmentId } : {}),
+          ...(payload.sessionId !== undefined ? { sessionId: payload.sessionId } : {}),
+          ...(payload.commandId !== undefined ? { commandId: payload.commandId } : {}),
+        }
+      } else if (event.type === 'execution.ended' && acc.open !== null) {
+        if (event.payload.instance === acc.open.instance) acc.open = null
       }
-    } else if (event.type === 'execution.ended' && open !== null) {
-      if (event.payload.instance === open.instance) open = null
     }
-  }
-  return open
+  },
+  finish: (acc) => (acc.open === null ? null : { ...acc.open }),
+})
+
+export function openExecution(events: AbEvent[]): OpenExecution | null {
+  return openExecutionReducer.reduce(events)
 }
 
+export type ExecutionOutcome = 'open' | 'completed' | 'stopped' | 'lost' | 'none'
+
+export const LAST_EXECUTION_OUTCOME_REDUCER_VERSION = 1
+
 /** The lifecycle state of the latest recorded execution: `open` (no matching
  * end yet), `completed`/`stopped`/`lost` (its recorded end), or `none`. */
-export function lastExecutionOutcome(
-  events: AbEvent[],
-): 'open' | 'completed' | 'stopped' | 'lost' | 'none' {
-  let state: 'open' | 'completed' | 'stopped' | 'lost' | 'none' = 'none'
-  for (const event of events) {
-    if (event.type === 'execution.started') {
-      state = 'open'
-    } else if (event.type === 'execution.ended' && state === 'open') {
-      state = event.payload.outcome
+export const lastExecutionOutcomeReducer = defineReducer<
+  { state: ExecutionOutcome },
+  AbEvent,
+  ExecutionOutcome
+>({
+  version: LAST_EXECUTION_OUTCOME_REDUCER_VERSION,
+  initial: () => ({ state: 'none' }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'execution.started') {
+        acc.state = 'open'
+      } else if (event.type === 'execution.ended' && acc.state === 'open') {
+        acc.state = event.payload.outcome
+      }
     }
-  }
-  return state
+  },
+  finish: (acc) => acc.state,
+})
+
+export function lastExecutionOutcome(events: AbEvent[]): ExecutionOutcome {
+  return lastExecutionOutcomeReducer.reduce(events)
 }
 
 function observationIdentity(open: {
@@ -124,12 +146,23 @@ async function releaseSettledLease(
  * Observation errors are contained and read as `running` (conservative: never
  * reap on an unknown); the next tick retries.
  */
-export async function settleExecution(
+export function settleExecution(
   deps: ExecutionSettlementDeps,
   slug: string,
   events: AbEvent[],
 ): Promise<ExecutionSettlement> {
-  const open = openExecution(events)
+  return settleOpenExecution(deps, slug, openExecution(events))
+}
+
+/** `settleExecution` over an already-derived open execution, for callers that
+ * hold the projection (a reducer snapshot advanced to the log tail) and so
+ * never need the event array. A `running` result or an observation error
+ * touches no event rows. */
+export async function settleOpenExecution(
+  deps: ExecutionSettlementDeps,
+  slug: string,
+  open: OpenExecution | null,
+): Promise<ExecutionSettlement> {
   if (open === null) return 'settled'
   if (open.commandId === undefined || deps.execution.observe === undefined) return 'running'
   let observation: ExecutionObservation

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

@@ -61,8 +61,13 @@ export async function runHarvestChild(
     // Full build-child composition parity, in the same order: plugins load
     // first or materializePluginRuntimes silently no-ops and leaves any
     // plugin-provided runtime unrouted in the guest.
+    // Guest tolerance (AUT-517): a harvest runner launch is always
+    // environment-supervised — the process is structurally a guest and never
+    // constructs a workspace provider — so a configured provider plugin the
+    // guest cannot resolve is skipped with a notice instead of failing.
     const plugins = await loadPlugins(config.plugins, workspacePath, {
       packageRoot: input.repo,
+      ...(input.supervision.kind === 'environment' ? { guest: true } : {}),
     })
     const { runtimes: builtins } = createProductionRuntimes()
     const runtimes = await materializePluginRuntimes(builtins, plugins, {

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

@@ -8,6 +8,7 @@
  * supervisor died.
  */
 import type { RepositoryEvent } from '../events/repository'
+import { defineReducer } from '../kernel/incremental'
 import {
   DEFAULT_MAX_HARVEST_RECOVERY_ATTEMPTS,
   actionableHarvestRun,
@@ -16,42 +17,53 @@ import {
 } from '../kernel/harvest'
 import type { HarvestRunnerResult } from './harvest-runner'
 
-/** Open harvest executions: every `harvest.execution.started` not followed by
- * a matching `harvest.execution.released`, in journal order. */
-export function openHarvestExecutions(events: readonly RepositoryEvent[]): Array<{
+export interface OpenHarvestExecution {
   execution: string
   provider: string
   environmentId: string
   sessionId?: string
   commandId?: string
   seq: number
-}> {
-  const open = new Map<
-    string,
-    {
-      execution: string
-      provider: string
-      environmentId: string
-      sessionId?: string
-      commandId?: string
-      seq: number
-    }
-  >()
-  for (const event of events) {
-    if (event.type === 'harvest.execution.started') {
-      open.set(event.payload.execution, {
-        execution: event.payload.execution,
-        provider: event.payload.provider,
-        environmentId: event.payload.environmentId,
-        ...(event.payload.sessionId !== undefined ? { sessionId: event.payload.sessionId } : {}),
-        ...(event.payload.commandId !== undefined ? { commandId: event.payload.commandId } : {}),
-        seq: event.seq,
-      })
-    } else if (event.type === 'harvest.execution.released') {
-      open.delete(event.payload.execution)
+}
+
+export const OPEN_HARVEST_EXECUTIONS_REDUCER_VERSION = 1
+
+/** Open harvest executions: every `harvest.execution.started` not followed by
+ * a matching `harvest.execution.released`, in journal order. The accumulator is
+ * an ordered array: a re-started execution keeps its original position, as it
+ * did in the `Map` this replaces. */
+export const openHarvestExecutionsReducer = defineReducer<
+  { open: OpenHarvestExecution[] },
+  RepositoryEvent,
+  OpenHarvestExecution[]
+>({
+  version: OPEN_HARVEST_EXECUTIONS_REDUCER_VERSION,
+  initial: () => ({ open: [] }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'harvest.execution.started') {
+        const entry: OpenHarvestExecution = {
+          execution: event.payload.execution,
+          provider: event.payload.provider,
+          environmentId: event.payload.environmentId,
+          ...(event.payload.sessionId !== undefined ? { sessionId: event.payload.sessionId } : {}),
+          ...(event.payload.commandId !== undefined ? { commandId: event.payload.commandId } : {}),
+          seq: event.seq,
+        }
+        const index = acc.open.findIndex((item) => item.execution === entry.execution)
+        if (index === -1) acc.open.push(entry)
+        else acc.open[index] = entry
+      } else if (event.type === 'harvest.execution.released') {
+        const index = acc.open.findIndex((item) => item.execution === event.payload.execution)
+        if (index !== -1) acc.open.splice(index, 1)
+      }
     }
-  }
-  return [...open.values()]
+  },
+  finish: (acc) => acc.open.map((item) => ({ ...item })),
+})
+
+export function openHarvestExecutions(events: readonly RepositoryEvent[]): OpenHarvestExecution[] {
+  return openHarvestExecutionsReducer.reduce(events)
 }
 
 export interface HarvestExecutionClassificationInput {

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

@@ -46,6 +46,7 @@ import { defaultProposalState } from './dispatcher'
 import {
   artifactRef,
   evaluateHarvestPressure,
+  evaluateHarvestPressureFromDigests,
   HARVEST_REPORT_ARTIFACT,
   HARVEST_SCAN_ARTIFACT,
   HARVEST_TRANSCRIPT_ARTIFACT,
@@ -230,7 +231,9 @@ export class HarvestRunner {
     try {
       await this.startHeartbeat()
       await this.ensureLease()
-      let events = await store.getRepoEvents(repo)
+      // Bounded read (AUT-489): reduceHarvest and the verdict/failure filters
+      // below consume durable types only, so the subset is replay-equivalent.
+      let events = await store.getRepoStateEvents(repo)
       let state = reduceHarvest(events)
       run = actionableHarvestRun(state)
 
@@ -238,19 +241,48 @@ export class HarvestRunner {
       // 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.getRepoEvents(repo)
+      events = await store.getRepoStateEvents(repo)
       state = reduceHarvest(events)
       run = openHarvestRun(state)
 
       if (!run) {
         await this.controlBoundary()
-        const scan = await scanUnclaimedObservations(store, repo)
-        // Scanning may span many build streams. Treat its completion as a
-        // boundary even when the threshold is not met, so a request arriving
-        // during the read is acknowledged before this runner returns idle.
+        // Flat-cost gate (AUT-521): the pressure trigger is evaluated from
+        // the journal and one repo-scoped digest batch read — no per-build
+        // history reads — so the idle evaluation no longer grows with
+        // accumulated finished builds. Only a tripped gate pays for the full
+        // unclaimed-observation scan, because the packet artifact needs the
+        // observation payloads no bounded source carries.
+        // 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),
+          store.getRepoBuildDigests(repo),
+        ])
+        const pressure = evaluateHarvestPressureFromDigests({
+          digests,
+          harvestEvents: gateEvents,
+          policy: this.currentConfig().policy,
+        })
+        if (pressure.trigger === undefined) {
+          // Treat the read's completion as a boundary even when the gate did
+          // not trip, so a request arriving during the read is acknowledged
+          // before this runner returns idle.
+          await this.controlBoundary()
+          return { outcome: 'idle' }
+        }
         await this.controlBoundary()
-        const pressure = evaluateHarvestPressure(scan, this.currentConfig().policy)
-        if (pressure.trigger === undefined) return { outcome: 'idle' }
+        const scan = await scanUnclaimedObservations(store, repo)
+        // The trigger came from an earlier read than this scan, and a claim
+        // may have landed in the window. Re-confirm the gate against the
+        // fresh scan (pure, free): an emptied window returns idle exactly as
+        // if the gate had not tripped, so a packet is only ever built from a
+        // scan that itself triggered.
+        const confirmed = evaluateHarvestPressure(scan, this.currentConfig().policy)
+        if (confirmed.trigger === undefined) {
+          await this.controlBoundary()
+          return { outcome: 'idle' }
+        }
         const runId = this.deps.ids('harvest')
         const packet = await makeHarvestScanPacket({
           store,
@@ -280,14 +312,15 @@ export class HarvestRunner {
               run: runId,
               observations: packet.observations.map((item) => item.occurrence),
               scan: artifactRef(deposited[0]!),
-              trigger: pressure.trigger,
+              trigger: confirmed.trigger,
               ...(this.deps.environment !== undefined
                 ? { environment: this.deps.environment }
                 : {}),
             },
           }),
         )
-        events = await store.getRepoEvents(repo)
+        // Bounded read (AUT-489): reduceHarvest consumes durable types only.
+        events = await store.getRepoStateEvents(repo)
         run = reduceHarvest(events).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
@@ -448,7 +481,9 @@ export class HarvestRunner {
             existing.verdict,
             existing.artifact,
           )
-          const event = (await this.deps.store.getRepoEvents(this.deps.repo)).find(
+          // 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' }> =>
@@ -515,7 +550,9 @@ export class HarvestRunner {
         event.actor.kind === 'agent' &&
         event.actor.session === session,
     })
-    const events = await this.deps.store.getRepoEvents(this.deps.repo)
+    // 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(
@@ -565,7 +602,9 @@ export class HarvestRunner {
   ): Promise<void> {
     const { store, repo, ids, workspacePath } = this.deps
     await this.ensureLease()
-    const events = await store.getRepoEvents(repo)
+    // 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' &&
@@ -823,7 +862,9 @@ export class HarvestRunner {
   }): Promise<void> {
     const { store, repo, ids, workspacePath } = this.deps
     await this.ensureLease()
-    const events = await store.getRepoEvents(repo)
+    // 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' &&
@@ -1296,7 +1337,9 @@ export class HarvestRunner {
 
   private async recordWorkflowFailure(run: string, error: unknown): Promise<void> {
     await this.ensureLease()
-    const events = await this.deps.store.getRepoEvents(this.deps.repo)
+    // 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 current = state.runs.find((candidate) => candidate.run === run)
     if (current?.status !== 'running') return
@@ -1349,7 +1392,8 @@ export class HarvestRunner {
    * outer budget and therefore remain recoverable. */
   private async settleRecoveryExhaustion(run: string): Promise<void> {
     await this.ensureLease()
-    const state = reduceHarvest(await this.deps.store.getRepoEvents(this.deps.repo))
+    // Bounded read (AUT-489): reduceHarvest consumes durable types only.
+    const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
     const decision = decideHarvestControl(state, this.maxRecoveryAttempts)
     if (decision.kind !== 'exhaust-recovery' || decision.run !== run) return
     await this.finalizeRecoveryExhaustion(decision.run, decision.attempts, decision.limit)
@@ -1374,7 +1418,8 @@ export class HarvestRunner {
     })
 
     await this.ensureLease()
-    const state = reduceHarvest(await this.deps.store.getRepoEvents(this.deps.repo))
+    // Bounded read (AUT-489): reduceHarvest consumes durable types only.
+    const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
     const decision = decideHarvestControl(state, this.maxRecoveryAttempts)
     if (
       decision.kind !== 'exhaust-recovery' ||
@@ -1410,7 +1455,8 @@ export class HarvestRunner {
   private async controlBoundary(run?: string): Promise<void> {
     while (true) {
       await this.ensureLease()
-      const state = reduceHarvest(await this.deps.store.getRepoEvents(this.deps.repo))
+      // Bounded read (AUT-489): reduceHarvest consumes durable types only.
+      const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
       const decision = decideHarvestControl(state, this.maxRecoveryAttempts)
       if (decision.kind === 'proceed') return
       if (decision.kind === 'park') {
@@ -1453,7 +1499,8 @@ export class HarvestRunner {
   }
 
   private async refreshRun(run: string): Promise<HarvestRunState> {
-    const state = reduceHarvest(await this.deps.store.getRepoEvents(this.deps.repo))
+    // Bounded read (AUT-489): reduceHarvest consumes durable types only.
+    const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
     const found = state.runs.find((candidate) => candidate.run === run)
     if (!found) throw new Error(`unknown harvest run "${run}"`)
     return found