@defrex/autobuild 0.12.0 → 0.14.0

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

@@ -1,8 +1,10 @@
+import { readBuildDigests } from '../store/reduced-reads'
+import { readBuildFacts, type CurrentBuildFacts } from '../store/reduced-reads'
+import { ensureExecutionProgress } from './execution-no-progress'
+import { ticketIdentity } from '../ports/tickets/identity'
+import { ticketLifecycle } from '../ports/tickets/lifecycle'
 import { ensureDispatchBudget } from './dispatch-failure-budget'
-import {
-  reduceTicketSourceHealth,
-  type TicketSourceDegradation,
-} from '../kernel/ticket-source-health'
+import type { TicketSourceDegradation } from '../kernel/ticket-source-health'
 /**
  * The dispatcher process (SPEC §3.3, §12): watches the TicketSource for
  * Ready tickets, claims, provisions a workspace, and launches build-runners
@@ -57,19 +59,18 @@ import {
 } from '../kernel/auto-merge'
 import {
   autoMergeDefaultTarget,
-  latestAutoMergeDefault,
+  pickAutoMergeDefault,
   type AutoMergeDefaultFact,
 } from '../kernel/auto-merge-default'
-import { reduceDispatchSettings } from '../kernel/dispatch-settings'
 import { decideNextFromFacts } from '../kernel/engine'
+import { composeBuildConfig } from '../config/live'
+import { BUILD_EFFECTIVE_CONFIG_ARTIFACT, parseEffectiveBuildConfig } from './build-execution-state'
 import {
   DEFAULT_MAX_HARVEST_RECOVERY_ATTEMPTS,
   decideHarvestControl,
-  harvestCreationsDuringReadyScan,
-  reduceHarvest,
+  harvestCreationsFromStates,
 } from '../kernel/harvest'
-import { pendingPrAttachmentReclaims } from '../kernel/pr-attachments'
-import { reduceBuild, type BuildState } from '../kernel/reducer'
+import type { BuildState } from '../kernel/reducer'
 import { createOperatorSandboxService, type OperatorSandboxService } from '../operator/sandbox'
 import type { ArtifactRef, TicketRef } from '../ontology'
 import { BUILD_EXECUTION_LEASE_TTL_MS } from '../ports/workspace/build-execution'
@@ -83,25 +84,15 @@ import type {
 import { TicketSourceRateLimitError } from '../ports/types'
 import type { Exec } from '../ports/workspace/git-worktree'
 import type { ArtifactMeta, BuildDigest, BuildRecord, BuildStore, Clock } from '../store/types'
-import { samplePinnedAssets } from '../store/ticket-assets'
+import { preparePinnedAssets } from '../store/ticket-assets'
 import { resolveRepoOrigin } from '../cli/repo-state'
 import { specConformance } from '../spec-standard'
 export { specConformance, type SpecConformance } from '../spec-standard'
 import { recordInfrastructureFailure as appendInfrastructureFailure } from './infrastructure-failure-budget'
 import { settleOpenExecution } from './execution-settlement'
-import { openHarvestExecutions } from './harvest-execution-state'
 import { isWorkDigest, RepoViewStore } from './repo-view'
-import {
-  baseBranchReducer,
-  openBuildWorkspace,
-  provisionMarkerReducer,
-  recoveryCheckpointReducer,
-  type OpenBuildWorkspace,
-  type ProvisionMarker,
-} from './dispatcher-selectors'
-import type { RepositoryEvent } from '../events/repository'
-import { sandboxStates } from './sandbox-state'
-import { settlePublicationBeforeRelease } from './publication-loss'
+import type { OpenBuildWorkspace, ProvisionMarker } from './dispatcher-selectors'
+import { settlePublicationFactsBeforeRelease } from './publication-loss'
 
 // ── Readiness resolution (SPEC §3.3) ─────────────────────────────────────────
 
@@ -148,16 +139,11 @@ export function readyCriteria(config: Config): {
  * readiness is: the file tracker's grooming area IS the `triage/` directory,
  * while a Linear team only has a "Triage" workflow state when the team's
  * triage feature is enabled — Backlog is the state every Linear team has.
- * The hosted source is the credential-bearing Linear proxy and shares that
- * fallback. Plugin sources use the neutral `Triage` fallback unless configured.
+ * Hosted projects default to lowercase triage; plugin sources use the neutral
+ * `Triage` fallback unless configured.
  */
 export function defaultTriageState(config: Config): string {
-  return (
-    config.tickets.triageState ??
-    (config.tickets.source === 'linear' || config.tickets.source === 'hosted'
-      ? 'Backlog'
-      : 'Triage')
-  )
+  return ticketLifecycle(config.tickets).triage
 }
 
 /**
@@ -547,6 +533,8 @@ export interface DispatcherDeps {
   retiredWorkspaces?: readonly WorkspaceProvider[]
   forge: Forge
   config: Config
+  /** Configuration-only publication for incompatible pins; never launches a runner. */
+  repairBuildConfig?: (slug: string) => Promise<void>
   /** Current process snapshot, captured once at the beginning of each tick.
    * Omission preserves the cron/static-config API. */
   getConfig?: () => Config
