@defrex/autobuild 0.9.0 → 0.10.0

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

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

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

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

package/packages/core/src/processes/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 {

package/packages/core/src/processes/orchestrator-tick.ts

@@ -31,6 +31,7 @@ import { reduceSession, type SessionTurnTrigger } from '../store/session-reducer
 import { reduceBuild } from '../kernel/reducer'
 import type { AbEvent } from '../events/catalog'
 import type { BuildStore, Clock } from '../store/types'
+import type { RepoViewStore } from './repo-view'
 import type { IdSource } from '../ids'
 import type { LanguageModel } from 'ai'
 import {
@@ -69,6 +70,10 @@ export interface OrchestratorTickOptions {
    * Less than ORCHESTRATOR_MIN_TURN_SECONDS skips the whole step
    * (suspension state is durable — skipping is safe). */
   remainingBudgetSeconds?: number
+  /** The dispatcher's repository view, when the tick runs under one: the wake
+   * pass reads its full build state through it (no replay of history the view
+   * already folded) and releases consumed window history through it. */
+  view?: Pick<RepoViewStore, 'buildState' | 'releaseWindowsBelow'>
   log?: (message: string) => void
 }
 
@@ -133,6 +138,9 @@ export async function runOrchestratorTickStep(
   const sessions = await store.listSessions(repo)
 
   // ── Resume pass ─────────────────────────────────────────────────────────
+  // The lowest cursors only cover sessions visited; a budget break leaves later
+  // sessions (possibly with lower cursors) uncounted, so it skips the trim.
+  let visitedAll = true
   for (const record of sessions) {
     const events = await store.getSessionEvents(record.id)
     const state = reduceSession(events)
@@ -202,9 +210,28 @@ export async function runOrchestratorTickStep(
 
   // ── Wake pass ───────────────────────────────────────────────────────────
   const builds = (await store.listBuilds()).filter((candidate) => candidate.repo === repo)
+  /** The lowest wake cursor across every session that scans, per source: the
+   * view may drop window history at or below it once the pass ends. */
+  const lowestBuildCursor = new Map<string, number>()
+  let lowestJournalCursor: number | undefined
+  let scanners = 0
   for (const record of sessions) {
     const events = await store.getSessionEvents(record.id)
     const state = reduceSession(events)
+    if (state.wakeGlobs.length > 0) {
+      scanners += 1
+      for (const build of builds) {
+        const cursor = state.wakeCursors[build.slug] ?? 0
+        lowestBuildCursor.set(
+          build.slug,
+          Math.min(lowestBuildCursor.get(build.slug) ?? cursor, cursor),
+        )
+      }
+      lowestJournalCursor = Math.min(
+        lowestJournalCursor ?? state.journalWakeCursor,
+        state.journalWakeCursor,
+      )
+    }
     if (state.status !== 'idle') continue
     if (state.wakeGlobs.length === 0) continue
     let filters: RegExp[]
@@ -226,7 +253,7 @@ export async function runOrchestratorTickStep(
       | undefined
     for (const build of builds) {
       const cursor = state.wakeCursors[build.slug] ?? 0
-      const buildEvents = await store.getEvents(build.slug)
+      const buildEvents = await store.getEvents(build.slug, cursor)
       for (const event of buildEvents) {
         if (event.seq <= cursor) continue
         if (!filters.some((regex) => regex.test(event.type))) continue
@@ -262,7 +289,10 @@ export async function runOrchestratorTickStep(
     // by the step's shared deadline; past the floor the wake defers to a
     // later tick.
     const remaining = remainingNow() - ORCHESTRATOR_MIN_TURN_SECONDS
-    if (remaining < ORCHESTRATOR_MIN_TURN_SECONDS) break
+    if (remaining < ORCHESTRATOR_MIN_TURN_SECONDS) {
+      visitedAll = false
+      break
+    }
 
     // A journal wake delivers the frozen event record only — the turn's
     // operator registry already exposes bounded repository reads, so no
@@ -283,7 +313,9 @@ export async function runOrchestratorTickStep(
         ? { event }
         : {
             event,
-            buildState: reduceBuild(await store.getEvents(newest.build)) as unknown as Record<
+            buildState: (options.view !== undefined
+              ? await options.view.buildState(newest.build)
+              : reduceBuild(await store.getEvents(newest.build))) as unknown as Record<
               string,
               unknown
             >,
@@ -301,6 +333,15 @@ export async function runOrchestratorTickStep(
     }
   }
 
+  if (options.view !== undefined && scanners > 0 && visitedAll) {
+    for (const [slug, cursor] of lowestBuildCursor) {
+      if (cursor > 0) options.view.releaseWindowsBelow({ build: slug }, cursor)
+    }
+    if (lowestJournalCursor !== undefined && lowestJournalCursor > 0) {
+      options.view.releaseWindowsBelow('journal', lowestJournalCursor)
+    }
+  }
+
   options.log?.(
     `orchestrator step: resumed=${report.resumed} reaped=${report.reaped} woken=${report.woken}`,
   )

package/packages/core/src/processes/publication-state.ts

@@ -1,32 +1,170 @@
 import type { AbEvent } from '../events/catalog'
+import { defineReducer, type IncrementalReducer } from '../kernel/incremental'
 
 export type PublicationRequest = Extract<AbEvent, { type: 'publication.requested' }>
 
+/** One entry of the order-preserving publication ledger: the fields the
+ * publication selectors read from each relevant event, in array order. */
+type LedgerItem =
+  | { t: 'request'; seq: number; event: PublicationRequest }
+  | { t: 'lost'; seq: number; request: number }
+  | { t: 'provisioned'; seq: number; ref: string }
+  | { t: 'released'; seq: number; ref?: string | null }
+  | { t: 'implement'; seq: number; round: number; base: string; head: string }
+  | { t: 'reconcile'; seq: number; mergeCommit: string }
+  | { t: 'finalize'; seq: number; headSha: string }
+  | { t: 'step'; seq: number; step: string; ok: boolean; headSha?: string }
+  /** A maximal run of consecutive irrelevant events. Only its max seq
+   * matters: the workspace scan's `seq > request.seq` break test. */
+  | { t: 'barrier'; seq: number }
+
+/** The publication family's accumulator: the whole event sequence in array
+ * order, relevant events compacted and each run of irrelevant ones collapsed
+ * to a barrier. Filtering to relevant types alone would be wrong, because
+ * `publicationRequestSettled` stops its workspace scan at the first event (of
+ * any type) whose seq exceeds the request's. */
+export interface PublicationLedger {
+  ledger: LedgerItem[]
+}
+
+/** Bump when `PublicationLedger` or its fold changes. */
+export const PUBLICATION_STATE_REDUCER_VERSION = 1
+
+function compact(event: AbEvent): LedgerItem | undefined {
+  switch (event.type) {
+    case 'publication.requested':
+      return { t: 'request', seq: event.seq, event }
+    case 'publication.lost':
+      return { t: 'lost', seq: event.seq, request: event.payload.request }
+    case 'workspace.provisioned':
+      return { t: 'provisioned', seq: event.seq, ref: event.payload.ref }
+    case 'workspace.released': {
+      const payload = event.payload as { ref?: string }
+      return 'ref' in payload
+        ? { t: 'released', seq: event.seq, ref: payload.ref ?? null }
+        : { t: 'released', seq: event.seq }
+    }
+    case 'implement.completed':
+      return {
+        t: 'implement',
+        seq: event.seq,
+        round: event.payload.round,
+        base: event.payload.commits.base,
+        head: event.payload.commits.head,
+      }
+    case 'reconcile.completed':
+      return { t: 'reconcile', seq: event.seq, mergeCommit: event.payload.mergeCommit }
+    case 'finalize.completed':
+      return { t: 'finalize', seq: event.seq, headSha: event.payload.pr.headSha }
+    case 'finalize.step-completed': {
+      const item: LedgerItem = {
+        t: 'step',
+        seq: event.seq,
+        step: event.payload.step,
+        ok: event.payload.ok,
+      }
+      const headSha = (event.payload as { headSha?: string }).headSha
+      if (headSha !== undefined) item.headSha = headSha
+      return item
+    }
+    default:
+      return undefined
+  }
+}
+
+function itemCompletes(item: LedgerItem, request: PublicationRequest): boolean {
+  if (item.seq <= request.seq) return false
+  const payload = request.payload
+  if (payload.operation === 'implement')
+    return (
+      item.t === 'implement' &&
+      item.round === payload.round &&
+      item.base === payload.base &&
+      item.head === payload.sha
+    )
+  if (payload.operation === 'reconcile')
+    return item.t === 'reconcile' && item.mergeCommit === payload.sha
+  if (payload.operation === 'finalize') return item.t === 'finalize' && item.headSha === payload.sha
+  return (
+    item.t === 'step' && item.step === payload.step && (!item.ok || item.headSha === payload.sha)
+  )
+}
+
+/** The publication selectors, derived from one ledger. */
+export interface PublicationView {
+  requestCompleted(request: PublicationRequest): boolean
+  requestSettled(request: PublicationRequest): boolean
+  latestUncompletedRequest(): PublicationRequest | undefined
+  lostRecorded(request: PublicationRequest): boolean
+  abandonedPending(): boolean
+  pending(): boolean
+}
+
+function viewOf(ledger: readonly LedgerItem[]): PublicationView {
+  const requestCompleted = (request: PublicationRequest): boolean =>
+    ledger.some((item) => itemCompletes(item, request))
+
+  const requestSettled = (request: PublicationRequest): boolean => {
+    let workspaceRef: string | undefined
+    for (const item of ledger) {
+      if (item.seq > request.seq) break
+      if (item.t === 'provisioned') workspaceRef = item.ref
+      else if (item.t === 'released') workspaceRef = undefined
+    }
+    return (
+      requestCompleted(request) ||
+      ledger.some(
+        (item) =>
+          item.seq > request.seq &&
+          item.t === 'released' &&
+          (item.ref === undefined || workspaceRef === undefined || item.ref === workspaceRef),
+      )
+    )
+  }
+
+  const latestUncompletedRequest = (): PublicationRequest | undefined => {
+    const item = ledger.findLast((entry) => entry.t === 'request' && !requestCompleted(entry.event))
+    return item?.t === 'request' ? item.event : undefined
+  }
+
+  return {
+    requestCompleted,
+    requestSettled,
+    latestUncompletedRequest,
+    lostRecorded: (request) =>
+      ledger.some((item) => item.t === 'lost' && item.request === request.seq),
+    abandonedPending() {
+      const request = latestUncompletedRequest()
+      return request !== undefined && requestSettled(request)
+    },
+    pending: () => ledger.some((item) => item.t === 'request' && !requestSettled(item.event)),
+  }
+}
+
+export const publicationStateReducer: IncrementalReducer<
+  PublicationLedger,
+  AbEvent,
+  PublicationView
+> = defineReducer<PublicationLedger, AbEvent, PublicationView>({
+  version: PUBLICATION_STATE_REDUCER_VERSION,
+  initial: () => ({ ledger: [] }),
+  fold(acc, events) {
+    for (const event of events) {
+      const item = compact(event)
+      const last = acc.ledger[acc.ledger.length - 1]
+      if (item !== undefined) acc.ledger.push(item)
+      else if (last?.t === 'barrier') last.seq = Math.max(last.seq, event.seq)
+      else acc.ledger.push({ t: 'barrier', seq: event.seq })
+    }
+  },
+  finish: (acc) => viewOf(acc.ledger),
+})
+
 export function publicationRequestCompleted(
   events: readonly AbEvent[],
   request: PublicationRequest,
 ): boolean {
-  return events.some((event) => {
-    if (event.seq <= request.seq) return false
-    if (request.payload.operation === 'implement')
-      return (
-        event.type === 'implement.completed' &&
-        event.payload.round === request.payload.round &&
-        event.payload.commits.base === request.payload.base &&
-        event.payload.commits.head === request.payload.sha
-      )
-    if (request.payload.operation === 'reconcile')
-      return (
-        event.type === 'reconcile.completed' && event.payload.mergeCommit === request.payload.sha
-      )
-    if (request.payload.operation === 'finalize')
-      return event.type === 'finalize.completed' && event.payload.pr.headSha === request.payload.sha
-    return (
-      event.type === 'finalize.step-completed' &&
-      event.payload.step === request.payload.step &&
-      (!event.payload.ok || event.payload.headSha === request.payload.sha)
-    )
-  })
+  return publicationStateReducer.reduce(events).requestCompleted(request)
 }
 
 /** A request is no longer publishable after its workspace is released. The
@@ -36,23 +174,7 @@ export function publicationRequestSettled(
   events: readonly AbEvent[],
   request: PublicationRequest,
 ): boolean {
-  let workspaceRef: string | undefined
-  for (const event of events) {
-    if (event.seq > request.seq) break
-    if (event.type === 'workspace.provisioned') workspaceRef = event.payload.ref
-    else if (event.type === 'workspace.released') workspaceRef = undefined
-  }
-  return (
-    publicationRequestCompleted(events, request) ||
-    events.some(
-      (event) =>
-        event.seq > request.seq &&
-        event.type === 'workspace.released' &&
-        (!('ref' in event.payload) ||
-          workspaceRef === undefined ||
-          event.payload.ref === workspaceRef),
-    )
-  )
+  return publicationStateReducer.reduce(events).requestSettled(request)
 }
 
 /** The latest `publication.requested` with no settling completion fact — the
@@ -61,11 +183,7 @@ export function publicationRequestSettled(
 export function latestUncompletedPublicationRequest(
   events: readonly AbEvent[],
 ): PublicationRequest | undefined {
-  const request = events.findLast(
-    (event) =>
-      event.type === 'publication.requested' && !publicationRequestCompleted(events, event),
-  )
-  return request?.type === 'publication.requested' ? request : undefined
+  return publicationStateReducer.reduce(events).latestUncompletedRequest()
 }
 
 /** Whether the durable loss record (AUT-328) has already been appended for
@@ -75,19 +193,13 @@ export function publicationLostRecorded(
   events: readonly AbEvent[],
   request: PublicationRequest,
 ): boolean {
-  return events.some(
-    (event) => event.type === 'publication.lost' && event.payload.request === request.seq,
-  )
+  return publicationStateReducer.reduce(events).lostRecorded(request)
 }
 
 export function abandonedPublicationPending(events: readonly AbEvent[]): boolean {
-  const request = latestUncompletedPublicationRequest(events)
-  return request !== undefined && publicationRequestSettled(events, request)
+  return publicationStateReducer.reduce(events).abandonedPending()
 }
 
 export function publicationPending(events: readonly AbEvent[]): boolean {
-  return events.some(
-    (request) =>
-      request.type === 'publication.requested' && !publicationRequestSettled(events, request),
-  )
+  return publicationStateReducer.reduce(events).pending()
 }