@defrex/autobuild 0.10.1 → 0.11.0

package/packages/core/src/processes/dispatcher.ts

@@ -1,3 +1,7 @@
+import {
+  reduceTicketSourceHealth,
+  type TicketSourceDegradation,
+} from '../kernel/ticket-source-health'
 /**
  * The dispatcher process (SPEC §3.3, §12): watches the TicketSource for
  * Ready tickets, claims, provisions a workspace, and launches build-runners
@@ -36,6 +40,7 @@
  * validation and fallback remain here. The supervising kernel reserves each
  * execution lease before launch; the child renews that same-holder lease.
  */
+import { createHash } from 'node:crypto'
 import type { Config } from '../config/schema'
 import type { LanguageModel } from 'ai'
 import { runOrchestratorTickStep } from './orchestrator-tick'
@@ -74,6 +79,7 @@ import type {
   TicketSource,
   WorkspaceProvider,
 } from '../ports/types'
+import { TicketSourceRateLimitError } from '../ports/types'
 import type { Exec } from '../ports/workspace/git-worktree'
 import type { ArtifactMeta, BuildDigest, BuildRecord, BuildStore, Clock } from '../store/types'
 import { samplePinnedAssets } from '../store/ticket-assets'
@@ -201,7 +207,9 @@ function findCycle(
   nodes: Map<string, DependencyState>,
   explored: Set<string>,
 ): string[] | null {
-  for (const next of nodes.get(from)?.blockedBy ?? []) {
+  const node = nodes.get(from)
+  if (!node?.exists || node.resolved) return null
+  for (const next of node.blockedBy) {
     const seen = path.indexOf(next)
     if (seen !== -1) return [...path.slice(seen), next]
     if (explored.has(next)) continue
@@ -301,7 +309,7 @@ export function validateSlugCandidate(candidate: string | null | undefined): str
 /** Counts per action, for observability and tests. An idempotent re-run of
  * `tick()` over unchanged state reports all zeroes — except invalid-record,
  * in-flight-creation, and dependency fields, which are standing queue reports rather than records of
- * action. They repeat on every ready scan by design, because that is the only
+ * action. They repeat between scans and refresh on completed scans, because that is the only
  * place the source problems are visible without provider inspection. */
 export interface TickReport {
   /** Janitor (§15.7): builds completed as merged. */
@@ -354,13 +362,15 @@ export interface TickReport {
   /** Standing queue depth: ready tickets still waiting after this tick —
    * excludes tickets already embodied by an active build, and ones that left
    * the queue this tick (dispatched, bounced, or claimed elsewhere). Like the
-   * invalid/dependency fields it re-reports on every ready scan. */
+   * invalid/dependency fields it repeats between completed scans. */
   queued: number
   /** Ready tickets withheld while Autobuild's own external creation is still
    * between durable reservation and settled blocker recording. */
   creationWithheld: number
   /** One line per creation hold, with Harvest run/proposal provenance. */
   creationDiagnostics: string[]
+  /** Ready tickets whose dependency reads failed rather than yielding a verdict. */
+  dependencyCheckFailed: number
   /** Dependency gate (§13): ready tickets held back by unresolved blockers. */
   dependencyBlocked: number
   /** One line per held ticket naming its unresolved blockers — the operator's
@@ -410,6 +420,7 @@ export function emptyTickReport(): TickReport {
     queued: 0,
     creationWithheld: 0,
     creationDiagnostics: [],
+    dependencyCheckFailed: 0,
     dependencyBlocked: 0,
     dependencyDiagnostics: [],
     harvestStarted: 0,
@@ -729,6 +740,7 @@ export class Dispatcher {
       }
     }
     const report = emptyTickReport()
+    this.restoreScan(report)
     /** Builds already launched this tick — a janitor/startup re-attach must
      * not be doubled by the sweep, nor a fresh dispatch by anything. */
     const launched = new Set<string>()
@@ -893,6 +905,81 @@ export class Dispatcher {
       .map(({ record }) => record)
   }
 
+  private async sourceCondition(
+    next?: TicketSourceDegradation,
+    successfulOperation?: 'ready-scan' | 'dependency-check',
+  ): Promise<void> {
+    await this.store.refreshJournal()
+    const current = reduceTicketSourceHealth(this.store.recordedJournal())
+    if (next !== undefined && current?.cause === next.cause && current.source === next.source) {
+      if (
+        next.cause === 'rate-limited' &&
+        next.operation === 'dependency-check' &&
+        current.operation !== 'dependency-check'
+      ) {
+        await this.store.appendRepo(this.deps.repo, {
+          actor: DISPATCHER,
+          type: 'dispatcher.ticket-source-dependency-limited',
+          payload: { source: current.source },
+        })
+      }
+      return
+    }
+    if (
+      next === undefined &&
+      current?.operation === 'dependency-check' &&
+      successfulOperation !== 'dependency-check'
+    )
+      return
+    if (current !== undefined) {
+      await this.store.appendRepo(this.deps.repo, {
+        actor: DISPATCHER,
+        type: 'dispatcher.ticket-source-recovered',
+        payload: { source: current.source, cause: current.cause, operation: current.operation },
+      })
+    }
+    if (next !== undefined) {
+      await this.store.ensureRepo(this.deps.repo)
+      await this.store.appendRepo(this.deps.repo, {
+        actor: DISPATCHER,
+        type: 'dispatcher.ticket-source-degraded',
+        payload: next,
+      })
+    }
+  }
+
+  private async sourceFailure(
+    error: unknown,
+    operation: 'ready-scan' | 'dependency-check',
+  ): Promise<void> {
+    const message = error instanceof Error ? error.message : String(error)
+    await this.sourceCondition(
+      error instanceof TicketSourceRateLimitError
+        ? {
+            source: error.source,
+            cause: 'rate-limited',
+            operation,
+            message,
+            resetAt: new Date(error.resetAt).toISOString(),
+          }
+        : {
+            source: this.deps.tickets.name,
+            cause: 'ready-scan-failed',
+            operation,
+            message: message || 'Ready scan failed',
+          },
+    )
+  }
+
+  private async listReady() {
+    try {
+      return await this.deps.tickets.listReady(readyCriteria(this.deps.config))
+    } catch (error) {
+      await this.sourceFailure(error, 'ready-scan')
+      throw error
+    }
+  }
+
   /** Observation-only ready listing for Store-backed frontends while intake is
    * disabled. It shares the active-ticket exclusion with dispatch but performs
    * no dependency fetch, claim, bounce, build, workspace, or launch side
@@ -910,14 +997,109 @@ export class Dispatcher {
         activeTicketIds.add(record.ticket.id)
       }
     }
-    const listing = await this.deps.tickets.listReady(readyCriteria(this.deps.config))
+    const report = emptyTickReport()
+    this.restoreScan(report)
+    const checkpoint = await this.scanCheckpoint('observation')
+    if (checkpoint.due) {
+      await this.store.refreshJournal()
+      const listing = await this.listReady()
+      await this.store.refreshJournal()
+      report.queued = listing.tickets.filter((ticket) => !activeTicketIds.has(ticket.ref.id)).length
+      report.invalidTickets = listing.diagnostics.length
+      report.ticketDiagnostics = [...listing.diagnostics]
+      report.dependencyBlocked = 0
+      report.dependencyDiagnostics = []
+      report.creationWithheld = 0
+      report.creationDiagnostics = []
+      await this.sourceCondition(undefined, 'ready-scan')
+      await this.completeScan(checkpoint, report)
+    }
     return {
-      queued: listing.tickets.filter((ticket) => !activeTicketIds.has(ticket.ref.id)).length,
-      invalidTickets: listing.diagnostics.length,
-      ticketDiagnostics: [...listing.diagnostics],
+      queued: report.queued,
+      invalidTickets: report.invalidTickets,
+      ticketDiagnostics: report.ticketDiagnostics,
     }
   }
 
+  private latestScan() {
+    return this.store
+      .recordedJournal()
+      .findLast(
+        (event): event is Extract<RepositoryEvent, { type: 'dispatcher.ticket-scan-completed' }> =>
+          event.type === 'dispatcher.ticket-scan-completed',
+      )?.payload
+  }
+
+  private restoreScan(report: TickReport): void {
+    const previous = this.latestScan()
+    if (previous === undefined) return
+    for (const key of [
+      'queued',
+      'invalidTickets',
+      'dependencyBlocked',
+      'creationWithheld',
+    ] as const)
+      report[key] = previous[key]
+    for (const key of [
+      'ticketDiagnostics',
+      'dependencyDiagnostics',
+      'creationDiagnostics',
+    ] as const)
+      report[key] = [...previous[key]]
+  }
+
+  private async scanCheckpoint(mode: 'admission' | 'observation') {
+    const digest = (await this.repoBuildDigests())
+      .filter(({ digest }) => digest.readinessChangeSeq !== undefined)
+      .map(({ record, digest }) => [record.slug, digest.readinessChangeSeq] as const)
+      .sort(([a], [b]) => a.localeCompare(b))
+    const hash = (value: unknown) =>
+      createHash('sha256').update(JSON.stringify(value)).digest('hex')
+    const readinessFingerprint = hash(digest)
+    const criteriaFingerprint = hash(readyCriteria(this.deps.config))
+    const startedAt = this.deps.clock().toISOString()
+    const previous = this.latestScan()
+    const elapsed =
+      previous === undefined ? Infinity : Date.parse(startedAt) - Date.parse(previous.startedAt)
+    return {
+      startedAt,
+      mode,
+      readinessFingerprint,
+      criteriaFingerprint,
+      due:
+        previous === undefined ||
+        elapsed < 0 ||
+        elapsed >= this.deps.config.ticketScanIntervalSeconds * 1000 ||
+        previous.readinessFingerprint !== readinessFingerprint ||
+        previous.criteriaFingerprint !== criteriaFingerprint ||
+        (mode === 'admission' && previous.mode === 'observation'),
+    }
+  }
+
+  private async completeScan(
+    checkpoint: Awaited<ReturnType<Dispatcher['scanCheckpoint']>>,
+    report: TickReport,
+  ): Promise<void> {
+    await this.store.ensureRepo(this.deps.repo)
+    await this.store.appendRepo(this.deps.repo, {
+      actor: DISPATCHER,
+      type: 'dispatcher.ticket-scan-completed',
+      payload: {
+        startedAt: checkpoint.startedAt,
+        mode: checkpoint.mode,
+        readinessFingerprint: checkpoint.readinessFingerprint,
+        criteriaFingerprint: checkpoint.criteriaFingerprint,
+        queued: report.queued,
+        invalidTickets: report.invalidTickets,
+        ticketDiagnostics: report.ticketDiagnostics.slice(0, 1000),
+        dependencyBlocked: report.dependencyBlocked,
+        dependencyDiagnostics: report.dependencyDiagnostics.slice(0, 1000),
+        creationWithheld: report.creationWithheld,
+        creationDiagnostics: report.creationDiagnostics.slice(0, 1000),
+      },
+    })
+  }
+
   /** Apply the newest durable `dispatcher.auto-merge-default-set` fact to every
    * current non-terminal build of this repository: on — request consent; off —
    * cancel it. Attribution is the toggling human's own actor, exactly as if
@@ -2859,6 +3041,13 @@ export class Dispatcher {
   ): Promise<void> {
     const store = this.store
     const { tickets, config } = this.deps
+    const checkpoint = await this.scanCheckpoint('admission')
+    if (!checkpoint.due) return
+    // Clear only standing measurement fields; action counters belong to this tick.
+    report.queued = report.invalidTickets = report.dependencyBlocked = report.creationWithheld = 0
+    report.ticketDiagnostics = []
+    report.dependencyDiagnostics = []
+    report.creationDiagnostics = []
     // Blocked and paused builds still occupy a slot: their workspaces and
     // pending work are live, only waiting on a human. Capacity is per repo
     // (§16.1) — another repo's builds never consume this repo's slots.
@@ -2878,9 +3067,12 @@ export class Dispatcher {
     // ready state are deduped against the active builds embodying them.
     await this.store.refreshJournal()
     const journalBeforeReady = this.store.recordedJournal()
-    const listing = await tickets.listReady(readyCriteria(config))
+    const listing = await this.listReady()
     await this.store.refreshJournal()
     const journalAfterReady = this.store.recordedJournal()
+    if (reduceTicketSourceHealth(journalAfterReady)?.cause === 'ready-scan-failed') {
+      await this.sourceCondition(undefined, 'ready-scan')
+    }
     const creationHolds = new Map(
       harvestCreationsDuringReadyScan(journalBeforeReady, journalAfterReady).map((creation) => [
         creation.creationKey.toLowerCase(),
@@ -2912,55 +3104,67 @@ export class Dispatcher {
     // still runs either way, so the standing queue-depth report stays honest —
     // this only declines to claim a ticket into a build that would immediately
     // sit held.
-    if (capacity <= 0 || paused) return
-    // One dependency-node cache per tick: blockers are commonly shared across
-    // the ready set, and a blocker's resolution must be re-read every tick
-    // (never cached across them) so a completion lands on the next pass.
-    const nodes = new Map<string, DependencyState>()
+    if (capacity <= 0 || paused) {
+      await this.sourceCondition(undefined, 'ready-scan')
+      if (!this.outOfBudget(opts)) await this.completeScan(checkpoint, report)
+      return
+    }
+    // One dependency-node cache per scan: blockers are commonly shared across
+    // the ready set. Never reuse ticket or dependency objects between scans.
+    const nodes = new Map<string, DependencyState>(
+      listing.tickets.map((ticket) => [
+        ticket.ref.id,
+        {
+          id: ticket.ref.id,
+          exists: true,
+          resolved: ticket.resolved,
+          blockedBy: [...(ticket.blockedBy ?? [])],
+        },
+      ]),
+    )
 
+    // Finish read-only evaluation before any intake claim: a later source
+    // failure must leave the entire ready set unclaimed. Publish dependency
+    // diagnostics only after the complete preflight succeeds.
+    let scanSuccessful = true
+    const verdicts = new Map<string, DependencyVerdict>()
+    const failed = new Set<string>()
     for (const ticket of ready) {
-      if (capacity <= 0) break
-      // Budget gate before the dependency fetch / claim / createBuild: the
-      // first ready read above stays (it is the standing queue-depth report);
-      // once the budget is spent no additional transport call is started, so
-      // the remaining tickets are left un-attempted for the next invocation.
-      if (this.outOfBudget(opts)) break
-
-      // Autobuild's own in-flight create gate precedes even dependency reads:
-      // the ready projection may have been captured before blocker recording.
-      // It spends no capacity and leaves queue depth unchanged.
+      if (this.outOfBudget(opts)) return
       if (withheld.has(ticket.ref.id)) continue
-
-      // The dependency gate runs FIRST — before the claim, before the spec
-      // gate. A blocked ticket must not be claimed, must not be bounced, must
-      // create no build or workspace, and must not spend capacity; it is
-      // simply not this tick's work. Note this sits *above* [tickets]'s
-      // readyLabels / readyState gate: those criteria produced `ready`, and the
-      // gate subtracts from it — labels and state can make a ticket a
-      // candidate but can never override an unresolved blocker.
-      if ((ticket.blockedBy ?? []).length > 0) {
-        let verdict: DependencyVerdict
-        try {
-          await this.loadDependencyGraph(ticket, nodes)
-          verdict = analyzeDependencies(ticket.ref.id, ticket.blockedBy ?? [], nodes)
-        } catch (error) {
-          // A broken graph is this ticket's problem, not the tick's: skip it
-          // and let unrelated eligible tickets dispatch normally.
-          verdict = {
-            unresolved: [ticket.ref.id],
-            diagnostics: [
-              `ticket ${ticket.ref.id}: dependency check failed — ${
-                error instanceof Error ? error.message : String(error)
-              }`,
-            ],
-          }
-        }
-        if (verdict.unresolved.length > 0) {
-          report.dependencyBlocked += 1
-          report.dependencyDiagnostics.push(...verdict.diagnostics)
-          continue
+      if (ticket.blockersResolved === true || (ticket.blockedBy ?? []).length === 0) continue
+      let verdict: DependencyVerdict
+      try {
+        if (!(await this.loadDependencyGraph(ticket, nodes, opts))) return
+        verdict = analyzeDependencies(ticket.ref.id, ticket.blockedBy ?? [], nodes)
+      } catch (error) {
+        if (error instanceof TicketSourceRateLimitError) {
+          await this.sourceFailure(error, 'dependency-check')
+          throw error
         }
+        scanSuccessful = false
+        failed.add(ticket.ref.id)
+        report.dependencyCheckFailed += 1
+        report.dependencyDiagnostics.push(
+          `ticket ${ticket.ref.id}: dependency check failed — ${error instanceof Error ? error.message : String(error)}`,
+        )
+        continue
       }
+      verdicts.set(ticket.ref.id, verdict)
+    }
+    if (this.outOfBudget(opts)) return
+    if (failed.size === 0) await this.sourceCondition(undefined, 'dependency-check')
+    for (const verdict of verdicts.values()) {
+      if (verdict.unresolved.length > 0) {
+        report.dependencyBlocked += 1
+        report.dependencyDiagnostics.push(...verdict.diagnostics)
+      }
+    }
+    for (const ticket of ready) {
+      if (capacity <= 0 || this.outOfBudget(opts)) break
+      if (withheld.has(ticket.ref.id)) continue
+      if (failed.has(ticket.ref.id)) continue
+      if ((verdicts.get(ticket.ref.id)?.unresolved.length ?? 0) > 0) continue
 
       // Claim-before-launch (§12): losing the claim means another dispatcher
       // (or an earlier tick) owns this ticket.
@@ -3036,36 +3240,36 @@ export class Dispatcher {
       // means the remote provisioning continuation owns the rest.
       if (outcome === 'completed' || outcome === 'deferred') report.dispatched += 1
     }
+    if (scanSuccessful && !this.outOfBudget(opts)) await this.completeScan(checkpoint, report)
   }
 
   /**
-   * Close `nodes` over everything reachable from `ticket`'s blockers, so the
-   * analyzer can both gate and name a cycle. Breadth-first, one port call per
-   * level, skipping ids already cached — the common case (a blocker or two,
-   * none of them blocked themselves) is a single call.
-   *
-   * INVARIANT: `nodes` contains only states actually returned by the source.
-   * The cache is shared across the tick's tickets, so a node this ticket
-   * invents is a node the *next* ticket will trust as a fact about its own
-   * blocker. Nothing is seeded here for that reason (f_8bc9ee0c); the
-   * analyzer takes the ticket's own blockers as an argument instead, and
-   * `findCycle` closes a cycle via its path rather than the map.
-   *
-   * A provider-side cycle terminates the walk: an id already in `nodes` is
-   * never re-queued, so every reachable node is fetched exactly once.
+   * Walk unresolved branches in provider order. Listing facts and dependency
+   * reads share a tick-local cache; traversal visits are local to this root.
    */
   private async loadDependencyGraph(
     ticket: Ticket,
     nodes: Map<string, DependencyState>,
-  ): Promise<void> {
-    let frontier = [...new Set(ticket.blockedBy ?? [])].filter((id) => !nodes.has(id))
+    opts: TickOpts = {},
+  ): Promise<boolean> {
+    const visited = new Set<string>()
+    let frontier = [...new Set(ticket.blockedBy ?? [])]
     while (frontier.length > 0) {
-      const states = await this.deps.tickets.dependencyStates(frontier)
-      for (const state of states) nodes.set(state.id, state)
-      frontier = [...new Set(states.flatMap((state) => state.blockedBy))].filter(
-        (id) => !nodes.has(id),
-      )
+      if (this.outOfBudget(opts)) return false
+      const uncached = frontier.filter((id) => !nodes.has(id))
+      if (uncached.length > 0) {
+        const states = await this.deps.tickets.dependencyStates(uncached)
+        for (const state of states) nodes.set(state.id, state)
+      }
+      const next: string[] = []
+      for (const id of frontier) {
+        visited.add(id)
+        const node = nodes.get(id)
+        if (node?.exists && !node.resolved) next.push(...node.blockedBy)
+      }
+      frontier = [...new Set(next)].filter((id) => !visited.has(id))
     }
+    return true
   }
 
   /** Bounce (§6.3): back to Triage with a comment citing the standard and

package/packages/core/src/processes/repo-view.ts

@@ -32,7 +32,8 @@
  * What is held:
  *
  * - the bounded repository journal (`getRepoStateEvents`' subset), pruned on
- *   arrival by the same keep rule — durable types plus the tail from the latest
+ *   arrival by the same keep rule — durable facts, latest-only measurements,
+ *   and the tail (excluding latest-only types) from the latest
  *   `dispatcher.run-started` — which is exact for seq-ordered input;
  * - for *work* builds (nonterminal, aborted, reclaim-pending, execution-open),
  *   the full event array. Settled terminal builds hold only the discovery

package/packages/core/src/store/adapter.ts

@@ -48,6 +48,7 @@ export {
   REPOSITORY_RUN_SCOPED_EVENT_TYPES,
   REPOSITORY_STATE_EVENT_TYPES,
   readRepoStateEventsWithAnchorRecheck,
+  REPOSITORY_LATEST_EVENT_TYPES,
 } from './repo-state-events'
 export {
   DEFAULT_ARTIFACT_RETENTION_MAX_REVISIONS,

package/packages/core/src/store/contract.ts

@@ -607,21 +607,25 @@ export function describeBuildStoreContract(name: string, factory: BuildStoreFact
           })
           expect(digests.get('dg-done')).toEqual({
             slug: 'dg-done',
+            readinessChangeSeq: 2,
             terminal: 'done',
             observations: [{ seq: 3, ts: tsOf('dg-done', 3) }],
           })
           expect(digests.get('dg-cleaning')).toEqual({
             slug: 'dg-cleaning',
+            readinessChangeSeq: 2,
             terminal: 'aborted',
             observations: [{ seq: 3, ts: tsOf('dg-cleaning', 3) }],
           })
           expect(digests.get('dg-abandoned')).toEqual({
             slug: 'dg-abandoned',
+            readinessChangeSeq: 3,
             terminal: 'done',
             observations: [],
           })
           expect(digests.get('dg-overwrite')).toEqual({
             slug: 'dg-overwrite',
+            readinessChangeSeq: 4,
             terminal: 'done',
             observations: [],
           })
@@ -684,6 +688,7 @@ export function describeBuildStoreContract(name: string, factory: BuildStoreFact
           digest = (await store.getRepoBuildDigests(repo)).get('dg-paths')
           expect(digest).toEqual({
             slug: 'dg-paths',
+            readinessChangeSeq: 6,
             terminal: 'done',
             merged: secondMergeTs,
             observations: [
@@ -1176,6 +1181,48 @@ export function describeBuildStoreContract(name: string, factory: BuildStoreFact
         ]
       }
 
+      test('ticket-source health remains durable across newer runs', async () => {
+        await withStore(factory, undefined, async (store) => {
+          const repo = 'acme/source-health'
+          await store.ensureRepo(repo)
+          const condition = {
+            source: 'fake',
+            cause: 'rate-limited' as const,
+            operation: 'ready-scan' as const,
+            message: 'quota exhausted',
+            resetAt: '2026-10-14T12:00:00.000Z',
+          }
+          await store.appendRepo(repo, {
+            actor: DISPATCHER,
+            type: 'dispatcher.ticket-source-degraded',
+            payload: condition,
+          })
+          await store.appendRepo(repo, {
+            actor: DISPATCHER,
+            type: 'dispatcher.ticket-source-dependency-limited',
+            payload: { source: 'fake' },
+          })
+          for (const write of noopInvocation('new-run')) await store.appendRepo(repo, write)
+          const bounded = await store.getRepoStateEvents(repo)
+          expect(bounded[0]?.type).toBe('dispatcher.ticket-source-degraded')
+          expect(bounded[1]?.type).toBe('dispatcher.ticket-source-dependency-limited')
+          await store.appendRepo(repo, {
+            actor: DISPATCHER,
+            type: 'dispatcher.ticket-source-recovered',
+            payload: { source: 'fake', cause: 'rate-limited', operation: 'dependency-check' },
+          })
+          expect(
+            (await store.getRepoStateEvents(repo)).filter((event) =>
+              event.type.startsWith('dispatcher.ticket-source-'),
+            ),
+          ).toEqual(
+            (await store.getRepoEvents(repo)).filter((event) =>
+              event.type.startsWith('dispatcher.ticket-source-'),
+            ),
+          )
+        })
+      })
+
       function noopTickCounters() {
         return {
           merged: 0,
@@ -1202,6 +1249,68 @@ export function describeBuildStoreContract(name: string, factory: BuildStoreFact
         }
       }
 
+      test('latest-only scans stay bounded across scans, runs and repositories', async () => {
+        await withStore(factory, undefined, async (store) => {
+          for (const repo of ['acme/scans', 'acme/foreign-scans']) await store.ensureRepo(repo)
+          const appendScan = (repo: string, queued: number) =>
+            store.appendRepo(repo, {
+              actor: DISPATCHER,
+              type: 'dispatcher.ticket-scan-completed',
+              payload: {
+                startedAt: '2026-10-14T00:00:00.000Z',
+                mode: 'admission',
+                readinessFingerprint: 'r',
+                criteriaFingerprint: 'c',
+                queued,
+                invalidTickets: 0,
+                ticketDiagnostics: [],
+                dependencyBlocked: 0,
+                dependencyDiagnostics: [],
+                creationWithheld: 0,
+                creationDiagnostics: [],
+              },
+            })
+          await store.appendRepo('acme/scans', {
+            actor: humanActor('op'),
+            type: 'dispatcher.intake-set',
+            payload: { enabled: true },
+          })
+          const check = async (expected: number, rows: number) => {
+            const all = await store.getRepoEvents('acme/scans')
+            const bounded = await store.getRepoStateEvents('acme/scans')
+            expect(bounded).toEqual(projectRepositoryStateEvents(all))
+            expect(bounded).toHaveLength(rows)
+            const scans = bounded.filter((e) => e.type === 'dispatcher.ticket-scan-completed')
+            expect(scans).toHaveLength(1)
+            expect(scans[0]!.payload).toMatchObject({ queued: expected })
+            expect(reduceDispatchSettings(bounded)).toEqual(reduceDispatchSettings(all))
+          }
+          for (let i = 0; i < 200; i++) await appendScan('acme/scans', i)
+          await check(199, 2)
+          for (let i = 200; i < 400; i++) {
+            await appendScan('acme/scans', i)
+            await appendScan('acme/foreign-scans', 999)
+          }
+          await check(399, 2)
+          for (let run = 0; run < 20; run++) {
+            for (const write of noopInvocation(`scan-run-${run}`))
+              await store.appendRepo('acme/scans', write)
+            await appendScan('acme/scans', run)
+          }
+          await check(19, 6)
+          for (const write of noopInvocation('scan-final'))
+            await store.appendRepo('acme/scans', write)
+          await check(19, 6) // latest scan is older than the run anchor
+          for (let i = 0; i < 100; i++) await appendScan('acme/scans', i)
+          await check(99, 6)
+          expect(
+            (await store.getRepoEvents('acme/scans')).filter(
+              (e) => e.type === 'dispatcher.ticket-scan-completed',
+            ),
+          ).toHaveLength(520)
+        })
+      })
+
       test('unknown repo rejects like getRepoEvents', async () => {
         await withStore(factory, undefined, async (store) => {
           await expect(store.getRepoStateEvents('acme/never-seen')).rejects.toThrow(/unknown repo/)