@defrex/autobuild 0.13.0 → 0.14.0

package/packages/core/src/kernel/reducer-registry.ts

@@ -1,3 +1,22 @@
+import { terminalGuardReducer } from './terminal-guard'
+import { repositoryAttentionReducer } from './repository-attention'
+import {
+  dispatcherRunFactsReducer,
+  buildStreamSeedReducer,
+  buildReadFactsReducer,
+  repositoryReadFactsReducer,
+  optionalValue,
+} from './read-facts'
+import { validateAccumulator, encodeReducerValue } from '../store/reducer-value-validation'
+import {
+  effectiveConfigReducer,
+  buildDelegationReducer,
+  harvestDelegationReducer,
+} from './service-facts'
+import { phaseSchema } from '../ontology'
+import { z } from 'zod'
+import type { ValueCatalogEntry } from '../store/reducer-values'
+import { dispatchFrontendReducer } from '../cli/dispatch-repository-feed'
 import { executionNoProgressReducer } from '../processes/execution-no-progress'
 import { summaryBoundaryReducer, summaryRequestsReducer } from './pr-summary'
 import { dispatchFailureBudgetReducer } from '../processes/dispatch-failure-budget'
@@ -52,6 +71,7 @@ import {
 import { buildReducer } from './reducer'
 
 export interface RegisteredReducer {
+  valueRead: ValueCatalogEntry | { excluded: string }
   // biome-ignore lint/suspicious/noExplicitAny: the registry is heterogeneous
   reducer: IncrementalReducer<any, any, any>
   /** The whole-array functions (or private methods) this reducer backs. */
@@ -60,7 +80,24 @@ export interface RegisteredReducer {
 
 /** Parameterized reducers are registered with representative arguments; the
  * accumulator shape does not depend on them. */
-export const REDUCERS: Record<string, RegisteredReducer> = {
+const REGISTERED: Record<string, Omit<RegisteredReducer, 'valueRead'>> = {
+  baseBranchValue: { reducer: optionalValue(baseBranchReducer), covers: [] },
+  publishedBranchHeadValue: { reducer: optionalValue(publishedBranchHeadReducer), covers: [] },
+  verifyDiffBaseValue: { reducer: optionalValue(verifyDiffBaseReducer), covers: [] },
+  recordedBaseShaValue: { reducer: optionalValue(recordedBaseShaReducer), covers: [] },
+  terminalGuard: {
+    reducer: terminalGuardReducer({ phase: 'plan', round: 1, session: 'session' }),
+    covers: [],
+  },
+  dispatcherRunFacts: { reducer: dispatcherRunFactsReducer('run-a'), covers: [] },
+  repositoryAttention: { reducer: repositoryAttentionReducer, covers: [] },
+  repositoryReadFacts: { reducer: repositoryReadFactsReducer, covers: [] },
+  buildStreamSeed: { reducer: buildStreamSeedReducer, covers: [] },
+  buildReadFacts: { reducer: buildReadFactsReducer, covers: [] },
+  effectiveConfig: { reducer: effectiveConfigReducer, covers: [] },
+  buildDelegation: { reducer: buildDelegationReducer, covers: [] },
+  harvestDelegation: { reducer: harvestDelegationReducer, covers: [] },
+  dispatchFrontend: { reducer: dispatchFrontendReducer, covers: [] },
   executionNoProgress: { reducer: executionNoProgressReducer, covers: [] },
   summaryBoundary: { reducer: summaryBoundaryReducer, covers: ['summaryBoundary'] },
   summaryRequests: { reducer: summaryRequestsReducer, covers: ['pendingSummaryRequests'] },
@@ -122,9 +159,9 @@ export const REDUCERS: Record<string, RegisteredReducer> = {
   phaseFailures: { reducer: phaseFailuresReducer('plan', 1), covers: ['phaseFailures'] },
   openBuildWorkspace: {
     reducer: openBuildWorkspaceReducer,
-    covers: ['openBuildWorkspace', 'openWorkspace', 'forgeWorkspacePath'],
+    covers: ['openBuildWorkspace'],
   },
-  baseBranch: { reducer: baseBranchReducer, covers: ['baseBranchOf'] },
+  baseBranch: { reducer: baseBranchReducer, covers: [] },
   provisionMarker: { reducer: provisionMarkerReducer, covers: ['openProvisionMarker'] },
   recoveryCheckpoint: { reducer: recoveryCheckpointReducer, covers: ['recoveryCheckpoint'] },
   currentDeferralObservation: {
@@ -143,9 +180,106 @@ export const REDUCERS: Record<string, RegisteredReducer> = {
   pinnedAssets: { reducer: pinnedAssetsReducer, covers: ['findPinnedRevision'] },
 }
 
+/** Qualification concerns the existing finished contract, including absence. */
+const valueExclusions: Record<string, string> = {
+  dispatchFrontend: 'returns a list of raw repository journal events',
+  journalView: 'returns a list of raw repository journal events',
+  repositoryStateEvents: 'returns a list of raw repository journal events',
+  session: 'consumes operator-session logs rather than build or repository events',
+  publicationState: 'finished value contains executable selector functions',
+  logIndex: 'finished value contains Maps and Sets',
+  hostedPrAttachments: 'finished value is a Map',
+  ...Object.fromEntries(
+    [
+      'summaryBoundary',
+      'ticketSourceHealth',
+      'frozenPrImageHost',
+      'publishedBranchHead',
+      'verifyDiffBase',
+      'recordedBaseSha',
+      'baseBranch',
+      'provisionMarker',
+      'recoveryCheckpoint',
+    ].map((name) => [name, 'finished contract can return top-level undefined, which is not JSON']),
+  ),
+}
+const repositoryValues = new Set([
+  'repositoryReadFacts',
+  'dispatcherRunFacts',
+  'repositoryAttention',
+  'effectiveConfig',
+  'harvestDelegation',
+  'harvest',
+  'dispatchSettings',
+  'dispatchStatus',
+  'sandboxStates',
+  'openHarvestExecutions',
+  'openTick',
+  'autoMergeDefault',
+])
+const noArgs = z.object({}).strict()
+const parameterized: Record<string, Pick<ValueCatalogEntry, 'args' | 'create'>> = {
+  terminalGuard: {
+    args: z
+      .object({ phase: phaseSchema, round: z.number().int(), session: z.string().min(1) })
+      .strict(),
+    create: (args) => terminalGuardReducer(args),
+  },
+  dispatchStatus: {
+    args: z.object({ run: z.string().min(1) }).strict(),
+    create: ({ run }) => dispatchStatusReducer(run),
+  },
+  dispatcherRunFacts: {
+    args: z.object({ run: z.string().min(1) }).strict(),
+    create: ({ run }) => dispatcherRunFactsReducer(run),
+  },
+  openTick: {
+    args: z.object({ run: z.string().min(1) }).strict(),
+    create: ({ run }) => openTickReducer(run),
+  },
+  dispatchFailureBudget: {
+    args: z.object({ infrastructureOwnsWorkspace: z.boolean() }).strict(),
+    create: ({ infrastructureOwnsWorkspace }) =>
+      dispatchFailureBudgetReducer(infrastructureOwnsWorkspace),
+  },
+  phaseFailures: {
+    args: z.object({ phase: phaseSchema, round: z.number().int().nonnegative() }).strict(),
+    create: ({ phase, round }) => phaseFailuresReducer(phase, round),
+  },
+}
+export const REDUCERS: Record<string, RegisteredReducer> = Object.fromEntries(
+  Object.entries(REGISTERED).map(([name, entry]) => [
+    name,
+    {
+      ...entry,
+      valueRead: valueExclusions[name]
+        ? { excluded: valueExclusions[name] }
+        : {
+            scope: repositoryValues.has(name) ? 'repo' : 'build',
+            args: parameterized[name]?.args ?? noArgs,
+            validate: (state: unknown) => validateAccumulator(name, state),
+            value: encodeReducerValue,
+            adapt: (events: Parameters<ValueCatalogEntry['adapt']>[0]) =>
+              name === 'buildDigest'
+                ? events.map((event) => ({
+                    type: event.type,
+                    seq: event.seq,
+                    ts: event.ts,
+                    ...('hostedSeq' in event.payload ? { hostedSeq: event.payload.hostedSeq } : {}),
+                    ...('instance' in event.payload ? { instance: event.payload.instance } : {}),
+                  }))
+                : events,
+            create: parameterized[name]?.create ?? (() => entry.reducer),
+          },
+    },
+  ]),
+)
+
 /** Event-array functions that are deliberately not reducers, each with the
  * concrete reason. */
 export const EXCLUDED: Record<string, string> = {
+  shouldPublishTick:
+    'Publication decision over a new report and actual start time plus the bounded recorded journal; no event-only reduction can decide whether an unrecorded tick has effects.',
   projectDispatcherLiveness:
     'combines mutable repository lease metadata and an explicit clock with correlated facts; cannot be restored from an event-only snapshot',
   decideNext: 'a decision function over config; returns a Decision, not a state',

package/packages/core/src/kernel/repository-attention.ts

@@ -0,0 +1,179 @@
+import type { RepositoryEvent } from '../events/repository'
+import { defineReducer } from './incremental'
+type Degraded = Extract<RepositoryEvent, { type: 'dispatcher.ticket-source-degraded' }>
+type Failed = Extract<RepositoryEvent, { type: 'dispatcher.tick-failed' }>
+export type PersistenceObservation =
+  | {
+      type: 'dispatcher.ticket-source-persistent'
+      source: string
+      cause: string
+      message: string
+      resetAt?: string
+      episodeSeq: number
+      observedAt: string
+      dependencyLimited: boolean
+    }
+  | {
+      type: 'dispatcher.tick-failure-persistent'
+      run: string
+      firstFailure: string
+      error: string
+      episodeSeq: number
+      observedAt: string
+    }
+
+interface SourceAttention {
+  event: Degraded
+  deadline: number
+  dependencyLimited: boolean
+  requiresRetry: boolean
+  retryObserved: boolean
+}
+export interface RepositoryAttentionState {
+  sources: [string, SourceAttention][]
+  failure?: Failed
+  tickStarts: [string, number][]
+}
+/** Incremental journal projection. Episode starts survive run anchors and
+ * repeated evidence can strengthen, but never postpone, an existing deadline. */
+export class RepositoryAttention {
+  private sources: Map<string, SourceAttention>
+  private failure: Failed | undefined
+  private tickStarts: Map<string, number>
+  constructor(state?: RepositoryAttentionState) {
+    this.sources = new Map(state?.sources ?? [])
+    this.failure = state?.failure
+    this.tickStarts = new Map(state?.tickStarts ?? [])
+  }
+  snapshot(): RepositoryAttentionState {
+    return structuredClone({
+      sources: [...this.sources],
+      failure: this.failure,
+      tickStarts: [...this.tickStarts],
+    })
+  }
+
+  private sourceDefersTick(now: number): boolean {
+    return [...this.sources.values()].some(
+      (source) => now < source.deadline || (source.requiresRetry && !source.retryObserved),
+    )
+  }
+
+  /** Crossing resetAt alone does not prove persistence: the dispatcher must
+   * finish a tick that could actually retry after the provider cooldown. */
+  private observeRetry(run: string): void {
+    const startedAt = this.tickStarts.get(run)
+    this.tickStarts.delete(run)
+    if (startedAt === undefined) return
+    for (const source of this.sources.values()) {
+      if (startedAt >= source.deadline) source.retryObserved = true
+    }
+  }
+  fold(event: RepositoryEvent): void {
+    switch (event.type) {
+      case 'dispatcher.ticket-source-degraded': {
+        const existing = this.sources.get(event.payload.source)
+        const deadline =
+          'resetAt' in event.payload
+            ? Date.parse(event.payload.resetAt)
+            : Date.parse(event.ts) + 15 * 60_000
+        if (existing) {
+          existing.deadline = Math.min(existing.deadline, deadline)
+          existing.requiresRetry ||= 'resetAt' in event.payload
+        } else
+          this.sources.set(event.payload.source, {
+            event,
+            deadline,
+            dependencyLimited: false,
+            requiresRetry: 'resetAt' in event.payload,
+            retryObserved: false,
+          })
+        // Cooldown-driven failures are not an independent dispatcher outage.
+        if (this.sourceDefersTick(Date.parse(event.ts))) this.failure = undefined
+        break
+      }
+      case 'dispatcher.ticket-source-dependency-limited': {
+        const source = this.sources.get(event.payload.source)
+        if (source) source.dependencyLimited = true
+        break
+      }
+      case 'dispatcher.ticket-source-recovered':
+        this.sources.delete(event.payload.source)
+        break
+      case 'dispatcher.run-started':
+        this.failure = undefined
+        this.tickStarts.clear()
+        break
+      case 'dispatcher.run-stopped':
+        this.tickStarts.delete(event.payload.run)
+        if (this.failure?.payload.run === event.payload.run) this.failure = undefined
+        break
+      case 'dispatcher.tick-started':
+        this.tickStarts.set(event.payload.run, Date.parse(event.payload.startedAt ?? event.ts))
+        break
+      case 'dispatcher.tick-completed':
+        this.observeRetry(event.payload.run)
+        if (this.failure?.payload.run === event.payload.run) this.failure = undefined
+        break
+      case 'dispatcher.tick-failed':
+        this.observeRetry(event.payload.run)
+        if (this.sourceDefersTick(Date.parse(event.ts))) this.failure = undefined
+        else if (this.failure?.payload.run !== event.payload.run) this.failure = event
+        break
+    }
+  }
+  pending(now: Date): { identity: string; observation: PersistenceObservation }[] {
+    const results: { identity: string; observation: PersistenceObservation }[] = []
+    for (const {
+      event,
+      deadline,
+      dependencyLimited,
+      requiresRetry,
+      retryObserved,
+    } of this.sources.values()) {
+      if (now.getTime() < deadline || (requiresRetry && !retryObserved)) continue
+      results.push({
+        identity: `source:${event.seq}`,
+        observation: {
+          type: 'dispatcher.ticket-source-persistent',
+          ...event.payload,
+          episodeSeq: event.seq,
+          observedAt: now.toISOString(),
+          dependencyLimited,
+        },
+      })
+    }
+    const event = this.failure
+    if (
+      event &&
+      !this.sourceDefersTick(now.getTime()) &&
+      now.getTime() >= Date.parse(event.ts) + 5 * 60_000
+    )
+      results.push({
+        identity: `tick:${event.seq}`,
+        observation: {
+          type: 'dispatcher.tick-failure-persistent',
+          ...event.payload,
+          firstFailure: event.ts,
+          episodeSeq: event.seq,
+          observedAt: now.toISOString(),
+        },
+      })
+    return results
+  }
+}
+
+export const repositoryAttentionReducer = defineReducer<
+  RepositoryAttentionState,
+  RepositoryEvent,
+  RepositoryAttentionState
+>({
+  version: 1,
+  initial: () => ({ sources: [], tickStarts: [] }),
+  fold(acc, events) {
+    const attention = new RepositoryAttention(acc)
+    for (const event of events) attention.fold(event)
+    Object.assign(acc, attention.snapshot())
+  },
+  finish: (acc) => structuredClone(acc),
+})

package/packages/core/src/kernel/service-facts.ts

@@ -0,0 +1,135 @@
+/** Small semantic projections used by stateless service requests. */
+import type { AbEvent } from '../events/catalog'
+import type { RepositoryEvent } from '../events/repository'
+import type { ArtifactRef } from '../ontology'
+import { defineReducer } from './incremental'
+
+export const effectiveConfigReducer = defineReducer<
+  { run?: string; reference?: ArtifactRef },
+  RepositoryEvent,
+  { run?: string; reference?: ArtifactRef }
+>({
+  version: 1,
+  initial: () => ({}),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'dispatcher.run-started') {
+        acc.run = event.payload.run
+        acc.reference = event.payload.effectiveConfig
+      } else if (
+        event.type === 'dispatcher.config-reloaded' &&
+        event.payload.run === acc.run &&
+        event.payload.effectiveConfig !== undefined
+      ) {
+        acc.reference = event.payload.effectiveConfig
+      }
+    }
+  },
+  finish: (acc) => ({ ...acc }),
+})
+
+export function delegationFactKey(id: string): string {
+  return `id:${id}`
+}
+
+export interface EndingFact {
+  seq: number
+  at: string
+}
+export interface SessionFacts {
+  starts: number[]
+  endings: EndingFact[]
+}
+export interface BuildDelegationFacts {
+  lastSeq: number
+  sessions: Record<string, SessionFacts>
+  terminals: EndingFact[]
+}
+export interface HarvestDelegationFacts {
+  lastSeq: number
+  runs: Record<string, true>
+  sessions: Record<string, Record<string, SessionFacts>>
+  authorizations: Record<string, Record<string, { seq: number; leaseHolder: string }>>
+  releases: Record<string, string[]>
+  endings: Record<string, EndingFact[]>
+}
+/** Only lifecycle facts are retained. Contiguous canonical logs make every seq
+ * from 1 through lastSeq a valid anchor without one entry per dispatcher tick. */
+export const buildDelegationReducer = defineReducer<
+  BuildDelegationFacts,
+  AbEvent,
+  BuildDelegationFacts
+>({
+  version: 1,
+  initial: () => ({ lastSeq: 0, sessions: {}, terminals: [] }),
+  fold(acc, events) {
+    for (const event of events) {
+      acc.lastSeq = event.seq
+      if (event.type === 'session.started' || event.type === 'session.ended') {
+        const key = delegationFactKey(event.payload.session)
+        acc.sessions[key] ??= { starts: [], endings: [] }
+        const session = acc.sessions[key]!
+        if (event.type === 'session.started') session.starts.push(event.seq)
+        else session.endings.push({ seq: event.seq, at: event.ts })
+      } else if (event.type === 'build.completed' || event.type === 'build.aborted')
+        acc.terminals.push({ seq: event.seq, at: event.ts })
+    }
+  },
+  finish: (acc) => structuredClone(acc),
+})
+export const harvestDelegationReducer = defineReducer<
+  HarvestDelegationFacts,
+  RepositoryEvent,
+  HarvestDelegationFacts
+>({
+  version: 1,
+  initial: () => ({
+    lastSeq: 0,
+    runs: {},
+    sessions: {},
+    authorizations: {},
+    releases: {},
+    endings: {},
+  }),
+  fold(acc, events) {
+    for (const event of events) {
+      acc.lastSeq = event.seq
+      if (event.type === 'harvest.started') acc.runs[delegationFactKey(event.payload.run)] = true
+      if (event.type === 'harvest.execution.authorized') {
+        const key = delegationFactKey(event.payload.run)
+        acc.authorizations[key] ??= {}
+        const run = acc.authorizations[key]!
+        run[delegationFactKey(event.payload.execution)] ??= {
+          seq: event.seq,
+          leaseHolder: event.payload.leaseHolder,
+        }
+      }
+      if (event.type === 'harvest.session.started' || event.type === 'harvest.session.ended') {
+        const runKey = delegationFactKey(event.payload.run)
+        acc.sessions[runKey] ??= {}
+        const run = acc.sessions[runKey]!
+        const sessionKey = delegationFactKey(event.payload.session)
+        run[sessionKey] ??= { starts: [], endings: [] }
+        const session = run[sessionKey]!
+        if (event.type === 'harvest.session.started') session.starts.push(event.seq)
+        else session.endings.push({ seq: event.seq, at: event.ts })
+      }
+      if (event.type === 'harvest.execution.released' || event.type === 'harvest.execution.ended') {
+        const key = delegationFactKey(event.payload.execution)
+        acc.releases[key] ??= []
+        acc.releases[key]!.push(event.ts)
+      }
+      if (
+        event.type === 'harvest.completed' ||
+        event.type === 'harvest.escalated' ||
+        event.type === 'harvest.recovery-exhausted' ||
+        (event.type === 'harvest.failed' && !event.payload.willRetry)
+      ) {
+        const key = delegationFactKey(event.payload.run)
+        acc.endings[key] ??= []
+        acc.endings[key]!.push({ seq: event.seq, at: event.ts })
+      }
+    }
+  },
+  finish: (acc) => structuredClone(acc),
+})

package/packages/core/src/kernel/terminal-guard.ts

@@ -0,0 +1,133 @@
+import type { AbEvent } from '../events/catalog'
+import type { Phase } from '../ontology'
+import { isVerifyPhase, verifyStep } from '../ontology'
+import { phaseSpecFor } from './phases'
+import { defineReducer } from './incremental'
+type CliEnv = { phase: Phase; round: number; session: string }
+interface TerminalGuardAcc {
+  reconcileAttempt: number
+  sessionStartedSeq?: number
+  permanent?: { seq: number; diagnostic: string }
+  completion?: { seq: number; diagnostic: string }
+}
+export function terminalGuardReducer(env: CliEnv) {
+  const spec = phaseSpecFor(env.phase)
+  return defineReducer<TerminalGuardAcc, AbEvent, { diagnostic?: string }>({
+    version: 1,
+    initial: () => ({ reconcileAttempt: 0 }),
+    fold(acc, events) {
+      for (const event of events) {
+        if (event.type === 'spec.revised' && (isVerifyPhase(env.phase) || env.phase === 'finalize'))
+          delete acc.completion
+        if (event.type === 'reconcile.started') acc.reconcileAttempt = event.payload.attempt
+        if (event.type === 'session.started' && event.payload.session === env.session)
+          acc.sessionStartedSeq = event.seq
+        try {
+          checkEvent(event, env, acc.reconcileAttempt, acc.sessionStartedSeq)
+        } catch (error) {
+          const key = event.type === spec.terminalEvent ? 'completion' : 'permanent'
+          acc[key] ??= { seq: event.seq, diagnostic: (error as Error).message }
+        }
+      }
+    },
+    finish(acc) {
+      const first = [acc.permanent, acc.completion]
+        .filter((item) => item !== undefined)
+        .sort((a, b) => a.seq - b.seq)[0]
+      return first ? { diagnostic: first.diagnostic } : {}
+    },
+  })
+}
+function checkEvent(
+  event: AbEvent,
+  env: CliEnv,
+  reconcileAttempt: number,
+  sessionStartedSeq?: number,
+): void {
+  const spec = phaseSpecFor(env.phase)
+  const restartSeq = 0
+  if (event.type === 'session.ended' && event.payload.session === env.session) {
+    throw new Error(
+      `terminal rejected (D5): session "${env.session}" already ended ` +
+        `(session.ended at seq ${event.seq}) — a session that ended without ` +
+        'a terminal was failed and retried; only the live retry may complete ' +
+        'this phase round (§8.4).',
+    )
+  }
+  if (
+    sessionStartedSeq !== undefined &&
+    event.type === 'phase.failed' &&
+    event.payload.phase === env.phase &&
+    event.payload.round === env.round &&
+    event.seq > sessionStartedSeq
+  ) {
+    throw new Error(
+      `terminal rejected (D5): ${env.phase}@${env.round} already failed after ` +
+        `this session started (phase.failed at seq ${event.seq}) — the retry ` +
+        'session owns this round now (§8.4).',
+    )
+  }
+  if (
+    event.type === 'escalation.raised' &&
+    event.actor.kind === 'agent' &&
+    event.actor.session === env.session
+  ) {
+    throw new Error(
+      `second terminal call rejected (D5): this session already escalated — ` +
+        `escalation.raised "${event.payload.id}" at seq ${event.seq}. ` +
+        'Every phase ends with exactly one terminal command (§8.4).',
+    )
+  }
+  if (
+    event.type === 'publication.requested' &&
+    event.actor.kind === 'agent' &&
+    event.actor.session === env.session &&
+    ((env.phase === 'implement' &&
+      event.payload.operation === 'implement' &&
+      event.payload.round === env.round) ||
+      (env.phase === 'reconcile' && event.payload.operation === 'reconcile') ||
+      (env.phase === 'finalize' && event.payload.operation === 'finalize'))
+  ) {
+    throw new Error(
+      `second terminal call rejected (D5): ${event.type} for ` +
+        `${env.phase}@${env.round} already recorded at seq ${event.seq}. ` +
+        'Remote publication is pending; do not run ab done again (§8.4).',
+    )
+  }
+  if (event.type !== spec.terminalEvent) return
+  if (
+    (event.type === 'verify.completed' || event.type === 'finalize.completed') &&
+    event.seq <= restartSeq
+  ) {
+    return
+  }
+  if (!terminalMatchesRound(event, env, reconcileAttempt)) return
+  throw new Error(
+    `second terminal call rejected (D5): ${event.type} for ` +
+      `${env.phase}@${env.round} already recorded at seq ${event.seq}. ` +
+      'Every phase ends with exactly one terminal command (§8.4).',
+  )
+}
+function terminalMatchesRound(event: AbEvent, env: CliEnv, reconcileAttempt: number): boolean {
+  switch (event.type) {
+    case 'plan.completed':
+    case 'plan-review.verdict':
+    case 'implement.completed':
+    case 'code-review.verdict':
+      return event.payload.round === env.round
+    case 'verify.completed':
+      return (
+        isVerifyPhase(env.phase) &&
+        event.payload.step === verifyStep(env.phase) &&
+        event.payload.attempt === env.round
+      )
+    case 'finalize.completed':
+      // finalize runs once per build (§5) — any prior completion counts.
+      return true
+    case 'reconcile.completed':
+      // No started event before it → conservative match (total over any log).
+      return reconcileAttempt === env.round || reconcileAttempt === 0
+    default:
+      return false
+  }
+}

package/packages/core/src/operator/control.ts

@@ -1,7 +1,6 @@
+import { readRepositoryFacts } from '../store/reduced-reads'
 import { humanActor, type Via } from '../events/envelope'
 import type { RepositoryEventEnvelope } from '../events/repository'
-import { reduceDispatchSettings } from '../kernel/dispatch-settings'
-import { reduceHarvest } from '../kernel/harvest'
 import type { BuildStore } from '../store/types'
 import { projectHarvest, type HarvestRunAction } from '../cli/dashboard/model'
 
@@ -65,7 +64,7 @@ export async function toggleRepositorySetting(opts: {
 }): Promise<{ enabled: boolean; event: RepositoryEventEnvelope }> {
   await opts.store.ensureRepo(opts.repo)
   // Bounded read (AUT-489): the settings reducer consumes durable types only.
-  const settings = reduceDispatchSettings(await opts.store.getRepoStateEvents(opts.repo))
+  const settings = (await readRepositoryFacts(opts.store, opts.repo)).value.settings
   const enabled = opts.setting === 'intake' ? !settings.intake : !settings.defaultAutoMerge
   return setRepositorySetting({ ...opts, enabled })
 }
@@ -78,7 +77,7 @@ export async function toggleHarvestGate(opts: {
 }): Promise<{ command: 'pause' | 'resume'; event: RepositoryEventEnvelope }> {
   await opts.store.ensureRepo(opts.repo)
   // Bounded read (AUT-489): the harvest reducer consumes durable types only.
-  const state = reduceHarvest(await opts.store.getRepoStateEvents(opts.repo))
+  const state = (await readRepositoryFacts(opts.store, opts.repo)).value.harvest
   const pending = state.pendingCommands.at(-1)
   const requestedPaused = pending === undefined ? state.paused : pending.command === 'pause'
   const command = requestedPaused ? 'resume' : 'pause'
@@ -101,8 +100,8 @@ export async function controlHarvestRun(opts: {
   await opts.store.ensureRepo(opts.repo)
   // Bounded read (AUT-489): the harvest reducer and the dashboard harvest
   // projection consume durable types only.
-  const events = await opts.store.getRepoStateEvents(opts.repo)
-  const state = reduceHarvest(events)
+  const events = (await readRepositoryFacts(opts.store, opts.repo)).value
+  const state = events.harvest
   const projected = projectHarvest(events)
   if (projected === undefined || projected.run !== opts.run) {
     throw new OperatorControlError(

package/packages/core/src/operator/index.ts

@@ -137,3 +137,5 @@ export {
 } from './query'
 
 export { ticketStateCreateRequestSchema } from './protocol'
+
+export { readBuildFacts } from '../store/reduced-reads'