@defrex/autobuild 0.12.0 → 0.14.0

package/packages/core/src/store/ticket-asset-snapshots.ts

@@ -0,0 +1,192 @@
+import { randomUUID } from 'node:crypto'
+import { gzipSync, gunzipSync } from 'node:zlib'
+import { z } from 'zod'
+import type { TicketAssetStore } from '../ports/types'
+import type { PinnedAsset } from '../events/payloads'
+import { contentHash, type BuildStore } from './types'
+import {
+  pinnedAssetOf,
+  summarizeTicketAsset,
+  validateTicketAssetInput,
+  validateTicketAssetStructure,
+  type TicketAsset,
+} from './ticket-assets'
+
+const CHUNK_BYTES = 256 * 1024
+const refSchema = z.strictObject({
+  kind: z.string().regex(/^ticket-snapshot-[a-f0-9-]+$/),
+  revision: z.number().int().nonnegative(),
+})
+const manifestSchema = z.strictObject({
+  version: z.literal(1),
+  meta: z.strictObject({
+    repo: z.string(),
+    ticketId: z.string(),
+    kind: z.string(),
+    name: z.string(),
+    revision: z.number().int().nonnegative(),
+    layout: z.enum(['file', 'tree']),
+    size: z.number().int().nonnegative(),
+    createdAt: z.string(),
+    entries: z.array(
+      z.discriminatedUnion('type', [
+        z.strictObject({ type: z.literal('dir'), path: z.string() }),
+        z.strictObject({
+          type: z.literal('file'),
+          path: z.string(),
+          size: z.number().int().nonnegative(),
+          blobRef: z.string(),
+        }),
+      ]),
+    ),
+  }),
+  files: z.array(
+    z.strictObject({
+      path: z.string(),
+      chunks: z.array(
+        refSchema.extend({ hash: z.string(), size: z.number().int().min(1).max(CHUNK_BYTES) }),
+      ),
+    }),
+  ),
+})
+
+function verifyMetadata(
+  meta: TicketAsset['meta'],
+  repo: string,
+  ticketId: string,
+  pin: PinnedAsset,
+): void {
+  const summary = pinnedAssetOf(summarizeTicketAsset(meta))
+  if (
+    meta.repo !== repo ||
+    meta.ticketId !== ticketId ||
+    Object.entries(summary).some(([key, value]) => pin[key as keyof typeof summary] !== value) ||
+    validateTicketAssetStructure(meta) !== meta.size
+  )
+    throw new Error('inconsistent ticket asset snapshot metadata')
+}
+
+function verify(asset: TicketAsset, repo: string, ticketId: string, pin: PinnedAsset): void {
+  const { meta, entries } = asset
+  verifyMetadata(meta, repo, ticketId, pin)
+  if (
+    validateTicketAssetInput({ ...meta, entries }) !== meta.size ||
+    entries.length !== meta.entries.length
+  ) {
+    throw new Error('inconsistent ticket asset snapshot metadata')
+  }
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i]!
+    const stored = meta.entries[i]!
+    if (
+      entry.path !== stored.path ||
+      entry.type !== stored.type ||
+      (entry.type === 'file' &&
+        stored.type === 'file' &&
+        (entry.content.length !== stored.size || contentHash(entry.content) !== stored.blobRef))
+    ) {
+      throw new Error('inconsistent ticket asset snapshot content')
+    }
+  }
+}
+
+/** Copy exact sampled revisions before publishing any pins. No current ticket rows
+ * are written to the destination; their revision sequences remain independent. */
+export async function prepareAssetSnapshots(
+  source: Pick<TicketAssetStore, 'listTicketAssets' | 'getTicketAsset'>,
+  store: Pick<BuildStore, 'putRepoArtifact' | 'ensureRepo'>,
+  repo: string,
+  ticketId: string,
+  canonicalTicketId: string = ticketId,
+): Promise<PinnedAsset[]> {
+  const pins = (await source.listTicketAssets(repo, ticketId)).map(pinnedAssetOf)
+  if (pins.length > 0) await store.ensureRepo(repo)
+  for (const pin of pins) {
+    const asset = await source.getTicketAsset(repo, ticketId, pin.kind, pin.name, pin.revision)
+    if (!asset) throw new Error('sampled ticket asset revision is missing')
+    manifestSchema.shape.meta.parse(asset.meta)
+    verify(asset, repo, canonicalTicketId, pin)
+    const files = []
+    for (const entry of asset.entries) {
+      if (entry.type !== 'file') continue
+      const chunks = []
+      for (let start = 0; start < entry.content.length; start += CHUNK_BYTES) {
+        const bytes = entry.content.slice(start, start + CHUNK_BYTES)
+        const meta = await store.putRepoArtifact(repo, {
+          kind: `ticket-snapshot-${randomUUID()}`,
+          content: bytes,
+        })
+        chunks.push({
+          kind: meta.kind,
+          revision: meta.revision,
+          size: bytes.length,
+          hash: contentHash(bytes),
+        })
+      }
+      files.push({ path: entry.path, chunks })
+    }
+    const meta = await store.putRepoArtifact(repo, {
+      kind: `ticket-snapshot-${randomUUID()}`,
+      // Compression also bounds manifests with many maximum-length escaped paths.
+      content: gzipSync(JSON.stringify({ version: 1, meta: { ...asset.meta, ticketId }, files })),
+    })
+    pin.snapshot = { kind: meta.kind, revision: meta.revision }
+  }
+  return pins
+}
+
+export async function readAssetSnapshot(
+  store: Pick<BuildStore, 'getRepoArtifact'>,
+  repo: string,
+  ticketId: string,
+  pin: PinnedAsset,
+  historicalTicketId?: string,
+): Promise<TicketAsset> {
+  if (!pin.snapshot) throw new Error('missing snapshot reference')
+  const artifact = await store.getRepoArtifact(repo, pin.snapshot.kind, pin.snapshot.revision)
+  if (!artifact) throw new Error('ticket asset snapshot manifest is missing')
+  const manifest = manifestSchema.parse(
+    JSON.parse(gunzipSync(artifact.content, { maxOutputLength: 4 * 1024 * 1024 }).toString('utf8')),
+  )
+  // BuildStore projections can display a readable ID while the immutable
+  // build.created event and its older snapshots retain the storage alias.
+  const snapshotTicketId =
+    manifest.meta.ticketId === historicalTicketId ? historicalTicketId : ticketId
+  verifyMetadata(manifest.meta, repo, snapshotTicketId, pin)
+  const entries: TicketAsset['entries'] = []
+  const files = new Map(manifest.files.map((file) => [file.path, file]))
+  if (
+    files.size !== manifest.files.length ||
+    files.size !== manifest.meta.entries.filter((entry) => entry.type === 'file').length
+  ) {
+    throw new Error('inconsistent ticket asset snapshot files')
+  }
+  for (const entry of manifest.meta.entries) {
+    if (entry.type === 'dir') {
+      entries.push(entry)
+      continue
+    }
+    const file = files.get(entry.path)
+    if (!file || file.chunks.reduce((size, chunk) => size + chunk.size, 0) !== entry.size) {
+      throw new Error('inconsistent ticket asset snapshot chunks')
+    }
+    const content = new Uint8Array(entry.size)
+    let offset = 0
+    for (const chunk of file.chunks) {
+      const artifact = await store.getRepoArtifact(repo, chunk.kind, chunk.revision)
+      if (
+        !artifact ||
+        artifact.content.length !== chunk.size ||
+        contentHash(artifact.content) !== chunk.hash
+      ) {
+        throw new Error('ticket asset snapshot chunk is missing or corrupt')
+      }
+      content.set(artifact.content, offset)
+      offset += chunk.size
+    }
+    entries.push({ type: 'file', path: entry.path, content })
+  }
+  const asset = { meta: manifest.meta, entries }
+  verify(asset, repo, snapshotTicketId, pin)
+  return asset
+}

