@defrex/autobuild 0.10.1 → 0.12.0

package/packages/core/src/processes/harvest-runner.ts

@@ -1,3 +1,4 @@
+import { delegateCredential } from '../store/remote/credentials'
 /**
  * Crash-safe repository-scoped harvest workflow:
  * scan -> synthesize <-> review -> file. It reuses `converge` for adversarial
@@ -100,11 +101,13 @@ export interface HarvestRunnerDeps {
    * executes in (hosted harvest). Stamped into the run's harvest.started
    * payload so the journal records where it ran; absent on local runs. */
   environment?: { provider: string; environmentId: string; sessionId?: string }
+  preparedRun?: { run: string }
   sessionEnv?: Record<string, string>
   opts?: HarvestRunnerOpts
 }
 
 export type HarvestRunnerResult =
+  | { outcome: 'prepared'; run: string; launch: 'started' | 'resumed' }
   | { outcome: 'idle' }
   | { outcome: 'held' }
   | { outcome: 'parked'; run?: string }
@@ -217,9 +220,9 @@ export class HarvestRunner {
     )
   }
 
-  async run(): Promise<HarvestRunnerResult> {
+  async run(preparationOnly = false): Promise<HarvestRunnerResult> {
     const { store, repo, instance } = this.deps
-    await store.ensureRepo(repo)
+    if (!this.deps.preparedRun) await store.ensureRepo(repo)
     if (
       this.deps.leaseHolder === undefined &&
       !(await store.claimRepoLease(repo, instance, this.leaseTtlMs))
@@ -233,101 +236,116 @@ export class HarvestRunner {
       await this.ensureLease()
       // Bounded read (AUT-489): reduceHarvest and the verdict/failure filters
       // below consume durable types only, so the subset is replay-equivalent.
-      let events = await store.getRepoStateEvents(repo)
-      let state = reduceHarvest(events)
-      run = actionableHarvestRun(state)
-
-      // Settle durable operator control before scanning or resuming work. The
-      // selected run comes from the full journal, so a shadowed failure or
-      // exhaustion barrier is recovered/reported before any later open run.
-      await this.controlBoundary(run?.run)
-      events = await store.getRepoStateEvents(repo)
-      state = reduceHarvest(events)
-      run = openHarvestRun(state)
-
-      if (!run) {
-        await this.controlBoundary()
-        // Flat-cost gate (AUT-521): the pressure trigger is evaluated from
-        // the journal and one repo-scoped digest batch read — no per-build
-        // history reads — so the idle evaluation no longer grows with
-        // accumulated finished builds. Only a tripped gate pays for the full
-        // unclaimed-observation scan, because the packet artifact needs the
-        // observation payloads no bounded source carries.
-        // Bounded read (AUT-489): the gate's journal input is consumed only
-        // through reduceHarvest, so the subset is replay-equivalent here too.
-        const [gateEvents, digests] = await Promise.all([
-          store.getRepoStateEvents(repo),
-          store.getRepoBuildDigests(repo),
-        ])
-        const pressure = evaluateHarvestPressureFromDigests({
-          digests,
-          harvestEvents: gateEvents,
-          policy: this.currentConfig().policy,
-        })
-        if (pressure.trigger === undefined) {
-          // Treat the read's completion as a boundary even when the gate did
-          // not trip, so a request arriving during the read is acknowledged
-          // before this runner returns idle.
+      if (this.deps.preparedRun) {
+        const events = await store.getRepoStateEvents(repo)
+        const authorization = events.find(
+          (event) =>
+            event.type === 'harvest.execution.authorized' &&
+            event.payload.execution === instance &&
+            event.payload.run === this.deps.preparedRun!.run,
+        )
+        if (authorization?.type !== 'harvest.execution.authorized')
+          throw new Error('prepared harvest execution unavailable')
+        run = reduceHarvest(events).runs.find((run) => run.run === this.deps.preparedRun!.run)
+        initial = authorization.payload.launch
+      } else {
+        let events = await store.getRepoStateEvents(repo)
+        let state = reduceHarvest(events)
+        run = actionableHarvestRun(state)
+
+        // Settle durable operator control before scanning or resuming work. The
+        // selected run comes from the full journal, so a shadowed failure or
+        // exhaustion barrier is recovered/reported before any later open run.
+        await this.controlBoundary(run?.run)
+        events = await store.getRepoStateEvents(repo)
+        state = reduceHarvest(events)
+        run = openHarvestRun(state)
+
+        if (!run) {
           await this.controlBoundary()
-          return { outcome: 'idle' }
-        }
-        await this.controlBoundary()
-        const scan = await scanUnclaimedObservations(store, repo)
-        // The trigger came from an earlier read than this scan, and a claim
-        // may have landed in the window. Re-confirm the gate against the
-        // fresh scan (pure, free): an emptied window returns idle exactly as
-        // if the gate had not tripped, so a packet is only ever built from a
-        // scan that itself triggered.
-        const confirmed = evaluateHarvestPressure(scan, this.currentConfig().policy)
-        if (confirmed.trigger === undefined) {
+          // Flat-cost gate (AUT-521): the pressure trigger is evaluated from
+          // the journal and one repo-scoped digest batch read — no per-build
+          // history reads — so the idle evaluation no longer grows with
+          // accumulated finished builds. Only a tripped gate pays for the full
+          // unclaimed-observation scan, because the packet artifact needs the
+          // observation payloads no bounded source carries.
+          // Bounded read (AUT-489): the gate's journal input is consumed only
+          // through reduceHarvest, so the subset is replay-equivalent here too.
+          const [gateEvents, digests] = await Promise.all([
+            store.getRepoStateEvents(repo),
+            store.getRepoBuildDigests(repo),
+          ])
+          const pressure = evaluateHarvestPressureFromDigests({
+            digests,
+            harvestEvents: gateEvents,
+            policy: this.currentConfig().policy,
+          })
+          if (pressure.trigger === undefined) {
+            // Treat the read's completion as a boundary even when the gate did
+            // not trip, so a request arriving during the read is acknowledged
+            // before this runner returns idle.
+            await this.controlBoundary()
+            return { outcome: 'idle' }
+          }
           await this.controlBoundary()
-          return { outcome: 'idle' }
+          const scan = await scanUnclaimedObservations(store, repo)
+          // The trigger came from an earlier read than this scan, and a claim
+          // may have landed in the window. Re-confirm the gate against the
+          // fresh scan (pure, free): an emptied window returns idle exactly as
+          // if the gate had not tripped, so a packet is only ever built from a
+          // scan that itself triggered.
+          const confirmed = evaluateHarvestPressure(scan, this.currentConfig().policy)
+          if (confirmed.trigger === undefined) {
+            await this.controlBoundary()
+            return { outcome: 'idle' }
+          }
+          const runId = this.deps.ids('harvest')
+          const packet = await makeHarvestScanPacket({
+            store,
+            tickets: this.deps.tickets,
+            repo,
+            run: runId,
+            observations: scan.observations,
+            state: scan.state,
+          })
+          // Scan preparation is not a claim. Re-read operator control immediately
+          // before atomically committing the immutable snapshot.
+          await this.controlBoundary()
+          initial = 'started'
+          await store.appendRepoWithArtifacts(
+            repo,
+            [
+              {
+                kind: HARVEST_SCAN_ARTIFACT,
+                content: `${JSON.stringify(packet, null, 2)}\n`,
+                metadata: { run: runId, observations: packet.observations.length },
+              },
+            ],
+            (deposited) => ({
+              actor: KERNEL,
+              type: 'harvest.started',
+              payload: {
+                run: runId,
+                observations: packet.observations.map((item) => item.occurrence),
+                scan: artifactRef(deposited[0]!),
+                trigger: confirmed.trigger,
+                ...(this.deps.environment !== undefined
+                  ? { environment: this.deps.environment }
+                  : {}),
+              },
+            }),
+          )
+          // Bounded read (AUT-489): reduceHarvest consumes durable types only.
+          events = await store.getRepoStateEvents(repo)
+          run = reduceHarvest(events).runs.find((candidate) => candidate.run === runId)
+          if (!run) throw new Error(`harvest.started did not reduce run "${runId}"`)
+          // A request racing the claim parks this exact run; its snapshot stays
+          // open and is resumed rather than scanned again.
+          await this.controlBoundary(run.run)
         }
-        const runId = this.deps.ids('harvest')
-        const packet = await makeHarvestScanPacket({
-          store,
-          tickets: this.deps.tickets,
-          repo,
-          run: runId,
-          observations: scan.observations,
-          state: scan.state,
-        })
-        // Scan preparation is not a claim. Re-read operator control immediately
-        // before atomically committing the immutable snapshot.
-        await this.controlBoundary()
-        initial = 'started'
-        await store.appendRepoWithArtifacts(
-          repo,
-          [
-            {
-              kind: HARVEST_SCAN_ARTIFACT,
-              content: `${JSON.stringify(packet, null, 2)}\n`,
-              metadata: { run: runId, observations: packet.observations.length },
-            },
-          ],
-          (deposited) => ({
-            actor: KERNEL,
-            type: 'harvest.started',
-            payload: {
-              run: runId,
-              observations: packet.observations.map((item) => item.occurrence),
-              scan: artifactRef(deposited[0]!),
-              trigger: confirmed.trigger,
-              ...(this.deps.environment !== undefined
-                ? { environment: this.deps.environment }
-                : {}),
-            },
-          }),
-        )
-        // Bounded read (AUT-489): reduceHarvest consumes durable types only.
-        events = await store.getRepoStateEvents(repo)
-        run = reduceHarvest(events).runs.find((candidate) => candidate.run === runId)
-        if (!run) throw new Error(`harvest.started did not reduce run "${runId}"`)
-        // A request racing the claim parks this exact run; its snapshot stays
-        // open and is resumed rather than scanned again.
-        await this.controlBoundary(run.run)
       }
-
+      if (!run) throw new Error('prepared harvest run unavailable')
+      if (preparationOnly) return { outcome: 'prepared', run: run.run, launch: initial }
       try {
         await this.ensureScanStep(run)
         await this.controlBoundary(run.run)
@@ -691,7 +709,7 @@ export class HarvestRunner {
             live.handle,
             `Revise harvest proposals for round ${spec.round}: run ab harvest context, address .ab/findings.json, then submit.`,
             {
-              env: this.sessionEnv(spec.run, spec.step, spec.round, session),
+              env: await this.sessionEnv(spec.run, spec.step, spec.round, session),
               ...(stream !== undefined ? { stream } : {}),
             },
           )
@@ -702,7 +720,7 @@ export class HarvestRunner {
             workspacePath,
             ...(target.model !== undefined ? { model: target.model } : {}),
             ...(target.args !== undefined ? { args: target.args } : {}),
-            env: this.sessionEnv(spec.run, spec.step, spec.round, session),
+            env: await this.sessionEnv(spec.run, spec.step, spec.round, session),
             ...(stream !== undefined ? { stream } : {}),
           })
           handle = turn.session
@@ -941,7 +959,7 @@ export class HarvestRunner {
           live.handle,
           `Revise harvest proposals for round ${spec.round}: run ab harvest context, address .ab/findings.json, then submit.`,
           {
-            env: this.sessionEnv(spec.run, spec.step, spec.round, session),
+            env: await this.sessionEnv(spec.run, spec.step, spec.round, session),
             ...(stream !== undefined ? { stream } : {}),
           },
         )
@@ -952,7 +970,7 @@ export class HarvestRunner {
           workspacePath,
           ...(resolved.model !== undefined ? { model: resolved.model } : {}),
           ...(resolved.args !== undefined ? { args: resolved.args } : {}),
-          env: this.sessionEnv(spec.run, spec.step, spec.round, session),
+          env: await this.sessionEnv(spec.run, spec.step, spec.round, session),
           ...(stream !== undefined ? { stream } : {}),
         })
         handle = turn.session
@@ -1391,6 +1409,7 @@ export class HarvestRunner {
    * give-up before returning. Initial/within-step failures do not spend this
    * outer budget and therefore remain recoverable. */
   private async settleRecoveryExhaustion(run: string): Promise<void> {
+    if (this.deps.preparedRun) return
     await this.ensureLease()
     // Bounded read (AUT-489): reduceHarvest consumes durable types only.
     const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
@@ -1459,6 +1478,7 @@ export class HarvestRunner {
       const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
       const decision = decideHarvestControl(state, this.maxRecoveryAttempts)
       if (decision.kind === 'proceed') return
+      if (this.deps.preparedRun) throw new HarvestParkedSignal(run)
       if (decision.kind === 'park') {
         throw new HarvestParkedSignal(actionableHarvestRun(state)?.run ?? run)
       }
@@ -1602,15 +1622,26 @@ export class HarvestRunner {
     }
   }
 
-  private sessionEnv(
+  private async sessionEnv(
     run: string,
     step: 'synthesize' | 'review',
     round: number,
     session: string,
-  ): Record<string, string> {
+  ): Promise<Record<string, string>> {
+    const parent = this.deps.sessionEnv
+    const token =
+      parent?.AB_STORE && /^https?:/i.test(parent.AB_STORE)
+        ? await delegateCredential(parent.AB_STORE, parent.AB_TOKEN, {
+            kind: 'harvest-phase',
+            repo: this.deps.repo,
+            id: run,
+            session,
+          })
+        : undefined
     return {
       AB_STORE: 'local',
       ...this.deps.sessionEnv,
+      ...(token ? { AB_TOKEN: token } : {}),
       AB_REPO: this.deps.repo,
       AB_HARVEST: run,
       AB_PHASE: `${step}@${round}`,
@@ -1638,7 +1669,18 @@ export class HarvestRunner {
     const open = target.openSessionStream
     if (open === undefined) return undefined
     const sink = createSessionStreamSink({
-      store: this.deps.store,
+      store: {
+        ...this.deps.store,
+        createStream: (scope, label) =>
+          this.deps.store.createStream(
+            scope,
+            this.deps.preparedRun
+              ? `harvest:${this.deps.preparedRun.run}:${this.deps.instance}:${label}`
+              : label,
+          ),
+        appendStreamParts: (id, parts) => this.deps.store.appendStreamParts(id, parts),
+        closeStream: (id, outcome) => this.deps.store.closeStream(id, outcome),
+      },
       scope: { kind: 'repo', repo: this.deps.repo },
       onDiagnostic: this.onDiagnostic,
     })

package/packages/core/src/processes/phase-failure-budget.ts

@@ -11,6 +11,7 @@ export const POLICY_PHASE_FAILURE_RESET_SCOPES = {
   'review-round-limit': 'matching-round',
   'verify-failure-limit': 'all-phase-rounds',
   'reconcile-no-progress': 'none',
+  'dispatch-failure-limit': 'none',
   'setup-failure-limit': 'none',
   'infrastructure-failure-limit': 'none',
   'phase-attempt-limit': 'matching-round',

package/packages/core/src/processes/publication-loss.ts

@@ -1,3 +1,5 @@
+import { summaryBoundary } from '../kernel/pr-summary'
+import { isRemoteWorkspace } from '../events/workspace-remote'
 /**
  * Last-chance publication settlement at the workspace-release boundary
  * (AUT-328). A pending `publication.requested` whose workspace is destroyed
@@ -37,7 +39,22 @@ export async function settlePublicationBeforeRelease(
   reason: string,
 ): Promise<AbEvent[]> {
   const request = latestUncompletedPublicationRequest(events)
-  if (request === undefined) return events
+  if (request === undefined) {
+    const workspace = events.findLast((event) => event.type === 'workspace.provisioned')
+    if (
+      workspace?.type === 'workspace.provisioned' &&
+      isRemoteWorkspace(workspace.payload) &&
+      summaryBoundary(events) !== undefined
+    ) {
+      try {
+        await deps.settlePublication?.(slug)
+      } catch {
+        /* Summary is best effort. */
+      }
+      return deps.store.getEvents(slug)
+    }
+    return events
+  }
   try {
     await deps.settlePublication?.(slug)
   } catch {

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/)

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

@@ -45,6 +45,7 @@ export type DigestEvent = DigestEventRow
 
 /** The carried accumulator for `reduceBuildDigest`. */
 export interface DigestAcc {
+  readinessChangeSeq?: number
   terminal?: BuildDigest['terminal']
   merged?: string
   observations: { seq: number; ts: string }[]
@@ -57,7 +58,7 @@ export interface DigestAcc {
 }
 
 /** Bump when `DigestAcc`'s shape or fold semantics change. */
-export const BUILD_DIGEST_REDUCER_VERSION = 2
+export const BUILD_DIGEST_REDUCER_VERSION = 3
 
 export const buildDigestReducer: IncrementalReducer<
   DigestAcc,
@@ -68,6 +69,8 @@ export const buildDigestReducer: IncrementalReducer<
   initial: (): DigestAcc => ({ observations: [], hosted: [], reclaimed: [], openInstance: null }),
   fold(acc, events) {
     for (const event of events) {
+      if (['pr.merged', 'build.completed', 'build.aborted'].includes(event.type))
+        acc.readinessChangeSeq = event.seq
       if (event.type === 'build.completed') acc.terminal = 'done'
       else if (event.type === 'build.aborted') acc.terminal = 'aborted'
       else if (event.type === 'pr.merged') acc.merged = event.ts
@@ -84,11 +87,20 @@ export const buildDigestReducer: IncrementalReducer<
       }
     }
   },
-  finish: ({ terminal, merged, observations, hosted, reclaimed, openInstance }) => {
+  finish: ({
+    readinessChangeSeq,
+    terminal,
+    merged,
+    observations,
+    hosted,
+    reclaimed,
+    openInstance,
+  }) => {
     const reclaimedSet = new Set(reclaimed)
     const reclaimPending = hosted.some((seq) => !reclaimedSet.has(seq))
     return {
       observations: [...observations],
+      ...(readinessChangeSeq !== undefined ? { readinessChangeSeq } : {}),
       ...(merged !== undefined ? { merged } : {}),
       ...(terminal !== undefined ? { terminal } : {}),
       ...(reclaimPending ? { reclaimPending: true as const } : {}),

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

@@ -46,6 +46,7 @@ import { createSessionScopedStore } from '../session-handle'
 import { DIGEST_EVENT_TYPES, type DigestEventRow, reduceBuildDigest } from '../digest'
 import {
   REPOSITORY_STATE_EVENT_TYPES,
+  REPOSITORY_LATEST_EVENT_TYPES,
   readRepoStateEventsWithAnchorRecheck,
 } from '../repo-state-events'
 import {
@@ -1188,14 +1189,26 @@ export class SqliteBuildStore implements BuildStore {
       },
       async (anchor) => {
         const durable = inArray(repoEvents.type, [...REPOSITORY_STATE_EVENT_TYPES])
+        const latest = REPOSITORY_LATEST_EVENT_TYPES.map((type) =>
+          and(
+            eq(repoEvents.type, type),
+            sql`${repoEvents.seq} = (SELECT seq FROM repo_events WHERE repo = ${repo} AND type = ${type} ORDER BY seq DESC LIMIT 1)`,
+          ),
+        )
+        const tail =
+          anchor === undefined
+            ? undefined
+            : and(
+                gte(repoEvents.seq, anchor),
+                sql`${repoEvents.type} NOT IN (${sql.join(
+                  REPOSITORY_LATEST_EVENT_TYPES.map((type) => sql`${type}`),
+                  sql`, `,
+                )})`,
+              )
         const rows = this.db
           .select()
           .from(repoEvents)
-          .where(
-            anchor === undefined
-              ? and(eq(repoEvents.repo, repo), durable)
-              : and(eq(repoEvents.repo, repo), or(gte(repoEvents.seq, anchor), durable)),
-          )
+          .where(and(eq(repoEvents.repo, repo), or(durable, tail, ...latest)))
           .orderBy(asc(repoEvents.seq))
           .all()
         return rows.map(

package/packages/core/src/store/remote/client.ts

@@ -578,7 +578,7 @@ export class RemoteBuildStore implements BuildStore {
 
   async getRepoHighWater(repo: string): Promise<number> {
     // Additive route beside `state-events`; the store service and client
-    // ship in version lockstep, so no protocol bump.
+    // retain this additive route throughout the supported client window.
     return this.requestJson('GET', `${this.repoPath(repo)}/high-water`, repoHighWaterSchema).then(
       (body) => (body as { seq: number }).seq,
     )