@@ -609,14 +597,14 @@ export interface DispatcherDeps {
 /** Latest `workspace.provisioned` not followed by a `workspace.released` —
  * the reducer deliberately ignores workspace events (liveness is the
  * dispatcher's concern), so the janitor scans the raw log. */
-function openWorkspace(events: AbEvent[]): OpenBuildWorkspace | null {
-  return openBuildWorkspace(events)
+function openWorkspace(events: CurrentBuildFacts): OpenBuildWorkspace | null {
+  return events.workspace
 }
 
 /** The build's base branch, from its own `build.created` fact (§15.3);
  * falls back to the repo config for logs missing one. */
-function baseBranchOf(events: AbEvent[], config: Config): string {
-  return baseBranchReducer.reduce(events) ?? config.baseBranch
+function baseBranchOf(events: CurrentBuildFacts, config: Config): string {
+  return events.baseBranch ?? config.baseBranch
 }
 
 function artifactRefOf(deposited: ArtifactMeta[]): ArtifactRef {
@@ -647,6 +635,38 @@ export function heldByRepositoryPause(state: BuildState, paused: boolean): boole
 }
 
 export class Dispatcher {
+  /** Read at each decision boundary: artifact revisions are independent of events. */
+  private async decideBuild(
+    slug: string,
+    state: Parameters<typeof decideNextFromFacts>[0],
+    log: Parameters<typeof decideNextFromFacts>[1],
+    report: TickReport,
+  ): Promise<ReturnType<typeof decideNextFromFacts> | undefined> {
+    let revision: number | undefined
+    try {
+      let artifact = await this.store.getArtifact(slug, BUILD_EFFECTIVE_CONFIG_ARTIFACT)
+      if (artifact === null) return decideNextFromFacts(state, log, this.deps.config)
+      revision = artifact.meta.revision
+      let pinned: Config
+      try {
+        pinned = parseEffectiveBuildConfig(artifact)
+      } catch (error) {
+        if (this.deps.repairBuildConfig === undefined) throw error
+        await this.deps.repairBuildConfig(slug)
+        artifact = await this.store.getArtifact(slug, BUILD_EFFECTIVE_CONFIG_ARTIFACT)
+        if (artifact === null) throw new Error('configuration repair deposited no pipeline')
+        revision = artifact.meta.revision
+        pinned = parseEffectiveBuildConfig(artifact)
+      }
+      return decideNextFromFacts(state, log, composeBuildConfig(pinned, this.deps.config))
+    } catch (error) {
+      report.blockedDiagnostics.push(
+        `build ${slug} pipeline${revision === undefined ? '' : ` revision ${revision}`} unavailable: pipeline decisions withheld; next tick retries. Restore readable build-branch configuration or use a compatible dispatcher version. ${error instanceof Error ? error.message : String(error)}`,
+      )
+      return undefined
+    }
+  }
+
   /** Memoized normalized origin of the served repository (one git call per
    * dispatcher), recorded on created builds so ambient reads can accept a
    * differently located checkout of the same repository by origin equality.
@@ -670,7 +690,7 @@ export class Dispatcher {
     return (
       this.deps.opts?.doneState ??
       (this.deps.config.tickets.source === 'hosted'
-        ? this.deps.config.tickets.doneState
+        ? ticketLifecycle(this.deps.config.tickets).done
         : undefined) ??
       'Done'
     )
@@ -725,14 +745,7 @@ export class Dispatcher {
   }
 
   async tick(opts: TickOpts = {}): Promise<TickReport> {
-    try {
-      return await this.runTick(opts)
-    } finally {
-      // Leave this tick's reduced state behind for the next process (a cache;
-      // a failure to write it is never a tick failure). Throttled in a
-      // resident dispatcher, always run by a cold single-tick process.
-      await this.store.persistSnapshots()
-    }
+    return this.runTick(opts)
   }
 
   private async runTick(opts: TickOpts): Promise<TickReport> {
@@ -757,9 +770,9 @@ export class Dispatcher {
     // likewise samples before calling `tick`); the auto-merge default fact is
     // the durable driver of this tick's fan-out below. Neither control
     // pretends to a serialization the store does not offer.
-    const repoEvents = this.store.recordedJournal()
-    const paused = reduceDispatchSettings(repoEvents).paused
-    const autoMergeDefault = latestAutoMergeDefault(repoEvents)
+    const repoFacts = this.store.repositoryFacts()
+    const paused = repoFacts.settings.paused
+    const autoMergeDefault = pickAutoMergeDefault(repoFacts.autoMerge)
     // The claim-time seed cites the newest fact whose enabled state matches
     // the launch sample, not blindly the newest fact: the CLI samples
     // `defaultAutoMerge` from its own earlier read, so an interleaved toggle
@@ -768,7 +781,7 @@ export class Dispatcher {
     // so the fan-out reconciles the build on the next tick instead of the
     // stale sample out-voting the durable default forever (f_b851c0e8).
     const autoMergeSeedFact =
-      opts.defaultAutoMerge === true ? latestAutoMergeDefault(repoEvents, true) : undefined
+      opts.defaultAutoMerge === true ? pickAutoMergeDefault(repoFacts.autoMerge, true) : undefined
     // Stage 0 — SETTLEMENT: observe foreign executions from durable facts plus
     // provider liveness and settle their completion, lease, and publication.
     // Runs before the janitor so its executionLeaseLive checks see freshly
@@ -882,7 +895,7 @@ export class Dispatcher {
     const store = this.store
     const { repo } = this.deps
     const records = (await store.listBuilds()).filter((record) => record.repo === repo)
-    const digests = await store.getRepoBuildDigests(repo)
+    const digests = await readBuildDigests(store, repo)
     return records.map((record) => {
       const digest = digests.get(record.slug)
       if (digest === undefined) {
@@ -918,7 +931,7 @@ export class Dispatcher {
     successfulOperation?: 'ready-scan' | 'dependency-check',
   ): Promise<void> {
     await this.store.refreshJournal()
-    const current = reduceTicketSourceHealth(this.store.recordedJournal())
+    const current = this.store.repositoryFacts().health
     if (next !== undefined && current?.cause === next.cause && current.source === next.source) {
       if (
         next.cause === 'rate-limited' &&
@@ -988,6 +1001,23 @@ export class Dispatcher {
     }
   }
 
+  private async activeTicketIdentities(refs: TicketRef[], listed: Ticket[]): Promise<Set<string>> {
+    const key = (ref: TicketRef) => `${ref.source}:${ref.id}`
+    const ids = new Set(refs.map(key))
+    if (this.deps.tickets.name !== 'hosted' || listed.length === 0) return ids
+    const listedIds = new Set(listed.map((ticket) => key(ticket.ref)))
+    const identity = ticketIdentity(this.deps.tickets)
+    try {
+      for (const ref of refs) {
+        if (ref.source === 'hosted' && !listedIds.has(key(ref))) ids.add(await identity(ref))
+      }
+    } catch (error) {
+      await this.sourceFailure(error, 'ready-scan')
+      throw error
+    }
+    return ids
+  }
+
   /** Observation-only ready listing for Store-backed frontends while intake is
    * disabled. It shares the active-ticket exclusion with dispatch but performs
    * no dependency fetch, claim, bounce, build, workspace, or launch side
@@ -999,20 +1029,21 @@ export class Dispatcher {
   }> {
     this.deps.config = this.deps.getConfig?.() ?? this.deps.config
     await this.store.refresh()
-    const activeTicketIds = new Set<string>()
-    for (const { record, digest } of await this.repoBuildDigests()) {
-      if (record.ticket !== undefined && digest.terminal === undefined) {
-        activeTicketIds.add(record.ticket.id)
-      }
-    }
     const report = emptyTickReport()
     this.restoreScan(report)
     const checkpoint = await this.scanCheckpoint('observation')
     if (checkpoint.due) {
       await this.store.refreshJournal()
       const listing = await this.listReady()
+      const refs: TicketRef[] = []
+      for (const { record, digest } of await this.repoBuildDigests()) {
+        if (record.ticket && digest.terminal === undefined) refs.push(record.ticket)
+      }
+      const activeTicketIds = await this.activeTicketIdentities(refs, listing.tickets)
       await this.store.refreshJournal()
-      report.queued = listing.tickets.filter((ticket) => !activeTicketIds.has(ticket.ref.id)).length
+      report.queued = listing.tickets.filter(
+        (ticket) => !activeTicketIds.has(`${ticket.ref.source}:${ticket.ref.id}`),
+      ).length
       report.invalidTickets = listing.diagnostics.length
       report.ticketDiagnostics = [...listing.diagnostics]
       report.dependencyBlocked = 0
@@ -1030,12 +1061,7 @@ export class Dispatcher {
   }
 
   private latestScan() {
-    return this.store
-      .recordedJournal()
-      .findLast(
-        (event): event is Extract<RepositoryEvent, { type: 'dispatcher.ticket-scan-completed' }> =>
-          event.type === 'dispatcher.ticket-scan-completed',
-      )?.payload
+    return this.store.repositoryFacts().scan
   }
 
   private restoreScan(report: TickReport): void {
@@ -1167,15 +1193,30 @@ export class Dispatcher {
       return
     }
     // Bounded subset (AUT-489): the harvest reducer consumes durable types only.
-    const state = reduceHarvest(this.store.recordedJournal())
+    const state = this.store.repositoryFacts().harvest
     if (decideHarvestControl(state, this.maxHarvestRecoveryAttempts).kind !== 'park') {
       start()
     }
   }
 
-  private async launch(slug: string, launched: Set<string>): Promise<LaunchRunnerResult> {
+  private async launch(
+    slug: string,
+    launched: Set<string>,
+    report: TickReport = emptyTickReport(),
+  ): Promise<LaunchRunnerResult> {
     if (launched.has(slug)) return 'already-active'
     launched.add(slug)
+    if (
+      !(await ensureExecutionProgress(
+        this.store,
+        this.deps.ids,
+        slug,
+        this.deps.config,
+        (state, log) => this.decideBuild(slug, state, log, report),
+      ))
+    ) {
+      return 'already-active'
+    }
     return this.deps.launchRunner(slug)
   }
 
@@ -1238,13 +1279,13 @@ export class Dispatcher {
    * repository lease. */
   private async settleHarvestExecutions(opts: TickOpts = {}): Promise<void> {
     const active = this.deps.activeHarvestExecutions?.() ?? new Set<string>()
-    let events: RepositoryEvent[]
+    let facts: ReturnType<RepoViewStore['repositoryFacts']>
     try {
       // The earlier stages awaited providers; take the journal delta so a
       // foreign append (operator activity, harvest facts) made meanwhile is
       // seen before any destructive decision below.
       await this.store.refreshJournal()
-      events = this.store.recordedJournal()
+      facts = this.store.repositoryFacts()
     } catch {
       // The read itself failed (a transient store error — a missing record
       // answers `[]` inside the helper, so it never reaches this arm):
@@ -1252,7 +1293,7 @@ export class Dispatcher {
       // tick proceeds, and the next tick retries what remains.
       return
     }
-    for (const execution of openHarvestExecutions(events)) {
+    for (const execution of facts.openHarvest) {
       if (active.has(execution.execution)) continue
       // Budget gate: once spent, stop settling further harvest executions;
       // the next tick retries what remains.
@@ -1341,13 +1382,13 @@ export class Dispatcher {
     const capability = this.deps.workspaces.orchestratorSandbox
     if (capability === undefined) return
     const providerName = this.deps.workspaces.name
-    let events: RepositoryEvent[]
+    let facts: ReturnType<RepoViewStore['repositoryFacts']>
     try {
       // The earlier stages awaited providers; take the journal delta so a
       // foreign append (operator activity, harvest facts) made meanwhile is
       // seen before any destructive decision below.
       await this.store.refreshJournal()
-      events = this.store.recordedJournal()
+      facts = this.store.repositoryFacts()
     } catch {
       // The read itself failed (a transient store error — a missing record
       // answers `[]` inside the helper, so it never reaches this arm):
@@ -1356,7 +1397,7 @@ export class Dispatcher {
       return
     }
     const idleMs = config.orchestrator.sandbox.idleMinutes * 60_000
-    for (const environment of sandboxStates(events)) {
+    for (const environment of facts.sandboxes) {
       if (environment.state !== 'live') continue
       // Budget gate: once spent, stop settling further environments; the
       // next tick retries what remains.
@@ -1438,8 +1479,8 @@ export class Dispatcher {
 
   /** The latest `workspace.provision-started` not yet followed by a
    * provisioned/released fact — an open provisioning marker. */
-  private openProvisionMarker(events: AbEvent[]): ProvisionMarker | undefined {
-    return provisionMarkerReducer.reduce(events)
+  private openProvisionMarker(events: CurrentBuildFacts): ProvisionMarker | undefined {
+    return events.provisionMarker
   }
 
   /** Liveness of the lease behind an open provision marker: `live` means a
@@ -1460,7 +1501,7 @@ export class Dispatcher {
    * report progress without awaiting any of it. */
   private async ensureProvisionContinuation(
     record: BuildRecord,
-    events: AbEvent[],
+    events: CurrentBuildFacts,
     tail: 'dispatch' | 'launch',
     seed?: {
       ticket: Ticket
@@ -1476,12 +1517,7 @@ export class Dispatcher {
     const marker = this.openProvisionMarker(events)
     if (marker !== undefined) {
       const liveness = await this.provisionMarkerLiveness(slug)
-      const failedAttempt = events.some(
-        (event) =>
-          event.type === 'dispatch.failed' &&
-          event.payload.stage === 'workspace' &&
-          event.seq > marker.seq,
-      )
+      const failedAttempt = events.latestWorkspaceFailureSeq > marker.seq
       if (liveness === 'live') return 'foreign-live'
       if (
         liveness === 'absent' &&
@@ -1496,7 +1532,7 @@ export class Dispatcher {
       // Expired lease, failed attempt, or an old lease-less marker: adopt.
     }
     const branch = record.branch ?? `ab/${slug}`
-    const generation = events.filter((event) => event.type === 'workspace.provisioned').length
+    const generation = events.workspaceGenerations
     await this.store.append(slug, {
       actor: DISPATCHER,
       type: 'workspace.provision-started',
@@ -1576,10 +1612,8 @@ export class Dispatcher {
         // so the next supervisor adopts the marker immediately.
         return
       }
-      const events = await store.getEvents(slug)
-      const priorGenerations = events.filter(
-        (event) => event.type === 'workspace.provisioned',
-      ).length
+      const events = (await readBuildFacts(store, slug)).value
+      const priorGenerations = events.workspaceGenerations
       const handle = await workspaces.provision({
         // Local providers provision FROM the physical checkout; remote
         // providers ignore the value (their host seams are injected).
@@ -1622,7 +1656,7 @@ export class Dispatcher {
       boundary = 'read'
       const record = await store.getBuild(slug)
       if (record === null) return
-      const queued = reduceBuild(await store.getEvents(slug)).status === 'queued'
+      const queued = (await readBuildFacts(store, slug)).value.state.status === 'queued'
       boundary = input.tail === 'dispatch' || queued ? 'dispatch' : 'launch'
       if (boundary === 'dispatch') await this.completeDispatchBoundaries(record, input.seed)
       else await this.deps.launchRunner(slug)
@@ -1632,10 +1666,10 @@ export class Dispatcher {
       // tick; it is not another provider workspace failure. Replacement
       // runner launch errors retain the existing infrastructure-budget path.
       if (boundary === 'read' || boundary === 'dispatch') return
-      const events = await store.getEvents(slug)
+      const events = (await readBuildFacts(store, slug)).value
       if (workspaces.recovery !== undefined) {
         const open = openWorkspace(events)
-        const latestRef = [...events].reverse().find((event) => event.type === 'workspace.released')
+        const latestRef = events.latestRelease
         await this.recordInfrastructureFailure(slug, events, {
           provider: workspaces.name,
           workspaceRef:
@@ -1648,7 +1682,7 @@ export class Dispatcher {
           cleanupPending: true,
         })
       }
-      const attempt = events.filter((event) => event.type === 'dispatch.failed').length + 1
+      const attempt = events.dispatchFailureCount + 1
       const message = (error instanceof Error ? error.message : String(error)).trim()
       await store.append(slug, {
         actor: DISPATCHER,
@@ -1697,9 +1731,9 @@ export class Dispatcher {
     for (const entry of entries) entry.controller.abort()
     for (const entry of entries) {
       try {
-        const events = await this.store.getEvents(entry.slug)
+        const events = (await readBuildFacts(this.store, entry.slug)).value
         if (this.openProvisionMarker(events) !== undefined) {
-          const attempt = events.filter((event) => event.type === 'dispatch.failed').length + 1
+          const attempt = events.dispatchFailureCount + 1
           await this.store.append(entry.slug, {
             actor: DISPATCHER,
             type: 'dispatch.failed',
@@ -1749,9 +1783,9 @@ export class Dispatcher {
         const executionLeaseLive = this.hasLiveExecutionLease(record)
         // Raw history, read at most once and only by a branch that acts on it:
         // the facts above answer every quiet-path question without it.
-        let loaded: AbEvent[] | undefined
-        const history = async (): Promise<AbEvent[]> => {
-          loaded ??= await this.store.getEvents(record.slug)
+        let loaded: CurrentBuildFacts | undefined
+        const history = async (): Promise<CurrentBuildFacts> => {
+          loaded ??= (await readBuildFacts(this.store, record.slug)).value
           return loaded
         }
         // Pipeline/ticket/workspace state is settled, but release-asset cleanup
@@ -1814,7 +1848,7 @@ export class Dispatcher {
     }
   }
 
-  private forgeWorkspacePath(events: AbEvent[]): string {
+  private forgeWorkspacePath(events: CurrentBuildFacts): string {
     return this.forgeWorkspacePathOf(openWorkspace(events))
   }
 
@@ -1838,7 +1872,7 @@ export class Dispatcher {
    * repeating on later ticks. `build.completed` is deliberately last. */
   private async cleanupAborted(
     record: BuildRecord,
-    events: AbEvent[],
+    events: CurrentBuildFacts,
     report: TickReport,
   ): Promise<void> {
     const store = this.store
@@ -1852,13 +1886,11 @@ export class Dispatcher {
     // in the main checkout, and origin mode has no checkout at all: the
     // local-branch git step is skipped, and the saga's later steps tolerate
     // its absence.
-    const hadLocalWorkspace = events.some(
-      (event) => event.type === 'workspace.provisioned' && !isRemoteWorkspace(event.payload),
-    )
-    const has = (type: AbEvent['type']): boolean => events.some((event) => event.type === type)
+    const hadLocalWorkspace = events.localWorkspace
+    const has = (type: AbEvent['type']): boolean => events.seenTypes.includes(type)
     const append = async <T extends EventWrite['type']>(write: EventWrite<T>): Promise<void> => {
-      const event = await store.append(record.slug, write)
-      events.push(event as AbEvent)
+      const _event = await store.append(record.slug, write)
+      Object.assign(events, (await readBuildFacts(store, record.slug)).value)
     }
     const fail = (operation: string, identity: string, error: unknown): never => {
       const detail = error instanceof Error ? error.message : String(error)
@@ -1875,7 +1907,7 @@ export class Dispatcher {
       }
     }
 
-    const reduced = reduceBuild(events)
+    const reduced = events.state
     if (reduced.pr !== undefined && !has('pr.closed') && !has('pr.merged')) {
       const closePr = forge.closePr
       if (closePr === undefined) {
@@ -1905,7 +1937,8 @@ export class Dispatcher {
 
     try {
       const released = await this.releaseWorkspace(record.slug, events, 'abort')
-      if (released !== undefined) events.push(released)
+      if (released !== undefined)
+        Object.assign(events, (await readBuildFacts(store, record.slug)).value)
     } catch (error) {
       fail('workspace release', `build ${record.slug}`, error)
     }
@@ -2002,7 +2035,7 @@ export class Dispatcher {
    * every partial cleanup is retried after a crash. */
   private async cleanupDiscarded(
     record: BuildRecord,
-    events: AbEvent[],
+    events: CurrentBuildFacts,
     report: TickReport,
   ): Promise<void> {
     const store = this.store
@@ -2032,7 +2065,7 @@ export class Dispatcher {
     record: BuildRecord,
     // `workspace` is the open workspace fact; `history` loads the raw log, which
     // only the branches that act on a PR transition need.
-    source: { history: () => Promise<AbEvent[]>; workspace: OpenBuildWorkspace | null },
+    source: { history: () => Promise<CurrentBuildFacts>; workspace: OpenBuildWorkspace | null },
     state: BuildState,
     report: TickReport,
     launched: Set<string>,
@@ -2072,12 +2105,12 @@ export class Dispatcher {
       if (state.prState === 'conflicted') return
       const events = await source.history()
       const baseSha = await this.baseSha(baseBranchOf(events, this.deps.config))
-      const conflicted = await store.append(record.slug, {
+      const _conflicted = await store.append(record.slug, {
         actor: DISPATCHER,
         type: 'pr.conflicted',
         payload: { baseSha },
       } satisfies EventWrite<'pr.conflicted'>)
-      events.push(conflicted)
+      Object.assign(events, (await readBuildFacts(this.store, record.slug)).value)
       if (openWorkspace(events) === null && this.deps.workspaces.recovery !== undefined) {
         // The reconcile workspace is provisioned by the tracked background
         // continuation, whose tail re-attaches the build-runner; this tick
@@ -2089,7 +2122,7 @@ export class Dispatcher {
       }
       // The dispatcher never runs agents (§15.7): re-attach a build-runner,
       // which executes the reconcile epilogue phase.
-      await this.launch(record.slug, launched)
+      await this.launch(record.slug, launched, report)
       report.conflicted += 1
       return
     }
@@ -2123,12 +2156,12 @@ export class Dispatcher {
         const latest = await store.buildFacts(record.slug)
         const latestState = latest.state
         const latestIntent = pendingAutoMerge(latestState)
-        const decision = decideNextFromFacts(latest.state, latest.log, this.deps.config)
+        const decision = await this.decideBuild(record.slug, latest.state, latest.log, report)
         if (
           latestState.pr?.number === pr.number &&
           latestIntent?.enabled === true &&
           latestIntent.commandSeq === autoMerge.commandSeq &&
-          decision.kind === 'wait' &&
+          decision?.kind === 'wait' &&
           decision.reason === 'awaiting-pr'
         ) {
           await forge.squashMerge(workspacePath, pr.number, result.headSha)
@@ -2203,12 +2236,9 @@ export class Dispatcher {
    * is deliberately post-terminal and best-effort: a provider, timeout, or
    * store failure cannot roll back build.completed/ticket/workspace work.
    * Pending handles remain derivable and are retried on every later tick. */
-  private async reclaimPrAttachments(slug: string, events: AbEvent[]): Promise<void> {
-    for (const hosted of pendingPrAttachmentReclaims(events)) {
-      const priorAttempts = events.filter(
-        (event) =>
-          event.type === 'pr-attachment.reclaim-failed' && event.payload.hostedSeq === hosted.seq,
-      ).length
+  private async reclaimPrAttachments(slug: string, events: CurrentBuildFacts): Promise<void> {
+    for (const hosted of events.pendingAttachments) {
+      const priorAttempts = events.reclaimCounts[String(hosted.seq)] ?? 0
       try {
         const capability = this.deps.forge.prAttachments
         if (capability === undefined) {
@@ -2248,13 +2278,13 @@ export class Dispatcher {
     }
   }
 
-  private recoveryCheckpoint(events: AbEvent[]): string | undefined {
-    return recoveryCheckpointReducer.reduce(events)
+  private recoveryCheckpoint(events: CurrentBuildFacts): string | undefined {
+    return events.recoveryCheckpoint
   }
 
   private async recordInfrastructureFailure(
     slug: string,
-    events: AbEvent[],
+    events: CurrentBuildFacts,
     input: {
       provider: string
       workspaceRef: string
@@ -2263,8 +2293,8 @@ export class Dispatcher {
       cleanupPending: boolean
     },
   ): Promise<void> {
-    const execution = [...events].reverse().find((event) => event.type === 'execution.started')
-    const appended = await appendInfrastructureFailure(
+    const execution = events.state.executions.at(-1)
+    const _appended = await appendInfrastructureFailure(
       { store: this.store, ids: this.deps.ids },
       {
         slug,
@@ -2272,22 +2302,19 @@ export class Dispatcher {
         maxAttempts: this.deps.config.policy.maxInfrastructureAttempts,
         provider: input.provider,
         workspaceRef: input.workspaceRef,
-        instance:
-          execution?.type === 'execution.started'
-            ? execution.payload.instance
-            : 'dispatcher-recovery',
-        ...(execution?.type === 'execution.started' && execution.payload.environmentId !== undefined
-          ? { environmentId: execution.payload.environmentId }
+        instance: execution !== undefined ? execution.instance : 'dispatcher-recovery',
+        ...(execution !== undefined && execution.environmentId !== undefined
+          ? { environmentId: execution.environmentId }
           : {}),
-        ...(execution?.type === 'execution.started' && execution.payload.sessionId !== undefined
-          ? { sessionId: execution.payload.sessionId }
+        ...(execution !== undefined && execution.sessionId !== undefined
+          ? { sessionId: execution.sessionId }
           : {}),
         operation: input.operation,
         error: input.error,
         cleanupPending: input.cleanupPending,
       },
     )
-    events.push(...appended)
+    Object.assign(events, (await readBuildFacts(this.store, slug)).value)
   }
 
   /** The provider that owns a recorded workspace: the one named on its
@@ -2303,7 +2330,7 @@ export class Dispatcher {
    * only after exact-name cleanup is durably acknowledged. */
   private async reapStaleWorkspace(
     slug: string,
-    events: AbEvent[],
+    events: CurrentBuildFacts,
     reason: 'pause' | 'blocked' | 'replacement',
   ): Promise<boolean> {
     const open = openWorkspace(events)
@@ -2314,18 +2341,13 @@ export class Dispatcher {
     // publication's fate BEFORE the destructive reap. The guard's append
     // failure propagates — a stale workspace with an unrecorded pending
     // request is never reaped (the next tick retries).
-    events = await settlePublicationBeforeRelease(
+    events = await settlePublicationFactsBeforeRelease(
       { store: this.store, settlePublication: this.settlePublication },
       slug,
       events,
       reason,
     )
-    const attempt =
-      events.filter(
-        (event) =>
-          event.type === 'infrastructure.cleanup-attempted' &&
-          event.payload.workspaceRef === open.ref,
-      ).length + 1
+    const attempt = (events.cleanupCounts[JSON.stringify(open.ref)] ?? 0) + 1
     try {
       const outcome = await recovery.reap({
         provider: open.provider,
@@ -2334,7 +2356,7 @@ export class Dispatcher {
         ...(open.localPath !== undefined ? { localPath: open.localPath } : {}),
         branch: open.branch,
       })
-      const cleaned = await this.store.append(slug, {
+      const _cleaned = await this.store.append(slug, {
         actor: DISPATCHER,
         type: 'infrastructure.cleanup-attempted',
         payload: {
@@ -2346,17 +2368,17 @@ export class Dispatcher {
           snapshots: outcome.snapshots,
         },
       })
-      events.push(cleaned)
-      const released = await this.store.append(slug, {
+      Object.assign(events, (await readBuildFacts(this.store, slug)).value)
+      const _released = await this.store.append(slug, {
         actor: DISPATCHER,
         type: 'workspace.released',
         payload: { ref: open.ref, reason },
       })
-      events.push(released)
+      Object.assign(events, (await readBuildFacts(this.store, slug)).value)
       return true
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
-      const failed = await this.store.append(slug, {
+      const _failed = await this.store.append(slug, {
         actor: DISPATCHER,
         type: 'infrastructure.cleanup-attempted',
         payload: {
@@ -2368,7 +2390,7 @@ export class Dispatcher {
           error: message || 'cleanup failed without an error message',
         },
       })
-      events.push(failed)
+      Object.assign(events, (await readBuildFacts(this.store, slug)).value)
       await this.recordInfrastructureFailure(slug, events, {
         provider: open.provider,
         workspaceRef: open.ref,
@@ -2384,7 +2406,7 @@ export class Dispatcher {
    * append `workspace.released`. Log-deduped, so re-runs are no-ops. */
   private async releaseWorkspace(
     slug: string,
-    events: AbEvent[],
+    events: CurrentBuildFacts,
     reason: 'completion' | 'abort' | 'pause' | 'blocked' | 'replacement' | 'discard' = 'completion',
   ): Promise<AbEvent | undefined> {
     const open = openWorkspace(events)
@@ -2403,7 +2425,7 @@ export class Dispatcher {
     // pending publication BEFORE any provider cleanup call, while the
     // workspace still exists. The guard's append failure propagates — the
     // release never proceeds past an unrecorded pending request.
-    events = await settlePublicationBeforeRelease(
+    events = await settlePublicationFactsBeforeRelease(
       { store: this.store, settlePublication: this.settlePublication },
       slug,
       events,
@@ -2411,15 +2433,10 @@ export class Dispatcher {
     )
     const recovery = owner.recovery
     if (recovery !== undefined) {
-      const attempt =
-        events.filter(
-          (event) =>
-            event.type === 'infrastructure.cleanup-attempted' &&
-            event.payload.workspaceRef === open.ref,
-        ).length + 1
+      const attempt = (events.cleanupCounts[JSON.stringify(open.ref)] ?? 0) + 1
       try {
         const outcome = await recovery.reap(handle)
-        const cleaned = await this.store.append(slug, {
+        const _cleaned = await this.store.append(slug, {
           actor: DISPATCHER,
           type: 'infrastructure.cleanup-attempted',
           payload: {
@@ -2431,10 +2448,10 @@ export class Dispatcher {
             snapshots: outcome.snapshots,
           },
         })
-        events.push(cleaned)
+        Object.assign(events, (await readBuildFacts(this.store, slug)).value)
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error)
-        const failed = await this.store.append(slug, {
+        const _failed = await this.store.append(slug, {
           actor: DISPATCHER,
           type: 'infrastructure.cleanup-attempted',
           payload: {
@@ -2446,7 +2463,7 @@ export class Dispatcher {
             error: message || 'cleanup failed without an error message',
           },
         })
-        events.push(failed)
+        Object.assign(events, (await readBuildFacts(this.store, slug)).value)
         await this.recordInfrastructureFailure(slug, events, {
           provider: open.provider,
           workspaceRef: open.ref,
@@ -2572,9 +2589,9 @@ export class Dispatcher {
     if (!(await this.dispatchBudget(record.slug))) return 'parked'
     let stage: EventPayload<'dispatch.failed'>['stage'] = 'create'
     try {
-      let events = await store.getEvents(record.slug)
-      if (!events.some((event) => event.type === 'build.created')) {
-        if (events.length !== 0 || record.ticket === undefined) {
+      let events = (await readBuildFacts(store, record.slug)).value
+      if (events.created === undefined) {
+        if (events.state.lastSeq !== 0 || record.ticket === undefined) {
           throw new Error(
             'build record lacks the immutable ticket facts needed to reconstruct build.created',
           )
@@ -2584,28 +2601,32 @@ export class Dispatcher {
         // can only sample the ticket's current assets (SPEC §6.3).
         const assets =
           seed?.assets ??
-          (await samplePinnedAssets(store, record.repo, record.ticket.id).catch(() => []))
+          (await preparePinnedAssets(this.deps.tickets, store, record.repo, record.ticket.id).catch(
+            (error) => {
+              // Preserve legacy recovery only without native assets. Native preparation
+              // must never publish an empty pin after losing the source bytes.
+              if (this.deps.tickets.assets || this.deps.tickets.name === 'hosted') throw error
+              return []
+            },
+          ))
         await store.appendIfCurrent(record.slug, 0, {
           actor: DISPATCHER,
           type: 'build.created',
           payload: this.buildCreatedPayload(record.ticket, record.repo, { ...seed, assets }),
         })
-        events = await store.getEvents(record.slug)
-        if (!events.some((event) => event.type === 'build.created')) {
+        events = (await readBuildFacts(store, record.slug)).value
+        if (events.created === undefined) {
           throw new Error('build.created reconstruction lost its conditional append race')
         }
       }
 
-      const created = events.find((event) => event.type === 'build.created')
+      const created = events.created
       const autoMergeUser = seed?.autoMergeUser ?? created?.payload.autoMergeRequestedBy
       // The claim's sampled default fact, for the request's fan-out provenance:
       // the seed's own value first (this dispatch created the build), else the
       // durable `build.created` fact a recovery pass resumes from.
       const autoMergeDefaultSeq = seed?.autoMergeDefaultSeq ?? created?.payload.autoMergeDefaultSeq
-      if (
-        autoMergeUser !== undefined &&
-        !events.some((event) => event.type === 'build.auto-merge-requested')
-      ) {
+      if (autoMergeUser !== undefined && !events.autoMergeEverRequested) {
         await store.append(record.slug, {
           actor: humanActor(autoMergeUser),
           type: 'build.auto-merge-requested',
@@ -2613,7 +2634,7 @@ export class Dispatcher {
             ...(autoMergeDefaultSeq !== undefined ? { defaultSeq: autoMergeDefaultSeq } : {}),
           },
         })
-        events = await store.getEvents(record.slug)
+        events = (await readBuildFacts(store, record.slug)).value
       }
 
       stage = 'workspace'
@@ -2628,9 +2649,7 @@ export class Dispatcher {
           launched.add(record.slug)
           return 'deferred'
         }
-        const priorGenerations = events.filter(
-          (event) => event.type === 'workspace.provisioned',
-        ).length
+        const priorGenerations = events.workspaceGenerations
         const handle = await this.deps.workspaces.provision({
           // Local providers provision FROM the physical checkout; remote
           // providers ignore the value (their host seams are injected).
@@ -2657,10 +2676,10 @@ export class Dispatcher {
             base: handle.base,
           },
         } satisfies EventWrite<'workspace.provisioned'>)
-        events = await store.getEvents(record.slug)
+        events = (await readBuildFacts(store, record.slug)).value
       }
     } catch (error) {
-      const events = await store.getEvents(record.slug)
+      const events = (await readBuildFacts(store, record.slug)).value
       if (stage === 'workspace' && this.deps.workspaces.recovery !== undefined) {
         const open = openWorkspace(events)
         await this.recordInfrastructureFailure(record.slug, events, {
@@ -2671,7 +2690,7 @@ export class Dispatcher {
           cleanupPending: true,
         })
       }
-      const attempt = events.filter((event) => event.type === 'dispatch.failed').length + 1
+      const attempt = events.dispatchFailureCount + 1
       const message = (error instanceof Error ? error.message : String(error)).trim()
       await store.append(record.slug, {
         actor: DISPATCHER,
@@ -2711,12 +2730,10 @@ export class Dispatcher {
     let stage: EventPayload<'dispatch.failed'>['stage'] = 'spec'
     let authored = false
     try {
-      const events = await store.getEvents(record.slug)
-      const state = reduceBuild(events)
+      const events = (await readBuildFacts(store, record.slug)).value
+      const state = events.state
       if (state.status !== 'queued' || state.discardRequest !== undefined) return 'parked'
-      if (
-        !events.some((event) => event.type === 'spec.imported' || event.type === 'spec.authored')
-      ) {
+      if (!events.specRecorded) {
         let ticket: Ticket
         if (seed?.ticket !== undefined) {
           ticket = seed.ticket
@@ -2774,10 +2791,7 @@ export class Dispatcher {
       }
 
       stage = 'comment'
-      if (
-        record.ticket !== undefined &&
-        !events.some((event) => event.type === 'dispatch.comment-posted')
-      ) {
+      if (record.ticket !== undefined && !events.commentPosted) {
         await this.deps.tickets.comment(record.ticket.id, `build ${record.slug} dispatched`)
         await store.append(record.slug, {
           actor: DISPATCHER,
@@ -2791,17 +2805,17 @@ export class Dispatcher {
       // provider awaits. Re-read immediately before launch so a request made
       // during those boundaries parks cleanly for the next janitor pass.
       await store.refreshBuild(record.slug)
-      const launchState = reduceBuild(await store.getEvents(record.slug))
+      const launchState = (await readBuildFacts(store, record.slug)).value.state
       if (launchState.status !== 'queued' || launchState.discardRequest !== undefined) {
         return 'parked'
       }
       if (launched === undefined) await this.deps.launchRunner(record.slug)
-      else await this.launch(record.slug, launched)
+      else await this.launch(record.slug, launched, report)
       if (authored && report !== undefined) report.authored += 1
       return 'completed'
     } catch (error) {
-      const events = await store.getEvents(record.slug)
-      const attempt = events.filter((event) => event.type === 'dispatch.failed').length + 1
+      const events = (await readBuildFacts(store, record.slug)).value
+      const attempt = events.dispatchFailureCount + 1
       const message = (error instanceof Error ? error.message : String(error)).trim()
       await store.append(record.slug, {
         actor: DISPATCHER,
@@ -2873,7 +2887,6 @@ export class Dispatcher {
     opts: TickOpts = {},
   ): Promise<void> {
     const store = this.store
-    const { config } = this.deps
     for (const record of await this.nonterminalBuilds()) {
       if (launched.has(record.slug)) continue
       // Budget gate: resume launches runners (transport-backed work).
@@ -2896,7 +2909,8 @@ export class Dispatcher {
         !(await this.dispatchBudget(record.slug))
       )
         continue
-      const decision = decideNextFromFacts(state, facts.log, config)
+      const decision = await this.decideBuild(record.slug, state, facts.log, report)
+      if (decision === undefined) continue
       if (decision.kind === 'wait') {
         if (decision.reason === 'blocked' && state.openEscalations.length > 0) {
           report.blockedDiagnostics.push(
@@ -2910,7 +2924,7 @@ export class Dispatcher {
       // Disposable remote environments must pass through the stale-lease
       // fencing sweep below; startup must never attach directly to an old VM.
       if (this.deps.workspaces.recovery !== undefined) continue
-      const result = await this.launch(record.slug, launched)
+      const result = await this.launch(record.slug, launched, report)
       if (result === 'scheduled') report.resumed += 1
     }
   }
@@ -2972,12 +2986,13 @@ export class Dispatcher {
         !(await this.dispatchBudget(record.slug))
       )
         continue
-      const decision = decideNextFromFacts(state, facts.log, this.deps.config)
+      const decision = await this.decideBuild(record.slug, state, facts.log, report)
+      if (decision === undefined) continue
       if (state.status === 'done' || state.status === 'aborted') continue
       // Raw history, read at most once and only by a branch that acts on it.
-      let loaded: AbEvent[] | undefined
-      const history = async (): Promise<AbEvent[]> => {
-        loaded ??= await this.store.getEvents(record.slug)
+      let loaded: CurrentBuildFacts | undefined
+      const history = async (): Promise<CurrentBuildFacts> => {
+        loaded ??= (await readBuildFacts(this.store, record.slug)).value
         return loaded
       }
       // Liveness gate (durable supervision): a recorded execution the provider
@@ -3061,7 +3076,7 @@ export class Dispatcher {
       if (
         facts.workspace === null &&
         this.deps.workspaces.recovery !== undefined &&
-        (await history()).some((event) => event.type === 'workspace.provisioned')
+        (await history()).workspaceGenerations > 0
       ) {
         const kicked = await this.ensureProvisionContinuation(record, await history(), 'launch')
         if (kicked === 'kicked') {
@@ -3073,7 +3088,7 @@ export class Dispatcher {
         // boundaries and the launch; this tick performs neither.
         continue
       }
-      const result = await this.launch(record.slug, launched)
+      const result = await this.launch(record.slug, launched, report)
       if (result === 'scheduled') report.swept += 1
     }
   }
@@ -3101,11 +3116,11 @@ export class Dispatcher {
     // pending work are live, only waiting on a human. Capacity is per repo
     // (§16.1) — another repo's builds never consume this repo's slots.
     let active = 0
-    const activeTicketIds = new Set<string>()
+    const activeRefs: TicketRef[] = []
     for (const { record, digest } of await this.repoBuildDigests()) {
       if (digest.terminal === undefined) {
         active += 1
-        if (record.ticket) activeTicketIds.add(record.ticket.id)
+        if (record.ticket) activeRefs.push(record.ticket)
       }
     }
     let capacity = config.capacity - active
@@ -3115,20 +3130,23 @@ export class Dispatcher {
     // dispatcher is saturated. Sources that keep a claimed ticket in the
     // ready state are deduped against the active builds embodying them.
     await this.store.refreshJournal()
-    const journalBeforeReady = this.store.recordedJournal()
+    const journalBeforeReady = this.store.repositoryFacts().harvest
     const listing = await this.listReady()
+    const activeTicketIds = await this.activeTicketIdentities(activeRefs, listing.tickets)
     await this.store.refreshJournal()
-    const journalAfterReady = this.store.recordedJournal()
-    if (reduceTicketSourceHealth(journalAfterReady)?.cause === 'ready-scan-failed') {
+    const journalAfterReady = this.store.repositoryFacts()
+    if (journalAfterReady.health?.cause === 'ready-scan-failed') {
       await this.sourceCondition(undefined, 'ready-scan')
     }
     const creationHolds = new Map(
-      harvestCreationsDuringReadyScan(journalBeforeReady, journalAfterReady).map((creation) => [
+      harvestCreationsFromStates(journalBeforeReady, journalAfterReady.harvest).map((creation) => [
         creation.creationKey.toLowerCase(),
         creation,
       ]),
     )
-    const ready = listing.tickets.filter((ticket) => !activeTicketIds.has(ticket.ref.id))
+    const ready = listing.tickets.filter(
+      (ticket) => !activeTicketIds.has(`${ticket.ref.source}:${ticket.ref.id}`),
+    )
     report.invalidTickets += listing.diagnostics.length
     report.ticketDiagnostics.push(...listing.diagnostics)
     report.queued = ready.length
@@ -3225,7 +3243,7 @@ export class Dispatcher {
 
       // Freeze the ticket's assets at the claim (SPEC §6.3): sampled before the
       // spec-authoring interval so edits made during it are never pinned.
-      const assets = await samplePinnedAssets(store, this.deps.repo, ticket.ref.id)
+      const assets = await preparePinnedAssets(tickets, store, this.deps.repo, ticket.ref.id)
 
       // Quality gate (§6.3): import a conforming ticket body as the spec;
       // author one for thin-but-groomed tickets; otherwise bounce.