@defrex/autobuild 0.9.0 → 0.10.0

package/packages/core/src/kernel/reducer.ts

@@ -24,6 +24,7 @@ import type {
   VerifyOutcome,
 } from '../ontology'
 import { verifyPhase } from '../ontology'
+import { defineReducer, type IncrementalReducer } from './incremental'
 
 /** An `escalation.raised` without a matching `escalation.answered` — the
  * definition of `blocked` (§15.5). Matched by id, so answers may arrive in
@@ -299,49 +300,133 @@ export function discardInFlight(state: Pick<BuildState, 'discardRequest'>): bool
   return state.discardRequest !== undefined
 }
 
-export function reduceBuild(events: AbEvent[]): BuildState {
-  let attached = false
-  let pausedFlag = false
-  let terminal: 'done' | 'aborted' | undefined
-  let outcome: BuildOutcome | undefined
-  let round = 0
-  let currentPhase: PhaseContext | undefined
-  let lastCompletedPhase: PhaseContext | undefined
-  const openEscalations = new Map<string, OpenEscalation>()
-  const answeredEscalations: AnsweredEscalation[] = []
-  const reviewRoundCeilings: BuildState['reviewRoundCeilings'] = {}
-  let pr: BuildState['pr']
-  let prState: PrLifecycle | undefined
-  const autoMerge: AutoMergeProjection = { requested: false }
-  let specRev: number | undefined
-  let restartSince = 0
-  let pinnedAssets: PinnedAsset[] = []
-  let finalizeCompletedSeq = 0
-  const finalizeSteps: BuildState['finalizeSteps'] = []
-  const plan: BuildState['plan'] = { round: 0, approved: false }
-  const implement: BuildState['implement'] = { round: 0 }
-  let codeReviewApproved = false
-  let codeReviewApproval: BuildState['codeReviewApproval']
-  const planReviewFindings: Finding[][] = []
-  const codeReviewFindings: Finding[][] = []
-  const verify: BuildState['verify'] = { maxAttemptSeen: 0, results: [], cycleSince: 0 }
-  let reconcileAttempts = 0
-  const observations: ObservationRecord[] = []
-  const setupFailures: BuildState['setupFailures'] = []
-  let setupFailure: BuildState['setupFailure']
-  const dispatchFailures: BuildState['dispatchFailures'] = []
-  const executions: BuildState['executions'] = []
-  const infrastructureFailures: BuildState['infrastructureFailures'] = []
-  let infrastructureFailure: BuildState['infrastructureFailure']
-  const cleanupAttempts: BuildState['cleanupAttempts'] = []
-  let discardRequest: BuildState['discardRequest']
-  const pending: Record<PendingCommand['command'], PendingCommand[]> = {
-    pause: [],
-    resume: [],
-    abort: [],
+/** The reducer's carried accumulator: everything `reduceBuild` folds, before
+ * the final status derivation. Plain JSON-shaped data (the escalation and
+ * session maps are insertion-ordered entry arrays) so it survives a round
+ * trip through `JSON.stringify` — the foundation for incremental advancement
+ * and cached state. */
+export interface BuildAcc {
+  attached: boolean
+  pausedFlag: boolean
+  terminal?: 'done' | 'aborted'
+  outcome?: BuildOutcome
+  round: number
+  currentPhase?: PhaseContext
+  lastCompletedPhase?: PhaseContext
+  openEscalations: OpenEscalation[]
+  answeredEscalations: AnsweredEscalation[]
+  reviewRoundCeilings: BuildState['reviewRoundCeilings']
+  pr: BuildState['pr']
+  prState?: PrLifecycle
+  autoMerge: AutoMergeProjection
+  specRev?: number
+  restartSince: number
+  pinnedAssets: PinnedAsset[]
+  finalizeCompletedSeq: number
+  finalizeSteps: BuildState['finalizeSteps']
+  plan: BuildState['plan']
+  implement: BuildState['implement']
+  codeReviewApproved: boolean
+  codeReviewApproval: BuildState['codeReviewApproval']
+  planReviewFindings: Finding[][]
+  codeReviewFindings: Finding[][]
+  verify: BuildState['verify']
+  reconcileAttempts: number
+  observations: ObservationRecord[]
+  setupFailures: BuildState['setupFailures']
+  setupFailure: BuildState['setupFailure']
+  dispatchFailures: BuildState['dispatchFailures']
+  executions: BuildState['executions']
+  infrastructureFailures: BuildState['infrastructureFailures']
+  infrastructureFailure: BuildState['infrastructureFailure']
+  cleanupAttempts: BuildState['cleanupAttempts']
+  discardRequest: BuildState['discardRequest']
+  pending: Record<PendingCommand['command'], PendingCommand[]>
+  openSessions: OpenSession[]
+  failures: Record<string, number>
+  lastEvent?: AbEvent
+}
+
+/** Bump when `BuildAcc`'s shape or the fold's semantics change. */
+export const BUILD_REDUCER_VERSION = 1
+
+function initialBuildAcc(): BuildAcc {
+  return {
+    attached: false,
+    pausedFlag: false,
+    round: 0,
+    openEscalations: [],
+    answeredEscalations: [],
+    reviewRoundCeilings: {},
+    pr: undefined,
+    autoMerge: { requested: false },
+    restartSince: 0,
+    pinnedAssets: [],
+    finalizeCompletedSeq: 0,
+    finalizeSteps: [],
+    plan: { round: 0, approved: false },
+    implement: { round: 0 },
+    codeReviewApproved: false,
+    codeReviewApproval: undefined,
+    planReviewFindings: [],
+    codeReviewFindings: [],
+    verify: { maxAttemptSeen: 0, results: [], cycleSince: 0 },
+    reconcileAttempts: 0,
+    observations: [],
+    setupFailures: [],
+    setupFailure: undefined,
+    dispatchFailures: [],
+    executions: [],
+    infrastructureFailures: [],
+    infrastructureFailure: undefined,
+    cleanupAttempts: [],
+    discardRequest: undefined,
+    pending: { pause: [], resume: [], abort: [] },
+    openSessions: [],
+    failures: {},
   }
-  const openSessions = new Map<string, OpenSession>()
-  const failures: Record<string, number> = {}
+}
+
+/** Fold `events` into `acc` in place. */
+function foldBuild(acc: BuildAcc, events: readonly AbEvent[]): void {
+  let attached = acc.attached
+  let pausedFlag = acc.pausedFlag
+  let terminal = acc.terminal
+  let outcome = acc.outcome
+  let round = acc.round
+  let currentPhase = acc.currentPhase
+  let lastCompletedPhase = acc.lastCompletedPhase
+  const openEscalations = new Map(acc.openEscalations.map((e) => [e.id, e]))
+  const answeredEscalations = acc.answeredEscalations
+  const reviewRoundCeilings = acc.reviewRoundCeilings
+  let pr = acc.pr
+  let prState = acc.prState
+  const autoMerge = acc.autoMerge
+  let specRev = acc.specRev
+  let restartSince = acc.restartSince
+  let pinnedAssets = acc.pinnedAssets
+  let finalizeCompletedSeq = acc.finalizeCompletedSeq
+  const finalizeSteps = acc.finalizeSteps
+  const plan = acc.plan
+  const implement = acc.implement
+  let codeReviewApproved = acc.codeReviewApproved
+  let codeReviewApproval = acc.codeReviewApproval
+  const planReviewFindings = acc.planReviewFindings
+  const codeReviewFindings = acc.codeReviewFindings
+  const verify = acc.verify
+  let reconcileAttempts = acc.reconcileAttempts
+  const observations = acc.observations
+  const setupFailures = acc.setupFailures
+  let setupFailure = acc.setupFailure
+  const dispatchFailures = acc.dispatchFailures
+  const executions = acc.executions
+  const infrastructureFailures = acc.infrastructureFailures
+  let infrastructureFailure = acc.infrastructureFailure
+  const cleanupAttempts = acc.cleanupAttempts
+  let discardRequest = acc.discardRequest
+  const pending = acc.pending
+  const openSessions = new Map(acc.openSessions.map((s) => [s.session, s]))
+  const failures = acc.failures
 
   const start = (ctx: PhaseContext): void => {
     currentPhase = ctx
@@ -362,7 +447,7 @@ export function reduceBuild(events: AbEvent[]): BuildState {
     per[r - 1] = findings
   }
 
-  let lastEvent: AbEvent | undefined
+  let lastEvent = acc.lastEvent
   for (const event of events) {
     switch (event.type) {
       // Facts the projection does not need (workspace liveness is the
@@ -737,55 +822,112 @@ export function reduceBuild(events: AbEvent[]): BuildState {
     lastEvent = event
   }
 
+  acc.attached = attached
+  acc.pausedFlag = pausedFlag
+  acc.terminal = terminal
+  acc.outcome = outcome
+  acc.round = round
+  acc.currentPhase = currentPhase
+  acc.lastCompletedPhase = lastCompletedPhase
+  acc.openEscalations = [...openEscalations.values()]
+  acc.pr = pr
+  acc.prState = prState
+  acc.specRev = specRev
+  acc.restartSince = restartSince
+  acc.pinnedAssets = pinnedAssets
+  acc.finalizeCompletedSeq = finalizeCompletedSeq
+  acc.codeReviewApproved = codeReviewApproved
+  acc.codeReviewApproval = codeReviewApproval
+  acc.reconcileAttempts = reconcileAttempts
+  acc.setupFailure = setupFailure
+  acc.infrastructureFailure = infrastructureFailure
+  acc.discardRequest = discardRequest
+  acc.openSessions = [...openSessions.values()]
+  acc.lastEvent = lastEvent
+}
+
+function finishBuild(acc: BuildAcc): BuildState {
+  const {
+    terminal,
+    pausedFlag,
+    attached,
+    currentPhase,
+    lastCompletedPhase,
+    lastEvent,
+    discardRequest,
+    pending,
+  } = acc
+
   // §15.5 precedence: aborted/done (terminal, latest wins) > paused >
   // blocked > running > queued. See BuildState.status for the paused+blocked
   // overlap rule.
   const status: BuildStatus =
     terminal ??
-    (pausedFlag ? 'paused' : openEscalations.size > 0 ? 'blocked' : attached ? 'running' : 'queued')
+    (pausedFlag
+      ? 'paused'
+      : acc.openEscalations.length > 0
+        ? 'blocked'
+        : attached
+          ? 'running'
+          : 'queued')
 
   const active = currentPhase ?? lastCompletedPhase
 
   return {
     status,
-    outcome,
+    outcome: acc.outcome,
     phase: active?.phase,
-    round,
+    round: acc.round,
     currentPhase,
     lastCompletedPhase,
-    openEscalations: [...openEscalations.values()],
-    answeredEscalations,
-    reviewRoundCeilings,
-    pr,
-    prState,
-    autoMerge,
-    finalizeCompletedSeq,
-    finalizeSteps,
+    openEscalations: [...acc.openEscalations],
+    answeredEscalations: acc.answeredEscalations,
+    reviewRoundCeilings: acc.reviewRoundCeilings,
+    pr: acc.pr,
+    prState: acc.prState,
+    autoMerge: acc.autoMerge,
+    finalizeCompletedSeq: acc.finalizeCompletedSeq,
+    finalizeSteps: acc.finalizeSteps,
     lastEvent,
     lastSeq: lastEvent?.seq ?? 0,
-    pinnedAssets,
-    specRev,
-    restartSince,
-    plan,
-    implement,
-    codeReviewApproved,
-    codeReviewApproval,
-    reviewFindings: { planReview: planReviewFindings, codeReview: codeReviewFindings },
-    verify,
-    reconcileAttempts,
-    observations,
-    setupFailures,
-    setupFailure,
-    dispatchFailures,
-    executions,
-    infrastructureFailures,
-    infrastructureFailure,
-    cleanupAttempts,
+    pinnedAssets: acc.pinnedAssets,
+    specRev: acc.specRev,
+    restartSince: acc.restartSince,
+    plan: acc.plan,
+    implement: acc.implement,
+    codeReviewApproved: acc.codeReviewApproved,
+    codeReviewApproval: acc.codeReviewApproval,
+    reviewFindings: { planReview: acc.planReviewFindings, codeReview: acc.codeReviewFindings },
+    verify: acc.verify,
+    reconcileAttempts: acc.reconcileAttempts,
+    observations: acc.observations,
+    setupFailures: acc.setupFailures,
+    setupFailure: acc.setupFailure,
+    dispatchFailures: acc.dispatchFailures,
+    executions: acc.executions,
+    infrastructureFailures: acc.infrastructureFailures,
+    infrastructureFailure: acc.infrastructureFailure,
+    cleanupAttempts: acc.cleanupAttempts,
     ...(terminal === undefined && discardRequest !== undefined ? { discardRequest } : {}),
     pendingCommands: [...pending.pause, ...pending.resume, ...pending.abort].sort(
       (a, b) => a.seq - b.seq,
     ),
-    sessions: { open: [...openSessions.values()] },
-    failures,
+    sessions: { open: [...acc.openSessions] },
+    failures: acc.failures,
   }
 }
+
+/** The incremental form of `reduceBuild`: advance a carried accumulator with
+ * only the events newer than it, then derive the state. */
+export const buildReducer: IncrementalReducer<BuildAcc, AbEvent, BuildState> = defineReducer({
+  version: BUILD_REDUCER_VERSION,
+  initial: initialBuildAcc,
+  fold: foldBuild,
+  finish: finishBuild,
+})
+
+export function reduceBuild(events: AbEvent[]): BuildState {
+  const acc = initialBuildAcc()
+  foldBuild(acc, events)
+  return finishBuild(acc)
+}

package/packages/core/src/operator/query.ts

@@ -7,13 +7,20 @@ import {
   parseEffectiveBuildConfig,
 } from '../processes/build-execution-state'
 import type { Artifact } from '../store/types'
-import { detail, statusFilter, summarize, type BuildDetail, type BuildSummary } from '../cli/status'
+import {
+  detail,
+  statusFilter,
+  summarizeFrom,
+  type BuildDetail,
+  type BuildSummary,
+} from '../cli/status'
 import { projectRepositoryStatus, type RepositoryStatus } from '../cli/repository-status'
 import { projectHarvestStatus, type HarvestStatusView } from '../cli/harvest'
 import {
   buildDashboardFromProjected,
   effectiveStatus,
   projectBuild,
+  projectBuildFromFacts,
   type DashboardBuild,
   type DashboardModel,
 } from '../cli/dashboard/model'
@@ -21,6 +28,8 @@ import { reduceBuild, type BuildState } from '../kernel/reducer'
 import { DISPATCHER_EFFECTIVE_CONFIG_ARTIFACT } from '../store/retention'
 import { reduceDispatchStatus } from '../kernel/dispatch-status'
 import { readRepoEventsIfRecorded, unclaimedObservationCount } from '../processes/harvest'
+import type { RepoViewStore } from '../processes/repo-view'
+import { withOperatorView } from './read-view'
 import type { RepositoryEvent } from '../events/repository'
 import type { BuildStore, Clock } from '../store/types'
 
@@ -42,6 +51,13 @@ export async function listOperatorBuilds(opts: {
   scope: BuildListScope
   now: Date
 }): Promise<BuildSummary[]> {
+  return withOperatorView(opts.store, opts.repo, 'builds', (view) => listFromView(view, opts))
+}
+
+async function listFromView(
+  view: RepoViewStore,
+  opts: { repo: string; scope: BuildListScope; now: Date },
+): Promise<BuildSummary[]> {
   const statuses = new Set(statusFilter(opts.scope === 'all', opts.scope === 'queued'))
   // Records are read and held before the digest read: builds are never
   // deleted, so every record iterated below is guaranteed an entry in the
@@ -50,14 +66,14 @@ export async function listOperatorBuilds(opts: {
   // check can only ever catch a genuine adapter bug, never a concurrent
   // dispatch. The reverse order would let a concurrent creation abort the
   // whole listing (AUT-488 finding f_3cb67aba).
-  const records = await opts.store.listBuilds()
-  // One digest read gates the per-build history reads (AUT-488): the active
-  // and queued scopes never show a terminal build, so a build whose digest
-  // already carries a terminal fact skips its `getEvents` round trip and the
-  // listing's store cost stays flat as finished builds accumulate. The `--all`
-  // scope includes terminal statuses, so it takes no digest read and skips
-  // nothing — byte-for-byte the old loop.
-  const digests = opts.scope === 'all' ? undefined : await opts.store.getRepoBuildDigests(opts.repo)
+  const records = await view.listBuilds()
+  // One digest read gates the per-build reads (AUT-488): the active and queued
+  // scopes never show a terminal build, so a build whose digest already
+  // carries a terminal fact is skipped and the listing's cost stays flat as
+  // finished builds accumulate. The `--all` scope includes terminal statuses,
+  // so it takes no digest read and skips nothing; its terminal builds are
+  // restored from the reducer snapshots the dispatcher leaves at settlement.
+  const digests = opts.scope === 'all' ? undefined : await view.getRepoBuildDigests(opts.repo)
   const output: BuildSummary[] = []
   for (const record of records) {
     if (record.repo !== opts.repo) continue
@@ -74,10 +90,10 @@ export async function listOperatorBuilds(opts: {
       // cleared — pinned against `reduceBuild` in store/digest.test.ts), so
       // `terminal !== undefined` is exactly reduced status `done`/`aborted`,
       // which the active and queued status sets never include. Skipping the
-      // history read therefore cannot change the emitted summaries.
+      // build therefore cannot change the emitted summaries.
       if (digest.terminal !== undefined) continue
     }
-    const projected = summarize(record, await opts.store.getEvents(record.slug), opts.now)
+    const projected = summarizeFrom(record, (await view.buildFacts(record.slug)).state, opts.now)
     if (statuses.has(projected.status)) output.push(projected)
   }
   return output.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
@@ -95,12 +111,15 @@ async function requireBuild(store: BuildStore, repo: string, slug: string) {
 export async function effectiveConfig(
   store: BuildStore,
   repo: string,
+  /** The bounded journal, when the caller already holds it (a repository
+   * view); otherwise it is read from the store. */
+  journal?: RepositoryEvent[],
 ): Promise<{
   config: Config
   repositoryEvents: RepositoryEvent[]
   status: ReturnType<typeof reduceDispatchStatus>
 }> {
-  const repositoryEvents = await readRepoEventsIfRecorded(store, repo)
+  const repositoryEvents = journal ?? (await readRepoEventsIfRecorded(store, repo))
   let latestRun: string | undefined
   for (const event of repositoryEvents) {
     if (event.type === 'dispatcher.run-started') latestRun = event.payload.run
@@ -237,14 +256,18 @@ export async function getRepositoryStatus(
   store: BuildStore,
   repo: string,
 ): Promise<RepositoryStatus> {
-  return projectRepositoryStatus(repo, await readRepoEventsIfRecorded(store, repo))
+  return withOperatorView(store, repo, 'journal', async (view) =>
+    projectRepositoryStatus(repo, view.recordedJournal()),
+  )
 }
 
 export async function getHarvestStatus(
   store: BuildStore,
   repo: string,
 ): Promise<HarvestStatusView> {
-  return projectHarvestStatus(repo, await readRepoEventsIfRecorded(store, repo))
+  return withOperatorView(store, repo, 'journal', async (view) =>
+    projectHarvestStatus(repo, view.recordedJournal()),
+  )
 }
 
 export interface OperatorDashboardSnapshot {
@@ -263,15 +286,26 @@ export async function getOperatorDashboard(opts: {
   repo: string
   clock: Clock
 }): Promise<OperatorDashboardSnapshot> {
-  const { config, repositoryEvents, status } = await effectiveConfig(opts.store, opts.repo)
-  const records = await opts.store.listBuilds()
+  return withOperatorView(opts.store, opts.repo, 'builds', (view) => dashboardFromView(view, opts))
+}
+
+async function dashboardFromView(
+  view: RepoViewStore,
+  opts: { repo: string; clock: Clock },
+): Promise<OperatorDashboardSnapshot> {
+  const { config, repositoryEvents, status } = await effectiveConfig(
+    view,
+    opts.repo,
+    view.recordedJournal(),
+  )
+  const records = await view.listBuilds()
   // One digest read covers every build of the repository (AUT-487): the
-  // row gate (a `done` digest means no row) and the observation count no
-  // longer need per-build histories, so the snapshot's store traffic stays
-  // flat as finished builds accumulate. Row-rendering builds still get their
-  // full history below, and the digest itself is derived from the event log
-  // on every call — nothing is persisted or cached between snapshots.
-  const digests = await opts.store.getRepoBuildDigests(opts.repo)
+  // row gate (a `done` digest means no row) and the observation count need no
+  // per-build histories, so the snapshot's traffic stays flat as finished
+  // builds accumulate. Row-rendering builds derive from the repository view's
+  // reducer snapshots plus a delta read (AUT-650); every snapshot is a cache
+  // the event log regenerates, so the response equals a full replay's.
+  const digests = await view.getRepoBuildDigests(opts.repo)
   const projected: DashboardBuild[] = []
   let activeCount = 0
   for (const record of records) {
@@ -295,12 +329,18 @@ export async function getOperatorDashboard(opts: {
     // could never be surfaced. The digest already excluded `done` builds
     // above; the gate stays as the authority for the row projection so the
     // digest and the reducer cannot silently diverge. Every row-rendering
-    // build still gets its full history and pinned pipeline.
-    const events = await opts.store.getEvents(record.slug)
-    const state = reduceBuild(events)
-    if (projectsNoDashboardRow(state)) continue
-    const pinned = await readPinnedConfig(opts.store, record.slug, config)
-    const row = projectBuild(record, state, config, events, undefined, pinned.config)
+    // build still gets its facts and pinned pipeline.
+    const facts = await view.buildFacts(record.slug)
+    if (projectsNoDashboardRow(facts.state)) continue
+    const pinned = await readPinnedConfig(view, record.slug, config)
+    const row = projectBuildFromFacts(
+      record,
+      facts.state,
+      { dashboard: facts.dashboard, log: facts.log, deferral: facts.deferral },
+      config,
+      undefined,
+      pinned.config,
+    )
     if (row !== null) projected.push(decorateWithPinnedMeta(row, pinned))
   }
   // The unclaimed-observation count comes from the digests and the journal

package/packages/core/src/operator/read-view.ts

@@ -0,0 +1,98 @@
+/**
+ * The operator read paths' repository view: every poll-driven route (dashboard,
+ * repository and harvest status, build listings) derives its state from a
+ * `RepoViewStore` cold-started from stored reducer snapshots and advanced with
+ * delta reads, so a poll's event-row cost follows the events appended since the
+ * last one, never the history, the open tabs, or the watchers.
+ *
+ * Passes are single-flight per `(store, repo)` within one serving process: at
+ * most one pass runs at a time, and requests arriving while it runs join the
+ * one trailing pass (each needs state at least as new as its arrival, which the
+ * running pass cannot promise). That trailing pass restores from the snapshot
+ * the previous pass persisted, so N concurrent pollers cost one delta read per
+ * pass, not N. The coordination is scheduling inside this process; every datum
+ * still comes from durable state, and a second serving process simply reads the
+ * same delta once itself (duplicate reads are bounded by the process count).
+ */
+import { RepoViewStore } from '../processes/repo-view'
+import type { BuildStore } from '../store/types'
+
+/** What a request reads: the journal alone, or the builds beside it. */
+export type OperatorViewNeed = 'journal' | 'builds'
+
+interface Waiter {
+  need: OperatorViewNeed
+  run: (view: RepoViewStore) => Promise<unknown>
+  resolve: (value: unknown) => void
+  reject: (error: unknown) => void
+}
+
+interface Flight {
+  running: boolean
+  queue: Waiter[]
+}
+
+const flights = new WeakMap<BuildStore, Map<string, Flight>>()
+
+function flightFor(store: BuildStore, repo: string): Flight {
+  let byRepo = flights.get(store)
+  if (byRepo === undefined) {
+    byRepo = new Map()
+    flights.set(store, byRepo)
+  }
+  let flight = byRepo.get(repo)
+  if (flight === undefined) {
+    flight = { running: false, queue: [] }
+    byRepo.set(repo, flight)
+  }
+  return flight
+}
+
+async function pass(store: BuildStore, repo: string, waiters: Waiter[]): Promise<void> {
+  const view = new RepoViewStore(store, { repo })
+  try {
+    if (waiters.some((waiter) => waiter.need === 'builds')) await view.refresh()
+    else await view.startJournal()
+  } catch (error) {
+    for (const waiter of waiters) waiter.reject(error)
+    return
+  }
+  await Promise.all(waiters.map((waiter) => waiter.run(view).then(waiter.resolve, waiter.reject)))
+  // Leave the advanced state behind for the next pass (this process's or
+  // another's). `held` also writes a settled build read for a listing. The
+  // cache never fails a read.
+  try {
+    await view.persistSnapshots({ force: true, held: true })
+  } catch {
+    // A cache: the next pass retries.
+  }
+}
+
+async function drain(store: BuildStore, repo: string, flight: Flight): Promise<void> {
+  flight.running = true
+  try {
+    while (flight.queue.length > 0) {
+      const waiters = flight.queue
+      flight.queue = []
+      await pass(store, repo, waiters)
+    }
+  } finally {
+    flight.running = false
+  }
+}
+
+/** Run `run` against a freshly advanced repository view. The view is only valid
+ * inside `run`; the response must not hold it. */
+export function withOperatorView<T>(
+  store: BuildStore,
+  repo: string,
+  need: OperatorViewNeed,
+  run: (view: RepoViewStore) => Promise<T>,
+): Promise<T> {
+  const flight = flightFor(store, repo)
+  const result = new Promise<T>((resolve, reject) => {
+    flight.queue.push({ need, run, resolve: resolve as (value: unknown) => void, reject })
+  })
+  if (!flight.running) void drain(store, repo, flight)
+  return result
+}

package/packages/core/src/ports/tickets/fake.ts

@@ -79,7 +79,11 @@ export class FakeTicketSource implements TicketSource {
     this.tickets.set(ticket.ref.id, cloneTicket(ticket))
   }
 
-  async listReady(criteria: { labels?: string[]; state?: string }): Promise<TicketListing> {
+  async listReady(criteria: {
+    labels?: string[]
+    state?: string
+    assignee?: string
+  }): Promise<TicketListing> {
     const labels = criteria.labels ?? []
     return {
       tickets: [...this.tickets.values()]