@defrex/autobuild 0.10.1 → 0.12.0

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

@@ -1,3 +1,10 @@
+import { RemoteBuildStore } from '../store/remote/client'
+import { delegateCredential } from '../store/remote/credentials'
+import { isRemoteStoreRef } from './repo-state'
+import { projectToken } from './project-credentials'
+import { settleSummaryRequests } from './pr-summary-publication'
+import { readDispatcherLiveness, StandbyIdentityResolver } from './dispatcher-liveness'
+import { formatDispatcherIdentity } from '../kernel/dispatcher-liveness'
 /**
  * `ab dispatch` — the operator's entry into the outer loop (SPEC §3.3, §12).
  * Runs OUTSIDE build sessions like init/upgrade/ticket (§16.3): it takes a
@@ -180,18 +187,6 @@ export { DISPATCHER_EFFECTIVE_CONFIG_ARTIFACT } from '../store/retention'
 // Local uses within this module.
 import { DISPATCHER_EFFECTIVE_CONFIG_ARTIFACT as _effectiveConfigKind } from '../store/retention'
 
-/** JSON encoding in the config schema's declarative input shape. Parsed Config
- * has normalized `{steps, stepConfigs}` sections; flattening named step tables
- * lets the frontend validate the artifact with the same strict configSchema. */
-function effectiveConfigContent(config: Config): string {
-  const { verify, finalize, ...root } = config
-  return JSON.stringify({
-    ...root,
-    verify: { steps: verify.steps, ...verify.stepConfigs },
-    finalize: { steps: finalize.steps, ...finalize.stepConfigs },
-  })
-}
-
 /** The pre-build naming prompt. Its output is only a proposal: dispatcher.ts
  * owns strict validation, timeout/failure fallback, and store-wide uniqueness. */
 export function slugNamingPrompt(spec: string): string {
@@ -210,7 +205,7 @@ 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) defined[key] = value
+    if (value !== undefined && key !== 'AB_TOKEN') defined[key] = value
   }
   return defined
 }