package/packages/core/src/store/ticket-assets.ts

@@ -1,13 +1,16 @@
+import { readPinnedAssets, readBuildFacts } from './reduced-reads'
 /**
  * Ticket assets (SPEC §7.1): named, versioned bundles of files attached to a
- * ticket and kept in the BuildStore, keyed by `(repo, ticketId, kind, name)`.
- * The ticket source never stores the contents; it only gets a note through
+ * ticket and kept in its service (hosted) or BuildStore (other sources), keyed by `(repo, ticketId, kind, name)`.
+ * Sources also get a human-readable note through
  * `TicketSource.comment()` (SPEC §13).
  *
  * This module is the shared, adapter-independent half: the types, the limits,
  * and the one validator every adapter calls before any write.
  */
 
+import { readAssetSnapshot, prepareAssetSnapshots } from './ticket-asset-snapshots'
+import type { TicketSource, TicketAssetStore } from '../ports/types'
 import type { AbEvent } from '../events/catalog'
 import type { PinnedAsset } from '../events/payloads'
 import { defineReducer } from '../kernel/incremental'
@@ -56,7 +59,8 @@ export interface TicketAssetMeta {
   ticketId: string
   kind: string
   name: string
-  /** 0-based per `(repo, ticketId, kind, name)`. A removal consumes a number
+  /** Increasing per `(repo, ticketId, kind, name)` (normally from zero; native
+   * file revisions reserve a separate range for legacy compatibility). A removal consumes a number
    * too (a tombstone), so revisions may skip. */
   revision: number
   layout: TicketAssetLayout
@@ -380,7 +384,27 @@ export async function samplePinnedAssets(
   return (await store.listTicketAssets(repo, ticketId)).map(pinnedAssetOf)
 }
 
-export const PINNED_ASSETS_REDUCER_VERSION = 1
+export async function preparePinnedAssets(
+  source: TicketSource,
+  store: BuildStore,
+  repo: string,
+  ticketId: string,
+): Promise<PinnedAsset[]> {
+  if (!source.assets) {
+    if (source.name === 'hosted') throw new Error('hosted ticket source has no asset capability')
+    return samplePinnedAssets(store, repo, ticketId)
+  }
+  const ticket = await source.get(ticketId)
+  return prepareAssetSnapshots(
+    composeTicketAssets(source, store),
+    store,
+    repo,
+    ticketId,
+    ticket?.ref.id ?? ticketId,
+  )
+}
+
+export const PINNED_ASSETS_REDUCER_VERSION = 2
 
 /** The asset sets recorded by every `build.created`/`spec.revised` pin event
  * that carries one, in array order. Each pin event replaces the set, so the
@@ -443,7 +467,7 @@ export function findPinnedRevision(
  * needed, so a finished build still answers. Null when the build never pinned
  * `kind/name` (or the revision). Rejects an unknown build. */
 export async function resolvePinnedAsset(
-  store: Pick<BuildStore, 'getBuild' | 'getEvents' | 'getTicketAsset'>,
+  store: Pick<BuildStore, 'getBuild' | 'getReducerValue' | 'getTicketAsset' | 'getRepoArtifact'>,
   slug: string,
   kind: string,
   name: string,
@@ -452,7 +476,61 @@ export async function resolvePinnedAsset(
   const record = await store.getBuild(slug)
   if (record === null) throw new Error(`unknown build "${slug}"`)
   if (record.ticket === undefined) return null
-  const revision = findPinnedRevision(await store.getEvents(slug), kind, name, rev)
-  if (revision === undefined) return null
-  return store.getTicketAsset(record.repo, record.ticket.id, kind, name, revision)
+  const sets = (await readPinnedAssets(store, slug)).value.pins
+  const pin =
+    rev === undefined
+      ? sets.at(-1)?.find((a) => a.kind === kind && a.name === name)
+      : sets.flat().find((a) => a.kind === kind && a.name === name && a.revision === rev)
+  if (!pin) return null
+  if (pin.snapshot) {
+    const created = (await readBuildFacts(store, slug)).value.created
+    const asset = await readAssetSnapshot(
+      store,
+      record.repo,
+      record.ticket.id,
+      pin,
+      created?.type === 'build.created' ? created.payload.ticket?.id : undefined,
+    )
+    return { ...asset, meta: { ...asset.meta, ticketId: record.ticket.id } }
+  }
+  return store.getTicketAsset(record.repo, record.ticket.id, kind, name, pin.revision)
+}
+
+/** Native writes; merged reads preserve legacy file attachments and recorded revisions. */
+export function composeTicketAssets(
+  source: TicketSource,
+  legacy: TicketAssetStore,
+): TicketAssetStore {
+  const native = source.assets
+  if (!native) return legacy
+  if (!native.hasTicketAssetHistory) return native
+  const owns = (repo: string, id: string, kind: string, name: string) =>
+    native.hasTicketAssetHistory!(repo, id, kind, name)
+  return {
+    ticketAssetLimits: native.ticketAssetLimits.bind(native),
+    putTicketAsset: native.putTicketAsset.bind(native),
+    async getTicketAsset(repo, id, kind, name, rev) {
+      if (rev !== undefined)
+        return (
+          (await native.getTicketAsset(repo, id, kind, name, rev)) ??
+          legacy.getTicketAsset(repo, id, kind, name, rev)
+        )
+      return (await owns(repo, id, kind, name))
+        ? native.getTicketAsset(repo, id, kind, name)
+        : legacy.getTicketAsset(repo, id, kind, name)
+    },
+    async listTicketAssets(repo, id) {
+      const current = await native.listTicketAssets(repo, id)
+      for (const item of await legacy.listTicketAssets(repo, id)) {
+        if (!(await owns(repo, id, item.kind, item.name))) current.push(item)
+      }
+      return current
+    },
+    async removeTicketAsset(repo, id, kind, name) {
+      const previous = await this.getTicketAsset(repo, id, kind, name)
+      if (!previous) return null
+      await native.removeTicketAsset(repo, id, kind, name)
+      return previous?.meta ?? null
+    },
+  }
 }

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

@@ -1,3 +1,4 @@
+import type { ReducerValueRequest, ReducerValue } from './reducer-values'
 /**
  * The BuildStore seam (SPEC §7): the durable home of everything a build
  * produces — events, artifacts, transcripts — one logical place whether
@@ -127,10 +128,31 @@ export interface BuildDigest {
   executionOpen?: true
 }
 
+export type RepoTickCompletion =
+  | {
+      outcome: 'completed'
+      counters: RepositoryEventEnvelope<'dispatcher.tick-completed'>['payload']['counters']
+    }
+  | { outcome: 'failed'; error: string }
+
+/** Bounded operational telemetry; never workflow or queue authority. */
+export interface RepoTickObservation {
+  /** The run that last began or finished a tick. */
+  run: string
+  open?: { startedAt: string }
+  /** Retained across begin, even when the next run has a different holder. */
+  finished?: RepoTickCompletion & { run: string; startedAt: string; completedAt: string }
+}
+export interface RepoTickFinish {
+  observation: RepoTickObservation
+  events: RepositoryEvent[]
+}
+
 export interface RepositoryRecord {
   repo: string
   createdAt: string
   updatedAt: string
+  tick?: RepoTickObservation
   /** Repository workflow lease (harvest single-flight), separate from builds. */
   lease?: { holder: string; expiresAt: string }
   heartbeatAt?: string
@@ -384,12 +406,16 @@ export interface BuildStore {
    * journal's trailing events. Unknown repo rejects like `getRepoEvents`;
    * never an `ensureRepo` side effect. */
   getRepoHighWater(repo: string): Promise<number>
+  /** A named JSON answer reduced from the authoritative log. Checkpoints are
+   * maintained privately by the adapter and cannot be supplied by callers. */
+  getReducerValue(scope: SnapshotScope, request: ReducerValueRequest): Promise<ReducerValue>
   /** The stored reducer snapshot for a scope (a build log or a repository
    * journal), a cache beside the log and never an authority. `null` when
    * absent, when the stored version differs from `version`, when the stored
    * cursor is ahead of the scope's log tail, or when the scope is unknown (no
    * `ensureRepo` side effect, no rejection). A store without snapshot storage
-   * answers `null`. */
+   * answers `null`. Reserved `value.*` names reject: their checkpoints are
+   * internal to getReducerValue, not public snapshot resources. */
   getReducerSnapshot(
     scope: SnapshotScope,
     reducer: string,
@@ -401,7 +427,8 @@ export interface BuildStore {
    * past it), or when the cursor is equal and `version` is higher. Everything
    * else, and any cursor beyond the log tail, is a no-op. Atomic, so
    * concurrent writers cannot undo each other's progress. Resolves `true`
-   * when the row was written. */
+   * when the row was written. Reserved `value.*` names reject before storage
+   * access; only getReducerValue may write these checkpoints. */
   putReducerSnapshot(
     scope: SnapshotScope,
     reducer: string,
@@ -412,7 +439,7 @@ export interface BuildStore {
   listRepoArtifacts(repo: string, kind?: string): Promise<RepositoryArtifactMeta[]>
   // ── Ticket assets (SPEC §7.1 — files attached to a ticket) ─────────────
   // Keyed by (repo, ticketId, kind, name); revisions are 0-based. The store
-  // owns the bytes, the ticket source only ever gets a note (SPEC §13).
+  // owns these bytes; hosted current assets use the ticket service store (SPEC §13).
   /** The effective ceilings this store accepts for `repo` (a remote
    * deployment may advertise lower ones than the defaults). */
   ticketAssetLimits(repo: string): Promise<TicketAssetLimits>
@@ -456,6 +483,16 @@ export interface BuildStore {
     kind: string,
     name: string,
   ): Promise<TicketAssetMeta | null>
+  /** Fenced by the unexpired repository lease. Null means authority was lost.
+   * Finish validates all boundaries before atomically depositing them and telemetry.
+   * Neither method renews the lease. */
+  beginRepoTick(repo: string, holder: string): Promise<string | null>
+  finishRepoTick(
+    repo: string,
+    holder: string,
+    completion: RepoTickCompletion,
+    events: RepositoryEventWrite[],
+  ): Promise<RepoTickFinish | null>
   claimRepoLease(repo: string, holder: string, ttlMs: number): Promise<boolean>
   heartbeatRepo(repo: string, holder: string): Promise<boolean>
   releaseRepoLease(repo: string, holder: string): Promise<void>

package/packages/core/src/testing/dispatch-read-budget.ts

@@ -0,0 +1,215 @@
+import { expect } from 'bun:test'
+import { DispatchFrontend } from '../cli/dispatch-frontend'
+import type { DispatchChildResult } from '../cli/dispatch-process'
+import { createTerminalModeController } from '../cli/terminal-restore'
+import { DISPATCHER, humanActor } from '../events/envelope'
+import type { BuildStore } from '../store/types'
+
+const tickCounters = {
+  merged: 0,
+  closed: 0,
+  conflicted: 0,
+  abandoned: 0,
+  discarded: 0,
+  janitorFailed: 0,
+  recovered: 0,
+  dispatchFailed: 0,
+  resumed: 0,
+  swept: 0,
+  dispatched: 0,
+  authored: 0,
+  bounced: 0,
+  claimRaces: 0,
+  invalidTickets: 0,
+  dependencyBlocked: 0,
+  harvestStarted: 0,
+  harvestResumed: 0,
+  harvestCompleted: 0,
+  harvestEscalated: 0,
+  harvestFailed: 0,
+}
+
+/** Run the actual frontend lifecycle with a deterministic child and manual
+ * refreshes. Instrument the backing boundary, including HTTP server reads. */
+export async function dispatchReadBudget(store: BuildStore, backing: BuildStore): Promise<void> {
+  const repo = '/dashboard-read-budget'
+  await backing.ensureRepo(repo)
+  const metrics = {
+    rows: 0,
+    events: 0,
+    state: 0,
+    snapshots: 0,
+    digests: 0,
+    records: 0,
+    high: 0,
+    puts: 0,
+  }
+  const putSnapshot = backing.putReducerSnapshot.bind(backing)
+  backing.putReducerSnapshot = async (...args) => {
+    metrics.puts++
+    return putSnapshot(...args)
+  }
+  const getEvents = backing.getRepoEvents.bind(backing)
+  const getState = backing.getRepoStateEvents.bind(backing)
+  const getSnapshot = backing.getReducerSnapshot.bind(backing)
+  const getDigests = backing.getRepoBuildDigests.bind(backing)
+  const getRepo = backing.getRepo.bind(backing)
+  const getHigh = backing.getRepoHighWater.bind(backing)
+  backing.getRepoEvents = async (repo, since) => {
+    const events = await getEvents(repo, since)
+    metrics.events++
+    metrics.rows += events.length
+    return events
+  }
+  backing.getRepoStateEvents = async (repo) => {
+    metrics.state++
+    return getState(repo)
+  }
+  backing.getReducerSnapshot = async (...args) => {
+    metrics.snapshots++
+    return getSnapshot(...args)
+  }
+  backing.getRepoBuildDigests = async (repo) => {
+    metrics.digests++
+    return getDigests(repo)
+  }
+  backing.getRepo = async (repo) => {
+    metrics.records++
+    return getRepo(repo)
+  }
+  backing.getRepoHighWater = async (repo) => {
+    metrics.high++
+    return getHigh(repo)
+  }
+  let now = 0
+  let finish!: (result: DispatchChildResult) => void
+  let started!: () => void
+  let childRun = ''
+  const startup = new Promise<void>((resolve) => {
+    started = resolve
+  })
+  const frontend = new DispatchFrontend({
+    repo,
+    storeRef: 'test',
+    store,
+    env: {},
+    once: true,
+    clock: () => new Date(now),
+    input: { start: () => () => {} },
+    terminal: {
+      columns: 100,
+      rows: 24,
+      interactive: true,
+      write: () => {},
+      modes: createTerminalModeController(
+        () => {},
+        () => {},
+      ),
+    },
+    launchChild: ({ run }) => {
+      childRun = run
+      const completed = new Promise<DispatchChildResult>((resolve) => {
+        finish = resolve
+      })
+      void backing
+        .appendRepoWithArtifacts(
+          repo,
+          [
+            {
+              kind: 'config',
+              content: JSON.stringify({
+                capacity: 4,
+                roles: { default: { runtime: 'claude' } },
+                tickets: { source: 'file', readyState: 'ready' },
+              }),
+            },
+          ],
+          (artifacts) => ({
+            actor: DISPATCHER,
+            type: 'dispatcher.run-started',
+            payload: {
+              run,
+              pid: 1,
+              roleWarnings: [],
+              effectiveConfig: { kind: artifacts[0]!.kind, rev: artifacts[0]!.revision },
+            },
+          }),
+        )
+        .then(started)
+      return { completed, stop: async () => {} }
+    },
+  })
+  const running = frontend.run()
+  await startup
+  // Exercise exactly the controller operation used by timers and actions,
+  // without a wall-clock timer determining the batch boundaries.
+  const refresh = () => (frontend as unknown as { renderOnce(): Promise<void> }).renderOnce()
+  await refresh()
+  const initialSize = JSON.stringify(
+    (await getSnapshot({ kind: 'repo', repo }, 'dispatchFrontend', 2))?.state,
+  ).length
+  let recordReads: number | undefined
+  try {
+    for (let batch = 0; batch < 24; batch++) {
+      for (let i = 0; i < 128; i++) {
+        await backing.appendRepo(repo, {
+          actor: DISPATCHER,
+          type: 'dispatcher.tick-completed',
+          payload: {
+            run: childRun,
+            queued: 0,
+            counters: tickCounters,
+            janitorDiagnostics: [],
+            ticketDiagnostics: [],
+            creationDiagnostics: [],
+            dependencyDiagnostics: [],
+          },
+        })
+      }
+      const before = { ...metrics }
+      now += 6000
+      await refresh()
+      expect(metrics.puts - before.puts).toBe(1)
+      expect(metrics.rows - before.rows).toBe(128)
+      expect(metrics.events - before.events).toBe(1)
+      expect(metrics.state - before.state).toBe(0)
+      expect(metrics.snapshots - before.snapshots).toBe(0)
+      expect(metrics.digests - before.digests).toBe(1)
+      expect(metrics.high - before.high).toBe(0)
+      recordReads ??= metrics.records - before.records
+      expect(metrics.records - before.records).toBe(recordReads)
+      const size = JSON.stringify(
+        (await getSnapshot({ kind: 'repo', repo }, 'dispatchFrontend', 2))?.state,
+      ).length
+      // First advancement adds the child's identity; ticks add nothing.
+      expect(size).toBeLessThan(initialSize + 1000)
+      const rows = metrics.rows
+      await refresh()
+      expect(metrics.rows).toBe(rows)
+    }
+    // Advance the clock across rejected equal-cursor saves. A standby can
+    // remain quiet indefinitely; each 500 ms frame must not upload its cache.
+    const beforeQuiet = { ...metrics }
+    for (let poll = 0; poll < 40; poll++) {
+      now += 500
+      await refresh()
+    }
+    expect(metrics.puts - beforeQuiet.puts).toBe(4)
+    expect(metrics.rows).toBe(beforeQuiet.rows)
+  } finally {
+    finish({ outcome: 'normal', exitCode: 0 })
+    await running
+  }
+  await backing.appendRepo(repo, {
+    actor: humanActor('test'),
+    type: 'dispatcher.pause-set',
+    payload: { enabled: true },
+  })
+  // A new invocation restores persisted state without any bounded/full seed.
+  const { DispatchRepositoryFeed } = await import('../cli/dispatch-repository-feed')
+  const feed = new DispatchRepositoryFeed(store, repo, () => new Date(now))
+  const before = { ...metrics }
+  expect((await feed.refresh()).length).toBe(1)
+  expect(metrics.rows - before.rows).toBe(1)
+  expect(metrics.state - before.state).toBe(0)
+}

package/packages/core/src/testing/index.ts

@@ -64,3 +64,11 @@ export { resolveHarvestCliEnv } from '../cli/env'
 export { buildHarvestContext, submitHarvestProposals, submitHarvestVerdict } from '../cli/harvest'
 export { abConnect, abDisconnect } from '../cli/connect'
 export { ProjectCredentials } from '../cli/project-credentials'
+
+export { dispatchReadBudget } from './dispatch-read-budget'
+
+export {
+  reducedReadBudget,
+  countHistoricalRows,
+  type ReducedReadCosts,
+} from './reduced-read-budget'