@defrex/autobuild 0.11.0 → 0.12.0

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

@@ -1,3 +1,4 @@
+import { ensureDispatchBudget } from './dispatch-failure-budget'
 import {
   reduceTicketSourceHealth,
   type TicketSourceDegradation,
@@ -665,7 +666,15 @@ export class Dispatcher {
     return this.repoOrigin
   }
   private readonly leaseTtlMs: number
-  private readonly doneState: string
+  private get doneState(): string {
+    return (
+      this.deps.opts?.doneState ??
+      (this.deps.config.tickets.source === 'hosted'
+        ? this.deps.config.tickets.doneState
+        : undefined) ??
+      'Done'
+    )
+  }
   private readonly slugNamingTimeoutMs: number
   private readonly maxHarvestRecoveryAttempts: number
   private readonly provisionStaleMs: number
@@ -695,7 +704,6 @@ export class Dispatcher {
         ? deps.store
         : new RepoViewStore(deps.store, { repo: deps.repo })
     this.leaseTtlMs = deps.opts?.leaseTtlMs ?? 0
-    this.doneState = deps.opts?.doneState ?? 'Done'
     this.slugNamingTimeoutMs = deps.opts?.slugNamingTimeoutMs ?? DEFAULT_SLUG_NAMING_TIMEOUT_MS
     this.maxHarvestRecoveryAttempts =
       deps.opts?.maxHarvestRecoveryAttempts ?? DEFAULT_MAX_HARVEST_RECOVERY_ATTEMPTS
@@ -1508,6 +1516,10 @@ export class Dispatcher {
       generation,
       seed,
       tail,
+    }).catch(() => {
+      // Detached work must never reject into the dispatcher process. Failure
+      // recording can itself fail on a store outage; durable boundaries and
+      // lease expiry let the next tick repair or retry the unfinished work.
     })
     return 'kicked'
   }