@@ -262,6 +257,7 @@ interface ResumePrompt {
 /** The real adapters the loop drives — resolved by `wire` (default: the
  * production ports; tests inject fakes). */
 export interface DispatchWiring {
+  credentialIssuer?: typeof delegateCredential
   store: BuildStore
   tickets: TicketSource
   forge: Forge
@@ -280,7 +276,7 @@ export interface DispatchWiring {
    * same store as `store`, so an agent's `ab` commands write where the
    * dispatcher reads. */
   storeRef: string
-  /** Scoped token for a remote store (D8, `AB_TOKEN`); passed to sessions. */
+  /** Private parent authority for remote exchange; never passed to execution. */
   token?: string
   ids: IdSource
   uuids: UuidSource
@@ -691,6 +687,9 @@ class DispatchLoop {
    * discarded on Escape. All read semantics live in the shared feed module. */
   private sessionFeed: SessionStreamFeed | undefined
   private warningLine: string | undefined
+  /** Invocation-local ownership; independent of every notice slot. */
+  private standby: string | undefined
+  private standbyResolver: StandbyIdentityResolver | undefined
   /** Process-local, persistent release notice. It never shares the replaceable
    * warning slot and is re-applied to every store projection. */
   private availableUpgrade: string | undefined
@@ -1190,6 +1189,7 @@ class DispatchLoop {
       selection: _oldSelection,
       warningLines: _oldWarningLines,
       availableUpgrade: _oldAvailableUpgrade,
+      standby: _oldStandby,
       resumeInput: _oldResumeInput,
       abortConfirmation: _oldAbortConfirmation,
       view: _oldView,
@@ -1204,6 +1204,7 @@ class DispatchLoop {
     ]
     let effective: DashboardModel = {
       ...base,
+      ...(this.standby !== undefined ? { standby: this.standby } : {}),
       ...(this.availableUpgrade !== undefined ? { availableUpgrade: this.availableUpgrade } : {}),
       ...(warningLines.length > 0 ? { warningLines } : {}),
       ...(this.selection !== undefined ? { selection: this.selection } : {}),
@@ -1258,7 +1259,13 @@ class DispatchLoop {
     const limit =
       terminal === undefined
         ? 0
-        : sessionScrollLimit(view, terminal.columns, paintableRows(terminal.rows), upgrade)
+        : sessionScrollLimit(
+            view,
+            terminal.columns,
+            paintableRows(terminal.rows),
+            upgrade,
+            this.standby !== undefined,
+          )
     const current = view.follow ? limit : view.scroll
     const scroll =
       terminal === undefined
@@ -1270,6 +1277,7 @@ class DispatchLoop {
             current,
             delta,
             upgrade,
+            this.standby !== undefined,
           )
     let follow = view.follow
     if (delta < 0 && follow && scroll < limit) follow = false
@@ -1291,6 +1299,7 @@ class DispatchLoop {
       terminal.columns,
       paintableRows(terminal.rows),
       this.availableUpgrade !== undefined,
+      this.standby !== undefined,
     )
     return { ...view, scroll: view.follow ? limit : Math.min(view.scroll, limit) }
   }
@@ -1350,6 +1359,7 @@ class DispatchLoop {
                 this.view.scroll,
                 delta,
                 this.availableUpgrade !== undefined,
+                this.standby !== undefined,
               ),
       }
       this.syncModelControls()
@@ -2215,7 +2225,7 @@ class DispatchLoop {
     }
 
     const { store, tickets, runtimes, ids, uuids, clock, storeRef, token } = this.wiring
-    const runner = new HarvestRunner({
+    const harvestDeps = {
       store,
       tickets,
       config: this.currentConfig().config,
@@ -2230,16 +2240,66 @@ class DispatchLoop {
       ...(this.repoLeaseHolder !== undefined ? { leaseHolder: this.repoLeaseHolder } : {}),
       sessionEnv: {
         AB_STORE: storeRef,
-        ...(token !== undefined ? { AB_TOKEN: token } : {}),
       },
       opts: {
         maxRecoveryAttempts: this.maxHarvestRecoveryAttempts,
       },
-    })
+    }
 
     let tracked: Promise<void>
-    tracked = runner
-      .run()
+    tracked = (async () => {
+      if (!/^https?:/i.test(storeRef)) return new HarvestRunner(harvestDeps).run()
+      const prepared = await new HarvestRunner(harvestDeps).run(true)
+      if (prepared.outcome !== 'prepared') return prepared
+      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,
+        },
+      })
+      const scoped = await (this.wiring.credentialIssuer ?? delegateCredential)(storeRef, token, {
+        kind: 'harvest-runner',
+        execution: harvestDeps.instance,
+        repo: this.repoIdentity,
+        id: prepared.run,
+        leaseHolder: this.repoLeaseHolder ?? harvestDeps.instance,
+      })
+      const runnerStore = new RemoteBuildStore({ url: storeRef, token: scoped })
+      try {
+        const runnerTickets =
+          harvestDeps.config.tickets.source === 'hosted'
+            ? await createTicketSource(
+                harvestDeps.config.tickets,
+                { ...this.opts.env, AB_STORE: storeRef, AB_TOKEN: scoped },
+                this.opts.targetRepo,
+                resolveRepoStatePaths({
+                  repo: this.repoIdentity,
+                  checkout: this.opts.targetRepo,
+                  storeRef,
+                }).localStateRoot,
+                this.wiring.plugins,
+              )
+            : harvestDeps.tickets
+        return await new HarvestRunner({
+          ...harvestDeps,
+          store: runnerStore,
+          tickets: runnerTickets,
+          preparedRun: { run: prepared.run },
+          sessionEnv: { AB_STORE: storeRef, AB_TOKEN: scoped },
+        }).run()
+      } finally {
+        await runnerStore.appendRepo(this.repoIdentity, {
+          actor: DISPATCHER,
+          type: 'harvest.execution.ended',
+          payload: { execution: harvestDeps.instance, run: prepared.run },
+        })
+        await runnerStore.close()
+      }
+    })()
       .then((result) => {
         this.recordHarvestResult(result)
         if (
@@ -2283,6 +2343,24 @@ class DispatchLoop {
    * contract: provisioning takes minutes and must never stall a tick; the
    * single-flight guard covers the whole span. Every failure is contained
    * and retried on a later threshold tick. */
+  private async prepareHarvest(instance: string): Promise<HarvestRunnerResult> {
+    return new HarvestRunner({
+      store: this.wiring.store,
+      tickets: this.wiring.tickets,
+      config: this.currentConfig().config,
+      getConfig: () => this.currentConfig().config,
+      runtimes: this.wiring.runtimes,
+      repo: this.repoIdentity,
+      workspacePath: this.opts.targetRepo,
+      ids: this.wiring.ids,
+      uuids: this.wiring.uuids,
+      clock: this.wiring.clock,
+      instance,
+      ...(this.repoLeaseHolder ? { leaseHolder: this.repoLeaseHolder } : {}),
+      opts: { maxRecoveryAttempts: this.maxHarvestRecoveryAttempts },
+    }).run(true)
+  }
+
   private async launchHostedHarvest(
     harvestExecution: HarvestExecution,
     execution: string,
@@ -2333,13 +2411,44 @@ class DispatchLoop {
         if (pressure.trigger === undefined) return
       }
 
-      handle = await harvestExecution.start({
-        storeRef,
-        repo,
-        instance: execution,
-        baseBranch: this.currentConfig().config.baseBranch,
-        ...(this.repoLeaseHolder !== undefined ? { leaseHolder: this.repoLeaseHolder } : {}),
+      const prepared = await this.prepareHarvest(execution)
+      if (prepared.outcome !== 'prepared') return
+      await this.repoView.appendRepo(repo, {
+        actor: DISPATCHER,
+        type: 'harvest.execution.authorized',
+        payload: {
+          execution,
+          run: prepared.run,
+          launch: prepared.launch,
+          leaseHolder: this.repoLeaseHolder ?? execution,
+        },
       })
+      const launchAuth = /^https?:/i.test(storeRef)
+        ? {
+            token: await (this.wiring.credentialIssuer ?? delegateCredential)(
+              storeRef,
+              this.wiring.token,
+              {
+                kind: 'harvest-runner',
+                execution,
+                repo,
+                id: prepared.run,
+                leaseHolder: this.repoLeaseHolder ?? execution,
+              },
+            ),
+          }
+        : undefined
+      handle = await harvestExecution.start(
+        {
+          preparedRun: { run: prepared.run },
+          storeRef,
+          repo,
+          instance: execution,
+          baseBranch: this.currentConfig().config.baseBranch,
+          ...(this.repoLeaseHolder !== undefined ? { leaseHolder: this.repoLeaseHolder } : {}),
+        },
+        launchAuth,
+      )
       const identity = handle.identity
       if (
         identity === undefined ||
@@ -2612,7 +2721,7 @@ class DispatchLoop {
     return null
   }
 
-  private async settlePendingPublication(slug: string): Promise<void> {
+  private async settlePendingPublication(slug: string, reservation?: string): Promise<void> {
     // The guest appended through its own handle; settle against fresh state.
     await this.repoView.refreshBuild(slug)
     await settleWorkspacePublication(
@@ -2629,6 +2738,16 @@ class DispatchLoop {
       },
       slug,
     )
+    await settleSummaryRequests({
+      store: this.repoView,
+      forge: this.wiring.forge,
+      slug,
+      workspacePath: this.opts.targetRepo,
+      storeRef: this.wiring.storeRef,
+      clock: this.wiring.clock,
+      holder: `summary:${this.runId}`,
+      ...(reservation === undefined ? {} : { reservation }),
+    })
   }
 
   private async recordInfrastructureFailure(input: {
@@ -2720,13 +2839,25 @@ class DispatchLoop {
       // A prior publication acknowledgement may have been lost after its push
       // reached the durable branch. Reconcile that fact before a replacement
       // runner can rerun the phase and create a non-fast-forward successor.
-      await this.settlePendingPublication(slug)
-      const handle = await owning.execution.start({
-        slug,
-        storeRef: this.wiring.storeRef,
-        instance,
-        workspaceRef,
-      })
+      await this.settlePendingPublication(slug, instance)
+      const launchAuth = /^https?:/i.test(this.wiring.storeRef)
+        ? {
+            token: await (this.wiring.credentialIssuer ?? delegateCredential)(
+              this.wiring.storeRef,
+              this.wiring.token,
+              { kind: 'build-runner', id: slug },
+            ),
+          }
+        : undefined
+      const handle = await owning.execution.start(
+        {
+          slug,
+          storeRef: this.wiring.storeRef,
+          instance,
+          workspaceRef,
+        },
+        launchAuth,
+      )
       active.handle = handle
       const identity = handle.identity ?? {
         provider: owning.name,
@@ -3389,6 +3520,18 @@ class DispatchLoop {
     const claimed = await this.wiring.store
       .claimRepoLease(this.repoIdentity, holder, REPO_LEASE_TTL_MS)
       .catch(() => false)
+    if (this.dashboard && !this.opts.once) {
+      this.standbyResolver ??= new StandbyIdentityResolver(this.wiring.store, this.repoIdentity)
+      this.standby = claimed
+        ? undefined
+        : await this.standbyResolver.refresh(
+            this.runId,
+            this.yieldedTo ?? 'another invocation',
+            this.wiring.clock(),
+          )
+      this.syncModelControls()
+      this.paint()
+    }
     if (!claimed) {
       if (this.repoLeaseHolder !== undefined) {
         // We held the lease and the store says it is gone: a peer took over.
@@ -3474,10 +3617,17 @@ class DispatchLoop {
     const holder = this.runId
     if (!(await this.ensureRepoLease(holder))) {
       await this.recordTickYielded()
-      const peer = (await this.wiring.store.getRepo(this.repoIdentity).catch(() => null))?.lease
-        ?.holder
-      const message = `tick yielded: repository held by ${peer ?? 'another invocation'}`
-      this.warn(message)
+      if ((!this.dashboard && this.opts.kernelRunId === undefined) || this.opts.once) {
+        const peer = (await this.wiring.store.getRepo(this.repoIdentity).catch(() => null))?.lease
+          ?.holder
+        const liveness = await readDispatcherLiveness(
+          this.wiring.store,
+          this.repoIdentity,
+          this.wiring.clock(),
+        ).catch(() => null)
+        const message = `tick yielded: repository held by ${liveness?.dispatcher.holder ? formatDispatcherIdentity(liveness.dispatcher.holder) : (peer ?? 'another invocation')}`
+        this.warn(message)
+      }
       if (this.opts.once === true) return
       // Watch mode stays alive and retries the claim at every tick.
     }
@@ -3498,7 +3648,17 @@ class DispatchLoop {
         // lease and any provisioning state are released for the next
         // invocation.
         if (this.pastDeadline()) return
-        const initial = await this.dispatcherTick(true)
+        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),
+            },
+          })
+          throw error
+        })
         const initialPrinted = this.printReport(initial, false)
         await this.drainInFlight()
         const settledReports = await this.publishSettlementReports()
@@ -3649,16 +3809,21 @@ function acceptableOriginModeStore(storeRef: string): boolean {
  * names the operator's own machine (local development, integration harnesses).
  * Requirements are validated here so a misconfigured origin-mode launch fails
  * before any side effect. */
-async function resolveOriginModeState(opts: DispatchOpts): Promise<RepoStatePaths> {
+async function resolveOriginModeState(
+  opts: DispatchOpts,
+  configStore?: string,
+): Promise<RepoStatePaths> {
   const identity = normalizeGitRemoteUrl(opts.repository!)
-  const selectedStore = opts.storeRef ?? opts.env.AB_STORE
+  const selectedStore = opts.storeRef?.trim() || opts.env.AB_STORE?.trim() || configStore
   if (selectedStore === undefined || !acceptableOriginModeStore(selectedStore)) {
     throw new Error(
       'origin-mode dispatch requires an HTTPS BuildStore — set AB_STORE (or --store) to the hosted Store URL',
     )
   }
-  if (opts.env.AB_TOKEN === undefined || opts.env.AB_TOKEN === '') {
-    throw new Error('origin-mode dispatch requires AB_TOKEN for the remote Store')
+  if (!projectToken(selectedStore, identity, opts.env)) {
+    throw new Error(
+      'origin-mode dispatch requires a project credential; run ab connect or set AB_TOKEN',
+    )
   }
   // Checkout-less hosts (serverless functions, sandboxes) have no gh CLI and
   // no keyring, and the only workspace provider origin mode can run —
@@ -3676,6 +3841,7 @@ async function resolveOriginModeState(opts: DispatchOpts): Promise<RepoStatePath
   await mkdir(scratch, { recursive: true })
   return resolveRepoStatePaths({
     repo: identity,
+    configStore,
     checkout: scratch,
     ...(opts.storeRef !== undefined ? { storeRef: opts.storeRef } : {}),
     ...(opts.env.AB_STORE !== undefined ? { envStore: opts.env.AB_STORE } : {}),
@@ -3698,9 +3864,23 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
   if (opts.wire !== undefined && opts.nonStoreWire !== undefined) {
     throw new Error('dispatch wire and nonStoreWire are mutually exclusive')
   }
+  const explicitOriginStore = opts.storeRef?.trim() || opts.env.AB_STORE?.trim()
+  if (
+    opts.repository !== undefined &&
+    explicitOriginStore &&
+    !acceptableOriginModeStore(explicitOriginStore)
+  ) {
+    throw new Error(
+      'origin-mode dispatch requires an HTTPS BuildStore — set AB_STORE (or --store) to the hosted Store URL',
+    )
+  }
+  const originConfig =
+    opts.repository !== undefined
+      ? await fetchOriginModeConfig(opts, opts.originConfigTransport)
+      : undefined
   const state =
     opts.repository !== undefined
-      ? await resolveOriginModeState(opts)
+      ? await resolveOriginModeState(opts, originConfig?.config.store?.url)
       : await resolveRepoState({
           targetRepo: opts.targetRepo,
           exec: opts.exec,
@@ -3714,6 +3894,13 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
   const resolvedOpts: DispatchOpts = {
     ...opts,
     targetRepo: state.checkout,
+    env: {
+      ...opts.env,
+      AB_STORE: state.storeRef,
+      ...(isRemoteStoreRef(state.storeRef)
+        ? { AB_TOKEN: projectToken(state.storeRef, state.repo, opts.env) }
+        : {}),
+    },
     storeRef: state.storeRef,
     repo: opts.repo ?? state.repo,
   }
@@ -3771,7 +3958,7 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
   if (opts.repository !== undefined) {
     // Origin mode startup config: the base branch's autobuild.toml, fetched
     // through the forge (default branch first — baseBranch itself is config).
-    const fetched = await fetchOriginModeConfig(opts, opts.originConfigTransport)
+    const fetched = originConfig!
     configContent = fetched.content
     config = fetched.config
     if (config.forge !== 'github') {
@@ -3885,7 +4072,7 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
           },
           {
             kind: _effectiveConfigKind,
-            content: effectiveConfigContent(effectiveConfig),
+            content: effectiveBuildConfigContent(effectiveConfig),
             metadata: { run: runId, effectiveChanged },
           },
         ],
@@ -3950,7 +4137,7 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
     [
       {
         kind: _effectiveConfigKind,
-        content: effectiveConfigContent(config),
+        content: effectiveBuildConfigContent(config),
         metadata: { run: runId, revision: 0 },
       },
     ],
@@ -3963,6 +4150,7 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
         payload: {
           run: runId,
           pid: process.pid,
+          host: hostname(),
           effectiveConfig: { kind: artifact.kind, rev: artifact.revision },
           roleWarnings: roleKeyWarnings(config),
         },
@@ -3973,6 +4161,17 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
   const loop = new DispatchLoop(liveConfig, wiring, resolvedOpts, view)
   try {
     await loop.run()
+    const stopRequest = (
+      resolvedOpts.kernelRunId && resolvedOpts.signal?.aborted
+        ? await wiring.store.getRepoEvents(state.repo)
+        : []
+    ).find((event) => event.type === 'dispatcher.stop-requested' && event.payload.run === runId)
+    const stoppedSignal =
+      stopRequest?.type === 'dispatcher.stop-requested'
+        ? stopRequest.payload.signal
+        : typeof resolvedOpts.signal?.reason === 'string'
+          ? resolvedOpts.signal.reason
+          : undefined
     await view.appendRepo(state.repo, {
       actor: DISPATCHER,
       type: 'dispatcher.run-stopped',
@@ -3980,6 +4179,7 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
         run: runId,
         outcome: 'normal',
         exitCode: 0,
+        ...(stoppedSignal === undefined ? {} : { signal: stoppedSignal }),
         ...(loop.supersededByPeer ? { reason: 'superseded' as const } : {}),
       },
     })

package/packages/core/src/cli/dispatcher-liveness.ts

@@ -0,0 +1,91 @@
+import type { RepositoryEvent } from '../events/repository'
+import type { BuildStore, RepositoryRecord } from '../store/types'
+import { formatDispatcherIdentity, projectDispatcherLiveness } from '../kernel/dispatcher-liveness'
+
+/** Bounded first; a later yielding invocation can hide the owner's identity or
+ * an earlier stop. Only this correlation query falls back to full history. */
+export async function readDispatcherLiveness(
+  store: BuildStore,
+  repo: string,
+  now = new Date(),
+  subset?: RepositoryEvent[],
+) {
+  const record = await store.getRepo(repo)
+  let events = record === null ? [] : (subset ?? (await store.getRepoStateEvents(repo)))
+  const bounded = projectDispatcherLiveness(record, events, now)
+  if (
+    record &&
+    ((record.lease &&
+      !events.some(
+        (e) => e.type === 'dispatcher.run-started' && e.payload.run === record.lease!.holder,
+      )) ||
+      (bounded.state !== 'held' &&
+        events.some((e) => e.type === 'dispatcher.run-started') &&
+        !events.some((e) => e.type === 'dispatcher.run-stopped')))
+  ) {
+    events = await store.getRepoEvents(repo)
+  }
+  return { record, events, dispatcher: projectDispatcherLiveness(record, events, now) }
+}
+
+/** Invocation-local identity cache. Only start facts survive refreshes; ages
+ * always come from the current lease record and clock. Failed correlations are
+ * negatively cached so a standby cannot repeatedly replay a large journal. */
+export class StandbyIdentityResolver {
+  private readonly starts = new Map<string, RepositoryEvent>()
+  private readonly attempted = new Set<string>()
+  private readonly pending = new Map<string, Promise<void>>()
+
+  constructor(
+    private readonly store: BuildStore,
+    private readonly repo: string,
+  ) {}
+
+  ingest(events: readonly RepositoryEvent[]): void {
+    for (const event of events) {
+      if (event.type === 'dispatcher.run-started') this.starts.set(event.payload.run, event)
+    }
+  }
+
+  private async correlate(holder: string): Promise<void> {
+    const pending = this.pending.get(holder)
+    if (pending !== undefined) return pending
+    if (this.starts.has(holder) || this.attempted.has(holder)) return
+    this.attempted.add(holder)
+    const lookup = (async () => {
+      try {
+        this.ingest(await this.store.getRepoStateEvents(this.repo))
+        if (!this.starts.has(holder)) this.ingest(await this.store.getRepoEvents(this.repo, 0))
+      } catch {
+        // Identity is best effort; the sampled holder id remains sufficient.
+      }
+    })()
+    this.pending.set(holder, lookup)
+    try {
+      await lookup
+    } finally {
+      this.pending.delete(holder)
+    }
+  }
+
+  async refresh(
+    run: string,
+    yieldedHolder: string | undefined,
+    now: Date,
+  ): Promise<string | undefined> {
+    let record: RepositoryRecord | null
+    try {
+      record = await this.store.getRepo(this.repo)
+    } catch {
+      return yieldedHolder
+    }
+    const holder = record?.lease?.holder
+    if (holder === run) return undefined
+    if (holder === undefined) return yieldedHolder
+    await this.correlate(holder)
+    if (!this.starts.has(holder)) return holder
+    const projection = projectDispatcherLiveness(record, [...this.starts.values()], now)
+    const identity = projection.holder ?? projection.expiredHolder
+    return identity?.run === holder ? formatDispatcherIdentity(identity) : holder
+  }
+}