@defrex/autobuild 0.10.1 → 0.11.0

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

@@ -1,8 +1,11 @@
+import { readDispatcherLiveness } from './dispatcher-liveness'
+import { projectDispatcherLiveness } from '../kernel/dispatcher-liveness'
+import type { RepositoryRecord } from '../store/types'
 /**
  * `ab watch` — the sessionless, read-only streaming half of the status family
  * (§8.2, §7.2). It follows the event logs of one, several, or all active
- * builds in the repository — optionally the repository journal — and emits one
- * record per matching event as it lands, each carrying the full durable
+ * builds in the repository, plus the repository journal by default with no
+ * slugs, and emits one record per matching event as it lands, carrying the durable
  * envelope, the build's reduced state after that event, and an opaque cursor
  * so a later `--since` invocation resumes exactly where this one stopped.
  *
@@ -102,8 +105,8 @@ export const BUILD_ATTENTION_EVENTS = [
  * Compile `--event` globs to anchored matchers: `*` matches any run of
  * characters, `?` exactly one, everything else verbatim (so the dots inside
  * event type names are escaped). Each glob must match at least one type in
- * the build catalog — or, when `--repository` is given, in the repository
- * catalog — otherwise a usage error naming the glob is thrown before any
+ * the build catalog, or the repository catalog with no slugs or explicit
+ * `--repository` — otherwise a usage error naming the glob is thrown before any
  * store read. Supplying any glob replaces the attention set entirely.
  *
  * The compiler itself lives in `events/globs.ts`, shared with the
@@ -133,6 +136,7 @@ interface CursorPayload {
   /** The repository identity (normalized origin or checkout path). */
   repo: string
   /** Per-stream watch position: build slug → seq, `#repo` → seq. */
+  lostRuns?: string[]
   streams: Record<string, number>
 }
 
@@ -169,7 +173,13 @@ export function decodeCursor(
     throw malformed()
   }
   if (typeof payload !== 'object' || payload === null) throw malformed()
-  const { v, store, repo, streams } = payload as Record<string, unknown>
+  const { v, store, repo, streams, lostRuns } = payload as Record<string, unknown>
+  if (
+    lostRuns !== undefined &&
+    (!Array.isArray(lostRuns) ||
+      lostRuns.some((run) => typeof run !== 'string' || run.length === 0))
+  )
+    throw malformed()
   if (v !== 1 || typeof store !== 'string' || typeof repo !== 'string') throw malformed()
   if (typeof streams !== 'object' || streams === null || Array.isArray(streams)) throw malformed()
   for (const seq of Object.values(streams)) {
@@ -187,7 +197,13 @@ export function decodeCursor(
         `repository "${expected.repo}" — run from the repository the cursor came from`,
     )
   }
-  return { v: 1, store, repo, streams: streams as Record<string, number> }
+  return {
+    v: 1,
+    store,
+    repo,
+    streams: streams as Record<string, number>,
+    ...(lostRuns === undefined ? {} : { lostRuns: lostRuns as string[] }),
+  }
 }
 
 // ── Durations and cadence ────────────────────────────────────────────────────
@@ -237,6 +253,25 @@ export interface WatchRecordState {
   outcome: BuildOutcome | null
 }
 
