@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/kernel/auto-merge-default.ts

@@ -0,0 +1,157 @@
+/**
+ * The repository auto-merge default as a bulk action over in-flight builds.
+ *
+ * The durable `dispatcher.auto-merge-default-set` fact has always been the
+ * claim-time seed; it now also fans out onto every current non-terminal build
+ * of the repository, attributed to the operator who toggled it. The fan-out is
+ * a dispatcher-tick reconciliation driven by the durable fact — never a
+ * write-time walk — so a build claimed concurrently with the toggle and a
+ * build observed by a second dispatcher polling the same repository converge
+ * on the same state.
+ *
+ * Idempotency vs. per-build overrides: each answering command records the
+ * repository `seq` of the default fact that caused it (`defaultSeq`). A tick
+ * applies the default to a build only when the newest fact's seq is strictly
+ * newer than the build's recorded `defaultSeq`. When the build's requested
+ * state already matches the fact, the tick records a provenance-only
+ * `build.auto-merge-default-observed` marker instead of appending a duplicate
+ * command, so a later per-build toggle is not mistaken for staleness and
+ * reverted. A global toggle therefore re-applies over a per-build choice, a
+ * per-build toggle in between is stable, and pressing the toggle twice appends
+ * no duplicate request.
+ *
+ * Eligibility is expressed against `BuildState`, not `effectiveStatus`
+ * (dashboard/model.ts), whose contract is "DISPLAY-ONLY — nothing consults
+ * this"; a durable write path must not become its first consumer — the same
+ * precedent `bulk-control.ts` set for the pause/resume walk.
+ */
+import type { RepositoryEvent } from '../events/repository'
+import { defineReducer } from './incremental'
+import { discardInFlight, type BuildState } from './reducer'
+
+/** One `dispatcher.auto-merge-default-set` fact, resolved. `actor` is the
+ * event's actor — the human who toggled, `via` marker included — and is the
+ * attribution every fan-out command carries. */
+export interface AutoMergeDefaultFact {
+  enabled: boolean
+  /** The repository event's seq — the fan-out's comparison marker. */
+  seq: number
+  actor: RepositoryEvent['actor']
+}
+
+/** The newest `dispatcher.auto-merge-default-set` fact in the repository
+ * journal, or undefined when no default was ever set (the scan runs from the
+ * tail because seqs are monotonic, so the first hit is the newest). With
+ * `enabled`, the newest fact *matching that value* — the fact a claim-time
+ * seed built on a stale pre-tick sample must cite, so a newer opposite fact
+ * stays strictly newer than the seed's provenance and the next tick's
+ * fan-out can reconcile it (f_b851c0e8). */
+export function latestAutoMergeDefault(
+  events: RepositoryEvent[],
+  enabled?: boolean,
+): AutoMergeDefaultFact | undefined {
+  return pickAutoMergeDefault(autoMergeDefaultReducer.reduce(events), enabled)
+}
+
+export const AUTO_MERGE_DEFAULT_REDUCER_VERSION = 1
+
+/** The newest `dispatcher.auto-merge-default-set` fact in array order, overall
+ * and per value — `latestAutoMergeDefault(events, enabled)` is a lookup in
+ * this state, exact for any array order. */
+export interface AutoMergeDefaultFacts {
+  latest?: AutoMergeDefaultFact
+  latestEnabled?: AutoMergeDefaultFact
+  latestDisabled?: AutoMergeDefaultFact
+}
+
+export const autoMergeDefaultReducer = defineReducer<
+  AutoMergeDefaultFacts,
+  RepositoryEvent,
+  AutoMergeDefaultFacts
+>({
+  version: AUTO_MERGE_DEFAULT_REDUCER_VERSION,
+  initial: () => ({}),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type !== 'dispatcher.auto-merge-default-set') continue
+      const fact: AutoMergeDefaultFact = {
+        enabled: event.payload.enabled,
+        seq: event.seq,
+        actor: event.actor,
+      }
+      acc.latest = fact
+      if (fact.enabled) acc.latestEnabled = fact
+      else acc.latestDisabled = fact
+    }
+  },
+  finish: (acc) => ({ ...acc }),
+})
+
+export function pickAutoMergeDefault(
+  facts: AutoMergeDefaultFacts,
+  enabled?: boolean,
+): AutoMergeDefaultFact | undefined {
+  if (enabled === undefined) return facts.latest
+  return enabled ? facts.latestEnabled : facts.latestDisabled
+}
+
+/**
+ * A build the default may still act on: not terminal, and not on its way out.
+ * A pending abort (an explicit request or an accepted escalation answer) must
+ * never receive consent — a merge landing mid-abort is exactly the race this
+ * clause exists to close. The same holds for an outstanding discard request:
+ * `discardRequest` is present exactly while the build is non-terminal and its
+ * discard is unsettled, and the reducer settles it only by terminal completion
+ * — consent recorded inside that window can merge a build the operator already
+ * asked to discard (in the raced-runner-attachment case the discard is inert
+ * for a running build, and the recorded consent later drives the merge in
+ * `checkPr`). Direction-blind like the abort clause: the build terminalizes
+ * imminently either way. If discard ever grows a mid-flight settlement event,
+ * this predicate must be revisited.
+ */
+export function autoMergeDefaultEligible(state: BuildState): boolean {
+  if (state.status === 'done' || state.status === 'aborted') return false
+  // An empty log is a record whose `build.created` has not landed yet (the
+  // crash or one-await window between `createBuild` and the first append):
+  // writing an auto-merge command ahead of the immutable facts would leave the
+  // log unrecoverable — dispatch recovery rejects a log that does not start
+  // with `build.created` (f_647d40be). `lastSeq === 0` is exactly that log.
+  if (state.lastSeq === 0) return false
+  // An outstanding discard request is the same "on its way out" shape as a
+  // pending abort: it settles only by terminal completion (reducer.ts), so
+  // consent recorded inside that window can merge a build the operator
+  // already asked to discard. Direction-blind, like the abort clause — an
+  // OFF fan-out skipping it withdraws nothing that survives the settlement.
+  // Shared predicate: the per-build consent guard (build-control.ts) applies
+  // the same exclusion to consent-recording writes. A per-build OFF withdrawal
+  // stays available there — revocation only shrinks the merge set — which is a
+  // stated, directional divergence, not a silent one.
+  if (discardInFlight(state)) return false
+  return !state.pendingCommands.some((command) => command.command === 'abort')
+}
+
+/** What one default fact asks of one build: a real command, a pure provenance
+ * advance, or `undefined` for "nothing". */
+export type AutoMergeDefaultTarget = 'request' | 'cancel' | 'observed'
+
+/** What one default fact asks of one build, or undefined for "nothing".
+ *
+ * Seq-first: a build whose recorded provenance is already this fact (or newer)
+ * has had its day in court — a per-build toggle made after the fan-out stands
+ * until the default moves again. A build that sampled the default at claim time
+ * carries the fact's seq too, so a fresh claim is not re-fanned on the next
+ * tick.
+ *
+ * When the requested state already matches the fact, the fact still has to be
+ * *recorded* as observed (`'observed'`) so the next tick does not mistake a
+ * later per-build command for staleness: the marker advances `defaultSeq`
+ * without a duplicate request/cancel (f_28b3fba1). */
+export function autoMergeDefaultTarget(
+  state: BuildState,
+  fact: AutoMergeDefaultFact,
+): AutoMergeDefaultTarget | undefined {
+  if (!autoMergeDefaultEligible(state)) return undefined
+  if ((state.autoMerge.defaultSeq ?? 0) >= fact.seq) return undefined
+  if (state.autoMerge.requested === fact.enabled) return 'observed'
+  return fact.enabled ? 'request' : 'cancel'
+}

