@defrex/autobuild 0.13.0 → 0.14.0

package/packages/core/src/cli/dispatch-repository-feed.ts

@@ -0,0 +1,196 @@
+import { type RepositoryEvent, validateRepositoryEventWrite } from '../events/repository'
+import { defineReducer } from '../kernel/incremental'
+import { loadReducerSnapshot, persistReducerSnapshot } from '../store/snapshots'
+import type { BuildStore, Clock } from '../store/types'
+
+export function isDashboardRepositoryEvent(event: RepositoryEvent): boolean {
+  return (
+    event.type.startsWith('harvest.') ||
+    event.type === 'dispatcher.intake-set' ||
+    event.type === 'dispatcher.pause-set' ||
+    event.type === 'dispatcher.auto-merge-default-set'
+  )
+}
+
+export const dispatchFrontendReducer = defineReducer({
+  version: 2,
+  initial: (): { retained: RepositoryEvent[]; incompleteIdentities: boolean } => ({
+    retained: [],
+    incompleteIdentities: true,
+  }),
+  fold(acc, events: readonly RepositoryEvent[]) {
+    const facts = new Map(acc.retained.map((event) => [event.seq, event]))
+    for (const event of events) {
+      if (isDashboardRepositoryEvent(event) || event.type === 'dispatcher.run-started')
+        facts.set(event.seq, event)
+    }
+    acc.retained = [...facts.values()].sort((a, b) => a.seq - b.seq)
+  },
+  finish: (acc) => acc.retained,
+})
+
+/** One serialized, frontend-only repository projection. The consumed cursor is
+ * independent of retained facts: quiet ticks must never survive in the cache. */
+export class DispatchRepositoryFeed {
+  private cursor = 0
+  private ready = false
+  private retained: RepositoryEvent[] = []
+  private tail: Promise<void> = Promise.resolve()
+  private savedAt = -Infinity
+  private boundary: number | undefined
+  private recovery = false
+  incompleteIdentities = true
+
+  constructor(
+    private readonly store: BuildStore,
+    private readonly repo: string,
+    private readonly clock: Clock,
+  ) {}
+
+  get events(): RepositoryEvent[] {
+    return this.retained.filter(isDashboardRepositoryEvent)
+  }
+  get identities(): RepositoryEvent[] {
+    return this.retained.filter((e) => e.type === 'dispatcher.run-started')
+  }
+
+  private validate(events: RepositoryEvent[], cursor: number, contiguous: boolean): void {
+    let previous = cursor
+    for (const event of events) {
+      if (
+        event.repo !== this.repo ||
+        !Number.isInteger(event.seq) ||
+        event.seq <= previous ||
+        (contiguous && event.seq !== previous + 1) ||
+        typeof event.ts !== 'string' ||
+        !Number.isFinite(Date.parse(event.ts))
+      ) {
+        throw new Error('invalid dashboard repository delta')
+      }
+      validateRepositoryEventWrite(event)
+      previous = event.seq
+    }
+  }
+
+  async warm(): Promise<RepositoryEvent[]> {
+    this.recovery = true
+    this.boundary = await this.store.getRepoHighWater(this.repo)
+    this.recovery = false
+    try {
+      return await this.refresh()
+    } catch (error) {
+      this.recovery = true
+      throw error
+    }
+  }
+
+  refresh(persist = true): Promise<RepositoryEvent[]> {
+    let result: RepositoryEvent[] = []
+    const next = this.tail.then(async () => {
+      let cursor = this.cursor
+      let retained = this.retained
+      let incompleteIdentities = this.incompleteIdentities
+      let delta: RepositoryEvent[]
+      if (!this.ready) {
+        if ((await this.store.getRepo(this.repo)) === null) {
+          this.ready = true
+          this.recovery = false
+          return
+        }
+        const high = await this.store.getRepoHighWater(this.repo)
+        const snapshot = await loadReducerSnapshot(
+          this.store,
+          { kind: 'repo', repo: this.repo },
+          'dispatchFrontend',
+          dispatchFrontendReducer,
+        )
+        let restored = false
+        if (snapshot && snapshot.cursor <= high) {
+          try {
+            const state = snapshot.state as {
+              retained: RepositoryEvent[]
+              incompleteIdentities: boolean
+            }
+            if (!Array.isArray(state.retained) || typeof state.incompleteIdentities !== 'boolean')
+              throw new Error('invalid projection')
+            this.validate(state.retained, 0, false)
+            if (
+              state.retained.some(
+                (e) =>
+                  e.seq > snapshot.cursor ||
+                  !(isDashboardRepositoryEvent(e) || e.type === 'dispatcher.run-started'),
+              )
+            )
+              throw new Error('invalid retained fact')
+            incompleteIdentities = state.incompleteIdentities
+            retained = state.retained
+            cursor = snapshot.cursor
+            restored = true
+          } catch {
+            /* A malformed cache uses the bounded seed. */
+          }
+        }
+        if (!restored) {
+          const seed = await this.store.getRepoStateEvents(this.repo)
+          this.validate(seed, 0, false)
+          incompleteIdentities = true
+          retained = dispatchFrontendReducer.reduce(seed)
+          cursor = Math.max(high, seed.at(-1)?.seq ?? 0)
+        }
+        delta = await this.store.getRepoEvents(this.repo, cursor)
+        this.validate(delta, cursor, true)
+        // A failed prelaunch seed must not skip this invocation's config/start
+        // even if a competing run advanced the bounded seed's anchor.
+        if (this.recovery) {
+          const recovery = await this.store.getRepoEvents(this.repo, this.boundary ?? 0)
+          this.validate(recovery, this.boundary ?? 0, true)
+          delta = [...new Map([...delta, ...recovery].map((e) => [e.seq, e])).values()].sort(
+            (a, b) => a.seq - b.seq,
+          )
+        }
+      } else {
+        delta = await this.store.getRepoEvents(this.repo, cursor)
+        this.validate(delta, cursor, true)
+        // A standby correlation may have supplied an older identity while the
+        // delta read was pending. Keep those memoized facts in this commit.
+        retained = this.retained
+        incompleteIdentities = this.incompleteIdentities
+      }
+      retained = dispatchFrontendReducer.advance({ retained, incompleteIdentities }, delta).retained
+      this.cursor = Math.max(cursor, delta.at(-1)?.seq ?? 0)
+      this.incompleteIdentities = incompleteIdentities
+      this.retained = retained
+      this.ready = true
+      this.recovery = false
+      result = delta
+      if (persist) await this.save()
+    })
+    this.tail = next.catch(() => {})
+    return next.then(() => result)
+  }
+
+  remember(events: readonly RepositoryEvent[], complete = false): void {
+    this.retained = dispatchFrontendReducer.advance(
+      { retained: this.retained, incompleteIdentities: this.incompleteIdentities },
+      events.filter((e) => e.seq <= this.cursor),
+    ).retained
+    if (complete) this.incompleteIdentities = false
+  }
+
+  async save(force = false): Promise<void> {
+    if (!this.ready || (!force && this.clock().getTime() - this.savedAt < 5000)) return
+    // A rejected equal-cursor put and an unavailable store still cost a
+    // request. Bound attempts, not just successful writes, on quiet polls.
+    this.savedAt = this.clock().getTime()
+    await persistReducerSnapshot(
+      this.store,
+      { kind: 'repo', repo: this.repo },
+      'dispatchFrontend',
+      {
+        version: dispatchFrontendReducer.version,
+        cursor: this.cursor,
+        state: { retained: this.retained, incompleteIdentities: this.incompleteIdentities },
+      },
+    )
+  }
+}