+/** Lease-expiry evidence is an observation, never a fabricated journal event. */
+export interface WatchObservationRecord {
+  repo: string
+  build: null
+  state: null
+  observation: {
+    type: 'dispatcher.lost'
+    run: string
+    observedAt: string
+    leaseExpiresAt: string
+    pid?: number | null
+    host?: string | null
+    startedAt?: string | null
+    heartbeatAt?: string | null
+    heartbeatAgeMs?: number | null
+  }
+  cursor: string
+}
+
 export interface WatchRecord {
   /** The build slug, or null for a repository-journal event. */
   build: string | null
@@ -340,6 +375,10 @@ export function summarizeEvent(event: AbEvent | RepositoryEvent, state: BuildSta
       return `harvest run ${event.payload.run} escalated: ${singleLine(event.payload.reason)}`
     case 'harvest.failed':
       return `harvest run ${event.payload.run} failed at ${event.payload.step} (attempt ${event.payload.attempt}): ${singleLine(event.payload.error)}`
+    case 'dispatcher.ticket-source-degraded':
+      return `ticket source ${event.payload.source} degraded: ${event.payload.cause} (${event.payload.operation}) — ${singleLine(event.payload.message)}${'resetAt' in event.payload ? `; reset ${event.payload.resetAt}` : ''}`
+    case 'dispatcher.ticket-source-recovered':
+      return `ticket source ${event.payload.source} recovered: ${event.payload.cause} (${event.payload.operation})`
     case 'dispatcher.tick-failed':
       return `dispatcher tick failed: ${singleLine(event.payload.error)}`
     case 'dispatcher.config-rejected':
@@ -451,6 +490,7 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
   const sleep = opts.delay ?? defaultDelay
   const slugs = [...(opts.slugs ?? [])]
   const repository = opts.repository === true
+  const followRepository = repository || slugs.length === 0
 
   const timeoutMs =
     opts.timeout !== undefined
@@ -462,10 +502,14 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
       : undefined
 
   // Ambient scope, before any store access.
-  assertReadScope(slugs, { repository, env: opts.env })
+  assertReadScope(slugs, { repository: followRepository, env: opts.env })
 
   // Glob validation needs only the catalogs — before any store access.
-  const filters = compileEventGlobs(opts.events ?? [], { repository, usage: WATCH_USAGE })
+  const filters = compileEventGlobs(opts.events ?? [], {
+    repository: followRepository,
+    additionalCatalog: followRepository ? ['dispatcher.lost'] : [],
+    usage: WATCH_USAGE,
+  })
 
   await withAmbientReadStore(
     {
@@ -497,6 +541,13 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         record.repo === identity ||
         (record.repoOrigin !== undefined && normalizeGitRemoteUrl(record.repoOrigin) === identity)
 
+      const lostRuns = new Set(
+        opts.since ? (decodeCursor(opts.since, { store: storeRef, repo }).lostRuns ?? []) : [],
+      )
+      let livenessEvents: RepositoryEvent[] = []
+      let livenessSeq = 0
+      let livenessInitialized = false
+      const observedOwners = new Map<string, RepositoryRecord>()
       const streams = new Map<string, Stream>()
       // Every stream's position — matching or not, delivered or baselined —
       // lives here, so a resume never rescans or redelivers a filtered event.
@@ -514,7 +565,13 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
       }
 
       const encodeCurrent = (): string =>
-        encodeCursor({ v: 1, store: storeRef, repo, streams: { ...positions } })
+        encodeCursor({
+          v: 1,
+          store: storeRef,
+          repo,
+          streams: { ...positions },
+          lostRuns: [...lostRuns],
+        })
 
       /** One record, flushed the moment it is projected. `cursor` is the watch
        * position AFTER this event. */
@@ -534,6 +591,73 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         }
       }
 
+      const checkLiveness = async (): Promise<void> => {
+        if (!followRepository || stop) return
+        if (!livenessInitialized) {
+          const input = await readDispatcherLiveness(store, repo, now())
+          livenessEvents = input.events
+          livenessSeq = input.events.at(-1)?.seq ?? 0
+          livenessInitialized = true
+        }
+        if ((await store.getRepo(repo)) === null) return
+        const fresh = await store.getRepoEvents(repo, livenessSeq)
+        livenessEvents.push(...fresh)
+        livenessSeq = fresh.at(-1)?.seq ?? livenessSeq
+        // Sample metadata after the journal. Recheck both immediately before
+        // reporting: a failed read is infrastructure, never evidence of death.
+        const record = await store.getRepo(repo)
+        if (record?.lease) observedOwners.set(record.lease.holder, record)
+        for (const [id, owner] of observedOwners) {
+          if (
+            stop ||
+            lostRuns.has(id) ||
+            !owner.lease ||
+            Date.parse(owner.lease.expiresAt) > now().getTime()
+          )
+            continue
+          const delta = await store.getRepoEvents(repo, livenessSeq)
+          livenessEvents.push(...delta)
+          livenessSeq = delta.at(-1)?.seq ?? livenessSeq
+          const current = await store.getRepo(repo)
+          if (current?.lease?.holder === id) {
+            observedOwners.set(id, current)
+            if (Date.parse(current.lease.expiresAt) > now().getTime()) continue
+          }
+          const evidence = projectDispatcherLiveness(
+            current?.lease?.holder === id ? current : owner,
+            livenessEvents,
+            now(),
+          )
+          if (
+            livenessEvents.some((e) => e.type === 'dispatcher.run-stopped' && e.payload.run === id)
+          ) {
+            observedOwners.delete(id)
+            continue
+          }
+          if (!(filters.length ? filters.some((f) => f.test('dispatcher.lost')) : true)) continue
+          if (stop) return
+          lostRuns.add(id)
+          const cursor = encodeCurrent()
+          const observation = {
+            ...evidence.expiredHolder,
+            type: 'dispatcher.lost',
+            run: id,
+            observedAt: now().toISOString(),
+            leaseExpiresAt: (current?.lease?.holder === id ? current : owner).lease!.expiresAt,
+          }
+          opts.stdout(
+            opts.json
+              ? JSON.stringify({ repo, build: null, state: null, observation, cursor })
+              : `dispatcher.lost ${id} — lease expired ${observation.leaseExpiresAt}`,
+          )
+          emitted += 1
+          if (opts.count !== undefined && emitted >= opts.count) {
+            countCursor = cursor
+            requestStop()
+          }
+        }
+      }
+
       /** Record one event. `prefix` is the event prefix ENDING at `event` —
        * the record's state is the reduction after THIS event, never a
        * reduction over events that landed after it. The poll path passes the
@@ -678,6 +802,11 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
               const tail = await store.getRepoEvents(repo, last)
               last = tail.at(-1)?.seq ?? last
             }
+            const input = await readDispatcherLiveness(store, repo, now(), subset)
+            livenessEvents = input.events
+            livenessSeq = Math.max(last, input.events.at(-1)?.seq ?? 0)
+            livenessInitialized = true
+            if (input.record?.lease) observedOwners.set(input.record.lease.holder, input.record)
             stream.lastSeq = last
             positions[REPO_STREAM_KEY] = last
           }
@@ -752,7 +881,14 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
             tickStreak.onFailure(error)
           }
         }
-        if (allReadsOk) tickStreak.onSuccess()
+        if (allReadsOk) {
+          try {
+            await checkLiveness()
+            tickStreak.onSuccess()
+          } catch (error) {
+            tickStreak.onFailure(error)
+          }
+        }
       }
 
       // ── Initial scan ──
@@ -778,13 +914,14 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         await trackBuild(key, sinceStreams[key])
         if (stop) break
       }
-      if (repository) {
+      if (followRepository) {
         if (!(await trackRepository())) {
           makeFailureStreak('watch', opts.stderr).onFailure(
             new Error(`could not read the repository journal for "${repo}"`),
           )
         }
-      } else if (slugs.length === 0) {
+      }
+      if (!repository && slugs.length === 0) {
         // Membership discovery also baselines the default watch; a failed
         // discovery here is fatal — nothing has started yet.
         try {
@@ -795,6 +932,13 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         }
       }
 
+      if (followRepository && !stop) {
+        try {
+          await checkLiveness()
+        } catch (error) {
+          tickStreak.onFailure(error)
+        }
+      }
       // ── The poll loop ──
       const deadline = timeoutMs === 0 ? Number.POSITIVE_INFINITY : now().getTime() + timeoutMs
       const aborted = (): boolean => opts.signal?.aborted === true
@@ -875,10 +1019,11 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
 
         for (const stream of streams.values()) if (!shouldStop) launch(stream)
 
-        if (slugs.length === 0 && !shouldStop) {
+        if ((slugs.length === 0 || followRepository) && !shouldStop) {
           void remoteRunner.runDiscovery({
             step: async (): Promise<void> => {
-              await discoverBuilds()
+              if (slugs.length === 0) await discoverBuilds()
+              await checkLiveness()
             },
             // Unconditional, after the catch — exactly where the inline
             // launch loop ran: streams registered before a mid-discovery

package/packages/core/src/config/live.ts

@@ -14,6 +14,7 @@ export const DISPATCHER_CONFIG_ARTIFACT = 'dispatcher-config'
 export const CONFIG_RELOAD_CLASSIFICATION = {
   baseBranch: 'hot',
   capacity: 'hot',
+  ticketScanIntervalSeconds: 'hot',
   forge: 'restart',
   plugins: 'restart',
   pr: 'hot',

package/packages/core/src/config/schema.ts

@@ -644,7 +644,7 @@ const ORCHESTRATOR_APPROVAL_ENTRY = /^[a-z][a-z0-9_.]*(:[a-z0-9_-]+)?$/
 /** The attention set a new session's wake settings inherit when the
  * repository does not override `wake`: the build events an operator or agent
  * must wake up for (the same set `ab watch` filters on by default) plus the
- * repository-journal attention events (the same set `ab watch --repository`
+ * repository-journal attention events (the same set `ab watch`
  * follows), spelled as literal globs. Both halves of the attention set can
  * wake a session. */
 export const defaultOrchestratorWakeGlobs: readonly string[] = [
@@ -730,6 +730,7 @@ const configRootSchema = z.strictObject({
   baseBranch: z.string().min(1).default('main'),
   /** Concurrent builds for this repository (§16.1). */
   capacity: z.number().int().positive().default(1),
+  ticketScanIntervalSeconds: z.number().int().positive().default(60),
   /** Forge adapter selected from builtins and configured plugins. */
   forge: z
     .string()
@@ -769,7 +770,13 @@ const configRootSchema = z.strictObject({
 })
 
 /** Root metadata keeps strict error prose and documentation coverage honest. */
-export const TOP_LEVEL_SCALARS = ['baseBranch', 'capacity', 'forge', 'plugins'] as const
+export const TOP_LEVEL_SCALARS = [
+  'baseBranch',
+  'capacity',
+  'ticketScanIntervalSeconds',
+  'forge',
+  'plugins',
+] as const
 export const TOP_LEVEL_TABLES = Object.keys(configRootSchema.shape).filter(
   (key) => !(TOP_LEVEL_SCALARS as readonly string[]).includes(key),
 )

package/packages/core/src/events/globs.ts

@@ -10,8 +10,9 @@ import { EVENT_TYPES } from './payloads'
 import { REPOSITORY_EVENT_TYPES } from './repository'
 
 export interface CompileEventGlobsOptions {
-  /** Also accept matches in the repository-journal catalog (the `--repository`
-   * behavior of `ab watch`/`ab wait`). */
+  /** Also accept matches in the repository-journal catalog (the no-slug or
+   * explicit `--repository` behavior of `ab watch`; wait remains build-only). */
+  additionalCatalog?: readonly string[]
   repository?: boolean
   usage: string
 }
@@ -35,7 +36,11 @@ export function compileEventGlobs(
     const inBuildCatalog = EVENT_TYPES.some((type) => regex.test(type))
     const inRepositoryCatalog =
       opts.repository === true && REPOSITORY_EVENT_TYPES.some((type) => regex.test(type))
-    if (!inBuildCatalog && !inRepositoryCatalog) {
+    if (
+      !inBuildCatalog &&
+      !inRepositoryCatalog &&
+      !opts.additionalCatalog?.some((type) => regex.test(type))
+    ) {
       throw new Error(
         `--event "${glob}" matches no known event type${
           opts.repository ? ' in the build or repository catalogs' : ' in the build event catalog'

package/packages/core/src/events/repository.ts

@@ -64,6 +64,7 @@ const tickCountersSchema = z.strictObject({
   /** Added in plugin/API-era 1.4; optional so historical tick facts replay. */
   creationWithheld: z.number().int().nonnegative().optional(),
   dependencyBlocked: z.number().int().nonnegative(),
+  dependencyCheckFailed: z.number().int().nonnegative().optional(),
   /** Foreign executions settled from durable facts plus provider liveness.
    * Added with durable supervision; optional so historical tick facts replay. */
   settled: z.number().int().nonnegative().optional(),
@@ -353,14 +354,30 @@ export const orchestratorSandboxEventPayloadSchemas = {
 } as const
 
 export const dispatcherStatusEventPayloadSchemas = {
+  /** Completed ticket-source measurement, independent of dispatcher runs. */
+  'dispatcher.ticket-scan-completed': z.strictObject({
+    startedAt: z.iso.datetime(),
+    readinessFingerprint: z.string().min(1),
+    criteriaFingerprint: z.string().min(1),
+    mode: z.enum(['admission', 'observation']),
+    queued: z.number().int().nonnegative(),
+    invalidTickets: z.number().int().nonnegative(),
+    ticketDiagnostics: boundedDiagnostics,
+    dependencyBlocked: z.number().int().nonnegative(),
+    dependencyDiagnostics: boundedDiagnostics,
+    creationWithheld: z.number().int().nonnegative(),
+    creationDiagnostics: boundedDiagnostics,
+  }),
   /** A terminal frontend follows exactly one run. The referenced artifact is
    * the composed Config the kernel is actually using, never an on-disk guess. */
   'dispatcher.run-started': z.strictObject({
     run: dispatchRun,
     pid: z.number().int().positive(),
+    host: z.string().trim().min(1).optional(),
     effectiveConfig: artifactRefSchema,
     roleWarnings: boundedDiagnostics,
   }),
+  'dispatcher.stop-requested': z.strictObject({ run: dispatchRun, signal: z.string().min(1) }),
   'dispatcher.run-stopped': z.strictObject({
     run: dispatchRun,
     outcome: z.enum(['normal', 'abnormal', 'forced']),
@@ -449,7 +466,32 @@ export const dispatcherSettingEventPayloadSchemas = {
   'dispatcher.auto-merge-default-set': dispatcherSetting,
 } as const
 
+const ticketSourceCondition = {
+  source: z.string().min(1),
+  operation: z.enum(['ready-scan', 'dependency-check']),
+  message: z.string().min(1),
+}
+export const ticketSourceHealthEventPayloadSchemas = {
+  /** An existing listing-limit episode also encountered a limited dependency
+   * read. Strengthens recovery evidence without closing or reopening it. */
+  'dispatcher.ticket-source-dependency-limited': z.strictObject({ source: z.string().min(1) }),
+  'dispatcher.ticket-source-degraded': z.discriminatedUnion('cause', [
+    z.strictObject({
+      ...ticketSourceCondition,
+      cause: z.literal('rate-limited'),
+      resetAt: z.iso.datetime(),
+    }),
+    z.strictObject({ ...ticketSourceCondition, cause: z.literal('ready-scan-failed') }),
+  ]),
+  'dispatcher.ticket-source-recovered': z.strictObject({
+    source: z.string().min(1),
+    cause: z.enum(['rate-limited', 'ready-scan-failed']),
+    operation: z.enum(['ready-scan', 'dependency-check']),
+  }),
+} as const
+
 export const repositoryEventPayloadSchemas = {
+  ...ticketSourceHealthEventPayloadSchemas,
   ...harvestEventPayloadSchemas,
   ...orchestratorSandboxEventPayloadSchemas,
   ...dispatcherStatusEventPayloadSchemas,
@@ -461,11 +503,13 @@ export const REPOSITORY_EVENT_TYPES = Object.keys(
   repositoryEventPayloadSchemas,
 ) as RepositoryEventType[]
 
-/** The repository-journal attention set, followed only under `--repository`
- * by `ab watch` and scanned by the orchestrator wake pass. */
+/** Repository attention followed by `ab watch` with no slugs or explicit
+ * `--repository`, and scanned by the orchestrator wake pass. */
 export const REPOSITORY_ATTENTION_EVENTS = [
   'harvest.escalated',
   'harvest.failed',
+  'dispatcher.ticket-source-degraded',
+  'dispatcher.ticket-source-recovered',
   'dispatcher.tick-failed',
   'dispatcher.config-rejected',
   'dispatcher.harvest-runner-failed',
@@ -539,12 +583,17 @@ const allowedActorKinds: Record<RepositoryEventType, readonly ActorKind[]> = {
   'orchestrator.sandbox.published': ['human'],
   'orchestrator.sandbox.publish-failed': ['human'],
   'dispatcher.run-started': ['dispatcher'],
+  'dispatcher.stop-requested': ['dispatcher'],
   'dispatcher.run-stopped': ['dispatcher'],
   'dispatcher.tick-yielded': ['dispatcher'],
   'dispatcher.config-rejected': ['dispatcher'],
   'dispatcher.config-publication-failed': ['dispatcher'],
   'dispatcher.tick-started': ['dispatcher'],
   'dispatcher.tick-completed': ['dispatcher'],
+  'dispatcher.ticket-scan-completed': ['dispatcher'],
+  'dispatcher.ticket-source-dependency-limited': ['dispatcher'],
+  'dispatcher.ticket-source-degraded': ['dispatcher'],
+  'dispatcher.ticket-source-recovered': ['dispatcher'],
   'dispatcher.tick-failed': ['dispatcher'],
   'dispatcher.runner-settled': ['dispatcher'],
   'dispatcher.harvest-runner-failed': ['dispatcher'],

package/packages/core/src/integration/harness.ts

@@ -124,6 +124,7 @@ export function readyTicket(id: string, over: Partial<Omit<Ticket, 'ref'>> = {})
     title,
     body: over.body ?? CONFORMING_BODY,
     state: over.state ?? 'Ready',
+    resolved: false,
     labels: over.labels ?? ['autobuild'],
   }
 }
@@ -369,7 +370,7 @@ export async function assertSnapshotEquivalence(store: BuildStore, repo: string)
       dashboard: await attempt(() =>
         getOperatorDashboard({ store: target, repo, clock: () => at }),
       ),
-      status: await attempt(() => getRepositoryStatus(target, repo)),
+      status: await attempt(() => getRepositoryStatus(target, repo, at)),
       harvest: await attempt(() => getHarvestStatus(target, repo)),
       lists: await Promise.all(
         (['active', 'queued', 'all'] as const).map((scope) =>

package/packages/core/src/kernel/__snapshots__/reducer-registry.test.ts.snap

@@ -236,6 +236,7 @@ exports[`reducer registry accumulator shapes 1`] = `
     "$.lastEvent.payload.report.rev: number",
     "$.lastEvent.payload.report: object",
     "$.lastEvent.payload.request: number",
+    "$.lastEvent.payload.resetAt: string",
     "$.lastEvent.payload.retryable: boolean",
     "$.lastEvent.payload.role: string",
     "$.lastEvent.payload.roleWarnings: array",
@@ -414,6 +415,7 @@ exports[`reducer registry accumulator shapes 1`] = `
     "$.observations[].ts: string",
     "$.observations[]: object",
     "$.openInstance: null",
+    "$.readinessChangeSeq: number",
     "$.reclaimed: array",
     "$.terminal: string",
     "$: object",
@@ -436,6 +438,7 @@ exports[`reducer registry accumulator shapes 1`] = `
     "$.entries[].event: object",
     "$.entries[].headSha: string",
     "$.entries[].seq: number",
+    "$.entries[].seq: undefined",
     "$.entries[].t: string",
     "$.entries[]: object",
     "$: object",
@@ -611,6 +614,7 @@ exports[`reducer registry accumulator shapes 1`] = `
     "$.run: string",
     "$.warningNotice: string",
     "$.warningNotice: undefined",
+    "$.yieldedHolder: undefined",
     "$: object",
   ],
   "frozenPrImageHost": [
@@ -837,6 +841,7 @@ exports[`reducer registry accumulator shapes 1`] = `
     "$.retained[].actor.user: string",
     "$.retained[].actor: object",
     "$.retained[].payload.attempt: number",
+    "$.retained[].payload.cause: string",
     "$.retained[].payload.counters.claimed: number",
     "$.retained[].payload.counters.closed: number",
     "$.retained[].payload.counters.conflicted: number",
@@ -872,6 +877,7 @@ exports[`reducer registry accumulator shapes 1`] = `
     "$.retained[].payload.observations[].build: string",
     "$.retained[].payload.observations[].seq: number",
     "$.retained[].payload.observations[]: object",
+    "$.retained[].payload.operation: string",
     "$.retained[].payload.operator: string",
     "$.retained[].payload.outcome: string",
     "$.retained[].payload.pid: number",
@@ -881,6 +887,7 @@ exports[`reducer registry accumulator shapes 1`] = `
     "$.retained[].payload.report.kind: string",
     "$.retained[].payload.report.rev: number",
     "$.retained[].payload.report: object",
+    "$.retained[].payload.resetAt: string",
     "$.retained[].payload.roleWarnings: array",
     "$.retained[].payload.roleWarnings[]: string",
     "$.retained[].payload.run: string",
@@ -1103,6 +1110,7 @@ exports[`reducer registry accumulator shapes 1`] = `
     "$.ledger[].request: number",
     "$.ledger[].round: number",
     "$.ledger[].seq: number",
+    "$.ledger[].seq: undefined",
     "$.ledger[].step: string",
     "$.ledger[].t: string",
     "$.ledger[]: object",
@@ -1245,6 +1253,7 @@ exports[`reducer registry accumulator shapes 1`] = `
     "$.retained[].payload.report.rev: number",
     "$.retained[].payload.report: object",
     "$.retained[].payload.request: number",
+    "$.retained[].payload.resetAt: string",
     "$.retained[].payload.resolution: string",
     "$.retained[].payload.retryable: boolean",
     "$.retained[].payload.role: string",
@@ -1359,6 +1368,15 @@ exports[`reducer registry accumulator shapes 1`] = `
     "$.failures[]: number",
     "$: object",
   ],
+  "ticketSourceHealth": [
+    "$.active.cause: string",
+    "$.active.message: string",
+    "$.active.operation: string",
+    "$.active.resetAt: string",
+    "$.active.source: string",
+    "$.active: object",
+    "$: object",
+  ],
   "verifyDiffBase": [
     "$.pendingReconcileBase: string",
     "$.promoted: string",

package/packages/core/src/kernel/dispatch-status.ts

@@ -12,6 +12,7 @@ export interface DispatchStatus {
   queued?: number
   /** Standing count from newer tick facts; absent for historical events. */
   creationWithheld?: number
+  yieldedHolder?: string
   availableUpgrade?: string
   roleWarnings: string[]
   diagnostics: string[]
@@ -58,6 +59,7 @@ export function reduceDispatchStatus(
     state.lastSeq = event.seq
     switch (event.type) {
       case 'dispatcher.run-started':
+        state.yieldedHolder = undefined
         state.health = 'running'
         state.effectiveConfig = event.payload.effectiveConfig
         state.roleWarnings = [...event.payload.roleWarnings]
@@ -88,6 +90,12 @@ export function reduceDispatchStatus(
         )
         state.warningNotice = state.notice
         break
+      case 'dispatcher.tick-yielded':
+        state.yieldedHolder = event.payload.holder
+        break
+      case 'dispatcher.tick-started':
+        state.yieldedHolder = undefined
+        break
       case 'dispatcher.tick-completed':
         state.queued = event.payload.queued
         state.creationWithheld = event.payload.counters.creationWithheld
@@ -143,7 +151,7 @@ export function reduceDispatchStatus(
 
 /** Bump when `DispatchStatus`'s shape or fold semantics change (it is its own
  * accumulator: `lastSeq` makes the fold skip already-seen events). */
-export const DISPATCH_STATUS_REDUCER_VERSION = 1
+export const DISPATCH_STATUS_REDUCER_VERSION = 2
 
 /** The incremental form of `reduceDispatchStatus` for one run. The run is a
  * parameter, so this is a factory. */