package/packages/core/src/kernel/auto-merge.ts

@@ -2,6 +2,7 @@ import type { AbEvent, EventEnvelope, EventWrite } from '../events/catalog'
 import { KERNEL } from '../events/envelope'
 import { autoMergeDeferralClasses, type AutoMergeDeferralReason } from '../ports/types'
 import type { BuildStore } from '../store/types'
+import { defineReducer } from './incremental'
 import type { BuildState } from './reducer'
 
 /** The complete GitHub `mergeStateStatus` enum. Keeping this list closed is a
@@ -133,36 +134,104 @@ export function currentDeferralObservation(
   events: AbEvent[],
   prNumber: number,
   commandSeq: number,
-): Extract<AbEvent, { type: 'observation.recorded' }> | undefined {
+): DeferralObservation | undefined {
+  return deferralObservationFrom(
+    currentDeferralObservationReducer.reduce(events),
+    prNumber,
+    commandSeq,
+  )
+}
+
+type DeferralObservation = Extract<AbEvent, { type: 'observation.recorded' }>
+
+const DEFERRAL_REF_PREFIX = 'auto-merge-gate:pr:'
+
+/** One array-order ledger entry. Only the facts the currency predicate reads
+ * are kept, with every maximal run of other events collapsed to a barrier
+ * carrying the run's max seq: the head scan stops at the first event (of ANY
+ * type) with `seq >= observation.seq`, so an unrelated event must still be able
+ * to end it. */
+type DeferralLedgerEntry =
+  | { t: 'barrier'; seq: number }
+  | { t: 'observation'; event: DeferralObservation }
+  | { t: 'finalized'; seq: number; headSha: string }
+  | { t: 'terminal'; seq: number }
+  | { t: 'reconciled'; seq: number }
+
+export const CURRENT_DEFERRAL_OBSERVATION_REDUCER_VERSION = 1
+
+export interface DeferralLedger {
+  entries: DeferralLedgerEntry[]
+}
+
+export const currentDeferralObservationReducer = defineReducer<
+  DeferralLedger,
+  AbEvent,
+  DeferralLedger
+>({
+  version: CURRENT_DEFERRAL_OBSERVATION_REDUCER_VERSION,
+  initial: () => ({ entries: [] }),
+  fold(acc, events) {
+    for (const event of events) {
+      let entry: DeferralLedgerEntry | undefined
+      if (
+        event.type === 'observation.recorded' &&
+        event.payload.refs?.some((ref) => ref.startsWith(DEFERRAL_REF_PREFIX)) === true
+      ) {
+        entry = { t: 'observation', event }
+      } else if (event.type === 'finalize.completed') {
+        entry = { t: 'finalized', seq: event.seq, headSha: event.payload.pr.headSha }
+      } else if (event.type === 'pr.merged' || event.type === 'pr.closed') {
+        entry = { t: 'terminal', seq: event.seq }
+      } else if (event.type === 'reconcile.completed') {
+        entry = { t: 'reconciled', seq: event.seq }
+      }
+      if (entry !== undefined) {
+        acc.entries.push(entry)
+        continue
+      }
+      const last = acc.entries.at(-1)
+      if (last?.t === 'barrier') last.seq = Math.max(last.seq, event.seq)
+      else acc.entries.push({ t: 'barrier', seq: event.seq })
+    }
+  },
+  finish: (acc) => ({ entries: acc.entries.slice() }),
+})
+
+function deferralEntrySeq(entry: DeferralLedgerEntry): number {
+  return entry.t === 'observation' ? entry.event.seq : entry.seq
+}
+
+/** The current deferral observation for a PR/command over a reduced ledger. */
+export function deferralObservationFrom(
+  ledger: DeferralLedger,
+  prNumber: number,
+  commandSeq: number,
+): DeferralObservation | undefined {
   const marker = autoMergeDeferralRef(prNumber, commandSeq)
-  let observation: Extract<AbEvent, { type: 'observation.recorded' }> | undefined
-  for (let index = events.length - 1; index >= 0; index -= 1) {
-    const event = events[index]
-    if (
-      event !== undefined &&
-      event.type === 'observation.recorded' &&
-      event.payload.refs?.includes(marker) === true
-    ) {
-      observation = event
+  const { entries } = ledger
+  let observation: DeferralObservation | undefined
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index]
+    if (entry?.t === 'observation' && entry.event.payload.refs?.includes(marker) === true) {
+      observation = entry.event
       break
     }
   }
   if (observation === undefined) return undefined
 
   let headAtObservation: string | undefined
-  for (const event of events) {
-    if (event.seq >= observation.seq) break
-    if (event.type === 'finalize.completed') headAtObservation = event.payload.pr.headSha
+  for (const entry of entries) {
+    if (deferralEntrySeq(entry) >= observation.seq) break
+    if (entry.t === 'finalized') headAtObservation = entry.headSha
   }
 
-  for (const event of events) {
-    if (event.seq <= observation.seq) continue
-    if (event.type === 'pr.merged' || event.type === 'pr.closed') return undefined
-    if (event.type === 'reconcile.completed') return undefined
-    if (event.type === 'finalize.completed') {
-      if (headAtObservation === undefined) headAtObservation = event.payload.pr.headSha
-      else if (event.payload.pr.headSha !== headAtObservation) return undefined
-    }
+  for (const entry of entries) {
+    if (entry.t === 'observation' || entry.t === 'barrier') continue
+    if (entry.seq <= observation.seq) continue
+    if (entry.t === 'terminal' || entry.t === 'reconciled') return undefined
+    if (headAtObservation === undefined) headAtObservation = entry.headSha
+    else if (entry.headSha !== headAtObservation) return undefined
   }
   return observation
 }
@@ -186,10 +255,18 @@ export function hasAutoMergeDeferralObservation(
 export function currentAutoMergeDeferral(
   events: AbEvent[],
   state: Pick<BuildState, 'autoMerge' | 'pr'>,
+): string | undefined {
+  return currentAutoMergeDeferralFrom(currentDeferralObservationReducer.reduce(events), state)
+}
+
+/** `currentAutoMergeDeferral` over an already-reduced ledger. */
+export function currentAutoMergeDeferralFrom(
+  ledger: DeferralLedger,
+  state: Pick<BuildState, 'autoMerge' | 'pr'>,
 ): string | undefined {
   const pending = pendingAutoMerge(state)
   if (pending?.enabled !== true || state.pr === undefined) return undefined
-  return currentDeferralObservation(events, state.pr.number, pending.commandSeq)?.payload.summary
+  return deferralObservationFrom(ledger, state.pr.number, pending.commandSeq)?.payload.summary
 }
 
 const DEFERRAL_SUMMARIES = {

package/packages/core/src/kernel/dispatch-settings.ts

@@ -4,6 +4,7 @@
  * is authoritative; fresh repositories retain the historical process defaults.
  */
 import type { RepositoryEvent } from '../events/repository'
+import { defineReducer, type IncrementalReducer } from './incremental'
 
 export const DEFAULT_DISPATCH_INTAKE = true
 export const DEFAULT_DISPATCH_PAUSED = false
@@ -21,32 +22,36 @@ export interface DispatchSettings {
   defaultAutoMerge: boolean
 }
 
-export function reduceDispatchSettings(events: RepositoryEvent[]): DispatchSettings {
-  let intake = DEFAULT_DISPATCH_INTAKE
-  let paused = DEFAULT_DISPATCH_PAUSED
-  let defaultAutoMerge = DEFAULT_DISPATCH_AUTO_MERGE
-  let intakeSeq = 0
-  let pausedSeq = 0
-  let autoMergeSeq = 0
+/** The carried accumulator: the settings plus the seq of the fact that set
+ * each, which decides last-writer-wins independent of array order. */
+export interface DispatchSettingsAcc extends DispatchSettings {
+  intakeSeq: number
+  pausedSeq: number
+  autoMergeSeq: number
+}
+
+/** Bump when `DispatchSettingsAcc`'s shape or fold semantics change. */
+export const DISPATCH_SETTINGS_REDUCER_VERSION = 1
 
+function foldDispatchSettings(acc: DispatchSettingsAcc, events: readonly RepositoryEvent[]): void {
   for (const event of events) {
     switch (event.type) {
       case 'dispatcher.intake-set':
-        if (event.seq > intakeSeq) {
-          intake = event.payload.enabled
-          intakeSeq = event.seq
+        if (event.seq > acc.intakeSeq) {
+          acc.intake = event.payload.enabled
+          acc.intakeSeq = event.seq
         }
         break
       case 'dispatcher.pause-set':
-        if (event.seq > pausedSeq) {
-          paused = event.payload.enabled
-          pausedSeq = event.seq
+        if (event.seq > acc.pausedSeq) {
+          acc.paused = event.payload.enabled
+          acc.pausedSeq = event.seq
         }
         break
       case 'dispatcher.auto-merge-default-set':
-        if (event.seq > autoMergeSeq) {
-          defaultAutoMerge = event.payload.enabled
-          autoMergeSeq = event.seq
+        if (event.seq > acc.autoMergeSeq) {
+          acc.defaultAutoMerge = event.payload.enabled
+          acc.autoMergeSeq = event.seq
         }
         break
       default:
@@ -55,6 +60,26 @@ export function reduceDispatchSettings(events: RepositoryEvent[]): DispatchSetti
         break
     }
   }
+}
+
+export const dispatchSettingsReducer: IncrementalReducer<
+  DispatchSettingsAcc,
+  RepositoryEvent,
+  DispatchSettings
+> = defineReducer({
+  version: DISPATCH_SETTINGS_REDUCER_VERSION,
+  initial: () => ({
+    intake: DEFAULT_DISPATCH_INTAKE,
+    paused: DEFAULT_DISPATCH_PAUSED,
+    defaultAutoMerge: DEFAULT_DISPATCH_AUTO_MERGE,
+    intakeSeq: 0,
+    pausedSeq: 0,
+    autoMergeSeq: 0,
+  }),
+  fold: foldDispatchSettings,
+  finish: ({ intake, paused, defaultAutoMerge }) => ({ intake, paused, defaultAutoMerge }),
+})
 
-  return { intake, paused, defaultAutoMerge }
+export function reduceDispatchSettings(events: RepositoryEvent[]): DispatchSettings {
+  return dispatchSettingsReducer.reduce(events)
 }

package/packages/core/src/kernel/dispatch-status.ts

@@ -1,5 +1,6 @@
 import type { RepositoryEvent } from '../events/repository'
 import type { ArtifactRef } from '../ontology'
+import type { IncrementalReducer } from './incremental'
 
 export type DispatchHealth = 'starting' | 'running' | 'stopped' | 'failed'
 
@@ -139,3 +140,25 @@ export function reduceDispatchStatus(
   }
   return state
 }
+
+/** Bump when `DispatchStatus`'s shape or fold semantics change (it is its own
+ * accumulator: `lastSeq` makes the fold skip already-seen events). */
+export const DISPATCH_STATUS_REDUCER_VERSION = 1
+
+/** The incremental form of `reduceDispatchStatus` for one run. The run is a
+ * parameter, so this is a factory. */
+export function dispatchStatusReducer(
+  run: string,
+): IncrementalReducer<DispatchStatus, RepositoryEvent, DispatchStatus> {
+  return {
+    version: DISPATCH_STATUS_REDUCER_VERSION,
+    initial: () => ({ run, health: 'starting', roleWarnings: [], diagnostics: [], lastSeq: 0 }),
+    advance: (acc, events) => reduceDispatchStatus(events, run, acc),
+    finish: (acc) => ({
+      ...acc,
+      roleWarnings: [...acc.roleWarnings],
+      diagnostics: [...acc.diagnostics],
+    }),
+    reduce: (events) => reduceDispatchStatus(events, run),
+  }
+}