package/packages/core/src/cli/dispatch.ts

@@ -1,3 +1,11 @@
+import type { BuildState } from '../kernel/reducer'
+import {
+  readBuildFacts,
+  readRepositoryFacts,
+  readBuildSelector,
+  readDispatcherRunFacts,
+} from '../store/reduced-reads'
+import { shouldPublishTickFromFacts } from '../processes/tick-publication'
 import { issueTicketGrant, ticketGrantRequest } from '../ports/tickets/grants'
 import { RemoteBuildStore } from '../store/remote/client'
 import { delegateCredential } from '../store/remote/credentials'
@@ -54,17 +62,14 @@ import { loadPlugins, pluginResolutionKind } from '../plugins/load'
 import type { PluginRegistry } from '../plugins/registry'
 import { materializePluginRuntimes } from '../plugins/runtimes'
 import { DISPATCHER, KERNEL, humanActor } from '../events/envelope'
-import type { AbEvent } from '../events/catalog'
 import type { RepositoryEventWrite } from '../events/repository'
 import { randomIds, randomUuids, type IdSource, type UuidSource } from '../ids'
-import { reduceDispatchSettings } from '../kernel/dispatch-settings'
+import type { reduceDispatchSettings } from '../kernel/dispatch-settings'
 import {
   DEFAULT_MAX_HARVEST_RECOVERY_ATTEMPTS,
   actionableHarvestRun,
   decideHarvestControl,
-  reduceHarvest,
 } from '../kernel/harvest'
