@defrex/autobuild 0.12.0 → 0.14.0

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

@@ -1,3 +1,12 @@
+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'
 import { isRemoteStoreRef } from './repo-state'
@@ -53,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,
@@ -126,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'
@@ -163,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,
@@ -205,7 +215,8 @@ export function slugNamingPrompt(spec: string): string {
 function definedEnv(env: Record<string, string | undefined>): Record<string, string> {
   const defined: Record<string, string> = {}
   for (const [key, value] of Object.entries(env)) {
-    if (value !== undefined && key !== 'AB_TOKEN') defined[key] = value
+    if (value !== undefined && !['AB_TOKEN', 'AB_TICKET_TOKEN', 'AB_TICKET_URL'].includes(key))
+      defined[key] = value
   }
   return defined
 }
@@ -646,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[],
@@ -811,6 +823,7 @@ class DispatchLoop {
       forge: wiring.forge,
       config,
       getConfig: () => this.liveConfig.current().config,
+      repairBuildConfig: (slug) => this.publishBuildConfig(slug),
       repo: this.repoIdentity,
       // Origin mode: the forge answers remote base-branch questions; no
       // checkout git is probed for the served repository's origin.
@@ -847,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 {
@@ -855,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,
@@ -868,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: [] }
     }
   }
 
@@ -898,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,
@@ -928,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
@@ -941,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
@@ -958,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 {
@@ -1103,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;
@@ -1118,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
@@ -1171,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],
@@ -1607,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')
@@ -2248,6 +2261,110 @@ class DispatchLoop {
 
     let tracked: Promise<void>
     tracked = (async () => {
+      const ticketUrl =
+        harvestDeps.config.tickets.source === 'hosted'
+          ? (harvestDeps.config.tickets.url ?? (/^https?:/i.test(storeRef) ? storeRef : undefined))
+          : undefined
+      if (ticketUrl && ticketUrl.replace(/\/+$/, '') !== storeRef.replace(/\/+$/, '')) {
+        const ticketToken = projectToken(ticketUrl, this.repoIdentity, {
+          ...this.opts.env,
+          AB_TOKEN: undefined,
+        })
+        if (!ticketToken)
+          throw new Error('Independent hosted harvest requires a ticket-service project credential')
+        const issued = await issueTicketGrant(
+          ticketUrl,
+          ticketToken,
+          this.repoIdentity,
+          harvestDeps.instance,
+          'runner',
+        )
+        let remoteRunnerStore: RemoteBuildStore | undefined
+        let preparedRun: { run: string } | undefined
+        let buildScoped: string | undefined
+        let renew: ReturnType<typeof setInterval> | undefined
+        try {
+          if (/^https?:/i.test(storeRef)) {
+            const prepared = await new HarvestRunner(harvestDeps).run(true)
+            if (prepared.outcome !== 'prepared') {
+              return prepared
+            }
+            preparedRun = { run: prepared.run }
+            await this.repoView.appendRepo(this.repoIdentity, {
+              actor: DISPATCHER,
+              type: 'harvest.execution.authorized',
+              payload: {
+                execution: harvestDeps.instance,
+                run: prepared.run,
+                launch: prepared.launch,
+                leaseHolder: this.repoLeaseHolder ?? harvestDeps.instance,
+              },
+            })
+            buildScoped = await (this.wiring.credentialIssuer ?? delegateCredential)(
+              storeRef,
+              token,
+              {
+                kind: 'harvest-runner',
+                execution: harvestDeps.instance,
+                repo: this.repoIdentity,
+                id: prepared.run,
+                leaseHolder: this.repoLeaseHolder ?? harvestDeps.instance,
+              },
+            )
+            remoteRunnerStore = new RemoteBuildStore({ url: storeRef, token: buildScoped })
+          }
+          const sessionEnv = {
+            ...harvestDeps.sessionEnv,
+            ...(buildScoped ? { AB_TOKEN: buildScoped } : {}),
+            AB_TICKET_URL: ticketUrl,
+            AB_TICKET_TOKEN: issued.token,
+          }
+          let renewalFailure: unknown
+          renew = setInterval(() => {
+            void ticketGrantRequest(ticketUrl, issued.token, {
+              action: 'renew',
+              repo: this.repoIdentity,
+              id: issued.grant.id,
+            }).catch((error) => {
+              renewalFailure = error
+            })
+          }, 60_000)
+          const runnerTickets = await createTicketSource(
+            harvestDeps.config.tickets,
+            { ...this.opts.env, ...sessionEnv, AB_TOKEN: undefined },
+            this.opts.targetRepo,
+            undefined,
+            this.wiring.plugins,
+          )
+          const result = await new HarvestRunner({
+            ...harvestDeps,
+            ...(remoteRunnerStore ? { store: remoteRunnerStore } : {}),
+            ...(preparedRun ? { preparedRun } : {}),
+            tickets: runnerTickets,
+            sessionEnv,
+          }).run()
+          if (renewalFailure) throw renewalFailure
+          return result
+        } finally {
+          if (renew) clearInterval(renew)
+          try {
+            if (remoteRunnerStore && preparedRun) {
+              await remoteRunnerStore.appendRepo(this.repoIdentity, {
+                actor: DISPATCHER,
+                type: 'harvest.execution.ended',
+                payload: { execution: harvestDeps.instance, run: preparedRun.run },
+              })
+              await remoteRunnerStore.close()
+            }
+          } finally {
+            await ticketGrantRequest(ticketUrl, ticketToken, {
+              action: 'revoke',
+              repo: this.repoIdentity,
+              id: issued.grant.id,
+            })
+          }
+        }
+      }
       if (!/^https?:/i.test(storeRef)) return new HarvestRunner(harvestDeps).run()
       const prepared = await new HarvestRunner(harvestDeps).run(true)
       if (prepared.outcome !== 'prepared') return prepared
@@ -2274,7 +2391,12 @@ class DispatchLoop {
           harvestDeps.config.tickets.source === 'hosted'
             ? await createTicketSource(
                 harvestDeps.config.tickets,
-                { ...this.opts.env, AB_STORE: storeRef, AB_TOKEN: scoped },
+                {
+                  ...this.opts.env,
+                  AB_STORE: storeRef,
+                  AB_TOKEN: scoped,
+                  AB_HARVEST: prepared.run,
+                },
                 this.opts.targetRepo,
                 resolveRepoStatePaths({
                   repo: this.repoIdentity,
@@ -2369,6 +2491,8 @@ class DispatchLoop {
     const repo = this.repoIdentity
     let handle: BuildExecutionHandle | undefined
     let startedSeq: number | undefined
+    let ticketAuthority: { url: string; token: string; id: string } | undefined
+    let renewTickets: ReturnType<typeof setInterval> | undefined
     // Shared with `stopHostedHarvest` through the `hostedHarvest` entry: a
     // detach must stay observable to the completion chain even after the
     // entry is cleared, or the chain would classify and reap a live guest.
@@ -2388,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 ||
@@ -2438,6 +2562,36 @@ class DispatchLoop {
             ),
           }
         : undefined
+      const ticketConfig = this.currentConfig().config.tickets
+      if (
+        ticketConfig.source === 'hosted' &&
+        ticketConfig.url &&
+        ticketConfig.url.replace(/\/+$/, '') !== storeRef.replace(/\/+$/, '')
+      ) {
+        const ticketToken = projectToken(ticketConfig.url, repo, {
+          ...this.opts.env,
+          AB_TOKEN: undefined,
+        })
+        if (!ticketToken || !launchAuth)
+          throw new Error('Independent harvest requires scoped build and ticket credentials')
+        const issued = await issueTicketGrant(
+          ticketConfig.url,
+          ticketToken,
+          repo,
+          execution,
+          'runner',
+        )
+        ticketAuthority = { url: ticketConfig.url, token: issued.token, id: issued.grant.id }
+        renewTickets = setInterval(() => {
+          void ticketGrantRequest(ticketConfig.url!, issued.token, {
+            action: 'renew',
+            repo,
+            id: issued.grant.id,
+          }).catch(() => {
+            // Expiry fails subsequent reads closed; the guest cannot regain project authority.
+          })
+        }, 60_000)
+      }
       handle = await harvestExecution.start(
         {
           preparedRun: { run: prepared.run },
@@ -2447,7 +2601,9 @@ class DispatchLoop {
           baseBranch: this.currentConfig().config.baseBranch,
           ...(this.repoLeaseHolder !== undefined ? { leaseHolder: this.repoLeaseHolder } : {}),
         },
-        launchAuth,
+        launchAuth && ticketAuthority
+          ? { ...launchAuth, tickets: { url: ticketAuthority.url, token: ticketAuthority.token } }
+          : launchAuth,
       )
       const identity = handle.identity
       if (
@@ -2525,6 +2681,13 @@ class DispatchLoop {
         )
       }
     } finally {
+      if (renewTickets) clearInterval(renewTickets)
+      if (ticketAuthority && !detached.value)
+        await ticketGrantRequest(ticketAuthority.url, ticketAuthority.token, {
+          action: 'revoke',
+          repo,
+          id: ticketAuthority.id,
+        })
       this.hostedHarvest = undefined
     }
   }
@@ -2539,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,
@@ -2678,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
@@ -2696,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)
@@ -2765,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,
@@ -2807,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.
@@ -2901,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,
@@ -2968,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,
@@ -3249,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
@@ -3649,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)
@@ -3703,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
@@ -4161,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
@@ -4203,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()
   }
 }