@@ -1542,6 +1554,7 @@ export class Dispatcher {
     const slug = entry.slug
     let leaseClaimed = false
     let heartbeat: ReturnType<typeof setInterval> | undefined
+    let boundary: 'workspace' | 'read' | 'dispatch' | 'launch' = 'workspace'
     const stage: EventPayload<'dispatch.failed'>['stage'] = 'workspace'
     try {
       if (entry.controller.signal.aborted) {
@@ -1606,12 +1619,19 @@ export class Dispatcher {
       await store.releaseLease(slug, entry.instance)
       leaseClaimed = false
       if (entry.controller.signal.aborted) return
+      boundary = 'read'
       const record = await store.getBuild(slug)
       if (record === null) return
-      await (input.tail === 'dispatch'
-        ? this.completeDispatchBoundaries(record, input.seed)
-        : this.deps.launchRunner(slug))
+      const queued = reduceBuild(await store.getEvents(slug)).status === 'queued'
+      boundary = input.tail === 'dispatch' || queued ? 'dispatch' : 'launch'
+      if (boundary === 'dispatch') await this.completeDispatchBoundaries(record, input.seed)
+      else await this.deps.launchRunner(slug)
     } catch (error) {
+      // Dispatch boundaries own their failure facts and exhaustion repair.
+      // A failed tail read/write leaves durable unfinished work for the next
+      // tick; it is not another provider workspace failure. Replacement
+      // runner launch errors retain the existing infrastructure-budget path.
+      if (boundary === 'read' || boundary === 'dispatch') return
       const events = await store.getEvents(slug)
       if (workspaces.recovery !== undefined) {
         const open = openWorkspace(events)
@@ -2485,6 +2505,16 @@ export class Dispatcher {
     return sha
   }
 
+  private dispatchBudget(slug: string): Promise<boolean> {
+    return ensureDispatchBudget(
+      this.store,
+      this.deps.ids,
+      slug,
+      this.deps.config.policy.maxDispatchAttempts,
+      this.deps.workspaces.recovery !== undefined,
+    )
+  }
+
   // ── b. Interrupted dispatch recovery ───────────────────────────────────────
 
   /** The claim-time `build.created` payload. Assets are omitted when the ticket
@@ -2539,6 +2569,7 @@ export class Dispatcher {
   ): Promise<DispatchOutcome> {
     const store = this.store
     const { config } = this.deps
+    if (!(await this.dispatchBudget(record.slug))) return 'parked'
     let stage: EventPayload<'dispatch.failed'>['stage'] = 'create'
     try {
       let events = await store.getEvents(record.slug)
@@ -2628,8 +2659,6 @@ export class Dispatcher {
         } satisfies EventWrite<'workspace.provisioned'>)
         events = await store.getEvents(record.slug)
       }
-
-      return await this.completeDispatchBoundaries(record, seed, report, launched)
     } catch (error) {
       const events = await store.getEvents(record.slug)
       if (stage === 'workspace' && this.deps.workspaces.recovery !== undefined) {
@@ -2654,8 +2683,10 @@ export class Dispatcher {
         },
       })
       report.dispatchFailed += 1
+      await this.dispatchBudget(record.slug)
       return 'failed'
     }
+    return this.completeDispatchBoundaries(record, seed, report, launched)
   }
 
   /** The post-workspace dispatch boundaries — spec, comment, launch — shared
@@ -2676,10 +2707,13 @@ export class Dispatcher {
   ): Promise<Exclude<DispatchOutcome, 'deferred'>> {
     const store = this.store
 
+    if (!(await this.dispatchBudget(record.slug))) return 'parked'
     let stage: EventPayload<'dispatch.failed'>['stage'] = 'spec'
     let authored = false
     try {
       const events = await store.getEvents(record.slug)
+      const state = reduceBuild(events)
+      if (state.status !== 'queued' || state.discardRequest !== undefined) return 'parked'
       if (
         !events.some((event) => event.type === 'spec.imported' || event.type === 'spec.authored')
       ) {
@@ -2779,6 +2813,7 @@ export class Dispatcher {
         },
       })
       if (report !== undefined) report.dispatchFailed += 1
+      await this.dispatchBudget(record.slug)
       return 'failed'
     }
   }
@@ -2810,9 +2845,11 @@ export class Dispatcher {
       // Queued itself means runner attachment is still missing. Always enter
       // the fact-driven helper: it skips every completed boundary and retries
       // only the final launch when setup is already durable.
-      if ((await this.attemptDispatchCompletion(record, launched, report)) === 'completed') {
-        report.recovered += 1
-      }
+      const outcome = await this.attemptDispatchCompletion(record, launched, report)
+      if (outcome === 'completed') report.recovered += 1
+      // A failed boundary owns this tick's attempt; startup and lease recovery
+      // must not bypass the unfinished dispatch boundary later in the tick.
+      if (outcome === 'failed') launched.add(record.slug)
     }
   }
 
@@ -2853,6 +2890,12 @@ export class Dispatcher {
         continue
       }
 
+      if (
+        state.status === 'queued' &&
+        !state.pendingCommands.some((command) => command.command === 'abort') &&
+        !(await this.dispatchBudget(record.slug))
+      )
+        continue
       const decision = decideNextFromFacts(state, facts.log, config)
       if (decision.kind === 'wait') {
         if (decision.reason === 'blocked' && state.openEscalations.length > 0) {
@@ -2923,6 +2966,12 @@ export class Dispatcher {
       ) {
         continue
       }
+      if (
+        state.status === 'queued' &&
+        !state.pendingCommands.some((command) => command.command === 'abort') &&
+        !(await this.dispatchBudget(record.slug))
+      )
+        continue
       const decision = decideNextFromFacts(state, facts.log, this.deps.config)
       if (state.status === 'done' || state.status === 'aborted') continue
       // Raw history, read at most once and only by a branch that acts on it.

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

@@ -97,6 +97,7 @@ export async function runHarvestChild(
       uuids: randomUuids(),
       clock: systemClock,
       instance: input.instance,
+      ...(input.preparedRun ? { preparedRun: input.preparedRun } : {}),
       // Adopted holder: the guest skips its own claim, heartbeats the owning
       // dispatch loop's repository lease, and never releases it.
       ...(input.leaseHolder !== undefined ? { leaseHolder: input.leaseHolder } : {}),

package/packages/core/src/processes/harvest-execution-state.ts

@@ -92,9 +92,26 @@ export function classifyHarvestOutcome(
   input: HarvestExecutionClassificationInput,
 ): HarvestRunnerResult {
   const state = reduceHarvest(events)
-  const latestRun = state.runs.at(-1)
+  const started = events.find(
+    (event) =>
+      event.type === 'harvest.execution.started' && event.seq === input.executionStartedSeq,
+  )
+  const authorization =
+    started?.type === 'harvest.execution.started'
+      ? events.find(
+          (event) =>
+            event.type === 'harvest.execution.authorized' &&
+            event.payload.execution === started.payload.execution,
+        )
+      : undefined
+  const selected =
+    authorization?.type === 'harvest.execution.authorized' ? authorization.payload : undefined
+  const latestRun = selected
+    ? state.runs.find((run) => run.run === selected.run)
+    : state.runs.at(-1)
   if (latestRun !== undefined) {
-    const launch = latestRun.startedSeq > input.executionStartedSeq ? 'started' : 'resumed'
+    const launch =
+      selected?.launch ?? (latestRun.startedSeq > input.executionStartedSeq ? 'started' : 'resumed')
     // Recency gate: a terminal outcome counts only if its fact — the run's
     // terminal fact, or for an unresolved failure the failure fact itself
     // (`failureSeq`), which also covers exhaustion via `terminalSeq` —

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