@defrex/autobuild 0.8.0 → 0.10.0

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

@@ -0,0 +1,360 @@
+/**
+ * The dispatcher tick's orchestrator step (AUT-342): resume suspended turns,
+ * reap crashed ones, and wake idle sessions from build attention events.
+ *
+ * Two independent gates keep this inert where it does not belong, and BOTH
+ * are required:
+ *
+ * 1. The step is constructed only in origin mode — the gate lives in
+ *    `processes/dispatcher.ts` on `DispatcherDeps.repoOrigin` (set
+ *    exclusively by origin mode), so a local `ab dispatch` never constructs
+ *    the step at all: an `enabled = true` in a local repository's
+ *    autobuild.toml lists no sessions, builds no registry, and calls no
+ *    model.
+ * 2. In origin mode the step returns immediately unless the repository's
+ *    effective config enables the orchestrator — the disabled-repository
+ *    no-op.
+ *
+ * The wake cursor advances only through the recorded trigger (the reducer
+ * takes `max`), so a crash between scan and start cannot skip or duplicate a
+ * wake; other builds' — and the journal's — matching events re-trigger on
+ * later ticks. One turn per session per tick, never concurrent.
+ */
+import { ORCHESTRATOR_MIN_TURN_SECONDS, type Config } from '../config/schema'
+import { compileEventGlobs } from '../events/globs'
+import type { RepositoryEvent } from '../events/repository'
+import type { TicketSource } from '../ports/types'
+import { buildRegistry, type OperatorToolRegistry } from '../operator/registry'
+import type { OperatorSandboxService } from '../operator/sandbox'
+import { ticketBackendFromSource } from '../operator/ticket-source-backend'
+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 {
+  createOrchestratorTurnRunner,
+  type OrchestratorTurnRunner,
+  type WakeTurnInput,
+} from '../orchestrator/turn-runner'
+
+/** Minutes an open, unsuspended turn's stream may stay silent before the
+ * reaper fails it: a crashed invocation leaves the session `running` with an
+ * open stream and no runner. Suspended turns are NEVER reaped — a turn
+ * suspended for approval is precisely an open stream that goes quiet for
+ * however long the operator takes. */
+export const ORCHESTRATOR_STALE_TURN_MINUTES = 15
+
+export interface OrchestratorTickOptions {
+  store: BuildStore
+  repo: string
+  config: Config
+  clock: Clock
+  ids: IdSource
+  /** The dispatcher's ticket source, adapted into the registry's ticket
+   * backend so wake and resumed turns keep the full ticket surface. */
+  tickets: TicketSource
+  /** Injected language model; defaults to the configured gateway model. */
+  model?: LanguageModel
+  /** The operator-sandbox backend (AUT-584): when supplied, the tick's turns
+   * serve the `sandbox.*` tools under the same configuration/approval gating
+   * every binding applies. Absent (the compatibility case) → the registry
+   * filters them from advertisement AND dispatch. The origin-mode dispatcher
+   * builds it from its own wired provider; every other caller omits it. */
+  sandbox?: OperatorSandboxService
+  /** Remaining tick budget in seconds at step entry; every turn's deadline
+   * is recomputed from this against the clock, so N sessions draw down the
+   * SAME budget instead of each getting a fresh full slice (f_9c1161ae).
+   * 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
+}
+
+export interface OrchestratorTickReport {
+  resumed: number
+  reaped: number
+  woken: number
+}
+
+/** The registry the tick's turns run against: the in-process binding over
+ * the dispatcher's store, with the ticket source adapted into the backend
+ * `buildRegistry`'s ticket tools require (`buildMcpTicketBackend` reads a
+ * checkout's autobuild.toml and cannot run in origin mode). */
+export function orchestratorTickRegistry(options: OrchestratorTickOptions): OperatorToolRegistry {
+  return buildRegistry({
+    store: options.store,
+    tickets: ticketBackendFromSource({ source: options.tickets, config: options.config }),
+    ...(options.sandbox !== undefined ? { sandbox: options.sandbox } : {}),
+    clock: options.clock,
+    allowedRepo: options.repo,
+  })
+}
+
+export function orchestratorTickRunner(options: OrchestratorTickOptions): OrchestratorTurnRunner {
+  return createOrchestratorTurnRunner({
+    store: options.store,
+    registry: orchestratorTickRegistry(options),
+    repo: options.repo,
+    config: options.config,
+    clock: options.clock,
+    ids: options.ids,
+    ...(options.model !== undefined ? { model: options.model } : {}),
+    ...(options.remainingBudgetSeconds !== undefined
+      ? { remainingBudgetSeconds: options.remainingBudgetSeconds }
+      : {}),
+  })
+}
+
+/** One pass of the orchestrator step. The caller has already evaluated both
+ * gates (origin mode and `enabled`); this function assumes it may run. */
+export async function runOrchestratorTickStep(
+  options: OrchestratorTickOptions,
+): Promise<OrchestratorTickReport> {
+  const { store, repo, config, clock } = options
+  const report: OrchestratorTickReport = { resumed: 0, reaped: 0, woken: 0 }
+  const entry =
+    options.remainingBudgetSeconds === undefined
+      ? config.orchestrator.invocationBudgetSeconds
+      : options.remainingBudgetSeconds
+  if (entry < ORCHESTRATOR_MIN_TURN_SECONDS) return report
+
+  // The step's deadline, fixed at entry: every turn's slice is recomputed
+  // from the clock against THIS deadline, so the step can only consume the
+  // remaining slack no matter how many sessions it serves. (A fixed
+  // per-session value handed to each turn would let N sessions run
+  // N × remaining seconds past the tick deadline — f_9c1161ae.)
+  const deadlineMs = clock().getTime() + entry * 1000
+  const remainingNow = (): number =>
+    Math.max(0, Math.floor((deadlineMs - clock().getTime()) / 1000))
+
+  const runner = orchestratorTickRunner(options)
+  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)
+    if (state.status !== 'suspended' || state.openTurn === undefined) continue
+    // Budget suspensions resume always; approval suspensions only once the
+    // answer has landed (`pendingApproval` gone — the answered-approval
+    // fallback when the resuming operator-route invocation died). An
+    // unanswered approval stays put until the operator answers.
+    if (state.pendingApproval !== undefined) continue
+    // An answered approval resumes with the recorded decision, so the
+    // runner recovers the wire approvalId and appends the response part.
+    let approval: { decision: 'approve' | 'deny'; toolCallId: string } | undefined
+    if (state.suspendedCause === 'approval') {
+      for (const event of [...events].reverse()) {
+        if (event.type === 'approval.answered' && event.payload.turn === state.openTurn.turn) {
+          approval = { decision: event.payload.decision, toolCallId: event.payload.toolCallId }
+          break
+        }
+      }
+      if (approval === undefined) continue
+    }
+    // Draw down the shared deadline: a session is skipped — suspension state
+    // is durable, so skipping is always safe — when the step's remaining
+    // slack no longer leaves the floor for a meaningful turn slice.
+    const remaining = remainingNow() - ORCHESTRATOR_MIN_TURN_SECONDS
+    if (remaining < ORCHESTRATOR_MIN_TURN_SECONDS) break
+    const resumed = await runner.resumeTurn(record.id, {
+      ...(approval !== undefined ? { approval } : {}),
+      remainingBudgetSeconds: remaining,
+    })
+    if (resumed.resumed) {
+      report.resumed += 1
+      // One turn per session per tick, never concurrent: the loop outcome
+      // runs to its suspension/completion before the next session.
+      await resumed.outcome
+    }
+  }
+
+  // ── Crash reaper ────────────────────────────────────────────────────────
+  const staleMs = ORCHESTRATOR_STALE_TURN_MINUTES * 60_000
+  for (const record of sessions) {
+    const events = await store.getSessionEvents(record.id)
+    const state = reduceSession(events)
+    // Reap only a session whose reduced status is exactly `running` — an
+    // open turn with no pending approval and no suspension. A late approve
+    // answer must still find its pending approval and its turn.
+    if (state.status !== 'running' || state.openTurn === undefined) continue
+    const lastChunkTs = await lastStreamActivity(store, state.openTurn.stream)
+    if (lastChunkTs === null) continue
+    if (clock().getTime() - Date.parse(lastChunkTs) < staleMs) continue
+    const lastSeq = events[events.length - 1]?.seq ?? 0
+    const reaped = await store
+      .appendSessionEventIfCurrent(record.id, lastSeq, {
+        actor: { kind: 'agent', role: 'orchestrator', session: state.openTurn.turn },
+        type: 'turn.failed',
+        payload: {
+          turn: state.openTurn.turn,
+          kind: 'internal',
+          error: `turn invocation ended without an outcome (no stream activity for ${ORCHESTRATOR_STALE_TURN_MINUTES} minutes)`,
+        },
+      })
+      .catch(() => null)
+    if (reaped === null) continue // a resume landed first
+    await store.closeStream(state.openTurn.stream, 'aborted').catch(() => undefined)
+    report.reaped += 1
+  }
+
+  // ── 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[]
+    try {
+      filters = compileEventGlobs(state.wakeGlobs, {
+        repository: true,
+        usage: '[orchestrator].wake',
+      })
+    } catch {
+      continue // unmatchable settings wake nothing
+    }
+
+    // Scan every build's events after this session's per-build wake cursor,
+    // then the repository journal after its own cursor; select the single
+    // newest matching event across all scanned sources.
+    let newest:
+      | { build: string; event: AbEvent }
+      | { journal: true; event: RepositoryEvent }
+      | undefined
+    for (const build of builds) {
+      const cursor = state.wakeCursors[build.slug] ?? 0
+      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
+        if (
+          newest === undefined ||
+          event.ts > newest.event.ts ||
+          (event.ts === newest.event.ts && event.seq > newest.event.seq)
+        ) {
+          newest = { build: build.slug, event }
+        }
+      }
+    }
+    // The journal's seq space is independent of every build's; a `seq`
+    // tie-break across sources compares numbers from different spaces —
+    // deterministic, and only matters when two sources' newest matches share
+    // a millisecond timestamp.
+    const journalCursor = state.journalWakeCursor
+    const journalEvents = await store.getRepoEvents(repo, journalCursor)
+    for (const event of journalEvents) {
+      if (event.seq <= journalCursor) continue
+      if (!filters.some((regex) => regex.test(event.type))) continue
+      if (
+        newest === undefined ||
+        event.ts > newest.event.ts ||
+        (event.ts === newest.event.ts && event.seq > newest.event.seq)
+      ) {
+        newest = { journal: true, event }
+      }
+    }
+    if (newest === undefined) continue
+
+    // Same drawdown for wake turns: one turn per session per tick, bounded
+    // 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) {
+      visitedAll = false
+      break
+    }
+
+    // A journal wake delivers the frozen event record only — the turn's
+    // operator registry already exposes bounded repository reads, so no
+    // reduced state is coupled in. A build wake delivers the build's reduced
+    // state as before.
+    const event = {
+      seq: newest.event.seq,
+      ts: newest.event.ts,
+      type: newest.event.type,
+      payload: newest.event.payload,
+    }
+    const trigger: SessionTurnTrigger =
+      'journal' in newest
+        ? { kind: 'wake', journal: true, seq: newest.event.seq, type: newest.event.type }
+        : { kind: 'wake', build: newest.build, seq: newest.event.seq, type: newest.event.type }
+    const wake: WakeTurnInput =
+      'journal' in newest
+        ? { event }
+        : {
+            event,
+            buildState: (options.view !== undefined
+              ? await options.view.buildState(newest.build)
+              : reduceBuild(await store.getEvents(newest.build))) as unknown as Record<
+              string,
+              unknown
+            >,
+          }
+    const start = await runner.startTurn(record.id, trigger, wake, {
+      remainingBudgetSeconds: remaining,
+    })
+    if (start.started) {
+      report.woken += 1
+      // The cursor advances only through the recorded trigger (the reducer
+      // takes `max`), so a crash between scan and start cannot skip or
+      // duplicate a wake — and other builds' matching events re-trigger on
+      // later ticks.
+      await start.outcome
+    }
+  }
+
+  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}`,
+  )
+  return report
+}
+
+/** The newest chunk timestamp on a stream, or its creation time when the
+ * stream has no chunks yet — the liveness signal the reaper reads. */
+async function lastStreamActivity(store: BuildStore, streamId: string): Promise<string | null> {
+  const read = await store.readStream(streamId).catch(() => null)
+  if (read === null) return null
+  const last = read.chunks[read.chunks.length - 1]
+  if (last !== undefined) return last.ts
+  const record = await store.getStream(streamId)
+  return record?.createdAt ?? null
+}

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()
 }