@defrex/autobuild 0.8.0 → 0.10.0

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

@@ -1,5 +1,6 @@
 /** 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'
 import type { ArtifactRef } from '../ontology'
 import {
   harvestProposalSetSchema,
@@ -26,7 +27,14 @@ import {
 } from '../kernel/harvest'
 import type { TicketSource } from '../ports/types'
 import { specConformance } from '../spec-standard'
-import { contentHash, toBytes, type BuildStore } from '../store/types'
+import type { RepositoryEvent } from '../events/repository'
+import {
+  contentHash,
+  toBytes,
+  type BuildDigest,
+  type BuildRecord,
+  type BuildStore,
+} from '../store/types'
 
 export const HARVEST_SCAN_ARTIFACT = 'harvest-scan'
 export const HARVEST_PROPOSALS_ARTIFACT = 'harvest-proposals'
@@ -52,21 +60,33 @@ export interface HarvestPressure {
   trigger?: HarvestTrigger
 }
 
-/** Pure two-dimensional Harvest gate. Drift is measured from the oldest
- * unclaimed observation and excludes that observation's own build. */
-export function evaluateHarvestPressure(
-  scan: Pick<HarvestScanResult, 'observations' | 'merges'>,
+/** The build- and occurrence-shaped facts both pressure evaluations project
+ * onto: the unclaimed occurrences with their event timestamps, and the merge
+ * facts. Keeping the oldest-observation selection and drift arithmetic in one
+ * place makes the scan-based and digest-based evaluations equal by
+ * construction rather than by parallel maintenance (AUT-521). */
+interface HarvestPressureFacts {
+  unclaimed: { build: string; seq: number; ts: string }[]
+  merges: { build: string; ts: string }[]
+}
+
+function evaluateHarvestPressureFacts(
+  facts: HarvestPressureFacts,
   policy: { harvestThreshold: number; harvestMaxDrift: number },
 ): HarvestPressure {
-  const observationCount = scan.observations.length
+  const observationCount = facts.unclaimed.length
   if (observationCount === 0) return { observationCount, drift: 0 }
 
-  const oldest = scan.observations.reduce((candidate, observation) =>
-    observation.ts < candidate.ts ? observation : candidate,
-  )
+  // The oldest unclaimed occurrence: min ts, then build ascending, then seq
+  // ascending — exactly what the scan projection's sort-by-(build,seq) then
+  // strict-`<`-reduce produced, now stated as one comparator.
+  const oldest = [...facts.unclaimed].sort(
+    (a, b) =>
+      (a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0) || a.build.localeCompare(b.build) || a.seq - b.seq,
+  )[0]!
   const mergedBuilds = new Set<string>()
-  for (const merge of scan.merges) {
-    if (merge.build === oldest.occurrence.build || merge.ts <= oldest.ts) continue
+  for (const merge of facts.merges) {
+    if (merge.build === oldest.build || merge.ts <= oldest.ts) continue
     mergedBuilds.add(merge.build)
   }
   const drift = mergedBuilds.size
@@ -87,23 +107,94 @@ export function evaluateHarvestPressure(
   }
 }
 
-/** Raw structured `observation.recorded` envelopes across this repository.
- * The pair `{build, seq}` is the occurrence key; payload ids are not assumed
- * globally unique. */
-export async function scanUnclaimedObservations(
-  store: BuildStore,
-  repo: string,
-): Promise<HarvestScanResult> {
-  await store.ensureRepo(repo)
-  const harvestEvents = await store.getRepoEvents(repo)
-  const state = reduceHarvest(harvestEvents)
+/** Pure two-dimensional Harvest gate. Drift is measured from the oldest
+ * unclaimed observation and excludes that observation's own build. */
+export function evaluateHarvestPressure(
+  scan: Pick<HarvestScanResult, 'observations' | 'merges'>,
+  policy: { harvestThreshold: number; harvestMaxDrift: number },
+): HarvestPressure {
+  return evaluateHarvestPressureFacts(
+    {
+      unclaimed: scan.observations.map((observation) => ({
+        build: observation.occurrence.build,
+        seq: observation.occurrence.seq,
+        ts: observation.ts,
+      })),
+      merges: scan.merges,
+    },
+    policy,
+  )
+}
+
+/** The same gate from build digests and the repository journal alone
+ * (AUT-521): claimedness comes from the journal, unclaimed occurrences and
+ * merge facts from the digests — no per-build history reads. The merge facts
+ * use each digest's latest `pr.merged` ts; drift counts a build when any of
+ * its merges is strictly after the oldest unclaimed observation, and
+ * `max(merge.ts) > oldest.ts` is equivalent to `any(merge.ts) > oldest.ts`,
+ * so latest-wins carries exactly the drift fact the scan collects. */
+export function evaluateHarvestPressureFromDigests(input: {
+  digests: Map<string, BuildDigest>
+  harvestEvents: RepositoryEvent[]
+  policy: { harvestThreshold: number; harvestMaxDrift: number }
+}): HarvestPressure {
+  const claimed = claimedOccurrenceKeys(reduceHarvest(input.harvestEvents))
+  const unclaimed: HarvestPressureFacts['unclaimed'] = []
+  const merges: HarvestPressureFacts['merges'] = []
+  for (const digest of input.digests.values()) {
+    for (const observation of digest.observations) {
+      if (claimed.has(occurrenceKey({ build: digest.slug, seq: observation.seq }))) continue
+      unclaimed.push({ build: digest.slug, seq: observation.seq, ts: observation.ts })
+    }
+    if (digest.merged !== undefined) merges.push({ build: digest.slug, ts: digest.merged })
+  }
+  return evaluateHarvestPressureFacts({ unclaimed, merges }, input.policy)
+}
+
+/** The dispatcher harvest-launch gate's read sequence as one named seam
+ * (AUT-521): `ensureRepo`, one repo-scoped digest batch read, and the pure
+ * digest evaluation with the caller's policy. Per-evaluation cost is one
+ * journal read (passed in by the caller, which already holds it) plus one
+ * bounded digest read — flat in the number of accumulated finished builds,
+ * where the previous scan read every build's full history per evaluation. */
+export async function evaluateHarvestPressureFromStore(input: {
+  store: BuildStore
+  repo: string
+  harvestEvents: RepositoryEvent[]
+  policy: { harvestThreshold: number; harvestMaxDrift: number }
+}): Promise<HarvestPressure> {
+  await input.store.ensureRepo(input.repo)
+  const digests = await input.store.getRepoBuildDigests(input.repo)
+  return evaluateHarvestPressureFromDigests({
+    digests,
+    harvestEvents: input.harvestEvents,
+    policy: input.policy,
+  })
+}
+
+/** The deterministic core of the unclaimed-observation scan, over
+ * already-loaded streams: exactly the reduce/claim/collect/sort the
+ * store-reading scan performs, with no store calls. The dashboard consumes
+ * this directly with the journal and per-build event arrays it has already
+ * fetched (AUT-486), while `scanUnclaimedObservations` keeps the
+ * ensure/read/delegate shape its other callers depend on. */
+export function collectUnclaimedObservations(input: {
+  repo: string
+  records: BuildRecord[]
+  eventsByBuild: Map<string, AbEvent[]>
+  harvestEvents: RepositoryEvent[]
+}): HarvestScanResult {
+  const state = reduceHarvest(input.harvestEvents)
   const claimed = claimedOccurrenceKeys(state)
   const observations: HarvestObservation[] = []
   const merges: HarvestMerge[] = []
 
-  for (const record of await store.listBuilds()) {
-    if (record.repo !== repo) continue
-    const events = await store.getEvents(record.slug)
+  for (const record of input.records) {
+    if (record.repo !== input.repo) continue
+    const events = input.eventsByBuild.get(record.slug)
+    if (events === undefined) {
+      throw new Error(`eventsByBuild is missing an entry for build "${record.slug}"`)
+    }
     for (const event of events) {
       if (event.type === 'pr.merged') {
         merges.push({ build: record.slug, ts: event.ts })
@@ -132,6 +223,87 @@ export async function scanUnclaimedObservations(
   return { observations, merges, state }
 }
 
+/** The unclaimed-observation count from build digests and the repository
+ * journal alone (AUT-487): the same reduce/claim/count the store-reading scan
+ * performs, with no per-build history reads. The operator query consumes this
+ * directly, and the terminal dashboards consume it through
+ * `sampleUnclaimedObservationCount` (AUT-524), while `scanUnclaimedObservations`
+ * keeps the full-scan shape its remaining callers depend on (the harvest
+ * runner's packet scan — the only source of observation payloads — and its
+ * gate re-confirmation; the dispatcher's harvest-launch gate itself evaluates
+ * from digests, AUT-521). Occurrences are keyed `{build, seq}`; payload ids
+ * are not assumed globally unique. */
+export function unclaimedObservationCount(input: {
+  digests: Map<string, BuildDigest>
+  harvestEvents: RepositoryEvent[]
+}): number {
+  const claimed = claimedOccurrenceKeys(reduceHarvest(input.harvestEvents))
+  let count = 0
+  for (const digest of input.digests.values()) {
+    for (const observation of digest.observations) {
+      if (!claimed.has(occurrenceKey({ build: digest.slug, seq: observation.seq }))) count += 1
+    }
+  }
+  return count
+}
+
+/** The shared missing-record journal read (AUT-524): a repository whose
+ * journal record does not yet exist has an empty journal by definition, so
+ * the probe answers `[]` instead of letting `getRepoStateEvents` reject. The
+ * read writes nothing — a display path must not `ensureRepo` — while
+ * `scanUnclaimedObservations` keeps its materializing `ensureRepo` for its
+ * remaining callers.
+ *
+ * The journal read is bounded (AUT-489): every consumer — the terminal
+ * dashboards' observation-pressure sample, the operator query
+ * (operator/query.ts), the dispatcher's repository-wide controls and ready
+ * scans, and the operator sandbox service's journal reads — reduces durable
+ * event types plus the latest-run tail only, so the subset is
+ * replay-equivalent to a full journal replay. */
+export async function readRepoEventsIfRecorded(
+  store: BuildStore,
+  repo: string,
+): Promise<RepositoryEvent[]> {
+  return (await store.getRepo(repo)) === null ? [] : store.getRepoStateEvents(repo)
+}
+
+/** The terminal dashboards' observation-pressure sample (AUT-487): build
+ * digests plus the repository journal, reduced to the unclaimed-observation
+ * count. Store traffic is flat in the finished-build count — one journal read
+ * plus one repo-scoped digest read, plus the journal-record probe inside
+ * `readRepoEventsIfRecorded`. Its missing-record treatment (AUT-524) is the
+ * shared helper's, above. */
+export async function sampleUnclaimedObservationCount(
+  store: BuildStore,
+  repo: string,
+): Promise<number> {
+  const [digests, harvestEvents] = await Promise.all([
+    store.getRepoBuildDigests(repo),
+    readRepoEventsIfRecorded(store, repo),
+  ])
+  return unclaimedObservationCount({ digests, harvestEvents })
+}
+
+/** Raw structured `observation.recorded` envelopes across this repository.
+ * The pair `{build, seq}` is the occurrence key; payload ids are not assumed
+ * globally unique. */
+export async function scanUnclaimedObservations(
+  store: BuildStore,
+  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 records = await store.listBuilds()
+  const eventsByBuild = new Map<string, AbEvent[]>()
+  for (const record of records) {
+    if (record.repo !== repo) continue
+    eventsByBuild.set(record.slug, await store.getEvents(record.slug))
+  }
+  return collectUnclaimedObservations({ repo, records, eventsByBuild, harvestEvents })
+}
+
 /** Distinct previously filed/joined proposal tickets, reconciled through the
  * TicketSource's native lifecycle semantics. Resolved and missing entries stay
  * in the packet as tombstones rather than disappearing and being re-filed. */

package/packages/core/src/processes/infrastructure-failure-budget.ts

@@ -2,6 +2,7 @@ import type { AbEvent } from '../events/catalog'
 import { DISPATCHER } from '../events/envelope'
 import type { EventPayload } from '../events/payloads'
 import type { IdSource } from '../ids'
+import { defineReducer } from '../kernel/incremental'
 import type { BuildStore } from '../store/types'
 
 export type InfrastructureOperation = EventPayload<'infrastructure.failed'>['operation']
@@ -26,27 +27,39 @@ export interface InfrastructureFailureDependencies {
   ids: IdSource
 }
 
+export const INFRASTRUCTURE_FAILURE_RESET_REDUCER_VERSION = 1
+
 /** Infrastructure retries are re-armed only by a confirmed execution boundary
  * or a retry answer to this policy's own previously-raised exhaustion escalation. */
-export function infrastructureFailureResetSeq(events: readonly AbEvent[]): number {
-  const infrastructureEscalations = new Set<string>()
-  let resetSeq = 0
-  for (const event of events) {
-    if (
-      event.type === 'escalation.raised' &&
-      event.payload.policyCause === 'infrastructure-failure-limit'
-    ) {
-      infrastructureEscalations.add(event.payload.id)
-    } else if (
-      event.type === 'execution.ended' ||
-      (event.type === 'escalation.answered' &&
-        event.payload.resolution === 'retry' &&
-        infrastructureEscalations.has(event.payload.id))
-    ) {
-      resetSeq = event.seq
+export const infrastructureFailureResetReducer = defineReducer<
+  { escalations: string[]; resetSeq: number },
+  AbEvent,
+  number
+>({
+  version: INFRASTRUCTURE_FAILURE_RESET_REDUCER_VERSION,
+  initial: () => ({ escalations: [], resetSeq: 0 }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (
+        event.type === 'escalation.raised' &&
+        event.payload.policyCause === 'infrastructure-failure-limit'
+      ) {
+        if (!acc.escalations.includes(event.payload.id)) acc.escalations.push(event.payload.id)
+      } else if (
+        event.type === 'execution.ended' ||
+        (event.type === 'escalation.answered' &&
+          event.payload.resolution === 'retry' &&
+          acc.escalations.includes(event.payload.id))
+      ) {
+        acc.resetSeq = event.seq
+      }
     }
-  }
-  return resetSeq
+  },
+  finish: (acc) => acc.resetSeq,
+})
+
+export function infrastructureFailureResetSeq(events: readonly AbEvent[]): number {
+  return infrastructureFailureResetReducer.reduce(events)
 }
 
 export function normalizeInfrastructureError(error: unknown): string {