-import { reduceBuild } from '../kernel/reducer'
 import { dashboardBuildControl } from './dashboard/actions'
 import {
   buildDashboardFromProjected,
@@ -127,12 +132,10 @@ import {
   parseBuildConfigMetadata,
   parseDiagnostic,
   parseEffectiveBuildConfig,
-  selectOpenWorkspace,
 } from '../processes/build-execution-state'
 import { HarvestRunner, type HarvestRunnerResult } from '../processes/harvest-runner'
 import {
   sampleUnclaimedObservationCount,
-  readRepoEventsIfRecorded,
   evaluateHarvestPressureFromStore,
 } from '../processes/harvest'
 import { classifyHarvestOutcome } from '../processes/harvest-execution-state'
@@ -164,7 +167,13 @@ import {
 } from './repo-state'
 import { openStoreForRepoState } from './store-opening'
 import { DispatchFrontend } from './dispatch-frontend'
-import { systemClock, type BuildStore, type Clock } from '../store/types'
+import {
+  systemClock,
+  type BuildStore,
+  type Clock,
+  type RepoTickCompletion,
+  type RepoTickFinish,
+} from '../store/types'
 import { availableRelease } from './self-update'
 import {
   startUpgradeNotice,
@@ -648,6 +657,7 @@ class DispatchLoop {
    * manufacturing a zero queue measurement or losing diagnostics. */
   private lastTickStatus = {
     queued: 0,
+    blockedDiagnostics: [] as string[],
     janitorDiagnostics: [] as string[],
     ticketDiagnostics: [] as string[],
     creationDiagnostics: [] as string[],
@@ -850,7 +860,7 @@ class DispatchLoop {
   private async resolveBuildPipeline(slug: string): Promise<{
     source: Awaited<ReturnType<typeof resolvePipelineSource>>
     failures: PipelineSourceFailure[]
-    events: AbEvent[]
+    observations: BuildState['observations']
   }> {
     const failures: PipelineSourceFailure[] = []
     try {
@@ -858,12 +868,12 @@ class DispatchLoop {
       // the record's `branch` (when present) is the same fact. Using the event
       // keeps this read to the events the caller already needs and avoids an
       // extra build-record lookup on the hot launch path.
-      const events = await this.repoView.getEvents(slug)
-      const workspace = selectOpenWorkspace(events)
+      const facts = (await readBuildFacts(this.repoView, slug)).value
+      const workspace = facts.workspace
       const source = await resolvePipelineSource({
         slug,
         record: { ...(workspace !== null ? { branch: workspace.branch } : {}) },
-        events,
+        recordedBase: await readBuildSelector(this.repoView, slug, 'recordedBaseSha'),
         mode: this.opts.repository !== undefined ? 'origin' : 'checkout',
         forge: this.wiring.forge,
         checkout: this.opts.targetRepo,
@@ -871,13 +881,13 @@ class DispatchLoop {
         ...(workspace !== null ? { workspacePath: workspace.path } : {}),
         onFailure: (failure) => failures.push(failure),
       })
-      return { source, failures, events }
+      return { source, failures, observations: facts.observations }
     } catch (error) {
       failures.push({
         kind: 'store',
         detail: `build-event read failed: ${error instanceof Error ? error.message : String(error)}`,
       })
-      return { source: undefined, failures, events: [] }
+      return { source: undefined, failures, observations: [] }
     }
   }
 
@@ -901,7 +911,7 @@ class DispatchLoop {
    * naming the failed attempts; the documented fallbacks (an unpublished
    * branch, an unreadable legacy base) stay quiet. */
   private async publishBuildConfig(slug: string, snapshot = this.currentConfig()): Promise<void> {
-    const { source, failures, events } = await this.resolveBuildPipeline(slug)
+    const { source, failures, observations } = await this.resolveBuildPipeline(slug)
     if (source !== undefined) {
       await this.depositBuildConfig(
         slug,
@@ -931,7 +941,7 @@ class DispatchLoop {
       // option left that keeps the launch alive.
       await this.depositBuildConfig(slug, snapshot, snapshot.config)
     }
-    await this.filePipelineFallbackObservation(slug, reused, failures, events)
+    await this.filePipelineFallbackObservation(slug, reused, failures, observations)
   }
 
   /** File a build-scoped observation when a deposit hit an actionable
@@ -944,7 +954,7 @@ class DispatchLoop {
     slug: string,
     reused: PipelineSourceMeta | undefined,
     failures: PipelineSourceFailure[],
-    events: readonly AbEvent[],
+    observations: BuildState['observations'],
   ): Promise<void> {
     const actionable = failures.filter(isActionablePipelineFailure)
     if (actionable.length === 0) return
@@ -961,11 +971,7 @@ class DispatchLoop {
       }`
     // Deduplicated against the build's log: a parked build re-attaches every
     // sweep, and an outage must not harvest one identical diagnostic per tick.
-    if (
-      events.some(
-        (event) => event.type === 'observation.recorded' && event.payload.summary === summary,
-      )
-    ) {
+    if (observations.some((observation) => observation.summary === summary)) {
       return
     }
     try {
@@ -1106,9 +1112,11 @@ class DispatchLoop {
     // The view's bounded subset (AUT-489): the settings reducer consumes
     // durable types only. `refresh()` ran first in the tick, so this is the
     // delta-current journal, never a store read.
-    return reduceDispatchSettings(this.repoView.recordedJournal())
+    return this.repoView.repositoryFacts().settings
   }
 
+  private tickStartedAt: string | undefined
+
   private dispatcherTick(resumeCurrent: boolean): Promise<Awaited<ReturnType<Dispatcher['tick']>>> {
     return this.serialize(async () => {
       // Refresh before every watch decision. The owner publishes atomically;
@@ -1121,11 +1129,12 @@ class DispatchLoop {
         await this.recordTickYielded()
         return emptyTickReport()
       }
-      await this.appendStatus({
-        actor: DISPATCHER,
-        type: 'dispatcher.tick-started',
-        payload: { run: this.runId },
-      })
+      const startedAt = await this.repoView.beginRepoTick(this.repoIdentity, this.runId)
+      if (startedAt === null) {
+        this.superseded = true
+        return emptyTickReport()
+      }
+      this.tickStartedAt = startedAt
 
       // Unclaimed observations are display-only and sampled once per interactive
       // dispatcher tick from the journal and one repo-scoped digest read
@@ -1174,6 +1183,7 @@ class DispatchLoop {
       this.queuedCount = publishedReport.queued
       this.lastTickStatus = {
         queued: publishedReport.queued,
+        blockedDiagnostics: [...publishedReport.blockedDiagnostics],
         janitorDiagnostics: [...publishedReport.janitorDiagnostics],
         ticketDiagnostics: [...publishedReport.ticketDiagnostics],
         creationDiagnostics: [...publishedReport.creationDiagnostics],
@@ -1610,8 +1620,8 @@ class DispatchLoop {
     const { store } = this.wiring
     const repo = this.repoIdentity
     await store.ensureRepo(repo)
-    const events = await store.getRepoEvents(repo)
-    const state = reduceHarvest(events)
+    const events = (await readRepositoryFacts(store, repo)).value
+    const state = events.harvest
     const projected = projectHarvest(events)
     if (expectedRun === undefined || projected === undefined || projected.run !== expectedRun) {
       this.say('harvest run action ignored: selected run is no longer active')
@@ -2502,8 +2512,8 @@ class DispatchLoop {
       // reduces durable types only. Take the journal delta first — guests and
       // other dispatchers write harvest facts between ticks.
       await this.repoView.refreshJournal()
-      const events = this.repoView.recordedJournal()
-      const state = reduceHarvest(events)
+      const events = this.repoView.repositoryFacts().harvest
+      const state = events
       const control = decideHarvestControl(state, this.maxHarvestRecoveryAttempts)
       const resumePending =
         actionableHarvestRun(state) !== undefined ||
@@ -2692,7 +2702,7 @@ class DispatchLoop {
     // Bounded subset (AUT-489): classifyHarvestOutcome reduces harvest facts
     // only. A guest wrote the facts through its own handle, so read the delta.
     await this.repoView.refreshJournal()
-    const events = this.repoView.recordedJournal()
+    const events = this.repoView.repositoryFacts()
     const record = await store.getRepo(repo)
     return classifyHarvestOutcome(events, {
       executionStartedSeq: startedSeq,
@@ -2831,15 +2841,38 @@ class DispatchLoop {
       dependencyDiagnostics: _dependencyDiagnostics,
       ...counters
     } = merged
-    await this.appendStatus({
+    const completed = {
       actor: DISPATCHER,
-      type: 'dispatcher.tick-completed',
-      payload: {
-        run: this.runId,
-        ...this.lastTickStatus,
-        counters,
-      },
-    })
+      type: 'dispatcher.tick-completed' as const,
+      payload: { run: this.runId, ...this.lastTickStatus, counters },
+    }
+    if (settlementOnly) {
+      await this.appendStatus(completed)
+    } else {
+      const startedAt = this.tickStartedAt!
+      const facts = this.repoView.repositoryFacts()
+      const recent = facts.recentRuns.find(([run]) => run === this.runId)?.[1]
+      const runFacts = recent?.start
+        ? recent
+        : (await readDispatcherRunFacts(this.repoView, this.repoIdentity, this.runId)).value
+      const publish = shouldPublishTickFromFacts(merged, facts, runFacts, startedAt)
+      const events: RepositoryEventWrite[] = publish
+        ? [
+            {
+              actor: DISPATCHER,
+              type: 'dispatcher.tick-started',
+              payload: { run: this.runId, startedAt },
+            },
+            completed,
+          ]
+        : []
+      const result = await this.finishTick({ outcome: 'completed', counters }, events)
+      if (result === null) {
+        this.superseded = true
+        throw new Error('repository tick lease lost')
+      }
+      this.tickStartedAt = undefined
+    }
 
     this.pendingHarvest.harvestStarted -= snapshot.harvestStarted
     this.pendingHarvest.harvestResumed -= snapshot.harvestResumed
@@ -2849,10 +2882,72 @@ class DispatchLoop {
     return merged
   }
 
+  /** A remote finish can commit before its response is lost. Confirm that
+   * exact tick through durable telemetry before acknowledging its counters;
+   * never try to close an already committed boundary as a second failure. */
+  private async finishTick(
+    completion: RepoTickCompletion,
+    events: RepositoryEventWrite[],
+  ): Promise<RepoTickFinish | null> {
+    try {
+      return await this.repoView.finishRepoTick(this.repoIdentity, this.runId, completion, events)
+    } catch (error) {
+      const observation = (await this.wiring.store.getRepo(this.repoIdentity).catch(() => null))
+        ?.tick
+      const finished = observation?.finished
+      if (
+        observation?.run !== this.runId ||
+        observation.open ||
+        finished?.run !== this.runId ||
+        finished.startedAt !== this.tickStartedAt ||
+        finished.outcome !== completion.outcome ||
+        (finished.outcome === 'failed' &&
+          completion.outcome === 'failed' &&
+          finished.error !== completion.error) ||
+        (finished.outcome === 'completed' &&
+          completion.outcome === 'completed' &&
+          Object.entries(completion.counters).some(
+            ([key, value]) => finished.counters[key as keyof typeof finished.counters] !== value,
+          ))
+      )
+        throw error
+      // The failed response bypassed the view's own-write fold. Refresh its
+      // cursor from the journal, including any committed boundary pair.
+      await this.repoView.refresh()
+      return { observation, events: [] }
+    }
+  }
+
+  private async publishTickFailure(error: unknown): Promise<void> {
+    const failed = {
+      actor: DISPATCHER,
+      type: 'dispatcher.tick-failed' as const,
+      payload: { run: this.runId, error: error instanceof Error ? error.message : String(error) },
+    }
+    if (this.tickStartedAt === undefined) {
+      await this.appendStatus(failed)
+      return
+    }
+    const result = await this.finishTick({ outcome: 'failed', error: failed.payload.error }, [
+      {
+        actor: DISPATCHER,
+        type: 'dispatcher.tick-started',
+        payload: { run: this.runId, startedAt: this.tickStartedAt },
+      },
+      failed,
+    ])
+    if (result === null) {
+      this.superseded = true
+      return
+    }
+    this.tickStartedAt = undefined
+  }
+
   /** Settlement-only completions are serialized after operational ticks. Loop
    * so a result arriving during an awaited status append gets its own report. */
   private publishSettlementReports(): Promise<TickReport[]> {
     return this.serialize(async () => {
+      if (this.superseded) return []
       const reports: TickReport[] = []
       while (this.hasPendingHarvestResults()) {
         const report = await this.publishTickReport(emptyTickReport(), true)
@@ -2918,7 +3013,7 @@ class DispatchLoop {
       { store: this.repoView, ids: this.wiring.ids },
       {
         slug: input.slug,
-        events: await this.repoView.getEvents(input.slug),
+        events: (await readBuildFacts(this.repoView, input.slug)).value,
         maxAttempts: this.currentConfig().config.policy.maxInfrastructureAttempts,
         provider: input.identity?.provider ?? this.wiring.workspaces.name,
         workspaceRef: input.workspaceRef,
@@ -2960,18 +3055,9 @@ class DispatchLoop {
         this.failureNotice(`build ${slug} already held by another runner — skipped`)
         return 'already-active'
       }
-      const launchEvents = await this.repoView.getEvents(slug)
-      let workspaceRef: string | undefined
-      let workspaceProvider: string | undefined
-      for (const event of launchEvents) {
-        if (event.type === 'workspace.provisioned') {
-          workspaceRef = event.payload.ref
-          workspaceProvider = event.payload.provider
-        } else if (event.type === 'workspace.released') {
-          workspaceRef = undefined
-          workspaceProvider = undefined
-        }
-      }
+      const workspace = (await readBuildFacts(this.repoView, slug)).value.workspace
+      const workspaceRef = workspace?.ref
+      const workspaceProvider = workspace?.provider
       if (workspaceRef === undefined) throw new Error(`build ${slug} has no open workspace`)
       // Execute through the runtime that owns the workspace: a build
       // provisioned before a provider switch still runs where it lives.
@@ -3054,7 +3140,7 @@ class DispatchLoop {
               }
 
               await this.repoView.refreshBuild(slug)
-              const state = reduceBuild(await this.repoView.getEvents(slug))
+              const state = (await readBuildFacts(this.repoView, slug)).value.state
               if (diagnostic === null && exit.exitCode === 0) {
                 await this.appendStatus({
                   actor: DISPATCHER,
@@ -3121,12 +3207,7 @@ class DispatchLoop {
       if (leaseClaimed) {
         // The runner appended through its own handle: take the delta.
         await this.repoView.refreshBuild(slug)
-        const events = await this.repoView.getEvents(slug)
-        let workspaceRef = ''
-        for (const event of events) {
-          if (event.type === 'workspace.provisioned') workspaceRef = event.payload.ref
-          else if (event.type === 'workspace.released') workspaceRef = ''
-        }
+        const workspaceRef = (await readBuildFacts(this.repoView, slug)).value.workspace?.ref ?? ''
         if (workspaceRef !== '') {
           await this.recordInfrastructureFailure({
             slug,
@@ -3402,7 +3483,7 @@ class DispatchLoop {
     // no anchor dependence (anchor analysis recorded; the frontend seed needed one
     // only because reduceDispatchStatus folds here too — it does not here).
     // Missing journal record stays a read-only empty journal (AUT-524).
-    const repositoryEvents = await readRepoEventsIfRecorded(this.wiring.store, this.repoIdentity)
+    const repositoryEvents = (await readRepositoryFacts(this.wiring.store, this.repoIdentity)).value
 
     // Action-triggered and timer refreshes share the cache but may finish their
     // repository reads out of order. Never let an older build snapshot replace
@@ -3802,14 +3883,7 @@ class DispatchLoop {
         // invocation.
         if (this.pastDeadline()) return
         const initial = await this.dispatcherTick(true).catch(async (error: unknown) => {
-          await this.appendStatus({
-            actor: DISPATCHER,
-            type: 'dispatcher.tick-failed',
-            payload: {
-              run: this.runId,
-              error: error instanceof Error ? error.message : String(error),
-            },
-          })
+          await this.publishTickFailure(error)
           throw error
         })
         const initialPrinted = this.printReport(initial, false)
@@ -3856,11 +3930,7 @@ class DispatchLoop {
           startup = false
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error)
-          await this.appendStatus({
-            actor: DISPATCHER,
-            type: 'dispatcher.tick-failed',
-            payload: { run: this.runId, error: message },
-          })
+          await this.publishTickFailure(error)
           this.warn(`tick failed: ${message}`)
         }
         if (this.stopped || this.superseded) break
@@ -4314,11 +4384,10 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
   const loop = new DispatchLoop(liveConfig, wiring, resolvedOpts, view)
   try {
     await loop.run()
-    const stopRequest = (
+    const stopRequest =
       resolvedOpts.kernelRunId && resolvedOpts.signal?.aborted
-        ? await wiring.store.getRepoEvents(state.repo)
-        : []
-    ).find((event) => event.type === 'dispatcher.stop-requested' && event.payload.run === runId)
+        ? (await readDispatcherRunFacts(wiring.store, state.repo, runId)).value.stopRequest
+        : undefined
     const stoppedSignal =
       stopRequest?.type === 'dispatcher.stop-requested'
         ? stopRequest.payload.signal
@@ -4356,7 +4425,7 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
     // Every append this invocation made, `run-stopped` included, is in the
     // view; leave the reduced state behind so the next cold process reads
     // only what is newer than it.
-    await view.persistSnapshots({ force: true })
+
     if (resolvedOpts.wire === undefined) await wiring.store.close()
   }
 }